TensorRT Exportar para YOLOv8 Modelos

Desplegar modelos de visión por ordenador en entornos de alto rendimiento puede requerir un formato que maximice la velocidad y la eficacia. Esto es especialmente cierto cuando despliegas tu modelo en GPUs NVIDIA .

Utilizando el formato de exportación TensorRT , puedes mejorar tus Ultralytics YOLOv8 modelos para una inferencia rápida y eficaz en el hardware NVIDIA . Esta guía te dará unos pasos fáciles de seguir para el proceso de conversión y te ayudará a aprovechar al máximo la avanzada tecnología de NVIDIA en tus proyectos de aprendizaje profundo.

TensorRT

TensorRTdesarrollado por NVIDIA, es un kit avanzado de desarrollo de software (SDK) diseñado para la inferencia de aprendizaje profundo de alta velocidad. Es muy adecuado para aplicaciones en tiempo real como la detección de objetos.

Este conjunto de herramientas optimiza los modelos de aprendizaje profundo para las GPU NVIDIA y da lugar a operaciones más rápidas y eficientes. Los modelos TensorRT se someten a la optimización TensorRT , que incluye técnicas como la fusión de capas, la calibración de precisión (INT8 y FP16), la gestión dinámica de la memoria tensor y el autoajuste del núcleo. Convertir los modelos de aprendizaje profundo al formato TensorRT permite a los desarrolladores aprovechar plenamente el potencial de las GPU NVIDIA .

TensorRT es conocido por su compatibilidad con varios formatos de modelos, como TensorFlow, PyTorch y ONNX, lo que proporciona a los desarrolladores una solución flexible para integrar y optimizar modelos de distintos marcos de trabajo. Esta versatilidad permite un despliegue eficaz de los modelos en diversos entornos de hardware y software.

Características principales de los modelos TensorRT

TensorRT ofrecen una serie de características clave que contribuyen a su eficiencia y eficacia en la inferencia de aprendizaje profundo de alta velocidad:

• Calibración de precisión: TensorRT admite la calibración de precisión, lo que permite ajustar los modelos a requisitos de precisión específicos. Esto incluye la compatibilidad con formatos de precisión reducida como INT8 y FP16, que pueden aumentar aún más la velocidad de inferencia manteniendo niveles de precisión aceptables.

• Fusión de capas: El proceso de optimización TensorRT incluye la fusión de capas, en la que varias capas de una red neuronal se combinan en una sola operación. Esto reduce la sobrecarga computacional y mejora la velocidad de inferencia al minimizar el acceso a la memoria y el cálculo.

• Gestión dinámica de la memoria Tensor : TensorRT gestiona eficazmente el uso de la memoria tensor durante la inferencia, reduciendo la sobrecarga de memoria y optimizando la asignación de memoria. El resultado es una utilización más eficiente de la memoria GPU .

• Ajuste automático del núcleo: TensorRT aplica el ajuste automático del núcleo para seleccionar el núcleo GPU más optimizado para cada capa del modelo. Este enfoque adaptativo garantiza que el modelo aproveche al máximo la potencia de cálculo de GPU.

Opciones de despliegue en TensorRT

Antes de ver el código para exportar YOLOv8 modelos a la TensorRT formato, entendamos dónde TensorRT Normalmente se utilizan modelos.

TensorRT ofrece varias opciones de implantación, y cada opción equilibra de forma diferente la facilidad de integración, la optimización del rendimiento y la flexibilidad:

• Desplegar dentro de TensorFlow: Este método integra TensorRT en TensorFlow, permitiendo que los modelos optimizados se ejecuten en un entorno familiar de TensorFlow . Es útil para modelos con una mezcla de capas admitidas y no admitidas, ya que TF-TRT puede manejarlas eficazmente.

• API independiente en tiempo de ejecución TensorRT : Ofrece un control granular, ideal para aplicaciones de rendimiento crítico. Es más compleja, pero permite la implementación personalizada de operadores no compatibles.

• NVIDIA Triton Servidor de inferencias: Una opción que admite modelos de varios marcos. Especialmente adecuado para la inferencia en la nube o en el borde, proporciona funciones como la ejecución concurrente de modelos y el análisis de modelos.

Exportar modelos de YOLOv8 a TensorRT

Puedes mejorar la eficacia de la ejecución y optimizar el rendimiento convirtiendo los modelos de YOLOv8 al formato TensorRT .

Instalación

Para instalar el paquete necesario, ejecuta

# Install the required package for YOLOv8
pip install ultralytics

Para obtener instrucciones detalladas y buenas prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalaciónYOLOv8 . Mientras instalas los paquetes necesarios para YOLOv8, si encuentras alguna dificultad, consulta nuestra guía de Problemas comunes para encontrar soluciones y consejos.

Utilización

Antes de sumergirte en las instrucciones de uso, asegúrate de consultar la gama de modelosYOLOv8 que ofrece Ultralytics. Esto te ayudará a elegir el modelo más apropiado para los requisitos de tu proyecto.

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 más detalles sobre el proceso de exportación, visita la página de documentaciónUltralytics sobre exportación.

Exportar TensorRT con cuantización INT8

La exportación de modelos Ultralytics YOLO utilizando TensorRT con precisión INT8 ejecuta la cuantización post-entrenamiento (PTQ). TensorRT utiliza la calibración para la PTQ, que mide la distribución de activaciones dentro de cada activación tensor a medida que el modelo YOLO procesa la inferencia sobre datos de entrada representativos, y luego utiliza esa distribución para estimar valores de escala para cada tensor. Cada activación tensor candidata a la cuantización tiene una escala asociada que se deduce mediante un proceso de calibración.

Al procesar redes cuantificadas implícitamente, TensorRT utiliza INT8 de forma oportunista para optimizar el tiempo de ejecución de las capas. Si una capa se ejecuta más rápido en INT8 y tiene asignadas escalas de cuantización en sus entradas y salidas de datos, entonces se asigna a esa capa un núcleo con precisión INT8; de lo contrario, TensorRT selecciona una precisión de FP32 o FP16 para el núcleo en función de la que resulte en un tiempo de ejecución más rápido para esa capa.

Configurar la exportación INT8

Los argumentos proporcionados al utilizar exportar para un modelo Ultralytics YOLO en gran medida influyen en el rendimiento del modelo exportado. También tendrán que seleccionarse en función de los recursos del dispositivo disponibles, sin embargo, los argumentos por defecto debe funcionan para la mayoría GPU discretas Ampere (o más recientes) NVIDIA. El algoritmo de calibración utilizado es "ENTROPY_CALIBRATION_2" y puedes leer más detalles sobre las opciones disponibles en la Guía del desarrollador TensorRT. Ultralytics las pruebas constataron que "ENTROPY_CALIBRATION_2" era la mejor opción y las exportaciones se fijan en utilizar este algoritmo.

• workspace : Controla el tamaño (en GiB) de la asignación de memoria del dispositivo al convertir los pesos del modelo.

  • Ajusta el workspace según tus necesidades de calibración y la disponibilidad de recursos. Mientras que un valor workspace puede aumentar el tiempo de calibración, permite a TensorRT explorar una gama más amplia de tácticas de optimización, mejorando potencialmente el rendimiento y la precisión del modelo. Por el contrario, un workspace puede reducir el tiempo de calibración, pero puede limitar las estrategias de optimización, afectando a la calidad del modelo cuantizado.

  • Por defecto es workspace=4 (GiB), puede ser necesario aumentar este valor si la calibración se bloquea (sale sin avisar).

  • TensorRT informará UNSUPPORTED_STATE durante la exportación si el valor de workspace es mayor que la memoria disponible en el dispositivo, lo que significa que el valor de workspace debe reducirse.

  • Si workspace está ajustado al valor máximo y la calibración falla/se bloquea, considera la posibilidad de reducir los valores de imgsz y batch para reducir los requisitos de memoria.

  • Recuerda que la calibración para INT8 es específica de cada dispositivo, tomar prestado un GPU "de gama alta" para la calibración, podría dar lugar a un rendimiento deficiente cuando se ejecute la inferencia en otro dispositivo.

• batch : El tamaño máximo de lote que se utilizará para la inferencia. Durante la inferencia se pueden utilizar lotes más pequeños, pero la inferencia no aceptará lotes mayores que el especificado.

La experimentación de NVIDIA les ha llevado a recomendar el uso de al menos 500 imágenes de calibración representativas de los datos de tu modelo, con calibración de cuantización INT8. Se trata de una orientación y no de una duro requisito, y tendrás que experimentar con lo que se necesita para obtener buenos resultados en tu conjunto de datos. Dado que los datos de calibración son necesarios para la calibración INT8 con TensorRT, asegúrate de utilizar la opción data argumento cuando int8=True para TensorRT y utilizar data="my_dataset.yaml"que utilizará las imágenes de validación para calibrar. Cuando no se pasa ningún valor para data con exportación a TensorRT con cuantización INT8, por defecto se utilizará uno de los "pequeños" conjuntos de datos de ejemplo basados en la tarea modelo en lugar de lanzar un error.

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")

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

Ventajas de utilizar YOLO con TensorRT INT8

• Reducción del tamaño del modelo: La cuantización de FP32 a INT8 puede reducir el tamaño del modelo 4 veces (en disco o en memoria), lo que se traduce en tiempos de descarga más rápidos, menores requisitos de almacenamiento y menor huella de memoria al desplegar un modelo.

• Menor consumo de energía: Las operaciones de precisión reducida de los modelos INT8 exportados a YOLO pueden consumir menos energía en comparación con los modelos FP32, especialmente para los dispositivos alimentados por batería.

• Velocidades de inferencia mejoradas: TensorRT optimiza el modelo para el hardware de destino, lo que puede dar lugar a velocidades de inferencia más rápidas en GPU, dispositivos integrados y aceleradores.

Inconvenientes de utilizar YOLO con TensorRT INT8

• Disminución de las métricas de evaluación: Utilizar una precisión menor significará que mAP, Precision, Recall o cualquier otra métrica utilizada para evaluar el rendimiento del modelo es probable que sea algo peor. Véase el Sección de resultados para comparar las diferencias en mAP50 y mAP50-95 al exportar con INT8 en una pequeña muestra de varios dispositivos.

• Mayor tiempo de desarrollo: Encontrar los ajustes "óptimos" para la calibración INT8 para el conjunto de datos y el dispositivo puede llevar una cantidad significativa de pruebas.

• Dependencia del hardware: La calibración y las mejoras de rendimiento podrían depender en gran medida del hardware y los pesos de los modelos son menos transferibles.

Ultralytics YOLO TensorRT Rendimiento de las exportaciones

NVIDIA A100

GPU de consumo

Dispositivos integrados

Métodos de evaluación

Amplía las secciones siguientes para obtener información sobre cómo se exportaron y probaron estos modelos.

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"
)

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

Despliegue de modelos exportados de YOLOv8 TensorRT

Una vez exportados con éxito tus modelos Ultralytics YOLOv8 al formato TensorRT , ya estás preparado para desplegarlos. Para obtener instrucciones detalladas sobre el despliegue de tus modelos TensorRT en distintos entornos, echa un vistazo a los siguientes recursos:

• Despliega Ultralytics con un servidor Triton : Nuestra guía sobre cómo utilizar NVIDIA's Triton Inference (anteriormente TensorRT Inference) Server específicamente para su uso con modelos Ultralytics YOLO .

• Despliegue de redes neuronales profundas con NVIDIA TensorRT: Este artículo explica cómo utilizar NVIDIA TensorRT para desplegar redes neuronales profundas en plataformas de despliegue basadas en GPU de forma eficiente.

• IA de extremo a extremo para ordenadores basados en NVIDIA: NVIDIA TensorRT Despliegue: Esta entrada de blog explica el uso de NVIDIA TensorRT para optimizar y desplegar modelos de IA en PC basados en NVIDIA.

• Repositorio GitHub para NVIDIA TensorRT :: Este es el repositorio oficial de GitHub que contiene el código fuente y la documentación de NVIDIA TensorRT .

Resumen

En esta guía, nos centramos en la conversión de los modelos Ultralytics YOLOv8 al formato de modelo NVIDIA's TensorRT . Este paso de conversión es crucial para mejorar la eficacia y velocidad de los modelos YOLOv8 , haciéndolos más eficaces y adecuados para diversos entornos de despliegue.

Para más información sobre los detalles de uso, echa un vistazo a la documentación oficial deTensorRT .

Si tienes curiosidad por conocer otras integraciones de Ultralytics YOLOv8 , nuestra página de guía de integraciones ofrece una amplia selección de recursos informativos y puntos de vista.

PREGUNTAS FRECUENTES

¿Cómo convierto los modelos de YOLOv8 al formato TensorRT ?

Para convertir tus modelos Ultralytics YOLOv8 al formato TensorRT para una inferencia optimizada NVIDIA GPU , sigue estos pasos:

1. Instala el paquete necesario:

   pip install ultralytics
   

2. Exporta tu 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 más detalles, visita la guía de instalaciónYOLOv8 y la documentación de exportación.

¿Cuáles son las ventajas de utilizar TensorRT para los modelos YOLOv8 ?

Utilizar TensorRT para optimizar los modelos de YOLOv8 ofrece varias ventajas:

• Mayor velocidad de inferencia: TensorRT optimiza las capas del modelo y utiliza la calibración de precisión (INT8 y FP16) para acelerar la inferencia sin sacrificar significativamente la precisión.
• Eficiencia de la memoria: TensorRT gestiona dinámicamente la memoria de tensor , reduciendo la sobrecarga y mejorando la utilización de la memoria de GPU .
• Fusión de capas: Combina varias capas en una sola operación, reduciendo la complejidad computacional.
• Ajuste automático del núcleo: Selecciona automáticamente núcleos GPU optimizados para cada capa del modelo, garantizando el máximo rendimiento.

Para más información, explora las características detalladas de TensorRT aquí y lee nuestra secciónTensorRT visión general.

¿Puedo utilizar la cuantización INT8 con TensorRT para los modelos YOLOv8 ?

Sí, puedes exportar modelos YOLOv8 utilizando TensorRT con cuantización INT8. Este proceso implica la cuantización post-entrenamiento (PTQ) y la calibración:

1. Exporta con INT8:

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

2. Ejecuta la inferencia:

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

Para más detalles, consulta la sección Exportar TensorRT con cuantización INT8.

¿Cómo despliego los modelos YOLOv8 TensorRT en un servidor de inferencia NVIDIA Triton ?

El despliegue de los modelos YOLOv8 TensorRT en un servidor de inferencia NVIDIA Triton puede realizarse utilizando los siguientes recursos:

• Despliega Ultralytics YOLOv8 con Triton Servidor: Guía paso a paso para configurar y utilizar Triton Servidor de Inferencia.
• NVIDIA Triton Documentación del Servidor de Inferencia: Documentación oficial de NVIDIA para opciones de despliegue y configuraciones detalladas.

Estas guías te ayudarán a integrar eficazmente los modelos YOLOv8 en diversos entornos de implantación.

¿Cuáles son las mejoras de rendimiento observadas con los modelos de YOLOv8 exportados a TensorRT?

Las mejoras de rendimiento con TensorRT pueden variar en función del hardware utilizado. Aquí tienes algunos puntos de referencia típicos:

• NVIDIA A100:

  • Inferencia FP32: ~0,52 ms / imagen
  • Inferencia FP16: ~0,34 ms / imagen
  • Inferencia INT8: ~0,28 ms / imagen
  • Ligera reducción del mAP con precisión INT8, pero mejora significativa de la velocidad.

• GPU de consumo (por ejemplo, RTX 3080):

  • Inferencia FP32: ~1,06 ms / imagen
  • Inferencia FP16: ~0,62 ms / imagen
  • Inferencia INT8: ~0,52 ms / imagen

En la sección de rendimiento encontrarás pruebas de rendimiento detalladas para distintas configuraciones de hardware.

Para obtener información más completa sobre el rendimiento de TensorRT , consulta la documentación deUltralytics y nuestros informes de análisis del rendimiento.

Comentarios