Exportación a TensorRT para modelos YOLO26

Desplegar 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 despliegas tu modelo en GPUs de NVIDIA.

Al utilizar el formato de exportación TensorRT, puedes mejorar tus modelos Ultralytics YOLO26 para una inferencia rápida y eficiente en hardware de NVIDIA. Esta guía te dará 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 deep learning.

TensorRT

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

Este kit de herramientas optimiza los modelos de deep learning para GPUs de NVIDIA y da como resultado operaciones más rápidas y eficientes. Los modelos TensorRT se someten a la optimización de 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 ajuste automático de kernels. Convertir modelos de deep learning al formato TensorRT permite a los desarrolladores aprovechar al máximo el potencial de las GPUs de NVIDIA.

TensorRT es conocido por su compatibilidad con varios formatos de modelos, incluidos TensorFlow, PyTorch y ONNX, proporcionando a los desarrolladores una solución flexible para integrar y optimizar modelos de diferentes frameworks. Esta versatilidad permite un despliegue de modelos eficiente en 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 deep learning 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 aumentar aún más la velocidad de inferencia manteniendo niveles de precisión aceptables.

• Fusión de capas: El proceso de optimización de TensorRT incluye la fusión de capas, donde múltiples 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 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.

• Ajuste automático de kernels: TensorRT aplica el ajuste automático de kernels para seleccionar el kernel 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 ver 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, lo que permite que los modelos optimizados se ejecuten en un entorno familiar de TensorFlow. Es útil para modelos con una mezcla de capas soportadas y no soportadas, ya que TF-TRT puede manejarlas eficientemente.

• API de tiempo de ejecución de TensorRT independiente: 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 soporta modelos de varios frameworks. Particularmente adecuada para inferencia en la nube o en el borde, proporciona características como la ejecución simultánea de modelos y el análisis de modelos.

Exportar modelos YOLO26 a TensorRT

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

Instalación

Para instalar el paquete requerido, ejecuta:

# Install the required package for YOLO26
pip install ultralytics

Para obtener instrucciones detalladas y las mejores prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalación de YOLO26. Si encuentras alguna dificultad al instalar los paquetes necesarios para YOLO26, consulta nuestra guía de problemas comunes para ver 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

La exportación de modelos Ultralytics YOLO mediante TensorRT con precisión INT8 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 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.

Al procesar redes cuantizadas 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 escalas de cuantizació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, dependiendo 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 en gran medida 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 GPUs discretas NVIDIA Ampere (o posteriores). 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 valor de workspace según tus necesidades de calibración y la 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, lo que potencialmente mejora el rendimiento y la precisión del modelo. 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 aumentarse 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 debe reducirse o establecerse en None.

  • Si workspace se establece en el valor máximo y la calibración falla/se bloquea, considera usar None para la autoasignación o reduciendo los valores de 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 "alta gama" para la calibración podría resultar en un bajo rendimiento cuando la inferencia se ejecute en otro dispositivo.

• batch : El tamaño de lote máximo 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.

Experimentation by NVIDIA led them to recommend using at least 500 calibration images that are representative of the data for your model, with INT8 quantization calibration. This is a guideline and not a hard requirement, and you will need to experiment with what is required to perform well for your dataset. Since the calibration data is required for INT8 calibration with TensorRT, make certain to use the data argument when int8=True for TensorRT and use data="my_dataset.yaml", which will use the images from validation to calibrate with. When no value is passed for data with export to TensorRT with INT8 quantization, the default will be to use one of the "small" example datasets based on the model task instead of throwing an 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 hasta 4 veces (en disco o en memoria), lo que genera tiempos de descarga más rápidos, menores requisitos de almacenamiento y una huella de memoria reducida al desplegar un modelo.

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

• Velocidades de inferencia mejoradas: TensorRT optimiza el modelo para el hardware de destino, 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: El uso de una precisión menor significará que el mAP, la Precision, el 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.

• Tiempos de desarrollo aumentados: Encontrar los ajustes "óptimos" para la calibración INT8 para el dataset y el dispositivo puede requerir una cantidad significativa de pruebas.

• Dependencia de hardware: Las ganancias de calibración y 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 a TensorRT

NVIDIA A100

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

Despliegue de modelos YOLO26 exportados a TensorRT

Tras haber exportado correctamente tus modelos Ultralytics YOLO26 al formato TensorRT, ya estás listo para desplegarlos. Para obtener instrucciones detalladas sobre cómo desplegar tus modelos TensorRT en diversos entornos, echa un vistazo a los siguientes recursos:

• Despliega Ultralytics con un servidor Triton: Nuestra guía sobre cómo utilizar el servidor Triton Inference de NVIDIA (anteriormente TensorRT Inference Server) específicamente 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 basadas en GPU de forma eficiente.

• IA integral para PC basados en NVIDIA: Despliegue con NVIDIA TensorRT: Esta entrada del blog explica el uso de NVIDIA TensorRT para optimizar y desplegar modelos de IA en PC basados en NVIDIA.

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

Resumen

En esta guía, nos hemos centrado en convertir modelos Ultralytics YOLO26 al formato de modelo TensorRT de NVIDIA. Este paso de conversión es fundamental para mejorar la eficiencia y la velocidad de los modelos YOLO26, haciéndolos más eficaces y adecuados para diversos entornos de despliegue.

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

Si tienes curiosidad sobre otras integraciones de Ultralytics YOLO26, nuestra página de guía de integraciones ofrece una amplia selección de recursos informativos e ideas.

Preguntas frecuentes

¿Cómo convierto modelos YOLO26 al formato TensorRT?

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

1. Instala el paquete necesario:

   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 obtener más detalles, visita la guía de instalación de YOLO26 y la 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 los tensores dinámicamente, reduciendo el sobrecoste 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.
• Auto-ajuste de núcleos: Selecciona automáticamente los núcleos de GPU optimizados para cada capa del modelo, asegurando el máximo rendimiento.

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

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

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

1. Exportar con INT8:

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

2. Ejecutar inferencia:

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

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

¿Cómo despliego modelos YOLO26 TensorRT en un servidor NVIDIA Triton Inference?

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

• Despliega Ultralytics YOLO26 con Triton Server: Guía paso a paso sobre cómo configurar y utilizar Triton Inference Server.
• Documentación de NVIDIA Triton Inference Server: Documentación oficial de NVIDIA para opciones de despliegue y configuraciones detalladas.

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

¿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 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 una mejora significativa en la velocidad.

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