TensorRT Exportação para YOLOv8 Modelos

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ás a implementar o teu modelo em GPUs NVIDIA.

Ao utilizar o formato de exportação TensorRT , podes melhorar os teus Ultralytics YOLOv8 modelos para uma inferência rápida e eficiente no hardware NVIDIA. Este guia fornece-te passos fáceis de seguir para o processo de conversão e ajuda-te a tirar o máximo partido da tecnologia avançada da NVIDIA nos teus projectos de aprendizagem profunda.

TensorRT

TensorRT, desenvolvido pela 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 GPUs NVIDIA 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 auto-ajuste 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 GPUs NVIDIA.

TensorRT é conhecido pela sua compatibilidade com vários formatos de modelos, incluindo TensorFlow, PyTorch, e ONNX, fornecendo aos programadores uma solução flexível para integrar e otimizar modelos de diferentes estruturas. Esta versatilidade permite a implementação eficiente de modelos em diversos ambientes de hardware e software.

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.

• Fusão de camadas: O processo de otimização do TensorRT inclui a fusão de camadas, em que 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.

• 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 da 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. Essa abordagem adaptativa garante que o modelo aproveite ao máximo o poder computacional da GPU.

Opções de implantação em TensorRT

Antes de analisarmos o código para exportar os modelos YOLOv8 para o formato TensorRT , vamos perceber onde são normalmente utilizados os modelos TensorRT .

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, 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

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 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 GPUs NVIDIA discretas Ampere (ou mais recentes). 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.

  • Procura utilizar o mínimo workspace necessário, uma vez que isto impede o teste de algoritmos que requerem mais workspace de ser considerado pelo construtor TensorRT . Ao definir um valor mais elevado para workspace podes tomar consideravelmente mais tempo para calibrar e exportar.

  • 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 pedir emprestada uma GPU "topo de gama" para calibração pode resultar num fraco desempenho 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.

  Nota

  Durante a calibração, carrega duas vezes no botão batch Utiliza o tamanho fornecido. A utilização de pequenos lotes pode levar a um escalonamento impreciso durante a calibragem. Isto deve-se ao facto de o processo se ajustar com base nos dados que vê. Os lotes pequenos podem não captar toda a gama de valores, o que pode causar problemas na calibragem final. batch é duplicado automaticamente. Se não for especificado um tamanho de lote batch=1, a calibração será efectuada a batch=1 * 2 para reduzir os erros de escala de calibração.

As experiências da NVIDIA levaram-nos a recomendar a utilização de pelo menos 500 imagens de calibragem representativas dos dados do teu modelo, com calibragem de quantização INT8. Esta é uma orientação 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)!
)

model = YOLO("yolov8n.engine", task="detect") # load the model

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
out = model.export(
    format="engine",
    imgsz:640,
    dynamic:True,
    verbose:False,
    batch:8,
    workspace:2,
    int8=True,
    data:"data.yaml"  # COCO, ImageNet, or DOTAv1 for appropriate model task
)

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 Triton Inference (anteriormente TensorRT Inference) da NVIDIA especificamente para utilização com modelos Ultralytics YOLO .

• Implantando redes neurais profundas com a NVIDIA TensorRT: Este artigo explica como usar o 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 Deployment: Este post do blog explica o uso do NVIDIA TensorRT para otimizar e implantar modelos de AI 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 da NVIDIA TensorRT.

Resumo

Neste guia, concentramo-nos na conversão de modelos Ultralytics YOLOv8 para o formato de modelo TensorRT da NVIDIA. Este passo 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 implementaçã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.

Comentários