Link to this sectionUso de Python#

Bem-vindo à documentação de uso do Ultralytics YOLO em Python! Este guia foi projetado para ajudar você a integrar facilmente o Ultralytics YOLO aos seus projetos em Python para detecção de objetos, segmentação de instâncias, segmentação semântica 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!

Por exemplo, os usuários podem carregar um modelo, treiná-lo, avaliar seu desempenho em um conjunto de validação e até mesmo 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")

Link to this sectionTreinar#

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 especificado e hiperparâmetros. O processo de treinamento envolve a otimização dos parâmetros do modelo para que ele possa prever com precisão as classes e localizações dos objetos em uma imagem.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # pass any model type
results = model.train(epochs=5)

Exemplos de Treinamento

Link to this sectionValidar#

O modo Val é 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()

Exemplos de Val

Link to this sectionPrever#

O modo de Previsão é usado para fazer previsões usando um modelo YOLO treinado em novas imagens ou vídeos. Nesse modo, o modelo é carregado a partir de um arquivo de checkpoint, e o usuário pode fornecer imagens ou vídeos para realizar a inferência. O modelo prevê as classes e localizações 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])

Exemplos de Previsão

Link to this sectionExportar#

O modo de Exportação é usado para exportar um modelo YOLO para um formato que pode 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. Este modo é útil ao implantar o modelo em ambientes de produção.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)

Exemplos de Exportação

Link to this sectionRastrear#

O modo de Rastreamento é usado para rastrear objetos em tempo real usando um modelo YOLO. Nesse modo, o modelo é carregado a partir de um arquivo de checkpoint, e o usuário pode fornecer um fluxo de vídeo ao vivo para realizar o rastreamento de objetos em tempo real. Este 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")

Exemplos de Rastreamento

Link to this sectionBenchmark#

O modo Benchmark é usado para analisar a velocidade e a precisão de vários formatos de exportação para o 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_top1 (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 os usuários a escolher o formato de exportação ideal para seu caso de uso específico com base em suas necessidades de velocidade e precisão.

from ultralytics.utils.benchmarks import benchmark

# Benchmark
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)

Exemplos de Benchmark

Link to this sectionUsando Trainers#

A classe de modelo YOLO serve como um wrapper de alto nível para as classes Trainer. 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 machine learning.

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 Trainers 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 melhor desempenho.

Tutoriais de personalização

Link to this sectionFAQ#

Link to this sectionComo posso integrar o YOLO em meu projeto Python para detecção de objetos?#

Integrar o Ultralytics YOLO em 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 de Modo de Previsão.

Link to this sectionQuais 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.
• Val: Valide o desempenho do modelo em um conjunto de validação.
• Prever: 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: Analise o desempenho do modelo em diferentes configurações.

Cada modo é projetado para fornecer funcionalidades abrangentes para diferentes estágios do desenvolvimento e implantação de modelos.

Link to this sectionComo 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 mais detalhes sobre treinamento e hiperlinks para exemplos de uso, visite nossa página de Modo de Treinamento.

Link to this sectionComo 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.

Link to this sectionPosso validar meu modelo YOLO em diferentes conjuntos de dados?#

Sim, é possível validar modelos YOLO em diferentes conjuntos de dados. 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")

Confira a página do Modo Val para exemplos detalhados e uso.