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

Al usar 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 proporcionará 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 aprendizaje profundo.

Link to this sectionTensorRT#

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 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 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 modelo, incluidos 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 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.

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

Link to this sectionOpciones 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, permitiendo que los modelos optimizados se ejecuten en un entorno familiar de TensorFlow. Es útil para modelos con una mezcla de capas compatibles e incompatibles, ya que TF-TRT puede manejarlas 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.

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 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 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 encontrar soluciones y consejos.

Link to this sectionUso#

Antes de profundizar 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.

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 la exportación.

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

La exportación de modelos Ultralytics YOLO usando TensorRT con precisión INT8 ejecuta la cuantización post-entrenamiento (PTQ). TensorRT utiliza 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 candidato a 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.

Link to this sectionConfiguración de la exportación INT8#

Los argumentos proporcionados al usar export para un modelo Ultralytics YOLO 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 GPU discretas NVIDIA Ampere (o posteriores). El algoritmo de calibración utilizado es "MINMAX_CALIBRATION" para 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 encontraron que "MINMAX_CALIBRATION" es la mejor opción para 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 mientras se convierten los pesos del modelo.

  • Ajusta el valor de workspace de acuerdo a tus necesidades de calibración y disponibilidad de recursos. Aunque 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, mejorando potencialmente 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 por defecto es workspace=None, lo que permitirá a TensorRT asignar memoria automáticamente; al configurar manualmente, este valor podría 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 cierra, considera usar None para la asignación automática o reduciendo 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 (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 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")

Link to this sectionVentajas 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.

Link to this sectionInconvenientes de usar YOLO con TensorRT INT8#

• Decreases in evaluation metrics: Using a lower precision will mean that mAP, Precision, Recall or any other metric used to evaluate model performance is likely to be somewhat worse. See the Performance results section to compare the differences in mAP50 and mAP50-95 when exporting with INT8 on small sample of various devices.

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

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

Link to this sectionNVIDIA A100#

Link to this sectionGPUs de consumo#

Link to this sectionDispositivos integrados#

Link to this sectionMé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, 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 sectionImplementació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:

• Implementa 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 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 basadas en GPU.

• IA de extremo a extremo para PCs 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 PCs 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 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 otras integraciones de YOLO26 de Ultralytics, nuestra página de guía de integraciones ofrece una amplia selección de recursos e información útiles.

Link to this sectionFAQ#

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 de 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 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 las ventajas de usar TensorRT para los modelos YOLO26?#

Usar TensorRT para optimizar los modelos YOLO26 ofrece varias ventajas:

• Velocidad de inferencia más rápida: 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 el uso de la memoria de la GPU.
• Fusión de capas: Combina múltiples capas en operaciones individuales, reduciendo la complejidad computacional.
• Ajuste automático de kernels: 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 nuestra visión general detallada 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 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 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 de TensorRT en un NVIDIA Triton Inference Server?#

El despliegue de modelos YOLO26 de TensorRT en un NVIDIA Triton Inference Server se puede realizar utilizando los siguientes recursos:

• Despliega Ultralytics YOLO26 con Triton Server: Guía paso a paso sobre cómo configurar y utilizar Triton Inference Server.
• Despliegue de redes neuronales profundas con NVIDIA TensorRT: Guía de NVIDIA sobre el despliegue de modelos de aprendizaje profundo con TensorRT para obtener opciones y configuraciones de despliegue detalladas.

Estas guías te ayudarán a integrar los modelos YOLO26 de manera eficiente en varios 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. Estos son 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.

• GPUs de consumo (ej. RTX 3080):

  • Inferencia FP32: ~1.06 ms / imagen
  • Inferencia FP16: ~0.62 ms / imagen
  • Inferencia INT8: ~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 completa sobre el rendimiento de TensorRT, consulta la documentación de Ultralytics y nuestros informes de análisis de rendimiento.