Uso em Python
Bem-vindo à documentação de Uso em Python do Ultralytics YOLO! Este guia foi projetado para ajudar você a integrar perfeitamente o Ultralytics YOLO aos seus projetos em Python para detecção de objetos, segmentação e classificação. Aqui, você aprenderá como carregar e usar modelos pré-treinados, treinar novos modelos e realizar previsões em imagens. A interface Python, fácil de usar, é um recurso valioso para quem deseja incorporar o YOLO aos seus projetos, permitindo que você implemente rapidamente recursos avançados de detecção de objetos. Vamos começar!
Watch: Mastering Ultralytics YOLO: Python
Por exemplo, você pode carregar um modelo, treiná-lo, avaliar seu desempenho em um conjunto de validação e até exportá-lo para o formato ONNX com apenas algumas linhas de código.
from ultralytics import YOLO
# Create a new YOLO model from scratch
model = YOLO("yolo26n.yaml")
# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo26n.pt")
# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)
# Evaluate the model's performance on the validation set
results = model.val()
# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")
# Export the model to ONNX format
success = model.export(format="onnx")Train
O modo de Treinamento é usado para treinar um modelo YOLO em um conjunto de dados personalizado. Nesse modo, o modelo é treinado usando o conjunto de dados e hiperparâmetros especificados. O processo de treinamento envolve a otimização dos parâmetros do modelo para que ele possa prever com precisão as classes e locais de objetos em uma imagem.
from ultralytics import YOLO
model = YOLO("yolo26n.pt") # pass any model type
results = model.train(epochs=5)Val
O modo de Validação é usado para validar um modelo YOLO após ele ter sido treinado. Nesse modo, o modelo é avaliado em um conjunto de validação para medir sua precisão e desempenho de generalização. Esse modo pode ser usado para ajustar os hiperparâmetros do modelo a fim de melhorar seu desempenho.
from ultralytics import YOLO
# Load a YOLO model
model = YOLO("yolo26n.yaml")
# Train the model
model.train(data="coco8.yaml", epochs=5)
# Validate on training data
model.val()Prever
O modo de Predição é usado para fazer previsões usando um modelo YOLO treinado em novas imagens ou vídeos. Nesse modo, o modelo é carregado de um arquivo de checkpoint e você pode fornecer imagens ou vídeos para realizar a inferência. O modelo prevê as classes e locais dos objetos nas imagens ou vídeos de entrada.
import cv2
from PIL import Image
from ultralytics import YOLO
model = YOLO("model.pt")
# accepts all formats - image/dir/Path/URL/video/PIL/ndarray. 0 for webcam
results = model.predict(source="0")
results = model.predict(source="folder", show=True) # Display preds. Accepts all YOLO predict arguments
# from PIL
im1 = Image.open("bus.jpg")
results = model.predict(source=im1, save=True) # save plotted images
# from ndarray
im2 = cv2.imread("bus.jpg")
results = model.predict(source=im2, save=True, save_txt=True) # save predictions as labels
# from list of PIL/ndarray
results = model.predict(source=[im1, im2])Export
O modo de Exportação é usado para exportar um modelo YOLO para um formato que possa ser usado para implantação. Nesse modo, o modelo é convertido para um formato que pode ser usado por outras aplicações de software ou dispositivos de hardware. Esse modo é útil ao implantar o modelo em ambientes de produção.
Exporte um modelo oficial YOLO para ONNX com tamanho de lote e tamanho de imagem dinâmicos.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)Rastrear
O modo de Rastreamento é usado para rastrear objetos em tempo real usando um modelo YOLO. Nesse modo, o modelo é carregado de um arquivo de checkpoint e você pode fornecer um fluxo de vídeo ao vivo para realizar o rastreamento de objetos em tempo real. Esse modo é útil para aplicações como sistemas de vigilância ou carros autônomos.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt") # load an official detection model
model = YOLO("yolo26n-seg.pt") # load an official segmentation model
model = YOLO("path/to/best.pt") # load a custom model
# Track with the model
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")Benchmark
O modo de Benchmark é usado para avaliar a velocidade e a precisão de vários formatos de exportação para YOLO. Os benchmarks fornecem informações sobre o tamanho do formato exportado, suas métricas mAP50-95 (para detecção de objetos e segmentação) ou métricas accuracy_top5 (para classificação), e o tempo de inferência em milissegundos por imagem em vários formatos de exportação como ONNX, OpenVINO, TensorRT e outros. Essas informações podem ajudar você a escolher o formato de exportação ideal para seu caso de uso específico com base em seus requisitos de velocidade e precisão.
Faça o benchmark de um modelo oficial YOLO em todos os formatos de exportação.
from ultralytics.utils.benchmarks import benchmark
# Benchmark
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)Usando Treinadores
A classe de modelo YOLO serve como um wrapper de alto nível para classes de Treinador. Cada tarefa YOLO tem seu próprio treinador, que herda de BaseTrainer. Essa arquitetura permite maior flexibilidade e personalização em seus fluxos de trabalho de aprendizado de máquina.
from ultralytics.models.yolo.detect import DetectionPredictor, DetectionTrainer, DetectionValidator
# trainer
trainer = DetectionTrainer(overrides={})
trainer.train()
trained_model = trainer.best
# Validator
val = DetectionValidator(args=...)
val(model=trained_model)
# predictor
pred = DetectionPredictor(overrides={})
pred(source=SOURCE, model=trained_model)
# resume from last weight
overrides["resume"] = trainer.last
trainer = DetectionTrainer(overrides=overrides)Você pode personalizar facilmente os Treinadores para oferecer suporte a tarefas personalizadas ou explorar ideias de pesquisa e desenvolvimento. O design modular do Ultralytics YOLO permite que você adapte a estrutura às suas necessidades específicas, esteja você trabalhando em uma nova tarefa de visão computacional ou ajustando modelos existentes para obter melhor desempenho.
FAQ
Como posso integrar o YOLO ao meu projeto Python para detecção de objetos?
Integrar o Ultralytics YOLO aos seus projetos Python é simples. Você pode carregar um modelo pré-treinado ou treinar um novo modelo do zero. Veja como começar:
from ultralytics import YOLO
# Load a pretrained YOLO model
model = YOLO("yolo26n.pt")
# Perform object detection on an image
results = model("https://ultralytics.com/images/bus.jpg")
# Visualize the results
for result in results:
result.show()Veja exemplos mais detalhados em nossa seção Modo de Predição.
Quais são os diferentes modos disponíveis no YOLO?
O Ultralytics YOLO oferece vários modos para atender a diferentes fluxos de trabalho de aprendizado de máquina. Eles incluem:
- Treinar: Treine um modelo usando conjuntos de dados personalizados.
- Validação: Valide o desempenho do modelo em um conjunto de validação.
- Predição: Faça previsões em novas imagens ou fluxos de vídeo.
- Exportar: Exporte modelos para vários formatos como ONNX e TensorRT.
- Rastrear: Rastreamento de objetos em tempo real em fluxos de vídeo.
- Benchmark: Avalie o desempenho do modelo em diferentes configurações.
Cada modo foi projetado para fornecer funcionalidades abrangentes para diferentes estágios do desenvolvimento e implantação de modelos.
Como treino um modelo YOLO personalizado usando meu conjunto de dados?
Para treinar um modelo YOLO personalizado, você precisa especificar seu conjunto de dados e outros hiperparâmetros. Aqui está um exemplo rápido:
from ultralytics import YOLO
# Load the YOLO model
model = YOLO("yolo26n.yaml")
# Train the model with custom dataset
model.train(data="path/to/your/dataset.yaml", epochs=10)Para obter mais detalhes sobre treinamento e hiperlinks para exemplos de uso, visite nossa página de Modo de Treinamento.
Como exporto modelos YOLO para implantação?
Exportar modelos YOLO em um formato adequado para implantação é simples com a função export. Por exemplo, você pode exportar um modelo para o formato ONNX:
from ultralytics import YOLO
# Load the YOLO model
model = YOLO("yolo26n.pt")
# Export the model to ONNX format
model.export(format="onnx")Para várias opções de exportação, consulte a documentação do Modo de Exportação.
Posso validar meu modelo YOLO em diferentes conjuntos de dados?
Sim, validar modelos YOLO em diferentes conjuntos de dados é possível. Após o treinamento, você pode usar o modo de validação para avaliar o desempenho:
from ultralytics import YOLO
# Load a YOLO model
model = YOLO("yolo26n.yaml")
# Train the model
model.train(data="coco8.yaml", epochs=5)
# Validate the model on a different dataset
model.val(data="path/to/separate/data.yaml")Verifique a página de Modo de Validação para obter exemplos detalhados e uso.