Ir para o conteúdo

Uso do Python

Bem-vindo à documentação de Uso do Python do Ultralytics YOLO! Este guia foi projetado para ajudá-lo a integrar perfeitamente o Ultralytics YOLO em seus projetos 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 em seus projetos Python, permitindo que você implemente rapidamente recursos avançados de detecção de objetos. Vamos começar!



Assista: Dominando Ultralytics YOLO: Python

Por exemplo, os utilizadores podem carregar um modelo, treiná-lo, avaliar o seu desempenho num conjunto de validação e até mesmo exportá-lo para o formato ONNX com apenas algumas linhas de código.

Python

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolo11n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo11n.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")

Treinar

O modo de treinamento é usado para treinar um modelo YOLO em um conjunto de dados personalizado. Neste modo, o modelo é treinado usando o conjunto de dados e os 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 localizações de objetos em uma imagem.

Treinar

from ultralytics import YOLO

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

from ultralytics import YOLO

model = YOLO("yolo11n.yaml")
results = model.train(data="coco8.yaml", epochs=5)

model = YOLO("last.pt")
results = model.train(resume=True)

Exemplos de Treino

Validar

O Modo Val é usado para validar um modelo YOLO após o treinamento. Neste modo, o modelo é avaliado em um conjunto de validação para medir sua precisão e desempenho de generalização. Este modo pode ser usado para ajustar os hiperparâmetros do modelo para melhorar seu desempenho.

Validar

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on training data
model.val()

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on separate data
model.val(data="path/to/separate/data.yaml")

Exemplos de Validação

Prever

O modo de previsão é usado para fazer previsões usando um modelo YOLO treinado em novas imagens ou vídeos. Neste 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 de objetos nas imagens ou vídeos de entrada.

Prever

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])

# results would be a list of Results object including all the predictions by default
# but be careful as it could occupy a lot memory when there're many images,
# especially the task is segmentation.
# 1. return as a list
results = model.predict(source="folder")

# results would be a generator which is more friendly to memory by setting stream=True
# 2. return as a generator
results = model.predict(source=0, stream=True)

for result in results:
    # Detection
    result.boxes.xyxy  # box with xyxy format, (N, 4)
    result.boxes.xywh  # box with xywh format, (N, 4)
    result.boxes.xyxyn  # box with xyxy format but normalized, (N, 4)
    result.boxes.xywhn  # box with xywh format but normalized, (N, 4)
    result.boxes.conf  # confidence score, (N, 1)
    result.boxes.cls  # cls, (N, 1)

    # Segmentation
    result.masks.data  # masks, (N, H, W)
    result.masks.xy  # x,y segments (pixels), List[segment] * N
    result.masks.xyn  # x,y segments (normalized), List[segment] * N

    # Classification
    result.probs  # cls prob, (num_class, )

# Each result is composed of torch.Tensor by default,
# in which you can easily use following functionality:
result = result.cuda()
result = result.cpu()
result = result.to("cpu")
result = result.numpy()

Exemplos de Predição

Exportar

O modo de exportação é usado para exportar um modelo YOLO para um formato que pode ser usado para implantação. Neste modo, o modelo é convertido para um formato que pode ser usado por outros aplicativos de software ou dispositivos de hardware. Este modo é útil ao implantar o modelo em ambientes de produção.

Exportar

Exporte um modelo YOLO oficial para ONNX com tamanho de lote e tamanho de imagem dinâmicos. 

from ultralytics import YOLO

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

Exporte um modelo YOLO oficial para TensorRT em device=0 para aceleração em dispositivos CUDA. 

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="engine", device=0)

Exemplos de Exportação

Rastrear

O modo de rastreamento é usado para rastrear objetos em tempo real usando um modelo YOLO. Neste 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.

Rastrear

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official detection model
model = YOLO("yolo11n-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

Benchmark

Modo de benchmark é usado para traçar o perfil da velocidade e precisão de vários formatos de exportação para YOLO. Os benchmarks fornecem informações sobre o tamanho do formato exportado, seu mAP50-95 métricas (para deteção e segmentação de objetos) ou accuracy_top5 métricas (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.

Benchmark

Compare um modelo YOLO oficial em todos os formatos de exportação. 

from ultralytics.utils.benchmarks import benchmark

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

Exemplos de Benchmark

Usando Treinadores

O YOLO A classe de modelo serve como um wrapper de alto nível para as classes Trainer. Cada tarefa YOLO tem seu próprio treinador, que herda de BaseTrainer. Esta arquitetura permite maior flexibilidade e personalização em seus fluxos de trabalho de machine learning.

Exemplo de Treinador de Deteção

from ultralytics.models.yolo 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 suportar 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, seja trabalhando em uma nova tarefa de visão computacional ou ajustando modelos existentes para obter um melhor desempenho.

Tutoriais de personalização

FAQ

Como posso integrar o YOLO no 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("yolo11n.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 na nossa seção de Modo de Previsão.

Quais são os diferentes modos disponíveis no YOLO?

O YOLO da Ultralytics fornece vários modos para atender a diferentes fluxos de trabalho de aprendizado de máquina. Estes incluem:

  • Train: Treinar um modelo usando conjuntos de dados personalizados.
  • Val: Validar o desempenho do modelo num conjunto de validação.
  • Predict: Fazer previsões sobre novas imagens ou fluxos de vídeo.
  • Exportar: Exporte modelos para vários formatos, como ONNX e TensorRT.
  • Track: Rastreamento de objetos em tempo real em fluxos de vídeo.
  • Benchmark: Comparar o desempenho do modelo em diferentes configurações.

Cada modo é projetado para fornecer funcionalidades abrangentes para diferentes estágios de desenvolvimento e implementaçã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("yolo11n.yaml")

# Train the model with custom dataset
model.train(data="path/to/your/dataset.yaml", epochs=10)

Para mais detalhes sobre o 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 o export função. Por exemplo, você pode exportar um modelo para o formato ONNX:

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo11n.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, é possível validar modelos YOLO em diferentes conjuntos de dados. Após o treino, você pode usar o modo de validação para avaliar o desempenho:

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.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")

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



📅 Criado há 1 ano ✏️ Atualizado há 3 meses
glenn-jocher jk4e leonnil RizwanMunawar UltralyticsAssistant MatthewNoyce IvorZhu331 AyushExel Laughing-q

Comentários