TensorRT Exportação para YOLOv8 Modelos

Deploying computer vision models in high-performance environments can require a format that maximizes speed and efficiency. This is especially true when you are deploying your model on NVIDIA GPUs.

By using the TensorRT export format, you can enhance your Ultralytics YOLOv8 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, developed by NVIDIA, is an advanced software development kit (SDK) designed for high-speed deep learning inference. It's well-suited for real-time applications like object detection.

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 a uma 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 is known for its compatibility with various model formats, including TensorFlow, PyTorch, and ONNX, providing developers with a flexible solution for integrating and optimizing models from different frameworks. This versatility enables efficient model deployment across diverse hardware and software environments.

Principais características dos modelos TensorRT

TensorRT oferecem uma série de caracterí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. 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.

• Layer Fusion: The TensorRT optimization process includes layer fusion, where multiple layers of a neural network are combined into a single operation. This reduces computational overhead and improves inference speed by minimizing memory access and computation.

• 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 .

• Ajuste automático do kernel: TensorRT aplica o ajuste automático do kernel para selecionar o kernel GPU mais optimizado para cada camada do modelo. Esta abordagem adaptativa garante que o modelo tira o máximo partido do poder computacional do GPU.

Opções de implantação em TensorRT

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

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:

• Deploying within TensorFlow: This method integrates TensorRT into TensorFlow, allowing optimized models to run in a familiar TensorFlow environment. It's useful for models with a mix of supported and unsupported layers, as TF-TRT can handle these efficiently.

• 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, fornece recursos como execução simultânea de modelos e análise de modelos.

Exportação de modelos YOLOv8 para TensorRT

Podes melhorar a eficiência da execução e otimizar o desempenho convertendo os modelos YOLOv8 para o formato TensorRT .

Instalação

Para instalar o pacote necessário, executa:

# Install the required package for YOLOv8
pip install ultralytics

Para obter instruções detalhadas e melhores práticas relacionadas com o processo de instalação, consulta o nosso guia de instalaçãoYOLOv8 . Durante a instalação dos pacotes necessários para YOLOv8, se tiveres alguma dificuldade, consulta o nosso guia de Problemas comuns para obteres soluções e sugestões.

Utilização

Antes de mergulhar nas instruções de utilização, não te esqueças de verificar a gama de modelosYOLOv8 oferecidos por Ultralytics. Isto ajudar-te-á a escolher o modelo mais adequado às necessidades do teu projeto.

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

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

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

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

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

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

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

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

Exporting Ultralytics YOLO models using TensorRT with INT8 precision executes post-training quantization (PTQ). TensorRT uses calibration for PTQ, which measures the distribution of activations within each activation tensor as the YOLO model processes inference on representative input data, and then uses that distribution to estimate scale values for each tensor. Each activation tensor that is a candidate for quantization has an associated scale that is deduced by a calibration process.

Ao processar redes implicitamente quantizadas, o TensorRT usa a INT8 de forma oportuna para otimizar o tempo de execução da camada. Se uma camada for executada mais rapidamente em INT8 e tiver atribuído escalas de quantização às suas entradas e saídas de dados, então um kernel com precisão INT8 é atribuído a essa camada; caso contrário, TensorRT selecciona 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 utilizas exportação para um modelo Ultralytics YOLO irá muito influencia o desempenho do modelo exportado. Também terão de ser seleccionados com base nos recursos disponíveis do dispositivo, mas os argumentos predefinidos deve trabalha para a maioria Ampere (ou mais recente) NVIDIA GPUs discretas. O algoritmo de calibração utilizado é "ENTROPY_CALIBRATION_2" e podes 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 para utilizar este algoritmo.

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

  • Ajusta a workspace de acordo com as tuas necessidades de calibração e disponibilidade de recursos. Embora um valor maior workspace may increase calibration time, it allows TensorRT to explore a wider range of optimization tactics, potentially enhancing model performance and precisão. Conversely, a smaller 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=4 (GiB), este valor pode ter de ser aumentado se a calibração falhar (sair sem aviso).

  • TensorRT informa-te 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.

  • Se workspace estiver definido para o valor máximo e a calibração falhar, considera a possibilidade de reduzir os valores de imgsz e batch para reduzir os requisitos de memória.

  • Lembra-te 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 realizadas em NVIDIA levaram-nos a recomendar a utilização de, pelo menos, 500 imagens de calibração representativas dos dados do teu modelo, com calibração de quantização INT8. Esta é uma diretriz e não uma duro e terás de experimentar o que é necessário para ter um bom desempenho no teu conjunto de dados. Uma vez que os dados de calibração são necessários para a calibração INT8 com TensorRT, certifica-te de que usas o data argumento quando int8=True para TensorRT e utiliza data="my_dataset.yaml"que irá 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á utilizar um dos "pequenos" conjuntos de dados de exemplo baseados na tarefa modelo em vez de lançares 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 YOLOv8n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolov8n.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

• Reduz o 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 download 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 as métricas de avaliação: Se utilizares 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. Vê o Secção de resultados de desempenho para comparar as diferenças de mAP50 e mAP50-95 quando exportas com INT8 numa pequena amostra de vários dispositivos.

• Aumenta o 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

Expande as secções abaixo para obteres 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",
)

Implantação de modelos exportados YOLOv8 TensorRT

Depois de exportar com êxito os modelos Ultralytics YOLOv8 para o formato TensorRT , estás agora pronto para os implementar. Para obter instruções detalhadas sobre a implantação dos modelos TensorRT em várias configurações, dá uma olhada nos recursos a seguir:

• Implementa 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 de NVIDIA TensorRT .

Resumo

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

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

Se tiveres curiosidade em saber mais sobre integrações adicionais em Ultralytics YOLOv8 , a nossa página de guia de integração fornece uma vasta seleção de recursos informativos e conhecimentos.

FAQ

Como é que converto os modelos YOLOv8 para o formato TensorRT ?

Para converter seus modelos Ultralytics YOLOv8 para o formato TensorRT para otimizar a inferência NVIDIA GPU , siga estas etapas:

1. Instala o pacote necessário:

   pip install ultralytics
   

2. Exporta o teu modelo YOLOv8 :

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

Para mais informações, consulta o guia de instalaçãoYOLOv8 e a documentação de exportação.

Quais são as vantagens de utilizar TensorRT para os modelos YOLOv8 ?

A utilização do TensorRT para otimizar os modelos YOLOv8 oferece várias vantagens:

• 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 de memória: TensorRT gerencia a memória tensor dinamicamente, reduzindo a sobrecarga 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 otimizados para cada camada do modelo, garantindo o máximo desempenho.

Para mais informações, explora as características detalhadas de TensorRT aqui e lê a nossa secção de visão geral deTensorRT .

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

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

1. Exporta com INT8:

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

2. Executa a inferência:

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

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

Como posso implementar modelos YOLOv8 TensorRT num servidor de inferência NVIDIA Triton ?

A implantação de modelos YOLOv8 TensorRT em um servidor de inferência NVIDIA Triton pode ser feita usando os seguintes recursos:

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

Estes guias irão ajudar-te a integrar os modelos YOLOv8 de forma eficiente 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
  • Reduz ligeiramente o mAP com a precisão INT8, mas melhora significativamente a 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

Podes encontrar referências de desempenho detalhadas para diferentes configurações de hardware na secção de desempenho.

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

📅 C riado há 9 meses ✏️ Atualizado há 1 mês

Comentários