Salta para o conteúdo

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 Visão geral

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.

TensorRT Fusão de camadas

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

TensorRT Visão geral

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

Instalação

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

Utilização

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.

Dica

É fundamental garantir que o mesmo dispositivo que irá utilizar os pesos do modelo TensorRT para a implantação seja utilizado para exportar com precisão INT8, uma vez que os resultados da calibração podem variar entre dispositivos.

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

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 size is doubled automatically. If no batch size is specified batch=1, a calibração será efectuada a batch=1 * 2 para reduzir os erros de escala de calibração.

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.

Exemplo

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")
  1. Exporta com eixos dinâmicos, isto será ativado por defeito quando exportar com int8=True mesmo que não estejas explicitamente definido. Vê argumentos de exportação para mais informações.
  2. Define um tamanho máximo de lote de 8 para o modelo exportado, que calibra com batch = 2 * 8 para evitar erros de escala durante a calibração.
  3. Atribui 4 GiB de memória em vez de atribuir o dispositivo inteiro para o processo de conversão.
  4. Utiliza o conjunto de dados COCO para calibração, especificamente as imagens utilizadas para validação (5.000 no total).
# 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'
Cache de calibração

TensorRT gera uma calibração .cache que pode ser reutilizado para acelerar a exportação de futuros pesos do modelo utilizando os mesmos dados, mas isto pode resultar numa calibração deficiente quando os dados são muito diferentes ou se o batch é alterado drasticamente. Nestas circunstâncias, o valor existente .cache deve ser renomeado e movido para um diretório diferente ou eliminado por completo.

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.

Nota sobre as velocidades de inferência

É de esperar que as primeiras chamadas de inferência com um modelo exportado para TensorRT INT8 tenham tempos de pré-processamento, inferência e/ou pós-processamento mais longos do que o habitual. Isto também pode ocorrer quando alteras imgsz durante a inferência, especialmente quando imgsz não é o mesmo que foi especificado durante a exportação (exporta imgsz é definido como TensorRT perfil "ótimo").

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

Desempenho

Testado com o Ubuntu 22.04.3 LTS, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Consulta os Documentos de deteção para obteres exemplos de utilização com estes modelos treinados em COCO, que incluem 80 classes pré-treinadas.

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch tamanho
(pixéis)
FP32 Prevê 0.52 0.51 | 0.56 8 640
FP32 COCOval 0.52 0.52 0.37 1 640
FP16 Prevê 0.34 0.34 | 0.41 8 640
FP16 COCOval 0.33 0.52 0.37 1 640
INT8 Prevê 0.28 0.27 | 0.31 8 640
INT8 COCOval 0.29 0.47 0.33 1 640

Consulta os documentos de segmentação para obteres exemplos de utilização com estes modelos treinados em COCO, que incluem 80 classes pré-treinadas.

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n-seg.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(M)
mAPval
50-95(M)
batch tamanho
(pixéis)
FP32 Prevê 0.62 0.61 | 0.68 8 640
FP32 COCOval 0.63 0.52 0.36 0.49 0.31 1 640
FP16 Prevê 0.40 0.39 | 0.44 8 640
FP16 COCOval 0.43 0.52 0.36 0.49 0.30 1 640
INT8 Prevê 0.34 0.33 | 0.37 8 640
INT8 COCOval 0.36 0.46 0.32 0.43 0.27 1 640

Consulta os documentos de classificação para obteres exemplos de utilização com estes modelos treinados no ImageNet, que incluem 1000 classes pré-treinadas.

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n-cls.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
topo-1 top-5 batch tamanho
(pixéis)
FP32 Prevê 0.26 0.25 | 0.28 8 640
FP32 ImageNetval 0.26 0.35 0.61 1 640
FP16 Prevê 0.18 0.17 | 0.19 8 640
FP16 ImageNetval 0.18 0.35 0.61 1 640
INT8 Prevê 0.16 0.15 | 0.57 8 640
INT8 ImageNetval 0.15 0.32 0.59 1 640

Consulta os documentos de estimativa de pose para exemplos de utilização com estes modelos treinados em COCO, que incluem uma classe pré-treinada, "pessoa".

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n-pose.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
mAPval
50(P)
mAPval
50-95(P)
batch tamanho
(pixéis)
FP32 Prevê 0.54 0.53 | 0.58 8 640
FP32 COCOval 0.55 0.91 0.69 0.80 0.51 1 640
FP16 Prevê 0.37 0.35 | 0.41 8 640
FP16 COCOval 0.36 0.91 0.69 0.80 0.51 1 640
INT8 Prevê 0.29 0.28 | 0.33 8 640
INT8 COCOval 0.30 0.90 0.68 0.78 0.47 1 640

Consulta os documentos de deteção orientada para obteres exemplos de utilização com estes modelos treinados no DOTAv1, que incluem 15 classes pré-treinadas.

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n-obb.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch tamanho
(pixéis)
FP32 Prevê 0.52 0.51 | 0.59 8 640
FP32 DOTAv1val 0.76 0.50 0.36 1 640
FP16 Prevê 0.34 0.33 | 0.42 8 640
FP16 DOTAv1val 0.59 0.50 0.36 1 640
INT8 Prevê 0.29 0.28 | 0.33 8 640
INT8 DOTAv1val 0.32 0.45 0.32 1 640

GPUs de consumo

Desempenho de deteção (COCO)

Testado com o Windows 10.0.19045, python 3.10.9, ultralytics==8.2.4, tensorrt==10.0.0b6

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch tamanho
(pixéis)
FP32 Prevê 1.06 0.75 | 1.88 8 640
FP32 COCOval 1.37 0.52 0.37 1 640
FP16 Prevê 0.62 0.75 | 1.13 8 640
FP16 COCOval 0.85 0.52 0.37 1 640
INT8 Prevê 0.52 0.38 | 1.00 8 640
INT8 COCOval 0.74 0.47 0.33 1 640

Testado com o Windows 10.0.22631, python 3.11.9, ultralytics==8.2.4, tensorrt==10.0.1

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch tamanho
(pixéis)
FP32 Prevê 1.76 1.69 | 1.87 8 640
FP32 COCOval 1.94 0.52 0.37 1 640
FP16 Prevê 0.86 0.75 | 1.00 8 640
FP16 COCOval 1.43 0.52 0.37 1 640
INT8 Prevê 0.80 0.75 | 1.00 8 640
INT8 COCOval 1.35 0.47 0.33 1 640

Testado com o Pop!_OS 22.04 LTS, python 3.10.12, ultralytics==8.2.4, tensorrt==8.6.1.post1

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch tamanho
(pixéis)
FP32 Prevê 2.84 2.84 | 2.85 8 640
FP32 COCOval 2.94 0.52 0.37 1 640
FP16 Prevê 1.09 1.09 | 1.10 8 640
FP16 COCOval 1.20 0.52 0.37 1 640
INT8 Prevê 0.75 0.74 | 0.75 8 640
INT8 COCOval 0.76 0.47 0.33 1 640

Dispositivos incorporados

Desempenho de deteção (COCO)

Testado com JetPack 6.0 (L4T 36.3) Ubuntu 22.04.4 LTS, python 3.10.12, ultralytics==8.2.16, tensorrt==10.0.1

Nota

Tempos de inferência apresentados para mean, min (mais rápido), e max (mais lento) para cada teste utilizando pesos pré-treinados yolov8n.engine

Precisão Teste de avaliação média
(ms)
min | max
(ms)
mAPval
50(B)
mAPval
50-95(B)
batch tamanho
(pixéis)
FP32 Prevê 6.11 6.10 | 6.29 8 640
FP32 COCOval 6.17 0.52 0.37 1 640
FP16 Prevê 3.18 3.18 | 3.20 8 640
FP16 COCOval 3.19 0.52 0.37 1 640
INT8 Prevê 2.30 2.29 | 2.35 8 640
INT8 COCOval 2.32 0.46 0.32 1 640

Métodos de avaliação

Expande as secções abaixo para obteres informações sobre a forma como estes modelos foram exportados e testados.

Exportar configurações

Consulta o modo de exportação para obteres detalhes sobre os argumentos de configuração de exportação.

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"
)
Prever laço

Consulta o modo de previsão para obteres mais informações.

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",
    )
Configuração da validação

val modo para saber mais sobre argumentos de configuração de validação.

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:

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:

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.


📅 Created 8 months ago ✏️ Updated 6 days ago

Comentários