Exportação TensorRT para modelos YOLO26#

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 importante quando implementas o teu modelo em GPUs NVIDIA.

Ao usar o formato de exportação TensorRT, podes otimizar os teus modelos Ultralytics YOLO26 para uma inferência rápida e eficiente em hardware NVIDIA. Este guia fornece instruções 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 projetos de aprendizagem profunda.

TensorRT#

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

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

O 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 frameworks. Esta versatilidade permite uma implementação de modelos eficiente em diversos ambientes de hardware e software.

Principais funcionalidades dos modelos TensorRT#

Os modelos TensorRT oferecem várias funcionalidades importantes que contribuem para a sua eficiência e eficácia na inferência de aprendizagem profunda de alta velocidade:

• Calibração de precisão: O TensorRT suporta calibração de precisão, permitindo ajustar os modelos para requisitos específicos de precisão. 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, na qual várias camadas de uma rede neural são combinadas numa única operação. Isto reduz a sobrecarga computacional e melhora a velocidade de inferência, minimizando o acesso à memória e os cálculos.

• Gestão dinâmica da memória de tensores: O TensorRT gere eficientemente o uso da memória dos tensores durante a inferência, reduzindo a sobrecarga de memória e otimizando a alocação de memória. Isto resulta numa utilização mais eficiente da memória da GPU.

• Ajuste automático de kernels: O TensorRT aplica o ajuste automático de kernels para selecionar o kernel de GPU mais otimizado para cada camada do modelo. Esta abordagem adaptativa garante que o modelo aproveita plenamente o poder computacional da GPU.

Opções de implementação no TensorRT#

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

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

• Implementação no TensorFlow: Este método integra o TensorRT no TensorFlow, permitindo que os modelos otimizados sejam executados num ambiente TensorFlow familiar. É útil para modelos com uma combinação de camadas suportadas e não suportadas, pois o TF-TRT consegue processá-las eficientemente.

• API de runtime TensorRT autónoma: Oferece um controlo granular, ideal para aplicações críticas em termos de desempenho. É mais complexa, mas permite uma implementação personalizada de operadores não suportados.

• NVIDIA Triton Inference Server: Uma opção que suporta modelos de vários frameworks. Particularmente adequada para inferência na cloud ou na periferia, fornece funcionalidades como execução concorrente de modelos e análise de modelos.

Tarefas suportadas#

A exportação TensorRT suporta todas as sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com YOLO26, a única família que inclui essas cabeças.

Exportar modelos YOLO26 para TensorRT#

Podes melhorar a eficiência de execução e otimizar o desempenho convertendo modelos YOLO26 para o formato TensorRT.

Instalação#

Para instalar o pacote necessário, executa:

# Install the required package for YOLO26
pip install ultralytics

Para obter instruções detalhadas e boas práticas relacionadas com o processo de instalação, consulta o nosso guia de instalação do YOLO26. Durante a instalação dos pacotes necessários para YOLO26, se encontrares alguma dificuldade, consulta o nosso guia de problemas comuns para obter soluções e sugestões.

Utilização#

Antes de começares a consultar as instruções de utilização, vê a gama de modelos YOLO26 disponibilizados pela Ultralytics. Isto ajudar-te-á a escolher o modelo mais adequado aos requisitos do teu projeto.

O formato TensorRT suporta os modos Exportar, Prever e Validar. A inferência e a validação requerem uma GPU NVIDIA. Exporta o teu modelo e, em seguida, carrega o modelo exportado para executar a inferência ou validar a sua precisão.

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argumentos de Exportação#

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

Exportar TensorRT com quantização INT8#

A exportação de modelos YOLO do Ultralytics utilizando TensorRT com precisão INT8 executa a quantização pós-treinamento (PTQ). O TensorRT utiliza a calibração para a quantização pós-treinamento, que mede a distribuição das ativações dentro de cada tensor de ativação à medida que o modelo YOLO processa a inferência em dados de entrada representativos e, em seguida, utiliza 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. Um ponto de verificação ajustado com quantize=8 através do treinamento consciente de quantização já transporta os seus intervalos INT8, pelo que a sua exportação utiliza-os e ignora a calibração.

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

Configurar a exportação INT8#

Os argumentos fornecidos ao utilizar exportar para um modelo Ultralytics YOLO influenciam significativamente o desempenho do modelo exportado. No entanto, também têm de ser selecionados com base nos recursos disponíveis no dispositivo; os argumentos predefinidos devem funcionar para a maioria das GPUs NVIDIA discretas Ampere (ou mais recentes). O algoritmo de calibração utilizado é "MINMAX_CALIBRATION" para exportações GPU, enquanto as exportações DLA no NVIDIA Jetson utilizam "ENTROPY_CALIBRATION_2". Podes consultar mais detalhes sobre as opções disponíveis no TensorRT Developer Guide. Os testes da Ultralytics concluíram que "MINMAX_CALIBRATION" é a melhor opção para exportações GPU, e o algoritmo é selecionado automaticamente com base no dispositivo de exportação.

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

  • Ajusta o valor de workspace de acordo com as tuas necessidades de calibração e a disponibilidade de recursos. Embora um workspace maior possa aumentar o tempo de calibração, permite que o TensorRT explore uma gama mais ampla de estratégias de otimização, melhorando potencialmente o desempenho e a precisão do modelo. Por outro lado, um workspace menor pode reduzir o tempo de calibração, mas limitar as estratégias de otimização, afetando a qualidade do modelo quantizado.

  • O valor predefinido é workspace=None, o que permite ao TensorRT alocar memória automaticamente. Ao configurar manualmente, pode ser necessário aumentar este valor se a calibração falhar ou terminar inesperadamente (sem aviso).

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

  • Se workspace estiver definido com o valor máximo e a calibração falhar ou terminar inesperadamente, considera usar None para alocação automática ou reduzir os valores de imgsz e batch para diminuir os requisitos de memória.

  • Lembra-te de que a calibração para INT8 é específica de cada dispositivo; pedir emprestada uma GPU de "alta gama" para a calibração pode resultar num desempenho fraco quando a inferência for executada noutro dispositivo.

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

A experimentação levada a cabo pela NVIDIA levou-os a recomendar a utilização de pelo menos 500 imagens de calibração que sejam representativas dos dados para o teu modelo, com a calibração de quantização INT8. Esta é uma diretriz e não um requisito estrito, e terás de fazer experiências com o que é necessário para ter um bom desempenho para o teu conjunto de dados. Uma vez que os dados de calibração são necessários para a calibração de INT8 com TensorRT, certifica-te de que utilizas o argumento data ao exportar um ponto de verificação que não foi treinado com quantize=8 (quantização pós-treinamento) em quantize=8 para TensorRT, e utiliza data="my_dataset.yaml", que utilizará as imagens da validação para calibrar. Um ponto de verificação treinado com quantize=8 ignora a calibração, pelo que deves omitir data para o mesmo. Quando nenhum valor é passado para data com a exportação para TensorRT com quantização INT8, a predefinição será utilizar um dos conjuntos de dados de exemplo "pequenos" com base na tarefa do modelo em vez de gerar um erro.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(
    format="engine",
    dynamic=True,  # (1)!
    batch=8,  # (2)!
    workspace=4,  # (3)!
    quantize=8,
    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 reduzido do modelo: A quantização de FP32 para INT8 pode reduzir o tamanho do modelo em 4x (no disco ou na memória), resultando em tempos de transferência mais rápidos, menores requisitos de armazenamento e uma menor utilização de memória ao implementar um modelo.

• Menor consumo de energia: As operações de precisão reduzida dos modelos YOLO exportados para INT8 podem consumir menos energia do que os modelos FP32, especialmente em dispositivos alimentados por bateria.

• Velocidades de inferência melhoradas: O TensorRT otimiza o modelo para o hardware de destino, podendo resultar em velocidades de inferência superiores em GPUs, dispositivos incorporados e aceleradores.

Desvantagens de usar YOLO com TensorRT INT8#

• Diminuição das métricas de avaliação: A utilização de uma precisão inferior significa que mAP, Precision, Recall ou qualquer outra métrica usada para avaliar o desempenho do modelo provavelmente será um pouco pior. As camadas Sigmoid são mantidas com maior precisão para preservar a calibração das pontuações, mas o INT8 ainda pode alterar os valores de confiança; por isso, seleciona o limiar de operação a partir da própria curva F1 do modelo INT8. Consulta a secção de resultados de desempenho para comparar as diferenças em mAP50 e mAP50-95 ao exportar com INT8 numa pequena amostra de vários dispositivos.

• Aumento do tempo de desenvolvimento: Encontrar as definições "ideais" para a calibração INT8 do conjunto de dados e do dispositivo pode exigir uma quantidade significativa de testes.

• Dependência do hardware: A calibração e os ganhos de desempenho podem depender fortemente do hardware, e os pesos dos modelos são menos transferíveis.

Desempenho da exportação Ultralytics YOLO TensorRT#

NVIDIA A100#

GPUs de consumo#

Dispositivos incorporados#

Métodos de avaliação#

Expande as secções abaixo para obter 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, quantize=16)

# 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, quantize=8, 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",
)

Implementação de modelos YOLO26 TensorRT exportados#

Depois de exportares com sucesso os teus modelos Ultralytics YOLO26 para o formato TensorRT, estás agora pronto para os implementar. Para obteres instruções detalhadas sobre a implementação dos teus modelos TensorRT em vários contextos, consulta os seguintes recursos:

• Implementar o Ultralytics com um servidor Triton: o nosso guia sobre como utilizar o Triton Inference Server da NVIDIA (anteriormente TensorRT Inference Server), especificamente com modelos YOLO do Ultralytics.

• Implementar redes neuronais profundas com o NVIDIA TensorRT: este artigo explica como utilizar o NVIDIA TensorRT para implementar redes neuronais profundas de forma eficiente em plataformas de implementação baseadas em GPU.

• IA de ponta a ponta para PCs baseados em NVIDIA: implementação com NVIDIA TensorRT: esta publicação de blogue explica a utilização do NVIDIA TensorRT para otimizar e implementar modelos de IA em PCs baseados em NVIDIA.

• Repositório do GitHub para o 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, concentramo-nos na conversão de modelos Ultralytics YOLO26 para o formato de modelo TensorRT da NVIDIA. Este passo de conversão é essencial para melhorar a eficiência e a velocidade dos modelos YOLO26, tornando-os mais eficazes e adequados a diversos ambientes de implementação.

Para obteres mais informações sobre os detalhes de utilização, consulta a documentação oficial do TensorRT.

Se tens curiosidade sobre integrações adicionais do Ultralytics YOLO26, a nossa página do guia de integrações disponibiliza uma vasta seleção de recursos informativos e conhecimentos.

Perguntas frequentes#