Exportación a TensorRT para modelos YOLO26#

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 implementas tu modelo en GPU NVIDIA.

Al utilizar el formato de exportación TensorRT, puedes optimizar tus modelos Ultralytics YOLO26 para realizar inferencias rápidas y eficientes en hardware NVIDIA. Esta guía te proporcionará pasos sencillos 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 avanzado de desarrollo de software (SDK) diseñado para realizar inferencias de aprendizaje profundo a alta velocidad. Es muy adecuado para aplicaciones en tiempo real, como la detección de objetos.

Este kit de herramientas optimiza los modelos de aprendizaje profundo para GPU NVIDIA, lo que se traduce en 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 tensores y el ajuste automático de kernels. Convertir 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, incluidos TensorFlow, PyTorch y ONNX, lo que proporciona a los desarrolladores una solución flexible para integrar y optimizar modelos de distintos frameworks. 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 varias características principales que contribuyen a su eficiencia y eficacia en la inferencia de aprendizaje profundo a 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 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 de TensorRT incluye la fusión de capas, mediante la cual 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 memoria y los cálculos.

• Gestión dinámica de la memoria de tensores: TensorRT gestiona eficazmente el uso de la memoria de los tensores durante la inferencia, reduciendo la sobrecarga de memoria y optimizando su asignación. Esto se traduce en un uso más eficiente de la memoria de la GPU.

• Ajuste automático de kernels: TensorRT aplica un 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 plenamente la capacidad de cálculo de la GPU.

Opciones de implementación en TensorRT#

Antes de consultar el código para exportar modelos YOLO26 al formato TensorRT, entendamos dónde se suelen utilizar los modelos TensorRT.

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

• Implementación dentro de TensorFlow: Este método integra TensorRT en TensorFlow, lo que permite ejecutar modelos optimizados en un entorno familiar de TensorFlow. Es útil para modelos con una combinación de capas compatibles y no compatibles, ya que TF-TRT puede gestionarlas de forma eficiente.

• API de runtime independiente de TensorRT: Ofrece un control detallado, ideal para aplicaciones críticas para el rendimiento. Es más compleja, pero permite implementar operadores no compatibles de forma personalizada.

• NVIDIA Triton Inference Server: Una opción compatible con modelos de distintos frameworks. Es especialmente adecuada para la inferencia en la nube o en el edge, y proporciona funciones como la ejecución simultánea de modelos y el análisis de modelos.

Tareas compatibles#

La exportación a TensorRT admite las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad solo están disponibles 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 consultar instrucciones detalladas y buenas prácticas relacionadas con el proceso de instalación, revisa nuestra guía de instalación de YOLO26. Si encuentras dificultades al instalar los paquetes necesarios para YOLO26, consulta nuestra guía de problemas comunes para obtener soluciones y consejos.

Uso#

Antes de consultar las instrucciones de uso, no olvides revisar la variedad de modelos YOLO26 que ofrece 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 NVIDIA. Exporta tu modelo y, después, carga el modelo exportado para ejecutar inferencias 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 obtener más información sobre el proceso de exportación, visita la página de la documentación de Ultralytics sobre exportación.

Exportación a TensorRT con cuantización INT8#

La exportación de modelos Ultralytics YOLO con TensorRT con precisión INT8 ejecuta la cuantización posterior al entrenamiento (PTQ). TensorRT utiliza la calibración para la cuantización posterior al entrenamiento, la cual mide la distribución de las 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. Un punto de control ajustado con quantize=8 mediante quantization-aware training ya lleva incorporados sus rangos INT8, por lo que su exportación los utiliza y omite la 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, 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 en función de cuál proporcione un tiempo de ejecución más rápido para esa capa.

Configuración de la exportación INT8#

Los argumentos proporcionados al utilizar export para un modelo Ultralytics YOLO influirán en gran medida en el rendimiento del modelo exportado. No obstante, también tendrás que seleccionarlos en función de los recursos disponibles del dispositivo; los argumentos predeterminados deberían funcionar en la mayoría de las GPU NVIDIA discretas Ampere (o posteriores). El algoritmo de calibración utilizado es "MINMAX_CALIBRATION" para las exportaciones a GPU, mientras que las exportaciones a DLA en NVIDIA Jetson utilizan "ENTROPY_CALIBRATION_2". Puedes consultar más detalles sobre las opciones disponibles en la guía del desarrollador de TensorRT. Las pruebas de Ultralytics determinaron que "MINMAX_CALIBRATION" es la mejor opción para las exportaciones a 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 durante la conversión de los pesos del modelo.

  • Ajusta el valor de workspace según tus necesidades de calibración y la disponibilidad de recursos. Aunque un workspace mayor puede aumentar el tiempo de calibración, permite que TensorRT explore un abanico más amplio de estrategias de optimización, lo que podría mejorar el rendimiento y la precisión del modelo. Por el contrario, un workspace menor puede reducir el tiempo de calibración, pero limitar las estrategias de optimización y afectar a la calidad del modelo cuantizado.

  • El valor predeterminado es workspace=None, lo que permite que TensorRT asigne memoria automáticamente; al configurarlo manualmente, puede ser necesario aumentarlo si la calibración se bloquea (se cierra sin avisar).

  • TensorRT notificará UNSUPPORTED_STATE durante la exportación si el valor de workspace es superior a la memoria disponible en el dispositivo, lo que significa que debe reducirse el valor de workspace o establecerse en None.

  • Si workspace está establecido en el valor máximo y la calibración falla o se bloquea, considera utilizar None para la asignación automática o reducir los valores de imgsz y batch para disminuir los requisitos de memoria.

  • Recuerda que la calibración para INT8 es específica de cada dispositivo; tomar prestada una GPU de "alta gama" para la calibración podría provocar un rendimiento deficiente al ejecutar inferencias en otro dispositivo.

• batch : El tamaño máximo del 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 realizada por 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. Esto es una directriz y no un requisito estricto, y tendrás que experimentar con lo necesario 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 utilizar el argumento data al exportar un punto de control que no haya sido entrenado con quantize=8 (cuantización posterior al entrenamiento) en quantize=8 para TensorRT, y utiliza data="my_dataset.yaml", el cual utilizará las imágenes de la validación para realizar la calibración. Un punto de control entrenado con quantize=8 omite la calibración, por lo que debes omitir data para este. 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 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 utilizar YOLO con TensorRT INT8#

• Menor 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 descargas más rápidas, menores requisitos de almacenamiento y una huella de memoria reducida al implementar un modelo.

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

• Mayor velocidad de inferencia: TensorRT optimiza el modelo para el hardware de destino, lo que puede proporcionar velocidades de inferencia más altas en GPU, dispositivos integrados y aceleradores.

Desventajas de utilizar YOLO con TensorRT INT8#

• Disminución de las métricas de evaluación: Utilizar una precisión menor implica que mAP, Precision, Recall o cualquier otra métrica utilizada para evaluar el rendimiento del modelo probablemente empeore en cierta medida. Las capas Sigmoid se mantienen con una precisión mayor para conservar la calibración de las puntuaciones, pero INT8 aún puede modificar los valores de confianza; por tanto, selecciona el umbral de operación 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 distintos dispositivos.

• Aumento de los tiempos de desarrollo: Encontrar la configuración «óptima» para la calibración INT8 en un conjunto de datos y dispositivo puede requerir un número considerable de pruebas.

• Dependencia del hardware: La calibración y las mejoras de rendimiento pueden 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, 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 exportar correctamente tus modelos Ultralytics YOLO26 al formato TensorRT, ya puedes implementarlos. Para consultar instrucciones detalladas sobre la implementación de tus modelos TensorRT en distintos entornos, echa un vistazo a los siguientes recursos:

• Implementa Ultralytics con un servidor Triton: Nuestra guía sobre cómo usar el servidor de inferencia Triton de NVIDIA (anteriormente, servidor de inferencia TensorRT) específicamente 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 de forma eficiente en plataformas de implementación basadas en GPU.

• IA de extremo a extremo para PC basados en NVIDIA: implementación de NVIDIA TensorRT: Esta entrada de blog explica el uso de NVIDIA TensorRT para optimizar e implementar modelos de IA en PC basados 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 convertir modelos Ultralytics YOLO26 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, lo que los hace más eficaces y adecuados para diversos entornos de implementación.

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

Si te interesan otras integraciones de Ultralytics YOLO26, nuestra página de la guía de integraciones ofrece una amplia selección de recursos informativos y conocimientos.

Preguntas frecuentes#