TensorRT Export for YOLO11 Models

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. Isto é especialmente verdadeiro quando está a implementar o seu modelo em NVIDIA GPUs.

By using the TensorRT export format, you can enhance your Ultralytics YOLO11 models for swift and efficient inference on NVIDIA hardware. This guide will give you easy-to-follow steps for the conversion process and help you make the most of NVIDIA's advanced technology in your deep learning projects.

TensorRT

TensorRT, desenvolvido por NVIDIA, é um kit de desenvolvimento de software (SDK) avançado concebido para inferência de aprendizagem profunda a alta velocidade. É adequado para aplicações em tempo real, como a deteção de objectos.

Este kit de ferramentas optimiza os modelos de aprendizagem profunda para NVIDIA GPUs e resulta em operações mais rápidas e eficientes. Os modelos TensorRT são submetidos à otimização TensorRT , que inclui técnicas como a fusão de camadas, calibração de precisão (INT8 e FP16), gestão dinâmica da memória tensor e afinação automática do kernel. A conversão de modelos de aprendizagem profunda para o formato TensorRT permite aos programadores tirar o máximo partido do potencial das NVIDIA GPUs.

TensorRT é conhecido por sua compatibilidade com vários formatos de modelo, incluindo TensorFlow, PyTorche ONNX, proporcionando aos programadores uma solução flexível para integrar e otimizar modelos de diferentes estruturas. Essa versatilidade permite a implantação eficiente de modelos em diversos ambientes de hardware e software.

Principais caraterísticas dos modelos TensorRT

TensorRT oferecem uma série de caraterísticas-chave que contribuem para a sua eficiência e eficácia na inferência de aprendizagem profunda a alta velocidade:

• Calibração de precisão: TensorRT suporta calibração de precisão, permitindo que os modelos sejam ajustados para requisitos de precisão específicos. Isto 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 a fusão de camadas, em que várias camadas de uma rede neuronal são combinadas numa única operação. Isso reduz a sobrecarga computacional e melhora a velocidade de inferência, minimizando o acesso à memória e a computação.

• Gestão dinâmica da memória Tensor : TensorRT gere eficazmente a utilização da memória tensor durante a inferência, reduzindo a sobrecarga de memória e optimizando a atribuição de memória. Isto resulta numa utilização mais eficiente da memória GPU .

• Automatic Kernel Tuning: TensorRT applies automatic kernel tuning to select the most optimized GPU kernel for each layer of the model. This adaptive approach ensures that the model takes full advantage of the GPUs computational power.

Opções de implantação em TensorRT

Before we look at the code for exporting YOLO11 models to the TensorRT format, let's understand where TensorRT models are normally used.

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

• Implementando dentro de TensorFlow: Este método integra TensorRT em TensorFlow, permitindo que modelos otimizados sejam executados em um ambiente familiar TensorFlow . É útil para modelos com uma mistura de camadas suportadas e não suportadas, pois TF-TRT pode lidar com elas de forma eficiente.

• Autónomo TensorRT API de tempo de execução: Oferece controlo granular, ideal para aplicações de desempenho crítico. É mais complexa, mas permite a implementação personalizada de operadores não suportados.

• NVIDIA Triton Servidor de inferência: 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.

Exporting YOLO11 Models to TensorRT

You can improve execution efficiency and optimize performance by converting YOLO11 models to TensorRT format.

Instalação

Para instalar o pacote necessário, execute:

# Install the required package for YOLO11
pip install ultralytics

Para obter instruções detalhadas e melhores práticas relacionadas com o processo de instalação, consulte o nosso guia de instalaçãoYOLO11 . Ao instalar os pacotes necessários para YOLO11, se encontrar alguma dificuldade, consulte o nosso guia de Problemas comuns para obter soluções e dicas.

Utilização

Antes de se debruçar sobre as instruções de utilização, não deixe de consultar a gama de modelosYOLO11 propostos por Ultralytics. Isto ajudá-lo-á a escolher o modelo mais adequado às necessidades 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'

Para mais informações sobre o processo de exportação, visite a página de documentaçãoUltralytics sobre exportação.

Exportação de TensorRT com quantização INT8

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

Ao processar redes implicitamente quantizadas, o TensorRT utiliza a INT8 de forma oportuna para otimizar o tempo de execução das camadas. Se uma camada funcionar mais rapidamente em INT8 e tiver atribuído escalas de quantização às suas entradas e saídas de dados, é-lhe atribuído um kernel com precisão INT8; caso contrário, TensorRT seleciona uma precisão de FP32 ou FP16 para o kernel com base no que resultar num tempo de execução mais rápido para essa camada.

Configuração da exportação INT8

Os argumentos fornecidos quando se utiliza exportação para um modelo Ultralytics YOLO muito influenciam o desempenho do modelo exportado. Também terão de ser selecionados com base nos recursos disponíveis do dispositivo, mas os argumentos predefinidos deve funcionam para a maioria Ampere (ou mais recente) NVIDIA GPUs discretas. O algoritmo de calibração utilizado é "ENTROPY_CALIBRATION_2" e pode ler mais pormenores sobre as opções disponíveis no TensorRT Developer Guide. Ultralytics testes revelaram que "ENTROPY_CALIBRATION_2" foi a melhor escolha e as exportações estão fixadas na utilização deste algoritmo.

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

  • Ajustar o workspace de acordo com as suas necessidades de calibração e disponibilidade de recursos. Embora um valor maior workspace pode aumentar o tempo de calibração, permite ao TensorRT explorar uma gama mais vasta de tácticas de otimização, melhorando potencialmente o desempenho do modelo e exatidão. Inversamente, um menor workspace pode reduzir o tempo de calibração, mas pode limitar as estratégias de otimização, afectando a qualidade do modelo quantizado.

  • A predefinição é workspace=Noneque permitirá que o TensorRT atribua automaticamente a memória; ao configurar manualmente, este valor pode ter de ser aumentado se a calibração falhar (sair sem aviso).

  • TensorRT comunicará UNSUPPORTED_STATE durante a exportação se o valor de workspace é maior do que a memória disponível no dispositivo, o que significa que o valor para workspace deve ser reduzido ou fixado em None.

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

  • Lembre-se de que a calibração da INT8 é específica de cada dispositivo, pelo que a utilização de um dispositivo "topo de gama" GPU para calibração pode resultar num desempenho deficiente quando a inferência é executada noutro dispositivo.

• batch : O tamanho máximo do lote que será utilizado para a inferência. Durante a inferência, podem ser utilizados lotes mais pequenos, mas a inferência não aceitará lotes maiores do que o especificado.

As experiências efectuadas por NVIDIA levaram-nos a recomendar a utilização de, pelo menos, 500 imagens de calibração representativas dos dados do seu modelo, com calibração de quantização INT8. Esta é uma diretriz e não uma duro requisito, e terá de experimentar o que é necessário para obter um bom desempenho para o seu conjunto de dados. Uma vez que os dados de calibração são necessários para a calibração INT8 com TensorRT, certifique-se de que utiliza o data argumento quando int8=True para TensorRT e utilizar data="my_dataset.yaml", que utilizará as imagens de validação para calibrar. Quando não é passado nenhum valor para data com exportação para TensorRT com quantização INT8, a predefinição será a utilização de um dos "pequenos" conjuntos de dados de exemplo baseados na tarefa 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 da utilização de YOLO com TensorRT INT8

• Redução do tamanho do modelo: 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 descarregamento mais rápidos, menores requisitos de armazenamento e menor espaço de memória ao implantar um modelo.

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

• Velocidades de inferência melhoradas: TensorRT optimiza o modelo para o hardware de destino, o que pode levar a velocidades de inferência mais rápidas em GPUs, dispositivos incorporados e aceleradores.

Desvantagens da utilização de YOLO com TensorRT INT8

• Diminuição dos parâmetros de avaliação: A utilização de uma precisão inferior significa que mAP, Precision, Recall ou qualquer outra métrica utilizada para avaliar o desempenho do modelo é suscetível de ser um pouco pior. Ver o Secção de resultados de desempenho para comparar as diferenças de mAP50 e mAP50-95 ao exportar com INT8 numa pequena amostra de vários dispositivos.

• Aumento do tempo de desenvolvimento: Encontrar as definições "óptimas" para a calibração da INT8 para o conjunto de dados e o 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 dos modelos são menos transferíveis.

Ultralytics YOLO TensorRT Desempenho das exportações

NVIDIA A100

GPUs de consumo

Dispositivos incorporados

Métodos de avaliação

Expandir as secções abaixo para obter informações sobre a forma como estes 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",
)

Deploying Exported YOLO11 TensorRT Models

Having successfully exported your Ultralytics YOLO11 models to TensorRT format, you're now ready to deploy them. For in-depth instructions on deploying your TensorRT models in various settings, take a look at the following resources:

• Implantar Ultralytics com um servidor Triton : O nosso guia sobre como utilizar o servidor NVIDIA's Triton Inference (anteriormente TensorRT Inference) especificamente para utilização com modelos Ultralytics YOLO .

• Implantação de redes neurais profundas com NVIDIA TensorRT: Este artigo explica como usar NVIDIA TensorRT para implantar redes neurais profundas em plataformas de implantação baseadas em GPU de forma eficiente.

• IA de ponta a ponta para PCs baseados em NVIDIA: NVIDIA TensorRT Implantação: Esta postagem do blog explica o uso de NVIDIA TensorRT para otimizar e implantar 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

In this guide, we focused on converting Ultralytics YOLO11 models to NVIDIA's TensorRT model format. This conversion step is crucial for improving the efficiency and speed of YOLO11 models, making them more effective and suitable for diverse deployment environments.

Para obter mais informações sobre os detalhes de utilização, consulte a documentação oficialTensorRT .

If you're curious about additional Ultralytics YOLO11 integrations, our integration guide page provides an extensive selection of informative resources and insights.

FAQ

How do I convert YOLO11 models to TensorRT format?

To convert your Ultralytics YOLO11 models to TensorRT format for optimized NVIDIA GPU inference, follow these steps:

1. Instalar o pacote necessário:

   pip install ultralytics
   

2. Export your YOLO11 model:

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

For more details, visit the YOLO11 Installation guide and the export documentation.

What are the benefits of using TensorRT for YOLO11 models?

Using TensorRT to optimize YOLO11 models offers several benefits:

• Velocidade de inferência mais rápida: TensorRT optimiza as camadas do modelo e utiliza a calibração de precisão (INT8 e FP16) para acelerar a inferência sem sacrificar significativamente a precisão.
• Eficiência da memória: TensorRT gere a memória tensor dinamicamente, reduzindo as despesas gerais e melhorando a utilização da memória GPU .
• Fusão de camadas: Combina várias camadas em operações únicas, reduzindo a complexidade computacional.
• Auto-ajuste do kernel: Seleciona automaticamente os kernels GPU optimizados para cada camada do modelo, assegurando o máximo desempenho.

Para mais informações, explore as caraterísticas detalhadas de TensorRT aqui e leia a nossa secção de visão geral deTensorRT .

Can I use INT8 quantization with TensorRT for YOLO11 models?

Yes, you can export YOLO11 models using TensorRT with INT8 quantization. This process involves post-training quantization (PTQ) and calibration:

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 pormenores, consulte a secção de exportação TensorRT com quantização INT8.

How do I deploy YOLO11 TensorRT models on an NVIDIA Triton Inference Server?

Deploying YOLO11 TensorRT models on an NVIDIA Triton Inference Server can be done using the following resources:

• Implementar Ultralytics YOLOv8 com o servidor Triton : Orientação passo a passo sobre a configuração e utilização do Servidor de Inferência Triton .
• NVIDIA Triton Documentação do servidor de inferência: Documentação oficial do NVIDIA para opções e configurações de implantação detalhadas.

Estes guias ajudá-lo-ão a integrar eficazmente os modelos YOLOv8 em vários ambientes de implementação.

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

As melhorias de desempenho com TensorRT podem variar consoante o 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 do mAP com precisão INT8, mas melhoria significativa da 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

Na secção de desempenho podem ser encontradas referências de desempenho detalhadas para diferentes configurações de hardware.

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

📅C riado há 11 meses ✏️ Atualizado há 6 dias

Comentários