Exportação TensorRT para Modelos YOLO26#

A implantação de modelos de computer vision em ambientes de alto desempenho pode exigir um formato que maximize a velocidade e a eficiência. Isso é especialmente verdade quando estás a implantar o teu modelo em GPUs NVIDIA.

Ao usares o formato de exportação TensorRT, podes otimizar os teus modelos Ultralytics YOLO26 para uma inferência rápida e eficiente em hardware NVIDIA. Este guia fornece passos fáceis de seguir para o processo de conversão e ajuda-te a tirar o máximo partido da tecnologia avançada da NVIDIA nos teus projetos de deep learning.

TensorRT#

TensorRT, desenvolvido pela NVIDIA, é um kit de desenvolvimento de software (SDK) avançado concebido para inferência de deep learning de alta velocidade. É ideal para aplicações em tempo real, como object detection.

Este kit de ferramentas otimiza modelos de deep learning para GPUs NVIDIA e resulta em operações mais rápidas e eficientes. Os modelos TensorRT passam por otimização TensorRT, que inclui técnicas como fusão de camadas, calibração de precisão (INT8 e FP16), gerenciamento dinâmico de memória de tensores e ajuste automático de kernel. Converter modelos de deep learning para o formato TensorRT permite que os desenvolvedores realizem plenamente o potencial das GPUs NVIDIA.

O TensorRT é conhecido pela sua compatibilidade com vários formatos de modelos, incluindo TensorFlow, PyTorch e ONNX, oferecendo aos programadores uma solução flexível para integrar e otimizar modelos de diferentes frameworks. Esta versatilidade permite uma model deployment eficiente em diversos ambientes de hardware e software.

Principais Recursos dos Modelos TensorRT#

Os modelos TensorRT oferecem uma gama de recursos importantes que contribuem para sua eficiência e eficácia na inferência de deep learning de alta velocidade:

• Calibração de Precisão: O TensorRT oferece suporte à calibração de precisão, permitindo que os modelos sejam ajustados para requisitos de precisão específicos. Isso inclui suporte para formatos de precisão reduzida como INT8 e FP16, o que pode aumentar ainda mais a velocidade de inferência enquanto mantém níveis de precisão aceitáveis.

• Layer Fusion: O processo de otimização do TensorRT inclui a fusão de camadas, onde múltiplas camadas de uma neural network são combinadas numa única operação. Isto reduz a sobrecarga computacional e melhora a velocidade de inferência ao minimizar o acesso à memória e a computação.

• Gerenciamento Dinâmico de Memória de Tensores: O TensorRT gerencia de forma eficiente o uso de memória de tensores durante a inferência, reduzindo a sobrecarga de memória e otimizando a alocação. Isso resulta em uma utilização mais eficiente da memória da GPU.

• Ajuste Automático de Kernel: O TensorRT aplica ajuste automático de kernel para selecionar o kernel de GPU mais otimizado para cada camada do modelo. Essa abordagem adaptativa garante que o modelo aproveite ao máximo o poder computacional da GPU.

Opções de Implantação no TensorRT#

Antes de analisarmos o código para exportar modelos YOLO26 para o formato TensorRT, vamos entender onde os modelos TensorRT são normalmente usados.

O TensorRT oferece várias opções de implantação, e cada uma equilibra facilidade de integração, otimização de desempenho e flexibilidade de maneiras diferentes:

• Implantação no TensorFlow: Este método integra o TensorRT no TensorFlow, permitindo que modelos otimizados sejam executados num ambiente TensorFlow familiar. É útil para modelos com uma mistura de camadas suportadas e não suportadas, uma vez que o TF-TRT consegue geri-las de forma eficiente.

• API de Runtime do TensorRT Independente: Oferece controle granular, ideal para aplicações onde o desempenho é crítico. É mais complexo, mas permite a implementação personalizada de operadores não suportados.

• NVIDIA Triton Inference Server: Uma opção que suporta modelos de vários frameworks. Particularmente adequado para inferência em nuvem ou edge, fornece recursos como execução de modelo concorrente e análise de modelo.

Tarefas Suportadas#

A exportação para TensorRT suporta todas as sete tarefas do Ultralytics. Segmentação semântica e estimativa de profundidade estão disponíveis apenas com o YOLO26, a única família que possui essas camadas.

Exportando Modelos YOLO26 para TensorRT#

Você pode melhorar a eficiência da execução e otimizar o desempenho convertendo modelos YOLO26 para o formato TensorRT.

Instalação#

Para instalar o pacote necessário, execute:

# Install the required package for YOLO26
pip install ultralytics

Para instruções detalhadas e melhores práticas relacionadas com o processo de instalação, consulta o nosso YOLO26 Installation guide. Ao instalar os pacotes necessários para o YOLO26, se encontrares alguma dificuldade, consulta o nosso Common Issues guide para obter soluções e dicas.

Uso#

Antes de mergulhares nas instruções de uso, certifica-te de explorar a gama de YOLO26 models offered by Ultralytics. Isto ajudar-te-á a escolher o modelo mais adequado para os requisitos do teu projeto.

O formato TensorRT suporta os modos Export, Predict e Validate. A inferência e a validação requerem uma GPU NVIDIA. Exporta o teu modelo e, em seguida, carrega o modelo exportado para executar a inferência ou validar a sua precisão.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo26n.engine'

from ultralytics import YOLO

# Load the exported TensorRT model
model = YOLO("yolo26n.engine")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported TensorRT model
model = YOLO("yolo26n.engine")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argumentos de Exportação#

Para mais detalhes sobre o processo de exportação, visita a página de documentação do Ultralytics sobre exportação.

Exportando TensorRT com Quantização INT8#

A exportação de modelos Ultralytics YOLO utilizando TensorRT com precision INT8 executa a quantização pós-treino (PTQ). O TensorRT utiliza calibração para PTQ, que mede a distribuição de ativações dentro de cada tensor de ativação à medida que o modelo YOLO processa a inferência em dados de entrada representativos, e depois usa essa distribuição para estimar os valores de escala para cada tensor. Cada tensor de ativação que é candidato a quantização tem uma escala associada que é deduzida por um processo de calibração.

Ao processar redes quantizadas implicitamente, o TensorRT usa INT8 de forma oportunista para otimizar o tempo de execução da camada. Se uma camada é executada mais rápido em INT8 e possui escalas de quantização atribuídas em suas entradas e saídas de dados, então um kernel com precisão INT8 é atribuído a essa camada; caso contrário, o TensorRT seleciona uma precisão FP32 ou FP16 para o kernel, com base no que resultar em um tempo de execução mais rápido para aquela camada.

Configurando a Exportação INT8#

Os argumentos fornecidos ao usar export para um modelo Ultralytics YOLO vão influenciar grandemente o desempenho do modelo exportado. Também precisarão de ser selecionados com base nos recursos do dispositivo disponíveis; no entanto, os argumentos predefinidos devem funcionar para a maioria das Ampere (ou mais recentes) GPUs dedicadas da NVIDIA. O algoritmo de calibração utilizado é "MINMAX_CALIBRATION" para exportações em GPU, enquanto as exportações em DLA na NVIDIA Jetson usam "ENTROPY_CALIBRATION_2". Podes ler mais detalhes sobre as opções disponíveis no Guia de Desenvolvimento do TensorRT. Os testes da Ultralytics descobriram que "MINMAX_CALIBRATION" é a melhor escolha para exportações em GPU, e o algoritmo é selecionado automaticamente com base no dispositivo de exportação.

• workspace : Controla o tamanho (em GiB) da alocação de memória do dispositivo durante a conversão dos pesos do modelo.

  • Ajusta o valor de workspace de acordo com as tuas necessidades de calibração e a disponibilidade de recursos. Embora um workspace maior possa aumentar o tempo de calibração, permite que o TensorRT explore uma gama mais ampla de táticas de otimização, melhorando potencialmente o desempenho e a accuracy do modelo. Inversamente, um workspace menor pode reduzir o tempo de calibração, mas pode limitar as estratégias de otimização, afetando a qualidade do modelo quantizado.

  • O valor predefinido é workspace=None, que permitirá ao TensorRT alocar memória automaticamente; ao configurar manualmente, este valor poderá ter de ser aumentado se a calibração falhar (terminar sem aviso).

  • O TensorRT reportará UNSUPPORTED_STATE durante a exportação se o valor para workspace for maior do que a memória disponível para o dispositivo, o que significa que o valor para workspace deve ser reduzido ou definido como None.

  • Se workspace estiver definido para o valor máximo e a calibração falhar/terminar inesperadamente, considera usar None para alocação automática ou reduzir os valores para imgsz e batch para diminuir os requisitos de memória.

  • Lembre-se: a calibração para INT8 é específica para cada dispositivo; pegar emprestada uma GPU "high-end" para calibração pode resultar em baixo desempenho quando a inferência for executada em outro dispositivo.

• batch : O tamanho máximo do lote (batch-size) que será usado para inferência. Durante a inferência, podem ser usados lotes menores, mas a inferência não aceitará lotes maiores do que o especificado.

A experimentação por parte da NVIDIA levou-os a recomendar a utilização de pelo menos 500 imagens de calibração que sejam representativas dos dados para o teu modelo, com a calibração de quantização INT8. Esta é uma diretriz e não um requisito rígido, e vais precisar de experimentar o que é necessário para ter um bom desempenho com o teu conjunto de dados. Uma vez que os dados de calibração são necessários para a calibração INT8 com o TensorRT, certifica-te de usar o argumento data quando quantize=8 para o TensorRT e usa data="my_dataset.yaml", que utilizará as imagens de validation para calibrar. Quando nenhum valor é passado para data na exportação para o TensorRT com quantização INT8, a predefinição será usar um dos conjuntos de dados de exemplo "pequenos" com base na tarefa do modelo em vez de lançar um erro.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(
    format="engine",
    dynamic=True,  # (1)!
    batch=8,  # (2)!
    workspace=4,  # (3)!
    quantize=8,
    data="coco.yaml",  # (4)!
)

# Load the exported TensorRT INT8 model
model = YOLO("yolo26n.engine", task="detect")

# Run inference
result = model.predict("https://ultralytics.com/images/bus.jpg")

Vantagens de usar YOLO com TensorRT INT8#

• Tamanho de modelo reduzido: A quantização de FP32 para INT8 pode reduzir o tamanho do modelo em 4x (em disco ou na memória), levando a tempos de download mais rápidos, menores requisitos de armazenamento e menor pegada de memória ao implantar um modelo.

• Menor consumo de energia: Operações de precisão reduzida para modelos YOLO exportados em INT8 podem consumir menos energia em comparação com modelos FP32, especialmente para dispositivos alimentados por bateria.

• Velocidades de inferência aprimoradas: O TensorRT otimiza o modelo para o hardware alvo, levando potencialmente a velocidades de inferência mais rápidas em GPUs, dispositivos embarcados e aceleradores.

Desvantagens de usar YOLO com TensorRT INT8#

• Diminuições nas métricas de avaliação: Usar uma precisão inferior significa que mAP, Precision, Recall ou qualquer outra métrica usada para avaliar o desempenho do modelo será provavelmente um pouco pior. As camadas sigmóides são mantidas a uma maior precisão para preservar a calibração de pontuação, mas o INT8 ainda pode alterar os valores de confiança, por isso seleciona o limiar de operação a partir da curva F1 do próprio modelo INT8. Consulta a seção de resultados de desempenho para comparar as diferenças em mAP50 e mAP50-95 ao exportar com INT8 numa pequena amostra de vários dispositivos.

• Aumento nos tempos de desenvolvimento: Encontrar as configurações "ideais" para calibração INT8 para o conjunto de dados e dispositivo pode exigir uma quantidade significativa de testes.

• Dependência de hardware: A calibração e os ganhos de desempenho podem ser altamente dependentes do hardware, e os pesos do modelo são menos transferíveis.

Desempenho da Exportação TensorRT do Ultralytics YOLO#

NVIDIA A100#

GPUs de Consumo#

Dispositivos Embarcados#

Métodos de avaliação#

Expanda as seções abaixo para informações sobre como esses modelos foram exportados e testados.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# TensorRT FP32
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2)

# TensorRT FP16
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, quantize=16)

# TensorRT INT8 with calibration `data` (i.e. COCO, ImageNet, or DOTAv1 for appropriate model task)
out = model.export(
    format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, quantize=8, data="coco8.yaml"
)

import cv2

from ultralytics import YOLO

model = YOLO("yolo26n.engine")
img = cv2.imread("path/to/image.jpg")

for _ in range(100):
    result = model.predict(
        [img] * 8,  # batch=8 of the same image
        verbose=False,
        device="cuda",
    )

from ultralytics import YOLO

model = YOLO("yolo26n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet, or DOTAv1 for appropriate model task
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Implantando modelos YOLO26 TensorRT exportados#

Após exportar com sucesso seus modelos Ultralytics YOLO26 para o formato TensorRT, você está pronto para implantá-los. Para instruções detalhadas sobre a implantação de seus modelos TensorRT em vários cenários, dê uma olhada nos seguintes recursos:

• Implantar o Ultralytics com um Servidor Triton: O nosso guia sobre como utilizar o Servidor Triton Inference da NVIDIA (antigo TensorRT Inference) especificamente para modelos Ultralytics YOLO.

• Implantação de Redes Neuronais Profundas com NVIDIA TensorRT: Este artigo explica como utilizar o NVIDIA TensorRT para implantar redes neuronais profundas de forma eficiente em plataformas de implantação baseadas em GPU.

• IA de Ponta a Ponta para PCs Baseados em NVIDIA: Implantação com NVIDIA TensorRT: Esta publicação no blog explica a utilização do NVIDIA TensorRT para otimizar e implantar modelos de IA em PCs baseados em NVIDIA.

• Repositório GitHub para o NVIDIA TensorRT:: Este é o repositório oficial do GitHub que contém o código-fonte e a documentação para o NVIDIA TensorRT.

Resumo#

Neste guia, focamos na conversão de modelos Ultralytics YOLO26 para o formato de modelo TensorRT da NVIDIA. Esta etapa de conversão é crucial para melhorar a eficiência e a velocidade dos modelos YOLO26, tornando-os mais eficazes e adequados para diversos ambientes de implantação.

Para mais informações sobre detalhes de utilização, consulta a documentação oficial do TensorRT.

Se tens curiosidade sobre outras integrações do Ultralytics YOLO26, a nossa página do guia de integração disponibiliza uma seleção abrangente de recursos e informações úteis.

FAQ#