Exportação TensorRT para Modelos YOLO11

A implementaçã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 verdadeiro quando você está implementando seu modelo em GPUs NVIDIA.

Ao usar o formato de exportação TensorRT, você pode aprimorar seus modelos Ultralytics YOLO11 para inferência rápida e eficiente no hardware NVIDIA. Este guia fornecerá 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 aprendizado profundo.

TensorRT

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

Este kit de ferramentas otimiza modelos de aprendizado profundo 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 tensor e auto-ajuste de kernel. Converter modelos de aprendizado profundo para o formato TensorRT permite que os desenvolvedores percebam totalmente 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 frameworks. Essa versatilidade permite a implantação eficiente de modelos em diversos ambientes de hardware e software.

Principais Características 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 aprendizado profundo de alta velocidade:

• Calibração de Precisã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 do TensorRT inclui a 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 aproveite ao máximo o poder computacional das GPUs.

Opções de Implementação em TensorRT

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

O TensorRT oferece diversas 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 mistura de camadas suportadas e não suportadas, pois o TF-TRT pode lidar com elas de forma eficiente.

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

• Servidor de Inferência NVIDIA Triton: Uma opção que suporta modelos de várias estruturas. Particularmente adequado para inferência na nuvem ou na borda, ele fornece recursos como execução simultânea de modelos e análise de modelos.

Exportando Modelos YOLO11 para TensorRT

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

Instalação

Para instalar o pacote necessário, execute:

# Install the required package for YOLO11
pip install ultralytics

Para obter instruções detalhadas e práticas recomendadas relacionadas ao processo de instalação, consulte nosso guia de instalação do YOLO11. Ao instalar os pacotes necessários para o YOLO11, se você encontrar alguma dificuldade, consulte nosso guia de problemas comuns para obter soluções e dicas.

Utilização

Antes de se aprofundar nas instruções de uso, certifique-se de verificar a variedade de modelos YOLO11 oferecidos pela Ultralytics. Isso ajudará você a escolher o modelo mais adequado para os requisitos do seu projeto.

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

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

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

# Export a YOLO11n PyTorch model to TensorRT format
yolo export model=yolo11n.pt format=engine # creates 'yolo11n.engine''

# Run inference with the exported model
yolo predict model=yolo11n.engine source='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

Exportar 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 enquanto o modelo YOLO processa a inferência em dados de entrada representativos e, em seguida, 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 oportunisticamente 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 essa camada.

Configurando a Exportação INT8

Os argumentos fornecidos ao usar export para um modelo Ultralytics YOLO irá grandemente influenciam 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 deve funcionam para a maioria GPUs discretas NVIDIA Ampere (ou mais recentes). O algoritmo de calibração utilizado é "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" foi a melhor escolha e as exportações foram corrigidas para usar este algoritmo.

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

  • Ajuste o workspace valor de acordo com as suas necessidades de calibração e disponibilidade de recursos. Enquanto um workspace pode aumentar o tempo de calibração, mas permite que o TensorRT explore uma gama mais ampla de táticas de otimização, potencialmente melhorando o desempenho do modelo e precisão. Por outro lado, um workspace 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á que o TensorRT aloque memória automaticamente; ao configurar manualmente, este valor pode precisar ser aumentado se a calibração falhar (sair sem aviso).

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

  • Se workspace está definido com o valor máximo e a calibração falha/quebra, considere usar None para alocação automática ou reduzindo os valores para imgsz e batch para reduzir os requisitos de memória.

  • Lembre-se que a calibração para INT8 é específica para cada dispositivo, pegar emprestado uma GPU "de ponta" para calibração pode resultar em baixo desempenho quando a inferência é executada em outro dispositivo.

• batch : O tamanho máximo do lote 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.

A experimentação da NVIDIA os levou a recomendar o uso de pelo menos 500 imagens de calibração que sejam representativas dos dados para o seu modelo, com calibração de quantização INT8. Esta é uma diretriz e não uma difícil requisito, e você precisará experimentar o que é necessário para ter um bom desempenho para o seu conjunto de dados. Como os dados de calibração são necessários para a calibração INT8 com TensorRT, certifique-se de usar o data argumento quando int8=True para TensorRT e use data="my_dataset.yaml", que usará as imagens de validação para calibrar. Quando nenhum valor é passado para data Com a exportação para TensorRT com quantização INT8, o padrã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("yolov8n.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("yolov8n.engine", task="detect")

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

# Export a YOLO11n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolo11n.pt format=engine batch=8 workspace=4 int8=True data=coco.yaml # creates 'yolov8n.engine''

# Run inference with the exported TensorRT quantized model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

Vantagens de usar YOLO com TensorRT INT8

• Tamanho do 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 footprint de memória ao implementar um modelo.

• Menor consumo de energia: Operações com 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, o que pode levar 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 menor significará que mAP, Precision, Recall ou qualquer outra métrica usada para avaliar o desempenho do modelo provavelmente será um pouco pior. Veja o 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.

• Tempos de desenvolvimento aumentados: Encontrar as configurações "ideais" para a calibração INT8 para o conjunto de dados e o dispositivo pode levar uma quantidade significativa de testes.

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

Desempenho da Exportação do Ultralytics YOLO TensorRT

NVIDIA A100

GPUs de consumo

Dispositivos Embutidos

Métodos de avaliação

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

from ultralytics import YOLO

model = YOLO("yolov8n.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("yolov8n.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("yolov8n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet, or DOTAv1 for appropriate model task
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Implantação de Modelos TensorRT YOLO11 Exportados

Tendo exportado com sucesso seus modelos Ultralytics YOLO11 para o formato TensorRT, agora você está pronto para implantá-los. Para obter instruções detalhadas sobre como implantar seus modelos TensorRT em várias configurações, consulte os seguintes recursos:

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

• Implementando Redes Neurais Profundas com NVIDIA TensorRT: Este artigo explica como usar o NVIDIA TensorRT para implementar redes neurais profundas em plataformas de implementação baseadas em GPU de forma eficiente.

• IA de Ponta a Ponta para PCs Baseados em NVIDIA: Implementação NVIDIA TensorRT: Esta publicação de blogue explica o uso 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 NVIDIA TensorRT.

Resumo

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

Para obter mais informações sobre detalhes de uso, consulte a documentação oficial do TensorRT.

Se você está curioso sobre integrações adicionais do Ultralytics YOLO11, nossa página de guia de integração fornece uma extensa seleção de recursos informativos e insights.

FAQ

Como converto modelos YOLO11 para o formato TensorRT?

Para converter seus modelos Ultralytics YOLO11 para o formato TensorRT para inferência otimizada em NVIDIA GPU, siga estes passos:

1. Instale o pacote necessário:

   pip install ultralytics
   

2. Exporte seu modelo YOLO11:

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

Para mais detalhes, visite o guia de instalação do YOLO11 e a documentação de exportação.

Quais são os benefícios de usar o TensorRT para modelos YOLO11?

Usar o TensorRT para otimizar modelos YOLO11 oferece vários benefícios:

• Velocidade de Inferência Mais Rápida: O TensorRT otimiza as camadas do modelo e usa 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 do tensor dinamicamente, reduzindo a sobrecarga e melhorando a utilização da memória da GPU.
• Fusão de Camadas: Combina várias camadas em operações únicas, reduzindo a complexidade computacional.
• Auto-ajuste de Kernel: Seleciona automaticamente kernels de GPU otimizados para cada camada do modelo, garantindo o máximo desempenho.

Para saber mais, explore a documentação oficial do TensorRT da NVIDIA e a nossa visão geral detalhada do TensorRT.

Posso usar quantização INT8 com TensorRT para modelos YOLO11?

Sim, você pode exportar modelos YOLO11 usando TensorRT com quantização INT8. Este processo envolve quantização pós-treinamento (PTQ) e calibração:

1. Exportar com INT8:

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

2. Executar inferência:

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

Para mais detalhes, consulte a seção exportando TensorRT com quantização INT8.

Como implemento modelos YOLO11 TensorRT em um NVIDIA Triton Inference Server?

A implementação de modelos YOLO11 TensorRT num Servidor de Inferência NVIDIA Triton pode ser feita utilizando os seguintes recursos:

• Implementar Ultralytics YOLOv8 com o Servidor Triton: Orientação passo a passo sobre como configurar e usar o Triton Inference Server.
• Documentação do Servidor de Inferência NVIDIA Triton: Documentação oficial da NVIDIA para opções e configurações de implantação detalhadas.

Esses guias ajudarão você a integrar modelos YOLOv8 de forma eficiente em vários ambientes de implantação.

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

As melhorias de desempenho com TensorRT podem variar dependendo do hardware utilizado. Aqui estão 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 melhoria significativa na velocidade.

• GPUs de Consumo (por exemplo, RTX 3080):

  • Inferência FP32: ~1,06 ms / imagem
  • Inferência FP16: ~0,62 ms / imagem
  • Inferência INT8: ~0,52 ms / imagem

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

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

📅 Criado há 1 ano ✏️ Atualizado há 19 dias

Comentários