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 seu modelo treinado para diferentes formatos, tornando-o implantável em várias plataformas e dispositivos. Este guia abrangente visa orientá-lo pelas nuances da exportação de modelos, mostrando como alcançar máxima compatibilidade e desempenho.
Watch: How to Export Ultralytics YOLO26 in different formats for Deployment | ONNX, TensorRT, CoreML 🚀
Por que escolher o modo de exportação do YOLO26?
- Versatilidade: Exporte para vários formatos, incluindo ONNX, TensorRT, CoreML e outros.
- Desempenho: Obtenha até 5x de aceleração na GPU com TensorRT e 3x de aceleração na CPU com ONNX ou OpenVINO.
- Compatibilidade: Torne seu 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 recursos 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: Exporte 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 tranquila.
Exemplos de Uso
Exporte um modelo YOLO26n para um formato diferente, como ONNX ou TensorRT. Consulte a seçã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. Essas configurações são essenciais 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.
| Argumento | Tipo | Predefinição | Descrição |
|---|---|---|---|
format | str | 'torchscript' | Formato de destino para o modelo exportado, como 'onnx', 'torchscript', 'engine' (TensorRT), ou outros. Cada formato permite compatibilidade com diferentes ambientes de implementação. |
imgsz | int ou tuple | 640 | Tamanho de imagem desejado para a entrada do modelo. Pode ser um número inteiro para imagens quadradas (por exemplo, 640 para 640×640) ou um tuplo (height, width) para dimensões específicas. |
keras | bool | False | Ativa a exportação para o formato Keras para TensorFlow SavedModel, proporcionando compatibilidade com APIs e o serviço do TensorFlow. |
optimize | bool | False | Aplica otimização para dispositivos móveis ao exportar para TorchScript, reduzindo potencialmente o tamanho do modelo e melhorando o desempenho da inferência. Não compatível com o formato NCNN ou dispositivos CUDA. Para DeepX, ativa uma otimização de compilador superior que reduz a latência de inferência e aumenta o tempo de compilação. |
half | bool | False | Ativa a quantização FP16 (precisão média), reduzindo o tamanho do modelo e acelerando potencialmente a inferência em hardware suportado. Não compatível com quantização INT8 ou exportações apenas para CPU. Disponível apenas para certos formatos, p.ex. ONNX (ver abaixo). |
int8 | bool | False | Ativa a quantização INT8, comprimindo ainda mais o modelo e acelerando a inferência com perda mínima de precisão, principalmente para dispositivos de ponta (edge devices). Quando usado com TensorRT, realiza quantização pós-treino (PTQ). |
dynamic | bool | False | Permite tamanhos de entrada dinâmicos para exportações TorchScript, ONNX, OpenVINO, TensorRT e CoreML, aumentando a flexibilidade no manuseamento de dimensões de imagem variáveis. Definido automaticamente como True ao usar TensorRT com INT8. |
simplify | bool | True | Simplifica o grafo do modelo para exportações ONNX com onnxslim, melhorando potencialmente o desempenho e a compatibilidade com motores de inferência. |
opset | int | None | Especifica a versão do opset ONNX para compatibilidade com diferentes analisadores e runtimes ONNX. Se não estiver definido, usa a última versão suportada. |
workspace | float ou None | None | Define o tamanho máximo do espaço de trabalho em GiB para otimizações do TensorRT, equilibrando o uso de memória e o desempenho. Use None para a autoalocação pelo TensorRT até o máximo do dispositivo. |
nms | bool | False | Adiciona Non-Maximum Suppression (NMS) ao modelo exportado quando suportado (veja Formatos de Exportação), melhorando a eficiência do pós-processamento de detecção. Não disponível para modelos end2end. |
batch | int | 1 | Especifica o tamanho da inferência em lote do modelo de exportação ou o número máximo de imagens que o modelo exportado processará simultaneamente no modo predict. Para exportações de Edge TPU, isso é definido automaticamente como 1. |
device | str | None | Especifica o dispositivo para exportação: GPU (device=0), CPU (device=cpu), MPS para Apple silicon (device=mps), Huawei Ascend NPU (device=npu ou device=npu:0), ou DLA para NVIDIA Jetson (device=dla:0 ou device=dla:1). Exportações de TensorRT usam GPU automaticamente. |
data | str | 'coco8.yaml' | Caminho para o arquivo de configuração do dataset, essencial para calibração de quantização INT8. Se não for especificado com INT8 ativado, coco8.yaml será usado como fallback para calibração. |
fraction | float | 1.0 | Especifica a fração do dataset a ser usada para calibração de quantização INT8. Permite calibrar em um subconjunto do dataset completo, útil para experimentos ou quando os recursos são limitados. Se não for especificado com INT8 ativado, o dataset completo será usado. |
end2end | bool | None | Substitui o modo end-to-end em modelos YOLO que suportam inferência sem NMS (YOLO26, YOLOv10). Definir como False permite exportar esses modelos para serem compatíveis com o pipeline tradicional de pós-processamento baseado em NMS. Veja o guia de Detecção End-to-End para detalhes. |
O ajuste desses parâmetros permite a personalização do processo de exportação para atender a requisitos específicos, como ambiente de implantação, restrições de hardware e metas de desempenho. Selecionar o formato e as configurações apropriados é fundamental para alcançar o melhor equilíbrio entre tamanho, velocidade e precisão do modelo.
Formatos de exportação
Os formatos de exportação do YOLO26 disponíveis estão na tabela abaixo. Você pode exportar para qualquer formato usando o argumento format, por exemplo, format='onnx' ou format='engine'. Você pode prever ou validar diretamente nos modelos exportados, por exemplo, yolo predict model=yolo26n.onnx. Exemplos de uso são mostrados para seu modelo após a conclusão da exportação. Os modelos também podem ser exportados diretamente do navegador na Plataforma Ultralytics sem qualquer configuração local.
| Formato | Argumento format | Modelo | Metadados | Argumentos |
|---|---|---|---|---|
| PyTorch | - | yolo26n.pt | ✅ | - |
| TorchScript | torchscript | yolo26n.torchscript | ✅ | imgsz, half, dynamic, optimize, nms, batch, device |
| ONNX | onnx | yolo26n.onnx | ✅ | imgsz, half, dynamic, simplify, opset, nms, batch, device |
| OpenVINO | openvino | yolo26n_openvino_model/ | ✅ | imgsz, half, dynamic, int8, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n.engine | ✅ | imgsz, half, dynamic, simplify, workspace, int8, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n.mlpackage | ✅ | imgsz, dynamic, half, int8, nms, batch, device |
| TF SavedModel | saved_model | yolo26n_saved_model/ | ✅ | imgsz, keras, int8, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n.pb | ❌ | imgsz, batch, device |
| TF Lite | tflite | yolo26n.tflite | ✅ | imgsz, half, int8, nms, batch, data, fraction, device |
| TF Edge TPU | edgetpu | yolo26n_edgetpu.tflite | ✅ | imgsz, int8, data, fraction, device |
| TF.js | tfjs | yolo26n_web_model/ | ✅ | imgsz, half, int8, nms, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n.mnn | ✅ | imgsz, batch, int8, half, device |
| NCNN | ncnn | yolo26n_ncnn_model/ | ✅ | imgsz, half, batch, device |
| IMX500 | imx | yolo26n_imx_model/ | ✅ | imgsz, int8, data, fraction, nms, device |
| RKNN | rknn | yolo26n_rknn_model/ | ✅ | imgsz, batch, name, device |
| ExecuTorch | executorch | yolo26n_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n_axelera_model/ | ✅ | imgsz, batch, int8, data, fraction, device |
| DeepX | deepx | yolo26n_deepx_model/ | ✅ | imgsz, int8, data, optimize, device |
FAQ
Como exporto um modelo YOLO26 para o formato ONNX?
Exportar um modelo YOLO26 para o formato ONNX é simples com 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 obter mais detalhes sobre o processo, incluindo opções avançadas como o manuseio de diferentes tamanhos de entrada, consulte o guia de integração ONNX.
Quais são os benefícios de usar TensorRT para exportação de modelos?
Usar TensorRT para exportação de modelos oferece melhorias significativas de desempenho. Modelos YOLO26 exportados para TensorRT podem atingir até 5x de aceleração na GPU, tornando-o ideal para aplicações de inferência em tempo real.
- Versatilidade: Otimize modelos para uma configuração de hardware específica.
- Velocidade: Obtenha uma inferência mais rápida por meio de otimizações avançadas.
- Compatibilidade: Integre-se facilmente ao hardware NVIDIA.
Para saber mais sobre como integrar o TensorRT, consulte o guia de integração TensorRT.
Como habilito a quantização INT8 ao exportar meu modelo YOLO26?
A quantização INT8 é uma excelente maneira de comprimir o modelo e acelerar a inferência, especialmente em dispositivos de borda. Veja como você pode habilitar a quantização INT8:
from ultralytics import YOLO
model = YOLO("yolo26n.pt") # Load a model
model.export(format="engine", int8=True)A quantização INT8 pode ser aplicada a vários formatos, como TensorRT, OpenVINO e CoreML. Para obter resultados de quantização ideais, forneça um dataset representativo usando o parâmetro data.
Por que o tamanho de entrada dinâmico é importante 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 do processamento para diferentes casos de uso. Ao exportar para formatos como ONNX ou TensorRT, habilitar o tamanho de entrada dinâmico garante que o modelo possa se adaptar a diferentes formas de entrada perfeitamente.
Para habilitar esse recurso, use 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.
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:Desired image size for the model input (e.g.,640or(height, width)).half:Habilita a quantização FP16, reduzindo o tamanho do modelo e potencialmente acelerando a inferência.optimize:Aplica otimizações específicas para dispositivos móveis ou ambientes restritos.int8:Habilita a quantização INT8, altamente benéfica para implantações de IA de borda.
Para implantação em plataformas de hardware específicas, considere usar formatos de exportação especializados, como TensorRT para GPUs NVIDIA, CoreML para dispositivos Apple ou Edge TPU para dispositivos Google Coral.
O que os tensores de saída representam nos modelos YOLO exportados?
Ao exportar um modelo YOLO para formatos como ONNX ou TensorRT, a estrutura do tensor de saída depende da tarefa do modelo. Entender essas saídas é importante para implementações de inferência personalizadas.
Para modelos de detecção (por exemplo, yolo26n.pt), a saída é normalmente um único tensor formatado como (batch_size, 4 + num_classes, num_predictions) onde os canais representam coordenadas da caixa delimitadora mais 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), você normalmente obterá duas saídas: o primeiro tensor formatado como (batch_size, 4 + num_classes + mask_dim, num_predictions) (caixas, pontuações de classe e coeficientes de máscara), e o segundo tensor formatado como (batch_size, mask_dim, proto_h, proto_w) contendo 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 é normalmente formatado como (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 essas saídas para cada tipo de modelo.
Por que output0 é FP32 ao exportar com half=True e end2end=True?
Ao exportar com half=True (ou int8=True), a maioria dos tensores é convertida para precisão menor para reduzir o tamanho do modelo e melhorar o desempenho. No entanto, quando end2end=True é 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 internamente representados como valores de ponto flutuante. FP16 não pode representar valores inteiros acima de 2048 de forma confiável devido à sua precisão de mantissa limitada. Para evitar perda potencial de precisão ou IDs de classe incorretos, output0 é mantido intencionalmente em FP32.
Este comportamento é esperado e também se aplica a exportações de precisão menor ou quantizadas onde a fidelidade do índice de classe deve ser preservada.
Se forem necessárias saídas FP16 completas, exporte com end2end=False e realize o pós-processamento externamente.