Exportação para TensorRT de modelos YOLO26

Implantar modelos de visão computacional em ambientes de alto desempenho pode exigir um formato que maximize a velocidade e a eficiência. Isso é especialmente verdadeiro quando você está implantando seu modelo em GPUs da NVIDIA.

Ao usar o formato de exportação TensorRT, você pode aprimorar seus modelos Ultralytics YOLO26 para uma inferência rápida e eficiente em hardware NVIDIA. Este guia lhe dará passos fáceis de seguir para o processo de conversão e ajudará você a aproveitar ao máximo a tecnologia avançada da NVIDIA em seus projetos de deep learning.

TensorRT

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

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 uma 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 tensor e ajuste automático de kernels. Converter modelos de deep learning para o formato TensorRT permite que os desenvolvedores realizem plenamente o potencial das GPUs NVIDIA.

O TensorRT é conhecido por sua compatibilidade com vários formatos de modelo, incluindo TensorFlow, PyTorch e ONNX, fornecendo aos desenvolvedores uma solução flexível para integrar e otimizar modelos de diferentes estruturas. Essa versatilidade permite uma implantação de modelo 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, que podem aumentar ainda mais a velocidade de inferência, mantendo níveis de precisão aceitáveis.

• Fusão de camadas: O processo de otimização TensorRT inclui fusão de camadas, onde 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, minimizando o acesso à memória e a computação.

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

• Ajuste automático de kernel: O TensorRT aplica o 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 tire proveito total do 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 opção equilibra facilidade de integração, otimização de desempenho e flexibilidade de forma diferente:

• Implantação dentro do TensorFlow: Este 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 suportadas e não suportadas, pois o TF-TRT pode lidar com elas de forma eficiente.

• API de tempo de execução TensorRT independente: Oferece controle granular, ideal para aplicações onde o desempenho é crítico. É mais complexa, 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 na nuvem ou na borda (edge), fornece recursos como execução simultânea de modelos e análise de modelos.

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 práticas recomendadas relacionadas ao processo de instalação, consulte nosso guia de Instalação YOLO26. Ao instalar os pacotes necessários para o YOLO26, se você encontrar alguma dificuldade, consulte nosso guia de Problemas Comuns para soluções e dicas.

Utilização

Antes de mergulhar nas instruções de uso, não deixe de conferir a variedade de modelos YOLO26 oferecidos pela Ultralytics. Isso ajudará você a escolher o modelo mais apropriado para os requisitos do seu projeto.

from ultralytics import YOLO

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

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

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

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

Argumentos de Exportação

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

Exportando TensorRT com quantização INT8

A exportação de modelos Ultralytics YOLO usando 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 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 então usa essa distribuição para estimar os valores de escala para cada tensor. Cada tensor de ativação que é um candidato para 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 for executada mais rapidamente em INT8 e tiver escalas de quantização atribuídas em suas entradas e saídas de dados, um kernel com precisão INT8 será atribuído a essa camada; caso contrário, o TensorRT seleciona uma precisão de 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 influenciarão grandemente o desempenho do modelo exportado. Eles também precisarão ser selecionados com base nos recursos do dispositivo disponíveis; no entanto, os argumentos padrão devem funcionar para a maioria das GPUs discretas NVIDIA Ampere (ou mais recentes). O algoritmo de calibração usado é "MINMAX_CALIBRATION" e você pode ler mais detalhes sobre as opções disponíveis no Guia do Desenvolvedor TensorRT. Os testes da Ultralytics descobriram que "MINMAX_CALIBRATION" era a melhor escolha e as exportações são fixadas para usar este algoritmo.

• workspace : Controla o tamanho (em GiB) da alocação de memória do dispositivo enquanto converte os pesos do modelo.

  • Ajuste o valor de workspace de acordo com suas necessidades de calibração e disponibilidade de recursos. Embora um workspace maior possa aumentar o tempo de calibração, ele permite que o TensorRT explore uma gama mais ampla de táticas de otimização, potencialmente aprimorando o desempenho e a precisão do modelo. Por outro lado, 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 padrão é workspace=None, o que permitirá ao TensorRT alocar memória automaticamente; ao configurar manualmente, esse valor pode precisar ser aumentado se a calibração travar (sair sem aviso).

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

  • Se workspace estiver definido no valor máximo e a calibração falhar/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 para cada dispositivo; emprestar uma GPU "high-end" para calibração pode resultar em desempenho ruim 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, lotes menores podem ser usados, mas a inferência não aceitará lotes maiores do que o especificado.

Experimentation by NVIDIA led them to recommend using at least 500 calibration images that are representative of the data for your model, with INT8 quantization calibration. This is a guideline and not a hard requirement, and you will need to experiment with what is required to perform well for your dataset. Since the calibration data is required for INT8 calibration with TensorRT, make certain to use the data argument when int8=True for TensorRT and use data="my_dataset.yaml", which will use the images from validation to calibrate with. When no value is passed for data with export to TensorRT with INT8 quantization, the default will be to use one of the "small" example datasets based on the model task instead of throwing an error.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(
    format="engine",
    dynamic=True,  # (1)!
    batch=8,  # (2)!
    workspace=4,  # (3)!
    int8=True,
    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 (no disco ou na memória), levando a tempos de download mais rápidos, menores requisitos de armazenamento e menor consumo 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 de destino, potencialmente levando a velocidades de inferência mais rápidas em GPUs, dispositivos embarcados e aceleradores.

Desvantagens de usar YOLO com TensorRT INT8

• Decreases in evaluation metrics: Using a lower precision will mean that mAP, Precision, Recall or any other metric used to evaluate model performance is likely to be somewhat worse. See the Performance results section to compare the differences in mAP50 and mAP50-95 when exporting with INT8 on small sample of various devices.

• Tempos de desenvolvimento aumentados: Encontrar as configurações "ideais" para calibração INT8 para o conjunto de dados e o dispositivo pode levar um tempo significativo de teste.

• 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 Ultralytics YOLO TensorRT

NVIDIA A100

GPUs de Consumo

Dispositivos Embebidos

Métodos de avaliação

Expande as secções abaixo para informações sobre como estes 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, half=True)

# 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, int8=True, 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",
)

Implementar Modelos YOLO26 TensorRT Exportados

Tendo exportado com sucesso os teus modelos Ultralytics YOLO26 para o formato TensorRT, estás pronto para os implementar. Para instruções detalhadas sobre como implementar os teus modelos TensorRT em vários cenários, dá uma vista de olhos nos seguintes recursos:

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

• Implementar Redes Neuronais Profundas com NVIDIA TensorRT: Este artigo explica como utilizar o NVIDIA TensorRT para implementar redes neuronais profundas de forma eficiente em plataformas baseadas em GPU.

• IA de Ponta a Ponta para PCs baseados em NVIDIA: Implementação NVIDIA TensorRT: Esta publicação de blog explica a utilização do NVIDIA TensorRT para otimizar e implementar modelos de IA em PCs baseados em NVIDIA.

• Repositório GitHub para 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, concentrámo-nos na conversão de modelos Ultralytics YOLO26 para o formato de modelo TensorRT da NVIDIA. Este passo 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 implementaçã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 de guia de integração oferece uma seleção extensa de recursos informativos e perspetivas.

FAQ

Como posso converter modelos YOLO26 para o formato TensorRT?

Para converter os teus modelos Ultralytics YOLO26 para o formato TensorRT para uma inferência otimizada em GPU NVIDIA, segue estes passos:

1. Instala o pacote necessário:

   pip install ultralytics

2. Exporta o teu modelo YOLO26:

   from ultralytics import YOLO
   
   model = YOLO("yolo26n.pt")
   model.export(format="engine")  # creates 'yolo26n.engine'
   
   # Run inference
   model = YOLO("yolo26n.engine")
   results = model("https://ultralytics.com/images/bus.jpg")

Para mais detalhes, visita o guia de Instalação YOLO26 e a documentação de exportação.

Quais são os benefícios de utilizar TensorRT para modelos YOLO26?

Utilizar o TensorRT para otimizar modelos YOLO26 oferece vários benefícios:

• Velocidade de Inferência Mais Rápida: O TensorRT otimiza as camadas do modelo e utiliza calibração de precisão (INT8 e FP16) para acelerar a inferência sem sacrificar significativamente a precisão.
• Eficiência de Memória: O TensorRT gere a memória de tensores dinamicamente, reduzindo a sobrecarga e melhorando a utilização da memória da GPU.
• Fusão de Camadas: Combina múltiplas camadas em operações únicas, reduzindo a complexidade computacional.
• Auto-Ajuste de Kernels: Seleciona automaticamente kernels de GPU otimizados para cada camada do modelo, garantindo o desempenho máximo.

Para saberes mais, explora a documentação oficial do TensorRT da NVIDIA e a nossa visão geral aprofundada do TensorRT.

Posso utilizar quantização INT8 com o TensorRT para modelos YOLO26?

Sim, podes exportar modelos YOLO26 utilizando o TensorRT com quantização INT8. Este processo envolve quantização pós-treino (PTQ) e calibração:

1. Exportar com INT8:

   from ultralytics import YOLO
   
   model = YOLO("yolo26n.pt")
   model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")

2. Executar inferência:

   from ultralytics import YOLO
   
   model = YOLO("yolo26n.engine", task="detect")
   result = model.predict("https://ultralytics.com/images/bus.jpg")

Para mais detalhes, consulta a secção de exportação do TensorRT com quantização INT8.

Como posso implementar modelos YOLO26 TensorRT num Servidor NVIDIA Triton Inference?

A implementação de modelos YOLO26 TensorRT num Servidor NVIDIA Triton Inference pode ser feita utilizando os seguintes recursos:

• Implementa o Ultralytics YOLO26 com o Triton Server: Guia passo a passo sobre como configurar e utilizar o Triton Inference Server.
• Documentação do NVIDIA Triton Inference Server: Documentação oficial da NVIDIA para opções e configurações detalhadas de implementação.

Estes guias ajudar-te-ão a integrar modelos YOLO26 de forma eficiente em vários ambientes de implementação.

Quais são as melhorias de desempenho observadas com modelos YOLO26 exportados para TensorRT?

As melhorias de desempenho com TensorRT podem variar consoante o hardware utilizado. Aqui tens alguns benchmarks típicos:

• NVIDIA A100:

  • Inferência FP32: ~0.52 ms / imagem
  • Inferência FP16: ~0.34 ms / imagem
  • Inferência INT8: ~0.28 ms / imagem
  • Ligeira redução no mAP com precisão INT8, mas uma melhoria significativa na velocidade.

• GPUs de Consumo (ex.: RTX 3080):

  • Inferência FP32: ~1.06 ms / imagem
  • Inferência FP16: ~0.62 ms / imagem
  • Inferência INT8: ~0.52 ms / imagem

Benchmarks detalhados de desempenho para diferentes configurações de hardware podem ser encontrados na secção de desempenho.

Para informações mais abrangentes sobre o desempenho do TensorRT, consulta a documentação da Ultralytics e os nossos relatórios de análise de desempenho.