Link to this sectionExportação TensorRT para Modelos YOLO26#

Implantar 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 ao implantar seu modelo em GPUs NVIDIA.

Ao usar o formato de exportação TensorRT, você pode aprimorar seus modelos Ultralytics YOLO26 para uma inferência rápida e eficiente em hardware NVIDIA. Este guia fornecerá passos fáceis de seguir para o processo de conversão e o ajudará a aproveitar ao máximo a tecnologia avançada da NVIDIA em seus projetos de deep learning.

Link to this sectionTensorRT#

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

Este kit de ferramentas otimiza modelos de deep learning 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 tensores e ajuste automático de kernel. Converter modelos de deep learning para o formato TensorRT permite que os desenvolvedores realizem plenamente 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 uma implantação de modelo eficiente em diversos ambientes de hardware e software.

Link to this sectionPrincipais Recursos 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 deep learning de alta velocidade:

• Calibração de Precisão: 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, o que pode aumentar ainda mais a velocidade de inferência enquanto mantém níveis de precisão aceitáveis.

• Fusão de Camadas: O processo de otimização do TensorRT inclui fusão de camadas, onde múltiplas 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 ao minimizar o acesso à memória e a computação.

• Gerenciamento Dinâmico de Memória de Tensores: O TensorRT gerencia de forma eficiente o uso de memória de tensores durante a inferência, reduzindo a sobrecarga de memória e otimizando a alocação. Isso resulta em uma utilização mais eficiente da memória da GPU.

• Ajuste Automático de Kernel: O TensorRT aplica 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 da GPU.

Link to this sectionOpções de Implantação no TensorRT#

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

O TensorRT oferece várias opções de implantação, e cada uma equilibra facilidade de integração, otimização de desempenho e flexibilidade de maneiras diferentes:

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

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

• NVIDIA Triton Inference Server: Uma opção que suporta modelos de vários frameworks. Particularmente adequado para inferência em nuvem ou edge, fornece recursos como execução de modelo concorrente e análise de modelo.

Link to this sectionExportando Modelos YOLO26 para TensorRT#

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

Link to this sectionInstalação#

Para instalar o pacote necessário, execute:

# Install the required package for YOLO26
pip install ultralytics

Para instruções detalhadas e melhores práticas relacionadas ao processo de instalação, confere o nosso Guia de Instalação do YOLO26. Ao instalar os pacotes necessários para o YOLO26, caso encontres alguma dificuldade, consulta o nosso Guia de Problemas Comuns para soluções e dicas.

Link to this sectionUso#

Antes de mergulhar nas instruções de uso, certifique-se de conferir a gama de modelos YOLO26 oferecidos pela Ultralytics. Isso ajudará você a escolher o modelo mais apropriado para os requisitos do seu projeto.

O formato TensorRT suporta os modos Export, Predict e Validate. A inferência e a validação exigem uma GPU NVIDIA. Exporte seu modelo, depois carregue o modelo exportado para executar a inferência ou validar 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")

Link to this sectionArgumentos de Exportação#

Para mais detalhes sobre o processo de exportação, visite a página de documentação do Ultralytics sobre exportação.

Link to this sectionExportando 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 à medida que o modelo YOLO processa a inferência em dados de entrada representativos, e então usa essa distribuição para estimar valores de escala para cada tensor. Cada tensor de ativação candidato à quantização tem uma escala associada que é deduzida por um processo de calibração.

Ao processar redes quantizadas implicitamente, o TensorRT usa INT8 de forma oportunista para otimizar o tempo de execução da camada. Se uma camada é executada mais rápido em INT8 e possui escalas de quantização atribuídas em suas entradas e saídas de dados, então um kernel com precisão INT8 é atribuído a essa camada; caso contrário, o TensorRT seleciona uma precisão FP32 ou FP16 para o kernel, com base no que resultar em um tempo de execução mais rápido para aquela camada.

Link to this sectionConfigurando a Exportação INT8#

Os argumentos fornecidos ao usar export para um modelo Ultralytics YOLO influenciarão grandemente 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 devem funcionar para a maioria das GPUs discretas NVIDIA Ampere (ou mais recentes). O algoritmo de calibração usado é "MINMAX_CALIBRATION" para exportações de GPU, enquanto exportações DLA em NVIDIA Jetson usam "ENTROPY_CALIBRATION_2". Você pode ler mais detalhes sobre as opções disponíveis no Guia do Desenvolvedor do TensorRT. Os testes da Ultralytics descobriram que "MINMAX_CALIBRATION" é a melhor escolha para exportações de 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 enquanto converte os pesos do modelo.

  • Ajuste o valor de workspace de acordo com suas necessidades de calibração e disponibilidade de recursos. Embora um workspace maior possa aumentar o tempo de calibração, ele permite que o TensorRT explore uma gama mais ampla de táticas de otimização, potencialmente aumentando o desempenho e a precisão do modelo. Por outro lado, um workspace menor 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á ao TensorRT alocar memória automaticamente. Ao configurar manualmente, pode ser necessário aumentar esse valor se a calibração travar (sair sem aviso).

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

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

  • Lembre-se: a calibração para INT8 é específica para cada dispositivo; pegar emprestada uma GPU "high-end" para calibração pode resultar em baixo desempenho quando a inferência for executada em outro dispositivo.

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

Experimentation by NVIDIA led them to recommend using at least 500 calibration images that are representative of the data for your model, with INT8 quantization calibration. This is a guideline and not a hard requirement, and you will need to experiment with what is required to perform well for your dataset. Since the calibration data is required for INT8 calibration with TensorRT, make certain to use the data argument when int8=True for TensorRT and use data="my_dataset.yaml", which will use the images from validation to calibrate with. When no value is passed for data with export to TensorRT with INT8 quantization, the default will be to use one of the "small" example datasets based on the model task instead of throwing an error.

from ultralytics import YOLO

model = YOLO("yolo26n.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("yolo26n.engine", task="detect")

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

Link to this sectionVantagens de usar YOLO com TensorRT INT8#

• Tamanho de 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 pegada de memória ao implantar um modelo.

• Menor consumo de energia: Operações de 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 alvo, levando potencialmente a velocidades de inferência mais rápidas em GPUs, dispositivos embarcados e aceleradores.

Link to this sectionDesvantagens de usar YOLO com TensorRT INT8#

• Diminuições nas métricas de avaliação: Usar uma precisão menor significará que o mAP, Precision, Recall ou qualquer outra métrica usada para avaliar o desempenho do modelo provavelmente será um pouco pior. Veja a 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.

• Aumento nos tempos de desenvolvimento: Encontrar as configurações "ideais" para calibração INT8 para o conjunto de dados e 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 do modelo são menos transferíveis.

Link to this sectionDesempenho da Exportação TensorRT do Ultralytics YOLO#

Link to this sectionNVIDIA A100#

Link to this sectionGPUs de Consumo#

Link to this sectionDispositivos Embarcados#

Link to this sectionMétodos de avaliação#

Expanda as seções abaixo para informações sobre como esses 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, 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("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",
)

Link to this sectionImplantando modelos YOLO26 TensorRT exportados#

Após exportar com sucesso seus modelos Ultralytics YOLO26 para o formato TensorRT, você está pronto para implantá-los. Para instruções detalhadas sobre a implantação de seus modelos TensorRT em vários cenários, dê uma olhada nos seguintes recursos:

• Implantar Ultralytics com um Servidor Triton: Nosso guia sobre como usar o NVIDIA Triton Inference Server (antigo TensorRT Inference Server) especificamente com modelos Ultralytics YOLO.

• Implantando Redes Neurais Profundas com NVIDIA TensorRT: Este artigo explica como usar o NVIDIA TensorRT para implantar redes neurais profundas em plataformas baseadas em GPU de forma eficiente.

• IA de ponta a ponta para PCs com NVIDIA: Implantação NVIDIA TensorRT: Esta postagem explica o uso do NVIDIA TensorRT para otimizar e implantar modelos de IA em PCs com tecnologia NVIDIA.

• Repositório GitHub para NVIDIA TensorRT:: Este é o repositório oficial no GitHub que contém o código-fonte e a documentação do NVIDIA TensorRT.

Link to this sectionResumo#

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

Para mais informações sobre detalhes de uso, dê uma olhada na documentação oficial do TensorRT.

Se você tiver curiosidade sobre outras integrações do Ultralytics YOLO26, nossa página de guia de integração oferece uma vasta seleção de recursos e insights informativos.

Link to this sectionFAQ#

Link to this sectionComo converto modelos YOLO26 para o formato TensorRT?#

Para converter os teus modelos Ultralytics YOLO26 para o formato TensorRT para inferência otimizada em GPU NVIDIA, segue estes passos:

1. Instala o pacote necessário:

   pip install ultralytics

2. Exporta o teu modelo YOLO26:

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

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

Link to this sectionQuais são os benefícios de usar TensorRT para modelos YOLO26?#

Usar TensorRT para otimizar modelos YOLO26 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 de tensores 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 desempenho máximo.

Para saberes mais, explora a documentação oficial do TensorRT da NVIDIA e a nossa visão geral aprofundada do TensorRT.

Link to this sectionPosso usar quantização INT8 com TensorRT para modelos YOLO26?#

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

1. Exportar com INT8:

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

2. Executar inferência:

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

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

Link to this sectionComo implemento modelos YOLO26 TensorRT num NVIDIA Triton Inference Server?#

A implementação de modelos YOLO26 TensorRT num NVIDIA Triton Inference Server pode ser feita usando os seguintes recursos:

• Implementar Ultralytics YOLO26 com Triton Server: Orientação passo a passo sobre como configurar e usar o Triton Inference Server.
• Implementando Redes Neuronais Profundas com NVIDIA TensorRT: O guia da NVIDIA sobre a implementação de modelos de aprendizagem profunda com TensorRT para opções e configurações detalhadas de implementação.

Estes guias ajudar-te-ão a integrar modelos YOLO26 de forma eficiente em vários ambientes de implementação.

Link to this sectionQuais são as melhorias de desempenho observadas com modelos YOLO26 exportados para TensorRT?#

As melhorias de desempenho com TensorRT podem variar com base no hardware usado. 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 consumidor (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 detalhados de desempenho para diferentes configurações de hardware podem ser encontrados na secção de desempenho.

Para insights mais abrangentes sobre o desempenho do TensorRT, consulta a documentação do Ultralytics e os nossos relatórios de análise de desempenho.