Link to this sectionUso de Python#

Bem-vindo à documentação de Uso de Python do Ultralytics YOLO! Este guia foi projetado para ajudar você a integrar facilmente o Ultralytics YOLO em seus projetos 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 em seus projetos Python, 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 seus requisitos de velocidade e precisão.

from ultralytics.utils.benchmarks import benchmark

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

Exemplos de Benchmark

Link to this sectionUsando Trainers#

A classe de modelo YOLO serve como um wrapper de alto nível para classes Trainer. Cada tarefa YOLO tem seu próprio trainer, que herda de BaseTrainer. Esta 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 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 foi projetado para fornecer funcionalidades abrangentes para diferentes estágios de 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.