Exportação de modelos com Ultralytics YOLO#

Introdução#

O objetivo final de treinar um modelo é implantá-lo para aplicações no mundo real. O modo de exportação no Ultralytics YOLO26 oferece uma gama versátil de opções para exportar o teu modelo treinado para diferentes formatos, tornando-o implantável em várias plataformas e dispositivos. Este guia abrangente visa orientar-te sobre as nuances da exportação de modelos, mostrando como alcançar a máxima compatibilidade e desempenho.

Por que escolher o modo de exportação do YOLO26?#

• Versatilidade: Exporta para múltiplos formatos, incluindo ONNX, TensorRT, CoreML e muito mais.
• Desempenho: Obtém até 5x de aceleração em GPU com TensorRT e 3x de aceleração em CPU com ONNX ou OpenVINO.
• Compatibilidade: Torna o teu modelo universalmente implantável em inúmeros ambientes de hardware e software.
• Facilidade de uso: CLI simples e API Python para uma exportação de modelos rápida e direta.

Principais funcionalidades do modo de exportação#

Aqui estão algumas das funcionalidades de destaque:

• Exportação com um clique: Comandos simples para exportar para diferentes formatos.
• Exportação em lote: Exporta modelos capazes de inferência em lote.
• Inferência otimizada: Modelos exportados são otimizados para tempos de inferência mais rápidos.
• Vídeos tutoriais: Guias aprofundados e tutoriais para uma experiência de exportação fluida.

Exemplos de uso#

Exporta um modelo YOLO26n para um formato diferente como ONNX ou TensorRT. Vê a secção de Argumentos abaixo para uma lista completa de argumentos de exportação.

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

Argumentos#

Esta tabela detalha as configurações e opções disponíveis para exportar modelos YOLO para diferentes formatos. Estas definições são críticas para otimizar o desempenho, o tamanho e a compatibilidade do modelo exportado em várias plataformas e ambientes. A configuração adequada garante que o modelo esteja pronto para implantação na aplicação pretendida com eficiência ideal.

Ajustar estes parâmetros permite personalizar o processo de exportação para atender a requisitos específicos, tais como o ambiente de implementação, restrições de hardware e metas de desempenho. Selecionar o formato e as configurações adequadas é essencial para alcançar o melhor equilíbrio entre o tamanho do modelo, a velocidade e a precisão.

Formatos de Exportação#

Os formatos de exportação disponíveis para o YOLO26 encontram-se na tabela abaixo. Podes exportar para qualquer formato utilizando o argumento format, por exemplo, format='onnx' ou format='engine'. Podes prever ou validar diretamente em modelos exportados, ou seja, yolo predict model=yolo26n.onnx. São mostrados exemplos de uso para o teu modelo após a conclusão da exportação. Os modelos também podem ser exportados diretamente do navegador na Ultralytics Platform sem qualquer configuração local.

Opções de Quantização#

Usa o argumento quantize para solicitar a precisão da exportação. Os valores de texto não diferenciam maiúsculas de minúsculas, e o Ultralytics padroniza os apelidos aceites antes da exportação:

As flags obsoletas half=True e int8=True ainda são aceites com avisos de depreciação e redirecionam para quantize=16 e quantize=8.

Nem todos os formatos de exportação suportam todas as precisões. Pedidos explícitos de quantize geram essa precisão ou falham antes da exportação:

Para exportações INT8 e W8A16, fornece dados de calibração representativos com data, como data="coco8.yaml", a menos que a integração de destino documente um comportamento padrão ou ativado automaticamente. O esquema LiteRT "w8a32" (INT8 dinâmico) não necessita de dados de calibração.

O que vem a seguir#

Encontra o guia de integração do teu destino de implementação — ONNX, TensorRT, CoreML e muito mais estão na lista completa de integrações — para saberes como executar o modelo exportado.

FAQ#

Como exporto um modelo YOLO26 para o formato ONNX?#

Exportar um modelo YOLO26 para o formato ONNX é direto com o Ultralytics. Ele fornece métodos 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.

Quais são os benefícios de usar o TensorRT para exportação de modelos?#

Usar o TensorRT para exportação de modelos oferece melhorias de desempenho significativas. Modelos YOLO26 exportados para 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 hardware NVIDIA.

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

Como ativo a quantização INT8 ao exportar o meu modelo YOLO26?#

A quantização INT8 é uma excelente forma de comprimir o modelo e acelerar a inferência, especialmente em dispositivos de edge. 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 obter ótimos resultados de quantização, fornece um conjunto de dados representativo utilizando o parâmetro data. Consulta Opções de Quantização para ver os valores aceites de quantize e os formatos suportados.

Por que é importante o tamanho de entrada dinâmico ao exportar modelos?#

O tamanho de entrada dinâmico permite que o modelo exportado lide com dimensões de imagem variáveis, 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 se consiga adaptar a diferentes formas de entrada sem problemas.

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

Quais são os principais argumentos de exportação a considerar para otimizar o desempenho do modelo?#

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, tensorflow).
• imgsz: O tamanho de imagem desejado para a entrada do modelo (por exemplo, 640 ou (height, width)).
• quantize: Precisão de quantização, tal como 8/"int8", 16/"fp16", 32/"fp32", ou os esquemas mistos de peso/ativação "w8a16" e "w8a32" (LiteRT INT8 dinâmico) em formatos suportados. Consulta Opções de Quantização.
• optimize: Ativa uma otimização de compilador superior para exportações DEEPX.

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

O que representam os tensores de saída nos modelos YOLO exportados?#

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), a exportação de ponta a ponta (end-to-end) está ativada por predefinição nos formatos que a suportam, pelo que a saída tem a forma de (batch_size, max_detections, 6) com valores [x1, y1, x2, y2, confidence, class_id]. Com o max_det=300 predefinido, isto é habitualmente (batch_size, 300, 6). Alguns formatos restritos recorrem automaticamente ao layout de saída tradicional quando os operadores de ponta a ponta não são suportados.

Para modelos de deteção sem ser de ponta a ponta, ou modelos YOLO26 exportados com end2end=False, a saída é tipicamente um único tensor com a forma de (batch_size, 4 + num_classes, num_predictions), onde os canais representam as coordenadas das caixas mais as pontuações por classe, e num_predictions depende da resolução de entrada da exportação (e pode ser dinâmico).

Para modelos de segmentação (por exemplo, yolo26n-seg.pt), normalmente obterás duas saídas: o primeiro tensor com a forma 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 a forma de (batch_size, mask_dim, proto_h, proto_w), contendo protótipos de máscara utilizados com os coeficientes para gerar máscaras de instâncias. 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 tipicamente a forma de (batch_size, 4 + num_classes + keypoint_dims, num_predictions), onde keypoint_dims depende da especificação da 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 da exportação (e pode ser dinâmico).

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

Existe uma API de inferência C++ oficial da Ultralytics?#

O Ultralytics não fornece atualmente uma API de inferência em C++ dedicada para modelos YOLO. Para implementaçõ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 artefacto exportado com a API C++ nativa desse tempo 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 o ONNX Runtime C++, ou exporta com format=engine e executa o motor TensorRT a partir de uma aplicação TensorRT em C++. Quando utilizas o pós-processamento personalizado em C++, faz corresponder o layout do tensor de saída para a tua tarefa e definições de exportação; as exportações de deteção de ponta a ponta do YOLO26 normalmente retornam (batch, max_det, 6), enquanto as exportações que não são de ponta a ponta retornam tensores de previsão em bruto que exigem pós-processamento externo.

Por que razão o output0 é FP32 ao exportar modelos quantizados com end2end=True?#

Ao exportar com quantize=16 (FP16) ou quantize=8 (INT8), a maioria dos tensores é convertida para uma precisão inferior para reduzir o tamanho do modelo e melhorar o desempenho. No entanto, quando o end2end=True 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 ponto flutuante. O FP16 não consegue representar de forma fiável valores inteiros acima de 2048 devido à sua precisão de mantissa limitada. Para evitar uma potencial perda de precisão ou IDs de classe incorretos, o output0 é mantido propositadamente em FP32.

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

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