Python Utilização
Bem-vindo à documentação de uso do YOLO11 Python ! Este guia foi concebido para o ajudar a integrar facilmente o YOLO11 nos seus projectos Python para deteção, segmentação e classificação de objectos. Aqui, aprenderá a carregar e a utilizar modelos pré-treinados, a treinar novos modelos e a efetuar previsões em imagens. A interface fácil de utilizar Python é um recurso valioso para quem procura incorporar YOLO11 nos seus projectos Python , permitindo-lhe implementar rapidamente capacidades avançadas de deteção de objectos. Vamos começar!
Ver: Masterização Ultralytics YOLO11 : Python
Por exemplo, os utilizadores podem carregar um modelo, treiná-lo, avaliar o seu desempenho num conjunto de validação e até 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")
Comboio
O modo Train é utilizado para treinar um modelo YOLO11 num conjunto de dados personalizado. Neste modo, o modelo é treinado utilizando o conjunto de dados e os hiperparâmetros especificados. O processo de treino envolve a otimização dos parâmetros do modelo para que este possa prever com precisão as classes e localizações dos objectos numa imagem.
Comboio
Val
O modo Val é utilizado para validar um modelo YOLO11 depois de este ter sido treinado. Neste modo, o modelo é avaliado num conjunto de validação para medir a sua precisão e desempenho de generalização. Este modo pode ser utilizado para ajustar os hiperparâmetros do modelo para melhorar o seu desempenho.
Val
Prever
O modo Prever é utilizado para efetuar previsões utilizando um modelo YOLO11 treinado em novas imagens ou vídeos. Neste modo, o modelo é carregado a partir de um ficheiro de ponto de controlo e o utilizador pode fornecer imagens ou vídeos para realizar a inferência. O modelo prevê as classes e localizações dos objectos 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()
Exportação
O modo de exportação é utilizado para exportar um modelo YOLO11 para um formato que possa ser utilizado para implantação. Neste modo, o modelo é convertido para um formato que pode ser utilizado por outras aplicações de software ou dispositivos de hardware. Este modo é útil para a implantação do modelo em ambientes de produção.
Exportação
Exportação de um modelo oficial YOLO11n para ONNX com tamanho de lote e tamanho de imagem dinâmicos.
Pista
O modo de rastreio é utilizado para rastrear objectos em tempo real utilizando um modelo YOLO11 . Neste modo, o modelo é carregado a partir de um ficheiro de ponto de controlo e o utilizador pode fornecer um fluxo de vídeo em direto para efetuar o seguimento de objectos em tempo real. Este modo é útil para aplicações como sistemas de vigilância ou carros autónomos.
Pista
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")
Referência
O modo de referência é utilizado para determinar a velocidade e a precisão de vários formatos de exportação para YOLO11. Os parâmetros de referência fornecem informações sobre o tamanho do formato exportado, a sua mAP50-95 métricas (para deteção e segmentação de objectos) ou 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. Esta informação pode ajudar os utilizadores a escolher o melhor formato de exportação para o seu caso de utilização específico, com base nos seus requisitos de velocidade e precisão.
Referência
Utilização de formadores
YOLO A classe Model é um invólucro de alto nível para as classes Trainer. Cada tarefa YOLO tem seu próprio treinador que herda de BaseTrainer.
Exemplo de formador 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 = detect.DetectionTrainer(overrides=overrides)
Pode personalizar facilmente os Trainers para suportar tarefas personalizadas ou explorar ideias de I&D. Saiba mais sobre a personalização Trainers, Validators e Predictors para se adequar às necessidades do seu projeto na secção Personalização.
FAQ
Como posso integrar o YOLO11 no meu projeto Python para deteção de objectos?
Integrar Ultralytics YOLO11 nos seus projectos Python é simples. Pode carregar um modelo pré-treinado ou treinar um novo modelo a partir 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 secção Modo de previsão.
Quais são os diferentes modos disponíveis em YOLO11?
Ultralytics YOLO11 oferece vários modos para responder a diferentes fluxos de trabalho de aprendizagem automática. Estes incluem:
- Comboio: Treinar um modelo utilizando conjuntos de dados personalizados.
- Val: Validar o desempenho do modelo num conjunto de validação.
- Prever: Fazer previsões sobre novas imagens ou fluxos de vídeo.
- Exportação: Exportar modelos para vários formatos como ONNX, TensorRT.
- Pista: Seguimento de objectos em tempo real em fluxos de vídeo.
- Referência: Avaliar o desempenho do modelo de referência em diferentes configurações.
Cada modo foi concebido para fornecer funcionalidades abrangentes para diferentes fases de desenvolvimento e implementação de modelos.
Como é que treino um modelo YOLO11 personalizado utilizando o meu conjunto de dados?
Para treinar um modelo YOLO11 personalizado, é necessário especificar o 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 informações sobre a formação e hiperligações para exemplos de utilização, visite a nossa página Modo de comboio.
Como é que exporto modelos YOLO11 para implementação?
A exportação de modelos YOLO11 num formato adequado para implementação é simples com o export função. Por exemplo, é possível 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 o meu modelo YOLO11 em diferentes conjuntos de dados?
Sim, é possível validar os modelos YOLO11 em diferentes conjuntos de dados. Após a formação, pode utilizar o modo de validação para avaliar o desempenho:
from ultralytics import YOLO
# Load a YOLO11 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 Modo Val para obter exemplos e utilizações pormenorizados.
