TensorRT

TensorRT é o SDK da NVIDIA para inferência de aprendizado profundo de alto desempenho em GPUs NVIDIA. Ele recebe uma rede treinada, geralmente como um arquivo ONNX, e, durante a etapa de compilação, transforma a rede em um mecanismo, também chamado de arquivo de plano: um programa específico para GPU que combina camadas, opera com precisão reduzida e usa os kernels mais rápidos medidos na GPU de destino. Na etapa de execução, um aplicativo carrega o mecanismo e o executa, normalmente com menor latência de inferência e maior throughput do que a estrutura original. O TensorRT é fornecido como bibliotecas C++ e Python, além da ferramenta de linha de comando trtexec, e sua versão principal atual é o TensorRT 11, na versão 11.4 em outubro de 2026.

Como o TensorRT otimiza um modelo#

O construtor aplica várias otimizações ao grafo da rede:

• Fusão de camadas e tensores: Uma convolução, seu viés e sua ativação se tornam um único kernel, e as camadas cujas saídas nunca são usadas são removidas, mantendo os resultados intermediários no chip em vez de transferi-los repetidamente pela memória da GPU.
• Precisão reduzida: FP16 e BF16 reduzem pela metade o tráfego de memória em comparação com FP32; INT8 e FP8 reduzem esse tráfego novamente pela metade; e INT4 (somente para pesos) e FP4 vão além nas GPUs mais recentes, uma forma de quantização de modelos. O TensorRT 11 removeu as flags de compilação FP16 e INT8 e a calibração INT8 implícita do TensorRT 10, passando a exigir redes fortemente tipadas, nas quais nós de conversão e pares de quantização e desquantização declaram a precisão de cada camada. O Model Optimizer da NVIDIA pode inserir esses nós em um arquivo ONNX.
• Ajuste automático de kernels: Para cada camada, o construtor cronometra implementações candidatas, chamadas de táticas, na GPU real e mantém a mais rápida.
• Planejamento de memória: Os buffers de ativação são reutilizados entre camadas cujos períodos de vida não se sobrepõem, reduzindo a memória ocupada pelo mecanismo.
• Formas dinâmicas: Os perfis de otimização com formas mínima, ideal e máxima permitem que um único mecanismo aceite tamanhos de lote ou resoluções de imagem variáveis, com ajuste para a forma ideal.

A compilação de um mecanismo pode levar minutos, e o resultado é específico para o hardware. Por padrão, um mecanismo só é executado no tipo de GPU em que foi compilado e com a mesma versão do TensorRT; os mecanismos compatíveis com hardware e versões trocam parte da velocidade por portabilidade. Por isso, as implantações mantêm o arquivo ONNX e compilam os mecanismos nos locais onde serão executados:

Exportar um modelo para TensorRT#

Os modelos Ultralytics YOLO26 são exportados para TensorRT com model.export(format="engine"), que primeiro grava um arquivo ONNX e depois compila o mecanismo na GPU local, em FP16 com quantize=16 ou em INT8 com quantize=8, calibrado com imagens do conjunto de dados data. No TensorRT 11, a exportação aplica essas precisões por meio do Model Optimizer, conforme exigido pela API fortemente tipada:

from ultralytics import YOLO

# Criar um mecanismo TensorRT FP16 na GPU NVIDIA local (grava yolo26n.engine)
model = YOLO("yolo26n.pt")
model.export(format="engine", quantize=16)

# Carregar o mecanismo e executar a inferência pela mesma API
trt_model = YOLO("yolo26n.engine")
results = trt_model("https://ultralytics.com/images/bus.jpg")
results[0].save(filename="bus_tensorrt.jpg")

A imagem salva mostra as detecções produzidas pelo mecanismo FP16 na foto do ônibus, pela mesma interface YOLO usada pelo modelo PyTorch.

TensorRT vs. ferramentas relacionadas#

• ONNX: O formato de modelo portátil que o TensorRT consome com mais frequência. Um único arquivo ONNX pode ser compilado em mecanismos separados para uma GPU de data center e um módulo embarcado.
• ONNX Runtime com o provedor de execução TensorRT: Executa os subgrafos compatíveis com o TensorRT como mecanismos TensorRT e recorre a kernels CUDA ou de CPU para os demais, mantendo a API do ONNX Runtime.
• PyTorch: A estrutura em que a maioria dos modelos é treinada. O Torch-TensorRT compila modelos PyTorch diretamente com o TensorRT, sem uma etapa ONNX separada.
• Outros mecanismos de inferência: OpenVINO para hardware Intel, Core ML para dispositivos Apple e LiteRT para Android e dispositivos embarcados cumprem a mesma função em outros chips.
• TensorRT-LLM: Biblioteca de código aberto da NVIDIA para inferência de modelos de linguagem grandes, agora baseada em PyTorch, com kernels de atenção otimizados, quantização, decodificação especulativa e paralelismo em várias GPUs.

Aplicações no mundo real#

• Análise de vídeo: O DeepStream SDK da NVIDIA executa mecanismos TensorRT em pipelines com várias câmeras para análise de varejo, tráfego e segurança, nos quais vários fluxos compartilham uma GPU.
• Inspeção industrial: As câmeras em linhas de produção rápidas precisam de inferência em tempo real dentro do tempo em que cada peça fica à vista, algo viabilizado por mecanismos de precisão reduzida em GPUs compactas.
• Veículos autônomos: As redes de percepção de veículos autônomos são executadas como mecanismos TensorRT em plataformas NVIDIA DRIVE, como DRIVE AGX Orin e Thor.
• Robótica e dispositivos de borda: os módulos NVIDIA Jetson incluem TensorRT com o JetPack.