Exportación a TensorRT para modelos YOLO26#

Desplegar modelos de computer vision 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 GPU de NVIDIA.

Al utilizar el formato de exportación TensorRT, puedes optimizar tus modelos de Ultralytics YOLO26 para una inferencia rápida y eficiente en hardware de NVIDIA. Esta guía te ofrece pasos fáciles de seguir para el proceso de conversión y te ayuda 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 object detection.

Este kit de herramientas optimiza los modelos de aprendizaje profundo para GPU 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 autoajuste de kernels. Convertir modelos de aprendizaje profundo al formato TensorRT permite a los desarrolladores explotar plenamente 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 frameworks. Esta versatilidad permite un model deployment 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 aprendizaje profundo de alta velocidad:

• Calibración de precisión: TensorRT admite la calibración de precisión, permitiendo que los modelos se ajusten a requisitos de precisión específicos. Esto incluye soporte para formatos de precisión reducida como INT8 y FP16, los cuales pueden aumentar aún más la velocidad de inferencia manteniendo niveles de precisión aceptables.

• Layer Fusion: El proceso de optimización de TensorRT incluye la fusión de capas, donde múltiples capas de una neural network 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 de manera eficiente el uso de la memoria de tensores durante la inferencia, reduciendo la sobrecarga de memoria y optimizando su asignación. Esto resulta en una utilización más eficiente de la memoria de la GPU.

• Autoajuste de kernels: TensorRT aplica un autoajuste de kernels para seleccionar el kernel de GPU más optimizado para cada capa del modelo. Este enfoque adaptativo asegura 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 una 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 ejecutar modelos optimizados en un entorno de TensorFlow familiar. Es útil para modelos con una combinación de capas compatibles e incompatibles, ya que TF-TRT puede gestionarlas de manera eficiente.

• API de Runtime de TensorRT autónoma: Ofrece un control granular, ideal para aplicaciones donde el rendimiento es crítico. Es más compleja pero permite una implementación personalizada de operadores no soportados.

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

Tareas compatibles#

La exportación a TensorRT es compatible con las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad están disponibles únicamente con YOLO26, la única familia que incluye esas cabezas.

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 necesario, ejecuta:

# Install the required package for YOLO26
pip install ultralytics

Para obtener instrucciones detalladas y mejores prácticas relacionadas con el proceso de instalación, consulta nuestra YOLO26 Installation guide. Si encuentras alguna dificultad al instalar los paquetes necesarios para YOLO26, consulta nuestra Common Issues guide para ver soluciones y consejos.

Uso#

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

El formato TensorRT admite los modos Export, Predict y Validate. La inferencia y la validación requieren una GPU de NVIDIA. Exporta tu modelo y, a continuación, cárgalo para ejecutar la inferencia o validar su precisión.

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

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 de TensorRT con cuantización INT8#

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

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 asignadas escalas de cuantización en sus entradas y salidas de datos, entonces se asigna a esa capa un kernel con precisión INT8; de lo contrario, TensorRT selecciona una precisión de FP32 o FP16 para el kernel según lo que 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 de 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, aunque los argumentos predeterminados deberían funcionar para la mayoría de las GPU discretas de NVIDIA Ampere (o más recientes). El algoritmo de calibración utilizado es "MINMAX_CALIBRATION" para las exportaciones de GPU, mientras que las exportaciones de DLA en NVIDIA Jetson usan "ENTROPY_CALIBRATION_2". Puedes leer más detalles sobre las opciones disponibles en la Guía del desarrollador de TensorRT. Las pruebas de Ultralytics descubrieron que "MINMAX_CALIBRATION" es la mejor opción para las exportaciones de GPU, y el algoritmo se selecciona automáticamente según el dispositivo de exportación.

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

  • Ajusta el valor de workspace según tus necesidades de calibración y la disponibilidad de recursos. Si bien un workspace más grande puede aumentar el tiempo de calibración, permite que TensorRT explore 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 a la calidad del modelo cuantizado.

  • 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 (sale sin previo aviso).

  • 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 o establecerse en None.

  • Si workspace se establece en el valor máximo y la calibración falla o se interrumpe, considera usar None para la asignación automática o reduce los valores de imgsz y batch para disminuir los requisitos de memoria.

  • Recuerda: la calibración para INT8 es específica para cada dispositivo; tomar 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 que el especificado.

La experimentación realizada por NVIDIA les llevó a recomendar el uso de al menos 500 imágenes de calibración que sean representativas de los datos de tu modelo, con la calibración de cuantización INT8. Esto 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 dataset. Dado que los datos de calibración son necesarios para la calibración INT8 con TensorRT, asegúrate de utilizar el argumento data cuando quantize=8 sea para TensorRT y utiliza data="my_dataset.yaml", que utilizará las imágenes de validación para calibrar. Cuando no se pasa ningún valor para data al exportar a TensorRT con cuantización INT8, el valor predeterminado será utilizar uno de los datasets de ejemplo "pequeños" 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)!
    quantize=8,
    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 lleva a 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 alimentados por batería.

• Velocidades de inferencia mejoradas: TensorRT optimiza el modelo para el hardware objetivo, lo que potencialmente conduce a velocidades de inferencia más rápidas en GPU, dispositivos embebidos y aceleradores.

Inconvenientes de usar 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 probablemente empeore en cierta medida. Las capas sigmoideas se mantienen a mayor precisión para preservar la calibración de las puntuaciones, pero INT8 aún puede desplazar los valores de confianza, así que selecciona el umbral operativo a partir de la propia curva F1 del modelo INT8. 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 de los tiempos de desarrollo: Encontrar la configuración "óptima" para la calibración INT8 según el conjunto de datos y el dispositivo puede requerir una cantidad significativa de pruebas.

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

Rendimiento de la exportación a TensorRT de Ultralytics YOLO#

NVIDIA A100#

GPUs de consumo#

Dispositivos integrados#

Métodos de evaluación#

Despliega las secciones a continuación 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, quantize=16)

# 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, quantize=8, 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#

Tras haber exportado con éxito tus modelos YOLO26 de Ultralytics al formato TensorRT, ya estás listo para implementarlos. Para obtener instrucciones detalladas sobre cómo implementar tus modelos TensorRT en varios entornos, echa un vistazo a los siguientes recursos:

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

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

• IA de extremo a extremo para PC basadas en NVIDIA: Despliegue con NVIDIA TensorRT: esta entrada de blog explica el uso de NVIDIA TensorRT para optimizar y desplegar 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 para 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 implementación.

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

Si tienes curiosidad por conocer más integraciones de Ultralytics YOLO26, nuestra página de la guía de integración ofrece una amplia selección de recursos informativos y perspectivas.

FAQ#