Link to this sectionExportação para 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á etapas 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#

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

Este kit de ferramentas otimiza modelos de deep learning para GPUs NVIDIA, resultando em operações mais rápidas e eficientes. Os modelos TensorRT passam por uma 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 autoajuste de kernels. Converter modelos de deep learning para o formato TensorRT permite que 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 série de recursos principais que contribuem para sua eficiência e eficácia em 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, que podem 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 a 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 o cálculo.

• 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 de memória. Isso resulta em uma utilização mais eficiente da memória da GPU.

• Autoajuste de kernels: O TensorRT aplica o autoajuste de kernels para selecionar o kernel de GPU mais otimizado para cada camada do modelo. Essa abordagem adaptativa garante que o modelo tire proveito total do 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 usados normalmente.

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

• 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, já que o TF-TRT pode lidar com elas de forma eficiente.

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

• NVIDIA Triton Inference Server: Uma opção que oferece suporte a modelos de vários frameworks. Particularmente adequado para inferência na nuvem ou na borda (edge), ele fornece recursos como execução simultânea de modelos e análise de modelos.

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, consulte nosso Guia de Instalação do YOLO26. Se encontrar dificuldades ao instalar os pacotes necessários para o YOLO26, consulte nosso Guia de Problemas Comuns para soluções e dicas.

Link to this sectionUso#

Antes de mergulhar nas instruções de uso, não deixe 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 e, em seguida, 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 da 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 que é 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 das camadas. Se uma camada for executada mais rapidamente em INT8 e tiver escalas de quantização atribuídas em suas entradas e saídas de dados, então um kernel com precisão INT8 será 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 essa camada.

Link to this sectionConfigurando a exportação INT8#

Os argumentos fornecidos ao usar export para um modelo Ultralytics YOLO influenciarão significativamente 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 as exportações de DLA no 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 durante a conversão dos 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 aprimorando 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á que o TensorRT aloque 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 de workspace for maior do que a memória disponível para o dispositivo, o que significa que o valor de workspace deve ser reduzido ou definido como None.

  • Se o workspace estiver definido com o 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 de que a calibração para INT8 é específica para cada dispositivo; usar uma GPU de "alto desempenho" para calibração pode resultar em baixo desempenho quando a inferência for executada em outro dispositivo.

• batch : O tamanho máximo do lote (batch-size) 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.

A experimentação da NVIDIA os levou a recomendar o uso de pelo menos 500 imagens de calibração que sejam representativas dos dados para o seu modelo, com calibração de quantização INT8. Esta é uma diretriz e não um requisito rígido, e você precisará experimentar o que é necessário para ter um bom desempenho para seu conjunto de dados. Como os dados de calibração são necessários para a calibração INT8 com TensorRT, certifique-se de usar o argumento data quando int8=True para o TensorRT e usar data="my_dataset.yaml", que usará as imagens de validação para calibrar. Quando nenhum valor é passado para data na exportação para TensorRT com quantização INT8, o padrão será usar um dos "pequenos" conjuntos de dados de exemplo baseados 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)!
    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 reduzido 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 uso 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 de destino, potencialmente levando 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. Consulte a seção de resultados de desempenho para comparar as diferenças no mAP50 e mAP50-95 ao exportar com INT8 em uma pequena amostra de vários dispositivos.

• Tempos de desenvolvimento aumentados: Encontrar as configurações "ideais" para a calibração INT8 para seu 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 Ultralytics YOLO TensorRT#

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 sectionImplementação de Modelos YOLO26 Exportados para TensorRT#

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

• Implementa Ultralytics com um Servidor Triton: O nosso guia sobre como utilizar o Servidor Triton Inference da NVIDIA (anteriormente TensorRT Inference) especificamente com modelos Ultralytics YOLO.

• Implementar Redes Neuronais Profundas com NVIDIA TensorRT: Este artigo explica como utilizar o NVIDIA TensorRT para implementar redes neuronais profundas de forma eficiente em plataformas baseadas em GPU.

• IA de Ponta a Ponta para PCs baseados em NVIDIA: Implementação NVIDIA TensorRT: Esta publicação explica a utilização do NVIDIA TensorRT para otimizar e implementar 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 do NVIDIA TensorRT.

Link to this sectionResumo#

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

Para mais informações sobre 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 de guia de integração oferece uma vasta seleção de recursos e conhecimentos informativos.

Link to this sectionPerguntas Frequentes#

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

Para converteres os teus modelos Ultralytics YOLO26 para o formato TensorRT para uma 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 YOLO26 e a documentação de exportação.

Link to this sectionQuais são as vantagens de utilizar TensorRT para modelos YOLO26?#

Utilizar TensorRT para otimizar modelos YOLO26 oferece várias vantagens:

• Velocidade de Inferência Mais Rápida: O TensorRT otimiza as camadas do modelo e utiliza 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 múltiplas camadas em operações únicas, reduzindo a complexidade computacional.
• Auto-ajuste de Kernels: 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 detalhada do TensorRT.

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

Sim, podes exportar modelos YOLO26 utilizando 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 sobre exportação de TensorRT com quantização INT8.

Link to this sectionComo implemento modelos YOLO26 TensorRT num Servidor de Inferência NVIDIA Triton?#

A implementação de modelos YOLO26 TensorRT num Servidor de Inferência NVIDIA Triton pode ser feita utilizando os seguintes recursos:

• Implementar Ultralytics YOLO26 com Servidor Triton: Orientação passo a passo sobre como configurar e utilizar o Servidor Triton Inference.
• Implementar 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 de implementação detalhadas.

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 consoante o hardware utilizado. Aqui estão alguns benchmarks típicos:

• NVIDIA A100:

  • FP32 Inferência: ~0,52 ms / imagem
  • FP16 Inferência: ~0,34 ms / imagem
  • INT8 Inferência: ~0,28 ms / imagem
  • Ligeira redução no mAP com precisão INT8, mas melhoria significativa na velocidade.

• GPUs de Consumo (ex.: RTX 3080):

  • FP32 Inferência: ~1,06 ms / imagem
  • FP16 Inferência: ~0,62 ms / imagem
  • INT8 Inferência: ~0,52 ms / imagem

Benchmarks de desempenho detalhados para diferentes configurações de hardware podem ser encontrados na secção de desempenho.

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