Exportação para TensorRT de modelos YOLO26#

A implantação de modelos de visão computacional em ambientes de alto desempenho pode exigir um formato que maximize a velocidade e a eficiência. Isso é especialmente importante ao implantar o modelo em GPUs NVIDIA.

Com o formato de exportação TensorRT, você pode otimizar seus modelos Ultralytics YOLO26 para realizar inferências com rapidez e eficiência em hardware NVIDIA. Este guia apresenta etapas fáceis de seguir para o processo de conversão e ajuda você a aproveitar ao máximo a tecnologia avançada da NVIDIA em seus projetos de aprendizado profundo.

TensorRT#

O TensorRT, desenvolvido pela NVIDIA, é um kit de desenvolvimento de software (SDK) avançado projetado para inferência de aprendizado profundo em alta velocidade. Ele é adequado para aplicações em tempo real, como detecção de objetos.

Esse kit de ferramentas otimiza modelos de aprendizado profundo para GPUs NVIDIA, resultando em operações mais rápidas e eficientes. Os modelos TensorRT passam por otimização do 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 kernels. Converter modelos de aprendizado profundo para o formato TensorRT permite que os desenvolvedores aproveitem plenamente o potencial das GPUs NVIDIA.

O TensorRT é conhecido pela compatibilidade com vários formatos de modelo, incluindo TensorFlow, PyTorch e ONNX, oferecendo aos desenvolvedores uma solução flexível para integrar e otimizar modelos de diferentes frameworks. Essa versatilidade permite a implantação de modelos com eficiência em diversos ambientes de hardware e software.

Principais recursos dos modelos TensorRT#

Os modelos TensorRT oferecem vários recursos importantes que contribuem para sua eficiência e eficácia na inferência de aprendizado profundo em alta velocidade:

• Calibração de precisão: O TensorRT é compatível com a calibração de precisão, permitindo ajustar os modelos para requisitos específicos de precisão. Isso inclui suporte a formatos de precisão reduzida, como INT8 e FP16, que podem aumentar ainda mais a velocidade de inferência mantendo níveis aceitáveis de precisão.

• Fusão de camadas: O processo de otimização do TensorRT inclui a fusão de camadas, na qual várias camadas de uma rede neural são combinadas em uma única operação. Isso reduz a sobrecarga computacional e melhora a velocidade de inferência ao minimizar o acesso à memória e os cálculos.

• Gerenciamento dinâmico de memória de tensores: O TensorRT gerencia com eficiência o uso da memória dos tensores durante a inferência, reduzindo a sobrecarga de memória e otimizando sua alocação. Isso resulta em um uso mais eficiente da memória da GPU.

• Ajuste automático de kernels: O TensorRT realiza o ajuste automático de kernels para selecionar o kernel de GPU mais otimizado para cada camada do modelo. Essa abordagem adaptativa garante que o modelo aproveite plenamente o poder computacional da GPU.

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

Antes de vermos o código para exportar modelos YOLO26 para o formato TensorRT, vamos entender onde os modelos TensorRT costumam ser usados.

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

• Implantação no TensorFlow: Esse método integra o TensorRT ao TensorFlow, permitindo que modelos otimizados sejam executados em um ambiente TensorFlow familiar. É útil para modelos com uma combinação de camadas compatíveis e incompatíveis, pois o TF-TRT pode processá-las com eficiência.

• API autônoma de ambiente de execução TensorRT: Oferece controle granular e é ideal para aplicações críticas em termos de desempenho. É mais complexa, mas permite a implementação personalizada de operadores incompatíveis.

• Servidor de inferência NVIDIA Triton: Uma opção compatível com modelos de vários frameworks. Especialmente adequado para inferência na nuvem ou na borda, oferece recursos como execução simultânea de modelos e análise de modelos.

Tarefas suportadas#

A exportação para TensorRT é compatível com todas as sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas no YOLO26, a única família que inclui essas cabeças.

Exportação de modelos YOLO26 para TensorRT#

Você pode aumentar 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, executa:

# Install the required package for YOLO26
pip install ultralytics

Para obter instruções detalhadas e práticas recomendadas sobre o processo de instalação, consulte nosso guia de instalação do YOLO26. Se encontrar dificuldades ao instalar os pacotes necessários para o YOLO26, consulte nosso guia de problemas comuns para encontrar soluções e dicas.

Uso#

Antes de consultares as instruções de utilização, não te esqueças de ver a variedade de modelos YOLO26 disponibilizados pelo Ultralytics. Isto vai ajudar-te a escolher o modelo mais adequado aos requisitos do teu projeto.

O formato TensorRT é compatível com os modos Export, Predict e Validate. A inferência e a validação exigem uma GPU NVIDIA. Exporte seu modelo e, em seguida, carregue o modelo exportado para executar inferências ou validar sua precisão.

from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporta o modelo para o formato TensorRT
model.export(format="engine")  # cria 'yolo26n.engine'

from ultralytics import YOLO

# Carregar o modelo TensorRT exportado
model = YOLO("yolo26n.engine")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carregar o modelo TensorRT exportado
model = YOLO("yolo26n.engine")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

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

Exportação para TensorRT com quantização INT8#

A exportação de modelos Ultralytics YOLO usando o TensorRT com precisão INT8 executa a quantização pós-treinamento (PTQ). O TensorRT usa calibração para PTQ, que mede a distribuição das ativações em cada tensor de ativação enquanto o modelo YOLO processa inferências com dados de entrada representativos; em seguida, usa essa distribuição para estimar os valores de escala de cada tensor. Cada tensor de ativação candidato à quantização tem uma escala associada, determinada por um processo de calibração. Um checkpoint ajustado com quantize=8 por meio do treinamento com reconhecimento de quantização já contém seus intervalos INT8; por isso, a exportação os utiliza e ignora a calibração.

Ao processar redes com quantização implícita, o TensorRT usa INT8 de forma oportunista para otimizar o tempo de execução das camadas. Se uma camada for executada mais rapidamente em INT8 e tiver escalas de quantização atribuídas às entradas e saídas de dados, será atribuído a ela um kernel com precisão INT8; caso contrário, o TensorRT selecionará a precisão FP32 ou FP16 para o kernel, conforme a opção que resultar em menor tempo de execução para essa camada.

Configuração da exportação INT8#

Os argumentos fornecidos ao usar export para um modelo Ultralytics YOLO influenciam muito o desempenho do modelo exportado. Eles também precisam ser escolhidos de acordo com os recursos disponíveis no dispositivo; no entanto, os argumentos padrão devem funcionar na maioria das GPUs NVIDIA discretas Ampere (ou mais recentes). O algoritmo de calibração usado é "MINMAX_CALIBRATION" para exportações em GPU, enquanto as exportações DLA em NVIDIA Jetson usam "ENTROPY_CALIBRATION_2". Você pode ler mais detalhes sobre as opções disponíveis no Guia do desenvolvedor do TensorRT. Os testes da Ultralytics mostraram que "MINMAX_CALIBRATION" é a melhor opção 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.

  • Ajuste o valor de workspace de acordo com suas necessidades de calibração e os recursos disponíveis. Embora um workspace maior possa aumentar o tempo de calibração, ele permite que o TensorRT explore uma gama mais ampla de estratégias de otimização, o que pode melhorar o desempenho e a precisão do modelo. Por outro lado, um workspace menor pode reduzir o tempo de calibração, mas limitar as estratégias de otimização, afetando a qualidade do modelo quantizado.

  • O padrão é workspace=None, que permite ao TensorRT alocar memória automaticamente. Ao configurar esse valor manualmente, talvez seja necessário aumentá-lo se a calibração falhar (for encerrada sem aviso).

  • Durante a exportação, o TensorRT informará UNSUPPORTED_STATE se o valor de workspace for maior que a memória disponível no dispositivo; nesse caso, o valor de workspace deve ser reduzido ou definido como None.

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

  • Lembre-se de que a calibração para INT8 é específica de cada dispositivo. Usar uma GPU de "alto desempenho" emprestada para a calibração pode resultar em desempenho ruim quando a inferência for executada em outro dispositivo.

• batch : O tamanho máximo do lote usado na inferência. Com dynamic=True, lotes menores podem ser usados durante a inferência, mas a inferência não aceitará lotes maiores que o valor especificado.

Com base em experimentos, a NVIDIA recomenda usar pelo menos 500 imagens de calibração representativas dos dados do seu modelo para a calibração da quantização INT8. Essa é uma orientação, não um requisito rígido, e você precisará experimentar para descobrir o que funciona melhor para o seu conjunto de dados. Como os dados de calibração são necessários para a calibração INT8 com o TensorRT, use o argumento data ao exportar para TensorRT com quantize=8 um checkpoint que não tenha sido treinado com quantize=8 (quantização pós-treinamento) e use data="my_dataset.yaml", que utilizará as imagens de validação para a calibração. Um checkpoint treinado com quantize=8 ignora a calibração; por isso, omita data nesse caso. Se nenhum valor for passado para data ao exportar para TensorRT com quantização INT8, será usado por padrão um dos conjuntos de dados de exemplo "pequenos", com base na tarefa do modelo, em vez de gerar 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)!
)

# Carregar o modelo TensorRT INT8 exportado
model = YOLO("yolo26n.engine", task="detect")

# Executar inferência
result = model.predict("https://ultralytics.com/images/bus.jpg")

Vantagens de usar YOLO com TensorRT INT8#

• Tamanho reduzido do modelo: A quantização de FP32 para INT8 pode reduzir o tamanho do modelo em 4x (no disco ou na memória), resultando em downloads mais rápidos, menos espaço de armazenamento necessário e menor uso de memória ao implantar um modelo.

• Menor consumo de energia: As operações de precisão reduzida dos modelos YOLO exportados em INT8 podem consumir menos energia do que os modelos FP32, especialmente em dispositivos alimentados por bateria.

• Maior velocidade de inferência: O TensorRT otimiza o modelo para o hardware de destino, o que pode resultar em inferências mais rápidas em GPUs, dispositivos incorporados e aceleradores.

Desvantagens de usar YOLO com TensorRT INT8#

• Redução das métricas de avaliação: O uso de menor precisão significa que mAP, Precision, Recall ou qualquer outra métrica usada para avaliar o desempenho do modelo provavelmente terá resultados um pouco piores. As camadas Sigmoid são mantidas em maior precisão para preservar a calibração das pontuações, mas o INT8 ainda pode alterar os valores de confiança. Por isso, selecione o limiar operacional com base na própria curva F1 do modelo INT8. Consulte a seção de resultados de desempenho para comparar as diferenças em mAP50 e mAP50-95 ao exportar com INT8 em uma pequena amostra de vários dispositivos.

• Aumento do tempo de desenvolvimento: Encontrar as configurações "ideais" para a calibração INT8 de um conjunto de dados e dispositivo pode exigir muitos testes.

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

Desempenho da exportação de Ultralytics YOLO para TensorRT#

NVIDIA A100#

GPUs para consumidores#

Dispositivos incorporados#

Métodos de avaliação#

Expanda as seções abaixo para saber 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 com calibração `data` (ou seja, COCO, ImageNet ou DOTAv1 para a tarefa apropriada do modelo)
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 da mesma imagem
        verbose=False,
        device="cuda",
    )

from ultralytics import YOLO

model = YOLO("yolo26n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet ou DOTAv1 para a tarefa apropriada do modelo
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Implantação de modelos YOLO26 exportados para TensorRT#

Depois de exportar com sucesso seus modelos Ultralytics YOLO26 para o formato TensorRT, você já pode implantá-los. Para instruções detalhadas sobre a implantação dos modelos TensorRT em diferentes ambientes, consulte os seguintes recursos:

• Implantar Ultralytics com um servidor Triton: nosso guia sobre como usar o servidor Triton Inference da NVIDIA (anteriormente TensorRT Inference), especificamente com modelos Ultralytics YOLO.

• Implantação de redes neurais profundas com NVIDIA TensorRT: este artigo explica como usar o NVIDIA TensorRT para implantar redes neurais profundas com eficiência 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 do blog explica como usar o NVIDIA TensorRT para otimizar e implantar modelos de IA em PCs baseados em NVIDIA.

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

Resumo#

Neste guia, mostramos como converter modelos Ultralytics YOLO26 para o formato de modelo TensorRT da NVIDIA. Essa etapa de conversão é essencial para aumentar a eficiência e a velocidade dos modelos YOLO26, tornando-os mais eficazes e adequados a diversos ambientes de implantação.

Para obter mais informações sobre como usar o TensorRT, consulte a documentação oficial do TensorRT.

Se quiser conhecer outras integrações do Ultralytics YOLO26, nossa página do guia de integrações oferece uma ampla seleção de recursos informativos e análises.

Perguntas frequentes#