Link to this sectionExportació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 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 NVIDIA. Esta guía te proporcionará pasos sencillos para seguir el proceso de conversión y ayudarte a aprovechar al máximo la tecnología avanzada de NVIDIA en tus proyectos de deep learning.

Link to this sectionTensorRT#

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 conjunto de herramientas optimiza los modelos de deep learning para GPUs NVIDIA y da como resultado operaciones más rápidas y eficientes. Los modelos de 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 núcleos. Convertir modelos de deep learning 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 marcos. Esta versatilidad permite un despliegue de modelos eficiente en diversos entornos de hardware y software.

Link to this sectionCaracterísticas clave de los modelos TensorRT#

Los modelos TensorRT ofrecen una serie 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 varias capas de una red neuronal se combinan en una sola operación. Esto reduce la carga 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 eficazmente el uso de la 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 (kernel auto-tuning): TensorRT aplica el autoajuste automático de núcleos 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.

Link to this sectionOpciones de despliegue en TensorRT#

Antes de ver el código para exportar modelos YOLO26 al formato TensorRT, entendamos 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, permitiendo que modelos optimizados se ejecuten en un entorno conocido de TensorFlow. 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 (Runtime API) de TensorRT independiente: Ofrece un control granular, ideal para aplicaciones críticas para el rendimiento. Es más complejo pero permite la implementación personalizada de operadores no compatibles.

• 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 características como la ejecución simultánea de modelos y el análisis de modelos.

Link to this sectionExportación de modelos YOLO26 a TensorRT#

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

Link to this sectionInstalación#

Para instalar el paquete requerido, 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 guía de instalación de YOLO26. Si durante la instalación de los paquetes necesarios para YOLO26 encuentras alguna dificultad, consulta nuestra guía de problemas comunes para obtener soluciones y consejos.

Link to this sectionUso#

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 apropiado 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, luego carga el modelo exportado 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")

Link to this sectionArgumentos de exportación#

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

Link to this sectionExportación a TensorRT con cuantización INT8#

Exportar modelos Ultralytics YOLO usando 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 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, basándose en lo que resulte en un tiempo de ejecución más rápido para esa capa.

Link to this sectionConfiguració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 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" para exportaciones a GPU, mientras que las exportaciones DLA en NVIDIA Jetson utilizan "ENTROPY_CALIBRATION_2". Puedes leer 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 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 mientras se convierten los pesos del modelo.

  • Ajusta el valor de workspace según tus necesidades de calibración y disponibilidad de recursos. Aunque un workspace mayor 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 menor puede reducir el tiempo de calibración pero puede limitar las estrategias de optimización, afectando la calidad del modelo cuantizado.

  • El valor por defecto 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 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 bloquea, considera usar None para la asignación automática 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 "gama alta" para la calibración podría resultar en un rendimiento deficiente cuando la inferencia se ejecute en otro dispositivo.

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

La experimentación por parte 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 guía y no un requisito estricto, y necesitarás experimentar con lo que sea necesario para obtener un buen rendimiento para 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 cuando int8=True para TensorRT y usa 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 por defecto 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)!
    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")

Link to this sectionVentajas 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 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 de destino, lo que potencialmente conduce a velocidades de inferencia más rápidas en GPUs, dispositivos integrados y aceleradores.

Link to this sectionInconvenientes de usar YOLO con TensorRT INT8#

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

• Aumento de los tiempos de desarrollo: 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 ser altamente dependientes del hardware y los pesos del modelo son menos transferibles.

Link to this sectionRendimiento de exportación de Ultralytics YOLO TensorRT#

Link to this sectionNVIDIA A100#

Link to this sectionGPU de consumo#

Link to this sectionDispositivos integrados#

Link to this sectionMé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",
)

Link to this sectionDespliegue de modelos YOLO26 exportados a TensorRT#

Una vez que hayas exportado con éxito tus modelos YOLO26 de Ultralytics 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 (antes TensorRT Inference) de NVIDIA específicamente para su uso con modelos YOLO de Ultralytics.

• Despliegue de redes neuronales profundas con NVIDIA TensorRT: Este artículo explica cómo utilizar NVIDIA TensorRT para desplegar redes neuronales profundas de forma 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 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 de NVIDIA TensorRT.

Link to this sectionResumen#

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 efectivos y adecuados para diversos entornos de despliegue.

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

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

Link to this sectionPreguntas frecuentes#

Link to this section¿Cómo convierto 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 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.

Link to this section¿Cuáles son los beneficios de usar TensorRT para modelos YOLO26?#

Utilizar 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 la precisión de manera significativa.
• Eficiencia de memoria: TensorRT gestiona la memoria de los tensores de forma dinámica, reduciendo el consumo adicional y mejorando la utilización de la memoria de la GPU.
• Fusión de capas: Combina varias capas en operaciones únicas, reduciendo la complejidad computacional.
• Auto-ajuste del kernel: Selecciona automáticamente los kernels de GPU optimizados para cada capa del modelo, garantizando el máximo rendimiento.

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

Link to this section¿Puedo usar cuantización INT8 con TensorRT para modelos YOLO26?#

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

1. Exporta con INT8:

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

2. Ejecuta 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 de exportación de TensorRT con cuantización INT8.

Link to this section¿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 YOLO26 de Ultralytics con el servidor Triton: Guía paso a paso sobre la configuración y el uso del servidor Triton Inference.
• Despliegue de redes neuronales profundas con NVIDIA TensorRT: Guía de NVIDIA sobre el despliegue de modelos de aprendizaje profundo con TensorRT para conocer opciones y configuraciones de despliegue detalladas.

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

Link to this section¿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:

  • Inferencia FP32: ~0.52 ms / imagen
  • Inferencia FP16: ~0.34 ms / imagen
  • Inferencia INT8: ~0.28 ms / imagen
  • Ligera reducción en el 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 benchmarks 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.