Exportación a TensorRT para modelos YOLO26

Desplegar computer vision los modelos en entornos de alto rendimiento pueden requerir un formato que maximice la velocidad y la eficiencia. Esto es especialmente cierto cuando despliegas tu modelo en GPUs NVIDIA.

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

TensorRT

TensorRT, desarrollado por NVIDIA, es un kit de desarrollo de software (SDK) avanzado diseñado para una inferencia de aprendizaje profundo de alta velocidad. Es ideal para aplicaciones en tiempo real como object detection.

Este kit de herramientas optimiza los modelos de aprendizaje profundo para GPUs NVIDIA y resulta en 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, calibración de precisión (INT8 y FP16), gestión dinámica de memoria de tensores y autoajuste de núcleos. Convertir modelos de aprendizaje profundo al formato TensorRT permite a los desarrolladores aprovechar al máximo el potencial de las GPUs NVIDIA.

TensorRT es conocido por su compatibilidad con varios formatos de modelos, incluyendo TensorFlow, PyTorch, y ONNX, proporcionando a los desarrolladores una solución flexible para integrar y optimizar modelos de diferentes frameworks. Esta versatilidad permite un/a despliegue del modelo eficiente a través de diversos entornos de hardware y software.

Características clave 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 precisión específicos. Esto incluye soporte para formatos de precisión reducida como INT8 y FP16, que pueden impulsar 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, donde múltiples capas de un redes neuronales 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 memoria de tensores: TensorRT gestiona eficientemente el uso de memoria de 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.

• Autoajuste de núcleos: TensorRT aplica el autoajuste de núcleos (kernel auto-tuning) para seleccionar el núcleo de GPU más optimizado para cada capa del modelo. Este enfoque adaptativo garantiza que el modelo aproveche al máximo la potencia computacional de la GPU.

Opciones de despliegue en TensorRT

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

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

• Despliegue 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 manejarlas eficientemente.

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

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

Exportación de modelos YOLO26 a TensorRT

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

Instalación

Para instalar el paquete requerido, ejecuta:

# Install the required package for YOLO26
pip install ultralytics

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

Uso

Antes de sumergirte en las instrucciones de uso, asegúrate de echar un vistazo a la gama de modelos YOLO26 ofrecidos por Ultralytics. Esto te ayudará a elegir el modelo más adecuado para los requisitos de tu proyecto.

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

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

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

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

Argumentos de exportación

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

Exportación a TensorRT con cuantización INT8

Exportar modelos YOLO de Ultralytics utilizando TensorRT con cuantización INT8 precisión ejecuta la cuantización post-entrenamiento (PTQ). TensorRT utiliza la calibración para PTQ, la cual 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 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.

Al procesar redes cuantizadas implícitamente, TensorRT utiliza INT8 de manera oportunista para optimizar el tiempo de ejecución de las capas. Si una capa se ejecuta más rápido en INT8 y tiene escalas de cuantización asignadas en sus entradas y salidas de datos, entonces se asigna un núcleo con precisión INT8 a esa capa; de lo contrario, TensorRT selecciona una precisión de FP32 o FP16 para el núcleo según 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 YOLO de Ultralytics 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 por defecto deberían funcionar para la mayoría de las GPUs discretas NVIDIA Ampere (o más nuevas). El algoritmo de calibración utilizado es "MINMAX_CALIBRATION" y puedes leer más detalles sobre las opciones disponibles en la Guía para desarrolladores de TensorRT. Las pruebas de Ultralytics encontraron que "MINMAX_CALIBRATION" era la mejor opción y las exportaciones están fijadas para usar este algoritmo.

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

  • Ajusta el workspace valor según tus necesidades de calibración y disponibilidad de recursos. Aunque un workspace más grande 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 del modelo y precisión. Por el contrario, un workspace más pequeño puede reducir el tiempo de calibración, pero puede limitar las estrategias de optimización, afectando la calidad del modelo cuantizado.

  • El valor predeterminado es workspace=None, lo que permitirá a TensorRT asignar memoria automáticamente; al configurar manualmente, este valor puede necesitar ser aumentado si la calibración falla (se cierra sin aviso).

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

  • Si workspace está establecido en el valor máximo y la calibración falla/se bloquea, considera usar None para la autoasignación o reduciendo los valores para imgsz y batch para disminuir los requisitos de memoria.

  • Recuerda que la calibración para INT8 es específica para cada dispositivo, pedir prestada una GPU de "gama alta" para la calibración podría resultar en un bajo rendimiento cuando la inferencia se ejecute en otro dispositivo.

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

La experimentación de NVIDIA les llevó a recomendar el uso de al menos 500 imágenes de calibración que sean representativas de los datos para tu modelo, con la calibración de cuantización INT8. Esta es una directriz y no un requisito estricto, y tendrás que experimentar con lo que se requiere para obtener un buen rendimiento en tu conjunto de datos. Dado que los datos de calibración son necesarios para la calibración INT8 con TensorRT, asegúrate de usar el data argumento al 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á usar uno de los "pequeños" conjuntos de datos de ejemplo basados en la tarea del modelo en lugar de lanzar un 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")

Ventajas de usar YOLO con TensorRT INT8

• Tamaño del modelo reducido:La cuantización de FP32 a INT8 puede reducir el tamaño del modelo 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 desplegar un modelo.

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

• Mejora en las velocidades de inferencia:TensorRT optimiza el modelo para el hardware objetivo, lo que potencialmente conduce a velocidades de inferencia más rápidas en GPUs, dispositivos integrados y aceleradores.

Desventajas de usar YOLO con TensorRT INT8

• Disminución en las métricas de evaluación:Usar una precisión menor significará que el mAP, Precision, Recall o cualquier otra métrica utilizada para evaluar el rendimiento del modelo probablemente sea algo peor. Consulta 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.

• Aumento en los tiempos de desarrollo:Encontrar los ajustes "óptimos" para la calibración de INT8 para un conjunto de datos y un dispositivo puede requerir una cantidad significativa de pruebas.

• Dependencia del hardware:La calibración y las ganancias de rendimiento podrían depender mucho del hardware y los pesos del modelo son menos transferibles.

Rendimiento de exportación de Ultralytics YOLO a TensorRT

NVIDIA A100

GPUs de consumo

Dispositivos integrados

Métodos de evaluación

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

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

Implementación de modelos YOLO26 exportados a TensorRT

Una vez que hayas exportado con éxito tus modelos YOLO26 de Ultralytics al formato TensorRT, estarás listo para implementarlos. Para obtener instrucciones detalladas sobre cómo desplegar tus modelos TensorRT en diversos entornos, consulta los siguientes recursos:

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

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

• IA integral para ordenadores basados en NVIDIA: Implementación con NVIDIA TensorRT: Esta entrada del blog explica el uso de NVIDIA TensorRT para optimizar e implementar modelos de IA en ordenadores 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 hemos centrado en la conversión de modelos YOLO26 de Ultralytics al formato de modelo TensorRT de NVIDIA. Este paso de conversión es crucial para mejorar la eficiencia y la velocidad de los modelos YOLO26, haciéndolos más eficaces y adecuados para diversos entornos de despliegue.

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

Si tienes curiosidad sobre otras integraciones de YOLO26 de Ultralytics, nuestra página de guías de integración ofrece una amplia selección de recursos informativos y conocimientos.

Preguntas frecuentes

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

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

1. Instala el paquete requerido:

   pip install ultralytics

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

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

El uso de TensorRT para optimizar los modelos YOLO26 ofrece varias ventajas:

• Mayor velocidad de inferencia: TensorRT optimiza las capas del modelo y utiliza 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 de tensores de forma dinámica, reduciendo la sobrecarga y mejorando la utilización de la memoria de la GPU.
• Fusión de capas: Combina múltiples capas en operaciones únicas, reduciendo la complejidad computacional.
• Autoajuste de kernels: Selecciona automáticamente los kernels de GPU optimizados para cada capa del modelo, asegurando el máximo rendimiento.

Para saber más, explora la documentación oficial de TensorRT de NVIDIA y nuestro resumen detallado de TensorRT.

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

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

1. Exportación con INT8:

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

2. Ejecución de la inferencia:

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

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

¿Cómo implemento los modelos YOLO26 de TensorRT en un servidor de inferencia NVIDIA Triton?

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

• Implementar YOLO26 de Ultralytics con el servidor Triton: Guía paso a paso sobre cómo configurar y utilizar el servidor de inferencia Triton.
• Documentación del servidor de inferencia NVIDIA Triton: Documentación oficial de NVIDIA para conocer las opciones y configuraciones de implementación detalladas.

Estas guías te ayudarán a integrar los modelos YOLO26 de forma eficiente en diversos entornos de implementación.

¿Qué mejoras de rendimiento se observan con los modelos YOLO26 exportados a TensorRT?

Las mejoras de rendimiento con TensorRT pueden variar según el hardware utilizado. Aquí tienes algunos benchmarks típicos:

• NVIDIA A100:

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

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

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

Los benchmarks de rendimiento detallados para diferentes configuraciones de hardware se pueden encontrar en la sección de rendimiento.

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