Exportação de Modelos com Ultralytics YOLO#

Exportar um modelo YOLO26 para o formato ONNX é simples com o Ultralytics. Ele fornece métodos em Python e CLI para exportar modelos.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

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

Usar o TensorRT para exportação de modelos oferece melhorias significativas de desempenho. Modelos YOLO26 exportados para o TensorRT podem alcançar até 5x de aceleração de GPU, tornando-o ideal para aplicações de inferência em tempo real.

• Versatilidade: Otimiza modelos para uma configuração de hardware específica.
• Velocidade: Alcança inferência mais rápida através de otimizações avançadas.
• Compatibilidade: Integra-se perfeitamente com o hardware da NVIDIA.

Para saber mais sobre como integrar o TensorRT, consulta o guia de integração do TensorRT.

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

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # Load a model
model.export(format="onnx", quantize=8, data="coco8.yaml")

A quantização INT8 pode ser aplicada a formatos como ONNX, TensorRT, OpenVINO, CoreML e Rockchip RKNN. Para resultados ótimos de quantização, fornece um conjunto de dados representativo usando o parâmetro data. Consulta as Opções de Quantização para valores aceitos de quantize e formatos suportados.

O tamanho de entrada dinâmico permite que o modelo exportado lide com dimensões de imagem variadas, proporcionando flexibilidade e otimizando a eficiência de processamento para diferentes casos de uso. Ao exportar para formatos como ONNX ou TensorRT, ativar o tamanho de entrada dinâmico garante que o modelo possa se adaptar a diferentes formatos de entrada perfeitamente.

Para ativar esse recurso, 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 de entrada dinâmico é particularmente útil para aplicações onde as dimensões de entrada podem variar, como processamento de vídeo ou ao lidar com imagens de diferentes fontes.

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

• format: O formato de destino para o modelo exportado (por exemplo, onnx, torchscript, saved_model).
• imgsz: Tamanho de imagem desejado 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 e ativações "w8a16" e "w8a32" (INT8 dinâmico do LiteRT) em formatos suportados. Consulta as Opções de Quantização.
• optimize: Ativa maior otimização do compilador para exportações do DEEPX.

Para implantação 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 essas saídas é importante para implementações de inferência personalizadas.

Para modelos de detecção YOLO26 (por exemplo, yolo26n.pt) exportados com nms=False, os formatos suportados produzem saída sem NMS modelada como (batch_size, max_detections, 6) com valores de [x1, y1, x2, y2, confidence, class_id]. Com o max_det=300 padrão, isso é comumente (batch_size, 300, 6). Alguns formatos restritos recorrem automaticamente ao layout de saída tradicional quando operadores de ponta a ponta não são suportados.

Por padrão (nms=None), modelos de detecção, incluindo YOLO26, exportam previsões brutas de um para muitos: a saída é tipicamente um único tensor moldado como (batch_size, 4 + num_classes, num_predictions), onde os canais representam coordenadas de caixa mais pontuações por classe, e num_predictions depende da resolução de entrada de exportação (e pode ser dinâmica). O End-to-End Detection guide aborda quais formatos 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 com o formato de (batch_size, 4 + num_classes + mask_dim, num_predictions) (caixas, pontuações de classe e coeficientes de máscara) e o segundo tensor com o formato de (batch_size, mask_dim, proto_h, proto_w), contendo protótipos de máscara usados com os coeficientes para gerar máscaras de instâncias. Os tamanhos dependem da resolução de entrada de exportação (e podem ser dinâmicos).

Para modelos de pose (por exemplo, yolo26n-pose.pt), o tensor de saída tem tipicamente o formato de (batch_size, 4 + num_classes + keypoint_dims, num_predictions), onde keypoint_dims depende da especificação de pose (por exemplo, número de pontos-chave e se a confiança está incluída) e num_predictions depende da resolução de entrada de exportação (e pode ser dinâmico).

Os exemplos nos Exemplos de inferência ONNX demonstram como processar essas saídas para cada tipo de modelo.

O Ultralytics atualmente não fornece uma API de inferência C++ dedicada para modelos YOLO. Para implantações em C++, exporta o modelo para um formato de tempo de execução como ONNX, TensorRT, TorchScript ou MNN e, em seguida, carrega o artefato exportado com a API C++ nativa desse tempo de execução.

Por exemplo, exporta um modelo de detecçã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. Quando utilizas pós-processamento C++ personalizado, corresponde o layout do tensor de saída para a tua tarefa e definições de exportação; as exportações de deteção YOLO26 padrão retornam tensores de previsão brutos que requerem NMS externo. Exporta com nms=False para deteções sem NMS moldadas (batch, max_det, 6), ou nms=True para incorporar NMS em formatos suportados.

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

O tensor output0 contém índices de classe, que são representados internamente como valores de ponto flutuante. O FP16 não consegue representar com fiabilidade valores inteiros acima de 2048 devido à sua precisão de mantissa limitada. Para evitar potencial perda de precisão ou IDs de classe incorretos, output0 é intencionalmente mantido em FP32.

Este comportamento é esperado e também se aplica a exportações de menor precisão ou quantizadas onde a fidelidade do índice de classe deve ser preservada.

Se forem necessárias saídas completas em FP16, exporta com nms=None e executa o pós-processamento externamente.