TensorRT Exportar para YOLOv8 Modelos

La implantación de modelos de visión computerizada en entornos de alto rendimiento puede requerir un formato que maximice la velocidad y la eficiencia. Esto es especialmente cierto cuando implantas tu modelo en GPUs NVIDIA.

Utilizando el formato de exportación TensorRT , puedes mejorar tus Ultralytics YOLOv8 modelos para una inferencia rápida y eficaz en el hardware 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 avanzada tecnología de NVIDIA en tus proyectos de aprendizaje profundo.

TensorRT

TensorRTdesarrollado por NVIDIA, es un kit de desarrollo de software (SDK) avanzado diseñado para la inferencia de aprendizaje profundo 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 aprendizaje profundo para las GPU NVIDIA y da lugar a operaciones más rápidas y eficientes. Los modelos TensorRT se someten a la optimización 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 tensor y el autoajuste del núcleo. Convertir los 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, como TensorFlow, PyTorch y ONNX, lo que proporciona a los desarrolladores una solución flexible para integrar y optimizar modelos de distintos marcos de trabajo. Esta versatilidad permite un despliegue eficaz de los modelos en diversos entornos de hardware y software.

Características principales de los modelos TensorRT

TensorRT ofrecen una serie 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, lo que permite ajustar los modelos a requisitos de precisión específicos. Esto incluye la 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 TensorRT incluye la fusión de capas, en la que 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 la memoria Tensor : TensorRT gestiona eficazmente el uso de la memoria tensor durante la inferencia, reduciendo la sobrecarga de memoria y optimizando la asignación de memoria. El resultado es una utilización más eficiente de la memoria de la GPU.

• Ajuste automático del núcleo: TensorRT aplica el ajuste automático del núcleo 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 de cálculo de la GPU.

Opciones de despliegue en TensorRT

Antes de ver el código para exportar los modelos YOLOv8 al formato TensorRT , vamos a entender dónde se utilizan normalmente los modelos TensorRT .

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

• Desplegar 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 admitidas y no admitidas, ya que TF-TRT puede manejarlas eficazmente.

• API independiente en tiempo de ejecución TensorRT : Ofrece un control granular, ideal para aplicaciones de rendimiento crítico. Es más compleja, pero permite la implementación personalizada de operadores no compatibles.

• NVIDIA Triton Servidor de Inferencia: Una opción que admite modelos de varios marcos. Especialmente adecuado para la inferencia en la nube o en el borde, proporciona funciones como la ejecución concurrente de modelos y el análisis de modelos.

Exportar modelos de YOLOv8 a TensorRT

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

Instalación

Para instalar el paquete necesario, ejecuta

# Install the required package for YOLOv8
pip install ultralytics

Para obtener instrucciones detalladas y buenas prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalaciónYOLOv8 . Mientras instalas los paquetes necesarios para YOLOv8, si encuentras alguna dificultad, consulta nuestra guía de Problemas comunes para encontrar soluciones y consejos.

Utilización

Antes de sumergirte en las instrucciones de uso, asegúrate de consultar la gama de modelosYOLOv8 que ofrece Ultralytics. Esto te ayudará a elegir el modelo más apropiado para los requisitos de tu proyecto.

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.pt')

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

# Load the exported TensorRT model
tensorrt_model = YOLO('yolov8n.engine')

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

# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine''

# Run inference with the exported model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

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

Exportar TensorRT con cuantización INT8

La exportación de modelos Ultralytics YOLO utilizando TensorRT con precisión INT8 ejecuta la cuantización post-entrenamiento (PTQ). TensorRT utiliza la calibración para la PTQ, que mide la distribución de activaciones dentro de cada activación tensor a medida que el modelo YOLO procesa la inferencia sobre datos de entrada representativos, y luego utiliza esa distribución para estimar valores de escala para cada tensor. Cada activación tensor candidata a la cuantización tiene una escala asociada que se deduce mediante un proceso de calibración.

Al procesar redes cuantificadas 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 núcleo con precisión INT8; de lo contrario, TensorRT selecciona una precisión de FP32 o FP16 para el núcleo en función de la que resulte en un tiempo de ejecución más rápido para esa capa.

Configurar la exportación INT8

Los argumentos proporcionados al utilizar exportar para un modelo Ultralytics YOLO en gran medida influyen en el rendimiento del modelo exportado. También tendrán que seleccionarse en función de los recursos del dispositivo disponibles, sin embargo, los argumentos por defecto debe funcionan para la mayoría GPUs discretas NVIDIA Ampere (o más recientes). El algoritmo de calibración utilizado es "ENTROPY_CALIBRATION_2" y puedes leer más detalles sobre las opciones disponibles en la Guía del desarrollador TensorRT. Ultralytics las pruebas constataron que "ENTROPY_CALIBRATION_2" era la mejor opción y las exportaciones se fijan en utilizar este algoritmo.

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

  • Intenta utilizar la mínimo workspace valor requerido, ya que esto impide probar algoritmos que requieren más workspace de ser tenida en cuenta por el constructor de TensorRT . Establecer un valor más alto para workspace puede tomar considerablemente más largo para calibrar y exportar.

  • Por defecto es workspace=4 (GiB), puede ser necesario aumentar este valor si la calibración se bloquea (sale sin avisar).

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

  • Si workspace está ajustado al valor máximo y la calibración falla/se bloquea, considera la posibilidad de reducir los valores de imgsz y batch para reducir los requisitos de memoria.

  • Recuerda que la calibración para INT8 es específica de cada dispositivo, tomar prestada una GPU de "gama alta" para la calibración, podría dar lugar a un rendimiento deficiente cuando la inferencia se ejecute en otro dispositivo.

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

  Nota

  Durante la calibración, pulsa dos veces el botón batch se utilizará el tamaño proporcionado. Utilizar lotes pequeños puede dar lugar a un escalado inexacto durante el calibrado. Esto se debe a que el proceso se ajusta en función de los datos que ve. Los lotes pequeños podrían no capturar toda la gama de valores, lo que provocaría problemas en la calibración final, por lo que el batch se duplica automáticamente. Si no se especifica el tamaño del lote batch=1la calibración se realizará en batch=1 * 2 para reducir los errores de escala de calibración.

La experimentación de NVIDIA les ha llevado a recomendar el uso de al menos 500 imágenes de calibración que sean representativas de los datos de tu modelo, con calibración de cuantización INT8. Se trata de una directriz y no de una duro requisito, y tendrás que experimentar con lo que se necesita para obtener buenos resultados 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 la opción data argumento cuando int8=True para TensorRT y utilizar data="my_dataset.yaml"que utilizará las imágenes de validación para calibrar. Cuando no se pasa ningún valor para data con exportación a TensorRT con cuantización INT8, por defecto se utilizará uno de los "pequeños" conjuntos de datos de ejemplo basados en la tarea modelo en lugar de lanzar un error.

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(
    format="engine",
    dynamic=True, #(1)!
    batch=8, #(2)!
    workspace=4, #(3)!
    int8=True,
    data="coco.yaml", #(4)!
)

model = YOLO("yolov8n.engine", task="detect") # load the model

Ventajas de utilizar YOLO con TensorRT INT8

• Reducción del 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 tiempos de descarga más rápidos, menores requisitos de almacenamiento y menor huella de memoria al desplegar un modelo.

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

• Velocidades de inferencia mejoradas: TensorRT optimiza el modelo para el hardware de destino, lo que puede dar lugar a velocidades de inferencia más rápidas en GPU, dispositivos integrados y aceleradores.

Inconvenientes de utilizar 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 es probable que sea algo peor. Véase el Sección de resultados para comparar las diferencias en mAP50 y mAP50-95 al exportar con INT8 en una pequeña muestra de varios dispositivos.

• Mayor tiempo de desarrollo: Encontrar los ajustes "óptimos" 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 mejoras de rendimiento podrían depender en gran medida del hardware y los pesos de los modelos son menos transferibles.

Ultralytics YOLO TensorRT Rendimiento de las exportaciones

NVIDIA A100

GPU de consumo

Dispositivos integrados

Métodos de evaluación

Amplía las secciones siguientes para obtener información sobre cómo se exportaron y probaron estos modelos.

from ultralytics import YOLO

model = YOLO("yolov8n.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
out = model.export(
    format="engine",
    imgsz:640,
    dynamic:True,
    verbose:False,
    batch:8,
    workspace:2,
    int8=True,
    data:"data.yaml"  # COCO, ImageNet, or DOTAv1 for appropriate model task
)

import cv2
from ultralytics import YOLO

model = YOLO("yolov8n.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("yolov8n.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 exportados de YOLOv8 TensorRT

Una vez exportados con éxito tus modelos Ultralytics YOLOv8 al formato TensorRT , ya estás preparado para desplegarlos. Para obtener instrucciones detalladas sobre el despliegue de tus modelos TensorRT en distintos 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 Ultralytics YOLO .

• Implantación de Redes Neuronales Profundas con NVIDIA TensorRT: Este artículo explica cómo utilizar NVIDIA TensorRT para desplegar redes neuronales profundas en plataformas de despliegue basadas en GPU de forma eficiente.

• 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 implantar modelos de IA en PCs basados en NVIDIA.

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

Resumen

En esta guía, nos centramos en la conversión de los modelos Ultralytics YOLOv8 al formato de modelo TensorRT de NVIDIA. Este paso de conversión es crucial para mejorar la eficacia y la velocidad de los modelos YOLOv8 , haciéndolos más eficaces y adecuados para diversos entornos de implantación.

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

Si tienes curiosidad por conocer otras integraciones de Ultralytics YOLOv8 , nuestra página de guía de integraciones ofrece una amplia selección de recursos informativos y puntos de vista.

Comentarios