Exportação de modelos com o Ultralytics YOLO#

Exportar um modelo YOLO26 para o formato ONNX é simples com a Ultralytics. A biblioteca disponibiliza métodos Python e CLI para exportar modelos.

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n.pt")  # carrega um modelo oficial
model = YOLO("path/to/best.pt")  # carrega um modelo treinado de forma personalizada

# Exporta o modelo
model.export(format="onnx")

Para mais detalhes sobre o processo, incluindo opções avançadas como a gestão de diferentes tamanhos de entrada, consulta o guia de integração ONNX.

Usar TensorRT para exportar modelos proporciona melhorias significativas de desempenho. Os modelos YOLO26 exportados para TensorRT podem alcançar uma aceleração de GPU até 5x, o que os torna ideais para aplicações de inferência em tempo real.

• Versatilidade: otimiza modelos para uma configuração de hardware específica.
• Velocidade: obtém inferência mais rápida através de otimizações avançadas.
• Compatibilidade: integra-te facilmente com hardware NVIDIA.

Para saberes mais sobre a integração do TensorRT, consulta o guia de integração do TensorRT.

A quantização INT8 é uma excelente forma de comprimir o modelo e acelerar a inferência, sobretudo em dispositivos de periferia. Eis como podes ativar a quantização INT8:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # Carregar um modelo
model.export(format="onnx", quantize=8, data="coco8.yaml")

A quantização INT8 pode ser aplicada a formatos como ONNX, TensorRT, OpenVINO, CoreML, Rockchip RKNN e AMD Xilinx. Para obter resultados ideais de quantização, forneça um conjunto de dados representativo usando o parâmetro data. Consulte Opções de quantização para ver os valores quantize aceitos e os formatos compatíveis.

O tamanho dinâmico da entrada permite ao modelo exportado processar imagens com dimensões variáveis, proporcionando flexibilidade e otimizando a eficiência do processamento para diferentes casos de utilização. Ao exportar para formatos como ONNX ou TensorRT, ativar o tamanho dinâmico da entrada garante que o modelo se adapta sem problemas a diferentes formas de entrada.

Para ativar esta funcionalidade, usa a flag dynamic=True durante a exportação:

from ultralytics import YOLO

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

O dimensionamento dinâmico da entrada é particularmente útil em aplicações onde as dimensões de entrada podem variar, como no processamento de vídeo ou ao lidar com imagens de diferentes origens.

Por predefinição, os modelos PyTorch e as exportações dinâmicas usam preenchimento com retângulo mínimo, enquanto as exportações estáticas preenchem até ao valor completo de imgsz, pelo que as deteções perto do limiar de confiança podem diferir. Usa rect=False para a inferência nativa corresponder a uma exportação estática, ou exporta com dynamic=True quando disponível.

Compreender e configurar os argumentos de exportação é fundamental para otimizar o desempenho do modelo:

• format: O formato de destino do modelo exportado (por exemplo, onnx, torchscript, saved_model).
• imgsz: O tamanho de imagem pretendido para a entrada do modelo (por exemplo, 640 ou (height, width)).
• quantize: Precisão da quantização, como 8/"int8", 16/"fp16", 32/"fp32" ou os esquemas mistos de pesos/ativações "w8a16" e "w8a32" (INT8 dinâmico no LiteRT) nos formatos compatíveis. Consulta Opções de quantização.
• dynamic: Aceita tamanhos de entrada variáveis em formatos compatíveis com formas dinâmicas, como ONNX, OpenVINO e TensorRT.
• nms: Seleciona saídas em bruto para NMS externa (None), NMS integrada (True) ou a cabeça sem NMS (False).
• device: Dispositivo usado para rastrear o modelo durante a exportação, como cpu ou 0 para a primeira GPU CUDA; TorchScript FP16 requer uma GPU.

Para implementar em plataformas de hardware específicas, considera usar formatos de exportação especializados, como TensorRT para GPUs NVIDIA, CoreML para dispositivos Apple ou Edge TPU para dispositivos Google Coral.

Quando exportas um modelo YOLO para formatos como ONNX ou TensorRT, a estrutura do tensor de saída depende da tarefa do modelo. Compreender estas saídas é importante para implementações de inferência personalizadas.

Para modelos de deteção YOLO26 (por exemplo, yolo26n.pt) exportados com nms=False, os formatos compatíveis produzem uma saída sem NMS com forma semelhante a (batch_size, max_detections, 6) e [x1, y1, x2, y2, confidence, class_id] valores. Com o max_det=300 predefinido, esta saída é normalmente (batch_size, 300, 6). Alguns formatos com restrições recorrem automaticamente ao esquema de saída tradicional quando não são compatíveis com operadores de ponta a ponta.

Por predefinição (nms=None), os modelos de deteção, incluindo YOLO26, exportam previsões brutas de um para muitos: a saída é normalmente um único tensor com forma semelhante a (batch_size, 4 + num_classes, num_predictions), cujos canais representam as coordenadas das caixas e as pontuações por classe, e num_predictions depende da resolução de entrada da exportação (e pode ser dinâmica). O guia de deteção de ponta a ponta explica quais os formatos que mantêm a saída de ponta a ponta.

Para modelos de segmentação (por exemplo, yolo26n-seg.pt), normalmente obterás duas saídas: o primeiro tensor tem forma semelhante a (batch_size, 4 + num_classes + mask_dim, num_predictions) (caixas, pontuações de classe e coeficientes de máscara), e o segundo tensor tem forma semelhante a (batch_size, mask_dim, proto_h, proto_w) e contém protótipos de máscara usados com os coeficientes para gerar máscaras de instância. Os tamanhos dependem da resolução de entrada da exportação (e podem ser dinâmicos).

Para modelos de pose (por exemplo, yolo26n-pose.pt), o tensor de saída tem normalmente forma semelhante a (batch_size, 4 + num_classes + keypoint_dims, num_predictions), onde keypoint_dims depende da especificação da pose (por exemplo, do número de pontos-chave e da inclusão ou não de confiança), e num_predictions depende da resolução de entrada da exportação (e pode ser dinâmica).

Os exemplos em exemplos de inferência ONNX mostram como processar estas saídas para cada tipo de modelo.

Atualmente, a Ultralytics não disponibiliza uma API de inferência C++ dedicada para modelos YOLO. Para implementações em C++, exporta o modelo para um formato de execução, como ONNX, TensorRT, TorchScript ou MNN, e depois carrega o artefacto exportado com a API C++ nativa desse ambiente de execução.

Por exemplo, exporta um modelo de deteção com yolo export model=yolo26n.pt format=onnx e executa o ficheiro .onnx com ONNX Runtime C++, ou exporta com format=engine e executa o motor TensorRT a partir de uma aplicação C++ TensorRT. Ao usares pós-processamento C++ personalizado, ajusta o esquema do tensor de saída à tarefa e às definições de exportação; as exportações de deteção YOLO26 predefinidas devolvem tensores de previsão brutos que requerem NMS externo. Exporta com nms=False para obter deteções sem NMS com a forma (batch, max_det, 6), ou com nms=True para incorporar NMS nos formatos compatíveis.

Ao exportar com quantize=16 (FP16) ou quantize=8 (INT8), a maioria dos tensores é convertida para uma precisão inferior, reduzindo o tamanho do modelo e melhorando o desempenho. No entanto, quando nms=False está ativado, o pós-processamento (incluindo os índices de classe) é incorporado diretamente no grafo exportado.

O tensor output0 contém índices de classe, que são representados internamente como valores de vírgula flutuante. O FP16 não consegue representar de forma fiável valores inteiros acima de 2048 devido à precisão limitada da mantissa. Para evitar possíveis perdas de precisão ou IDs de classe incorretos, output0 é mantido intencionalmente em FP32.

Se precisares de saídas totalmente em FP16, exporta com nms=None numa GPU e executa o pós-processamento externamente. As exportações ONNX FP16 em CPU mantêm sempre as entradas e saídas em FP32, convertendo apenas o grafo interno.