Do laboratório à produção
Instala Ultralytics, executa YOLO26 nas tuas próprias imagens, compara os resultados com as tuas especificações e escolhe o próximo passo.
Dez minutos com um modelo pré-treinado respondem à pergunta que determina todo o teu plano: um modelo pronto a usar já cobre as tuas classes e a tua câmara, ou precisas dos teus próprios dados? Aqui, instalas Ultralytics, executas YOLO26 em imagens reais e comparas os resultados com as especificações que escreveste na primeira lição.
Prático
Instalar#
pip install ultralytics
yolo checksA primeira linha instala o pacote Python ultralytics e o comando yolo, além de PyTorch, se ainda não estiver instalado. yolo checks apresenta as versões de Python, PyTorch e CUDA, bem como o hardware que Ultralytics vai utilizar, para poderes confirmar a configuração antes de executar qualquer coisa. Usa um ambiente virtual novo; o guia de início rápido explica como configurar conda, Docker e GPU.
O pacote ultralytics é instalado no Python 3.8 e em versões mais recentes, mas as versões atuais do PyTorch precisam do Python 3.10 ou posterior. Se o seu ambiente for mais antigo, primeiro crie um novo ambiente virtual com uma versão recente do Python.
Sintoma: yolo checks mostra CPU em uma máquina com uma GPU NVIDIA, e a inferência é lenta. Causa: uma versão do PyTorch somente para CPU — por exemplo, a versão padrão pip no Windows. Solução: selecione seu sistema operacional, gerenciador de pacotes e versão do CUDA no seletor do PyTorch acima, execute o comando exibido e reinstale ultralytics. Em um Mac, como na captura de tela, a versão padrão é a correta; o Ultralytics é executado na CPU, a menos que você passe device=mps para usar a GPU da Apple.
Uma primeira previsão#
from ultralytics import YOLO
model = YOLO("yolo26n.pt") # baixa o modelo nano de ~5 MB na primeira utilização
results = model("https://ultralytics.com/images/bus.jpg", save=True)
for box in results[0].boxes:
print(model.names[int(box.cls)], round(float(box.conf), 2))Ambos apresentam um resumo de uma linha por imagem e guardam a imagem anotada em runs/detect/predict:
image 1/1 .../bus.jpg: 640x480 4 persons, 1 bus, 19.7ms
Speed: 0.9ms preprocess, 19.7ms inference, 0.4ms postprocess per image at shape (1, 3, 640, 480)
Results saved to runs/detect/predictLinha a linha: a imagem foi redimensionada para 640×480 para a inferência; o modelo encontrou quatro pessoas e um autocarro; a inferência demorou cerca de 20 ms num CPU de portátil. A linha Speed é a tua primeira verificação de latência — compara-a com a frequência de imagens por segundo indicada na linha de entrada das tuas especificações. Abre a imagem guardada: cada caixa inclui a classe, a caixa e a confiança da lição sobre deteção.
Compara os resultados com as tuas especificações#
| Pergunta | Se sim | Se não |
|---|---|---|
| As tuas classes estão entre as 80 classes do COCO que o modelo conhece? | Cria um protótipo sem qualquer treino | Precisas de dados rotulados e de um ajuste fino (guia de ajuste fino) |
| Nas tuas imagens, as caixas acima do teu limiar ficam sobre os objetos certos? | A tarefa e o ponto de vista correspondem | Conta com uma diferença de domínio: recolhe dados das tuas câmaras |
| O tipo de resultado é o que a tua linha de decisão exige? | Mantém a tarefa | Muda os pesos: -seg, -sem, -depth, -pose, -obb ou -cls |
| É suficientemente rápido para a frequência de imagens por segundo exigida pelo teu hardware de destino? | Avança | Experimenta um modelo mais pequeno ou um formato de exportação otimizado |
A primeira pergunta tem uma resposta exata: model.names apresenta todas as classes que o modelo pré-treinado conhece. Nas especificações para empilhadores, person é uma classe do COCO e forklift não é, portanto nenhum limiar fará com que o modelo pré-treinado detete um empilhador. Este é o resultado mais comum na primeira execução — o modelo cobre apenas parte das especificações — e a decisão certa é criar um protótipo da lógica de decisão com as classes disponíveis, enquanto constróis o conjunto de dados para as restantes.
O que muda na produção#
Um modelo implementado encontra condições que nunca foram amostradas no seu conjunto de dados: novas câmaras, estações do ano, produtos e uniformes. Sem novo treino, a precisão diminui; com treino regular com base no que observas em produção, recupera:
Todas as lições deste curso alimentam esse ciclo: as especificações definem uma falha, a auditoria de cobertura indica onde procurar, o verificador de rótulos e as diretrizes tornam úteis os novos dados, e as divisões e métricas fiáveis indicam se o modelo treinado novamente é realmente melhor. Dois hábitos ajudam a pôr o processo a funcionar desde o primeiro dia: regista uma amostra das entradas e previsões, incluindo as de baixa confiança, e mantém o conjunto de teste congelado para que todos os modelos sejam comparados com as mesmas imagens. Observabilidade e deriva aborda em detalhe a monitorização da deriva de dados.
O que fazer a seguir#
| Curso | Faz este curso quando |
|---|---|
| Criar conjuntos de dados YOLO de alto desempenho | As tuas classes não estão pré-treinadas ou as tuas cenas diferem do COCO |
| Treina o teu primeiro modelo YOLO | Tens um conjunto de dados rotulado e queres fazer um ajuste fino |
| Ultralytics YOLO em produção | Tens um modelo e precisas de exportação, rastreamento e monitorização |
| Desenvolve com a Ultralytics Platform | Queres gerir dados, rotulagem, treino e implementação num só lugar |
Preferes um fluxo de trabalho no navegador? A Ultralytics Platform executa o mesmo ciclo — carregar, anotar, treinar, implementar — sem instalação local:
Mostrar solução
from pathlib import Path
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# 1. Which classes in your output line does the pretrained model already know?
spec_classes = {"person", "forklift"}
known = set(model.names.values())
print(f"pretrained: {sorted(spec_classes & known)} needs your own data: {sorted(spec_classes - known)}")
# 2. What does it find on your images?
sources = [
"https://ultralytics.com/images/bus.jpg", # replace with your own images
"https://ultralytics.com/images/zidane.jpg",
]
for source, result in zip(sources, model.predict(sources, conf=0.25, save=True, verbose=False)):
names = [result.names[int(c)] for c in result.boxes.cls]
print(f"{Path(source).name}: {len(names)} detections -> {sorted(set(names))}")pretrained: ['person'] needs your own data: ['forklift']
bus.jpg: 5 detections -> ['bus', 'person']
zidane.jpg: 3 detections -> ['person', 'tie']Nas especificações para empilhadores: person está abrangida; forklift não está. Próximo passo: cria já um protótipo da regra de zona para pessoas com o modelo pré-treinado e começa o curso Criar conjuntos de dados YOLO de alto desempenho para recolher e rotular empilhadores a partir das câmaras do armazém.