Exportación a TensorRT para modelos YOLO11

Implementar modelos de visión artificial en entornos de alto rendimiento puede requerir un formato que maximice la velocidad y la eficiencia. Esto es especialmente cierto cuando se implementa el modelo en GPU NVIDIA.

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

TensorRT

TensorRT, desarrollado por NVIDIA, es un kit de desarrollo de software (SDK) avanzado 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 como resultado operaciones más rápidas y eficientes. Los modelos TensorRT se someten a una optimización de 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 de los tensores y el ajuste automático del kernel. La conversión de modelos de aprendizaje profundo al formato TensorRT permite a los desarrolladores aprovechar todo el potencial de las GPU NVIDIA.

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

Características principales de los modelos TensorRT

Los modelos TensorRT ofrecen una gama 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 para requisitos de exactitud 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 exactitud aceptables.

• Fusión de Capas: El proceso de optimización de TensorRT incluye la fusión de capas, donde 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 de Tensores: TensorRT gestiona eficientemente el uso de la memoria de los tensores durante la inferencia, reduciendo la sobrecarga de memoria y optimizando la asignación de memoria. Esto resulta en una utilización más eficiente de la memoria de la GPU.

• Ajuste Automático del Kernel: TensorRT aplica el ajuste automático del kernel para seleccionar el kernel de la GPU más optimizado para cada capa del modelo. Este enfoque adaptativo asegura que el modelo aproveche al máximo la potencia computacional de las GPUs.

Opciones de implementación en TensorRT

Antes de examinar el código para exportar modelos YOLO11 al formato TensorRT, comprendamos dónde se utilizan normalmente los modelos TensorRT.

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

• Implementación dentro de TensorFlow: Este método integra TensorRT en TensorFlow, permitiendo que los modelos optimizados se ejecuten en un entorno TensorFlow familiar. Es útil para modelos con una mezcla de capas compatibles e incompatibles, ya que TF-TRT puede manejarlos de manera eficiente.

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

• Servidor de Inferencia NVIDIA Triton: Una opción que admite modelos de varios frameworks. Particularmente adecuado para la inferencia en la nube o en el borde, proporciona características como la ejecución concurrente de modelos y el análisis de modelos.

Exportando modelos YOLO11 a TensorRT

Puede mejorar la eficiencia de la ejecución y optimizar el rendimiento convirtiendo los modelos YOLO11 a formato TensorRT.

Instalación

Para instalar el paquete requerido, ejecute:

# Install the required package for YOLO11
pip install ultralytics

Para obtener instrucciones detalladas y las mejores prácticas relacionadas con el proceso de instalación, consulte nuestra guía de instalación de YOLO11. Si tiene alguna dificultad al instalar los paquetes necesarios para YOLO11, consulte nuestra guía de problemas comunes para obtener soluciones y consejos.

Uso

Antes de sumergirse en las instrucciones de uso, asegúrese de consultar la gama de modelos YOLO11 ofrecidos por Ultralytics. Esto le ayudará a elegir el modelo más apropiado para los requisitos de su proyecto.

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

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

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

# Export a YOLO11n PyTorch model to TensorRT format
yolo export model=yolo11n.pt format=engine # creates 'yolo11n.engine''

# Run inference with the exported model
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'

Argumentos de exportación

Para obtener más detalles sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre la exportación.

Exportación de TensorRT con cuantificación INT8

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

Cuando se procesan redes cuantificadas implícitamente, TensorRT utiliza INT8 oportunistamente para optimizar el tiempo de ejecución de la capa. Si una capa se ejecuta más rápido en INT8 y tiene escalas de cuantificación asignadas en sus entradas y salidas de datos, entonces se asigna un kernel con precisión INT8 a esa capa; de lo contrario, TensorRT selecciona una precisión de FP32 o FP16 para el kernel en función de cuál resulte en un tiempo de ejecución más rápido para esa capa.

Configuración de la exportación INT8

Los argumentos proporcionados al usar export para un modelo Ultralytics YOLO influirán enormemente en el rendimiento del modelo exportado. También deberán seleccionarse en función de los recursos del dispositivo disponibles, sin embargo, los argumentos predeterminados deberían funcionar para la mayoría de las GPU discretas NVIDIA Ampere (o más recientes). El algoritmo de calibración utilizado es "MINMAX_CALIBRATION" y puede leer más detalles sobre las opciones disponibles en la Guía para desarrolladores de TensorRT. Las pruebas de Ultralytics encontraron que "MINMAX_CALIBRATION" fue la mejor opción y las exportaciones se fijan para usar este algoritmo.

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

  • Ajuste el workspace valor según sus necesidades de calibración y la disponibilidad de recursos. Si bien un valor más grande workspace puede aumentar el tiempo de calibración, permite que TensorRT explore una gama más amplia de tácticas de optimización, lo que podría mejorar el rendimiento del modelo y precisión. Por el contrario, un valor más pequeño workspace puede reducir el tiempo de calibración, pero puede limitar las estrategias de optimización, afectando la calidad del modelo cuantificado.

  • El valor predeterminado es workspace=None, lo que permitirá que TensorRT asigne memoria automáticamente. Al configurar manualmente, es posible que sea necesario aumentar este valor si la calibración falla (se cierra sin previo aviso).

  • TensorRT informará UNSUPPORTED_STATE durante la exportación si el valor de workspace es mayor que la memoria disponible para el dispositivo, lo que significa que el valor de workspace debería reducirse o establecerse en None.

  • Si workspace está configurado con el valor máximo y la calibración falla/se bloquea, considere usar None para la asignación automática o reduciendo los valores de imgsz y batch para reducir los requisitos de memoria.

  • Recuerde que la calibración para INT8 es específica para cada dispositivo, tomar prestada una GPU de "gama alta" para la calibración, podría resultar en un rendimiento deficiente cuando la inferencia se ejecuta 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 de lo que se especifica.

La experimentación de NVIDIA los llevó a recomendar el uso de al menos 500 imágenes de calibración que sean representativas de los datos de su modelo, con la calibración de cuantificación INT8. Esta es una guía y no un requisito estricto , y tendrá que experimentar con lo que se requiere para que funcione bien para su conjunto de datos. Dado que los datos de calibración son necesarios para la calibración INT8 con TensorRT, asegúrese de utilizar el argumento data cuando int8=True para TensorRT y usar data="my_dataset.yaml", que utilizará las imágenes de validación para calibrar. Cuando no se pasa ningún valor para data con la exportación a TensorRT con cuantización INT8, el valor predeterminado será utilizar uno de los conjuntos de datos de ejemplo "pequeños" basados en la tarea del modelo en lugar de generar 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 YOLO11n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolo11n.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 usar YOLO con TensorRT INT8

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

• Menor consumo de energía: Las operaciones de precisión reducida para los modelos YOLO exportados a INT8 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 conducir a velocidades de inferencia más rápidas en las GPU, los dispositivos integrados y los aceleradores.

Desventajas de usar YOLO con TensorRT INT8

• Disminución en las métricas de evaluación: Usar una precisión más baja significará que mAP, Precision, Recall o cualquier otra métrica utilizada para evaluar el rendimiento del modelo probablemente será algo peor. Consulte la sección de Resultados de rendimiento para comparar las diferencias en mAP50 y mAP50-95 al exportar con INT8 en una pequeña muestra de varios dispositivos.

• Tiempos de desarrollo aumentados: Encontrar la configuración "óptima" 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 ganancias de rendimiento podrían depender en gran medida del hardware y los pesos del modelo son menos transferibles.

Rendimiento de la exportación de Ultralytics YOLO TensorRT

NVIDIA A100

GPU para consumidores

Dispositivos integrados

Métodos de evaluación

Expanda las siguientes secciones 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",
)

Implementación de modelos TensorRT YOLO11 exportados

Una vez que haya exportado con éxito sus modelos Ultralytics YOLO11 al formato TensorRT, estará listo para implementarlos. Para obtener instrucciones detalladas sobre cómo implementar sus modelos TensorRT en diversas configuraciones, consulte los siguientes recursos:

• Implementar Ultralytics con un servidor Triton: Nuestra guía sobre cómo usar el servidor Triton Inference de NVIDIA (anteriormente TensorRT Inference) específicamente para usar con modelos Ultralytics YOLO.

• Implementación de redes neuronales profundas con NVIDIA TensorRT: Este artículo explica cómo usar NVIDIA TensorRT para implementar redes neuronales profundas en plataformas de implementación basadas en GPU de manera eficiente.

• IA de extremo a extremo para PC basadas en NVIDIA: Implementación de NVIDIA TensorRT: Esta publicación de blog explica el uso de NVIDIA TensorRT para optimizar e implementar modelos de IA en PC basadas en NVIDIA.

• Repositorio de 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 modelos Ultralytics YOLO11 al formato de modelo TensorRT de NVIDIA. Este paso de conversión es crucial para mejorar la eficiencia y la velocidad de los modelos YOLO11, haciéndolos más efectivos y adecuados para diversos entornos de implementación.

Para obtener más información sobre los detalles de uso, consulte la documentación oficial de TensorRT.

Si tienes curiosidad por conocer integraciones adicionales de Ultralytics YOLO11, nuestra página de guía de integración ofrece una amplia selección de recursos e información.

Preguntas frecuentes

¿Cómo convierto los modelos YOLO11 al formato TensorRT?

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

1. Instale el paquete requerido:

   pip install ultralytics
   

2. Exporte su modelo YOLO11:

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

Para obtener más detalles, visita la guía de instalación de YOLO11 y la documentación de exportación.

¿Cuáles son los beneficios de usar TensorRT para modelos YOLO11?

El uso de TensorRT para optimizar los modelos YOLO11 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 memoria: TensorRT gestiona la memoria del tensor de forma dinámica, lo que reduce la sobrecarga y mejora la utilización de la memoria de la GPU.
• Fusión de capas: Combina varias capas en operaciones individuales, lo que reduce la complejidad computacional.
• Ajuste automático del kernel: Selecciona automáticamente los kernels de GPU optimizados para cada capa del modelo, lo que garantiza el máximo rendimiento.

Para obtener más información, explora la documentación oficial de TensorRT de NVIDIA y nuestra descripción detallada de TensorRT.

¿Puedo usar la cuantización INT8 con TensorRT para modelos YOLO11?

Sí, puedes exportar modelos YOLO11 utilizando TensorRT con cuantificación INT8. Este proceso implica la cuantificación posterior al entrenamiento (PTQ) y la calibración:

1. Exportar con INT8:

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

2. Ejecutar inferencia:

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

Para obtener más detalles, consulte la sección de exportación de TensorRT con cuantificación INT8.

¿Cómo puedo implementar modelos YOLO11 TensorRT en un servidor de inferencia NVIDIA Triton?

La implementación de modelos TensorRT YOLO11 en un servidor de inferencia NVIDIA Triton se puede realizar utilizando los siguientes recursos:

• Implementación de Ultralytics YOLOv8 con Triton Server: Guía paso a paso sobre cómo configurar y usar Triton Inference Server.
• Documentación del Servidor de Inferencia NVIDIA Triton: Documentación oficial de NVIDIA con opciones de implementación y configuraciones detalladas.

Estas guías te ayudarán a integrar modelos YOLOv8 de manera eficiente en diversos entornos de implementación.

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

Las mejoras de rendimiento con TensorRT pueden variar según el 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 en mAP con precisión INT8, pero mejora significativa en la velocidad.

• GPUs de consumo (p. ej., RTX 3080):

  • Inferencia FP32: ~1.06 ms / imagen
  • Inferencia FP16: ~0.62 ms / imagen
  • Inferencia INT8: ~0.52 ms / imagen

Puedes encontrar puntos de referencia de rendimiento detallados para diferentes configuraciones de hardware en la sección de rendimiento.

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

📅 Creado hace 1 año ✏️ Actualizado hace 1 mes

Comentarios