Link to this sectionUltralytics YOLO26 en NVIDIA Jetson utilizando DeepStream SDK y TensorRT#

Esta guía completa proporciona un recorrido detallado para implementar Ultralytics YOLO26 en dispositivos NVIDIA Jetson utilizando DeepStream SDK y TensorRT. Aquí usamos TensorRT para maximizar el rendimiento de inferencia en la plataforma Jetson.

Esta guía repasa la configuración de DeepStream para YOLO26, la calibración INT8, la configuración de flujos múltiples y los resultados de los benchmarks.

Link to this section¿Qué es NVIDIA DeepStream?#

NVIDIA DeepStream SDK es un kit de herramientas completo de análisis de streaming basado en GStreamer para el procesamiento multisensor basado en IA, vídeo, audio y comprensión de imágenes. Es ideal para desarrolladores de IA de visión, socios de software, startups y fabricantes de equipos originales (OEM) que crean aplicaciones y servicios de IVA (Intelligent Video Analytics). Ahora puedes crear pipelines de procesamiento de flujo que incorporen redes neuronales y otras tareas complejas de procesamiento como seguimiento, codificación/decodificación de vídeo y renderizado de vídeo. Estos pipelines permiten el análisis en tiempo real de datos de vídeo, imagen y sensores. El soporte multiplataforma de DeepStream te ofrece una forma más rápida y sencilla de desarrollar aplicaciones y servicios de IA de visión en las instalaciones, en el borde (edge) y en la nube.

Link to this sectionRequisitos previos#

Antes de comenzar a seguir esta guía:

• Visita nuestra documentación, Guía de inicio rápido: NVIDIA Jetson con Ultralytics YOLO26 para configurar tu dispositivo NVIDIA Jetson con Ultralytics YOLO26
• Instala DeepStream SDK de acuerdo con la versión de JetPack
  • Para JetPack 4.6.4, instala DeepStream 6.0.1
  • Para JetPack 5.1.3, instala DeepStream 6.3
  • Para JetPack 6.1, instala DeepStream 7.1
  • Para JetPack 7.1, instala DeepStream 9.0

Link to this sectionConfiguración de DeepStream para YOLO26#

Aquí estamos utilizando el repositorio de GitHub marcoslucianops/DeepStream-Yolo que incluye soporte de NVIDIA DeepStream SDK para modelos YOLO. ¡Agradecemos los esfuerzos de marcoslucianops por sus contribuciones!

1. Instala Ultralytics con las dependencias necesarias

   cd ~
   pip install -U pip
   git clone https://github.com/ultralytics/ultralytics
   cd ultralytics
   pip install -e ".[export]" onnxslim

2. Clona el repositorio DeepStream-Yolo

   cd ~
   git clone https://github.com/marcoslucianops/DeepStream-Yolo

3. Copia el archivo export_yolo26.py desde el directorio DeepStream-Yolo/utils a la carpeta ultralytics

   cp ~/DeepStream-Yolo/utils/export_yolo26.py ~/ultralytics
   cd ultralytics

4. Descarga el modelo de detección Ultralytics YOLO26 (.pt) que prefieras desde YOLO26 releases. Aquí utilizamos yolo26s.pt.

   wget https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s.pt

5. Convierte el modelo a ONNX

   python3 export_yolo26.py -w yolo26s.pt

--opset 12

-s SIZE
--size SIZE
-s HEIGHT WIDTH
--size HEIGHT WIDTH

-s 1280
or
-s 1280 1280

--simplify

--dynamic

--batch 4

6. Copia el archivo de modelo .onnx generado y el archivo labels.txt a la carpeta DeepStream-Yolo

   cp yolo26s.onnx labels.txt ~/DeepStream-Yolo
   cd ~/DeepStream-Yolo

7. Establece la versión de CUDA según la versión de JetPack instalada

   Para JetPack 4.6.4:

   export CUDA_VER=10.2

   Para JetPack 5.1.3:

   export CUDA_VER=11.4

   Para JetPack 6.1:

   export CUDA_VER=12.6

8. Compila la biblioteca

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

9. Edita el archivo config_infer_primary_yolo26.txt de acuerdo con tu modelo (para YOLO26s con 80 clases)

   [property]
   ...
   onnx-file=yolo26s.onnx
   ...
   num-detected-classes=80
   ...
   parse-bbox-func-name=NvDsInferParseYolo
   ...

[property]
...
maintain-aspect-ratio=1
symmetric-padding=1
cluster-mode=4
...

10. Edita el archivo deepstream_app_config

    ...
    [primary-gie]
    ...
    config-file=config_infer_primary_yolo26.txt

11. También puedes cambiar la fuente de vídeo en el archivo deepstream_app_config. Aquí, se carga un archivo de vídeo predeterminado

    ...
    [source0]
    ...
    uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4

Link to this sectionEjecuta la inferencia#

deepstream-app -c deepstream_app_config.txt

Link to this sectionCalibración INT8#

Si deseas utilizar precisión INT8 para la inferencia, debes seguir los pasos a continuación:

1. Establece la variable de entorno OPENCV

   export OPENCV=1

2. Compila la biblioteca

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

3. Para el conjunto de datos COCO, descarga val2017, extráelo y muévelo a la carpeta DeepStream-Yolo

4. Crea un nuevo directorio para las imágenes de calibración

   mkdir calibration

5. Ejecuta lo siguiente para seleccionar 1000 imágenes aleatorias del conjunto de datos COCO para realizar la calibración

   for jpg in $(ls -1 val2017/*.jpg | sort -R | head -1000); do
     cp ${jpg} calibration/
   done

6. Crea el archivo calibration.txt con todas las imágenes seleccionadas

   realpath calibration/*jpg > calibration.txt

7. Establece las variables de entorno

   export INT8_CALIB_IMG_PATH=calibration.txt
   export INT8_CALIB_BATCH_SIZE=1

8. Actualiza el archivo config_infer_primary_yolo26.txt

   De

   ...
   model-engine-file=model_b1_gpu0_fp32.engine
   #int8-calib-file=calib.table
   ...
   network-mode=0
   ...

   A

   ...
   model-engine-file=model_b1_gpu0_int8.engine
   int8-calib-file=calib.table
   ...
   network-mode=1
   ...

Link to this sectionEjecutar inferencia INT8#

Ejecuta el mismo comando para crear el motor INT8 e iniciar la inferencia:

deepstream-app -c deepstream_app_config.txt

Link to this sectionConfiguración de múltiples flujos (MultiStream)#

Para configurar múltiples flujos en una sola aplicación DeepStream, realiza los siguientes cambios en el archivo deepstream_app_config.txt:

1. Cambia las filas y columnas para crear una visualización en cuadrícula de acuerdo con la cantidad de flujos que desees tener. Por ejemplo, para 4 flujos, podemos añadir 2 filas y 2 columnas.

   [tiled-display]
   rows=2
   columns=2

2. Añade un grupo [sourceN] separado para cada flujo, cada uno con su propio uri y num-sources=1.

   [source0]
   enable=1
   type=3
   uri=file:///path/to/video1.mp4
   num-sources=1
   
   [source1]
   enable=1
   type=3
   uri=file:///path/to/video2.mp4
   num-sources=1
   
   [source2]
   enable=1
   type=3
   uri=file:///path/to/video3.mp4
   num-sources=1
   
   [source3]
   enable=1
   type=3
   uri=file:///path/to/video4.mp4
   num-sources=1

Link to this sectionEjecutar inferencia de múltiples flujos#

Ejecuta el mismo comando para lanzar todos los flujos en la pantalla de mosaico:

deepstream-app -c deepstream_app_config.txt

Link to this sectionResultados de los benchmarks#

Los siguientes benchmarks resumen cómo funcionan los modelos YOLO11 a diferentes niveles de precisión de TensorRT con un tamaño de entrada de 640x640 en NVIDIA Jetson Orin NX 16GB. YOLO26 utiliza el mismo flujo de trabajo de exportación e inferencia de DeepStream descrito anteriormente.

Link to this sectionGráfico comparativo#

Link to this sectionTabla comparativa detallada#

Link to this sectionAgradecimientos#

Esta guía fue creada inicialmente por nuestros amigos de Seeed Studio, Lakshantha y Elaine.

Link to this sectionFAQ#

Link to this section¿Cómo configuro Ultralytics YOLO26 en un dispositivo NVIDIA Jetson?#

Para configurar Ultralytics YOLO26 en un dispositivo NVIDIA Jetson, primero necesitas instalar el DeepStream SDK compatible con tu versión de JetPack. Sigue la guía paso a paso en nuestra Guía de inicio rápido para configurar tu NVIDIA Jetson para la implementación de YOLO26.

Link to this section¿Cuál es el beneficio de usar TensorRT con YOLO26 en NVIDIA Jetson?#

Usar TensorRT con YOLO26 optimiza el modelo para la inferencia, reduciendo significativamente la latencia y mejorando el rendimiento en los dispositivos NVIDIA Jetson. TensorRT proporciona inferencia de deep learning de alto rendimiento y baja latencia mediante la fusión de capas, calibración de precisión y ajuste automático del kernel. Esto conduce a una ejecución más rápida y eficiente, especialmente útil para aplicaciones en tiempo real como análisis de vídeo y máquinas autónomas.

Link to this section¿Puedo ejecutar Ultralytics YOLO26 con DeepStream SDK en diferentes tipos de hardware NVIDIA Jetson?#

Sí, la guía para implementar Ultralytics YOLO26 con DeepStream SDK y TensorRT es compatible con toda la línea de NVIDIA Jetson. Esto incluye dispositivos como el Jetson Orin NX 16GB con JetPack 5.1.3 y el Jetson Nano 4GB con JetPack 4.6.4. Consulta la sección Configuración de DeepStream para YOLO26 para conocer los pasos detallados.

Link to this section¿Cómo puedo convertir un modelo YOLO26 a ONNX para DeepStream?#

Para convertir un modelo YOLO26 al formato ONNX para su implementación con DeepStream, utiliza el script utils/export_yolo26.py del repositorio DeepStream-Yolo.

Aquí tienes un ejemplo de comando:

python3 utils/export_yolo26.py -w yolo26s.pt --opset 12 --simplify

Para más detalles sobre la conversión de modelos, consulta nuestra sección de exportación de modelos.

Link to this section¿Cómo ejecuto la inferencia INT8 con YOLO26 en DeepStream?#

Para ejecutar la inferencia INT8, calibra el modelo en un conjunto de imágenes representativas y cambia la configuración de DeepStream al modo INT8. Descarga las imágenes COCO val2017, selecciona alrededor de 1000 imágenes de calibración, establece las variables de entorno INT8_CALIB_IMG_PATH y INT8_CALIB_BATCH_SIZE, luego actualiza config_infer_primary_yolo26.txt con model-engine-file=model_b1_gpu0_int8.engine, int8-calib-file=calib.table y network-mode=1. Consulta la sección calibración INT8 para ver los pasos completos. INT8 requiere actualmente TensorRT 8.x.

Link to this section¿Cómo ejecuto múltiples flujos de cámara con DeepStream en Jetson?#

Para procesar múltiples flujos en una sola aplicación DeepStream, edita el archivo deepstream_app_config.txt para añadir una cuadrícula de pantalla en mosaico y enumera cada URI de origen. Establece rows y columns bajo [tiled-display] para crear la cuadrícula, añade un grupo [sourceN] separado por flujo con su propio uri y num-sources=1, y ajusta la cuadrícula para adaptarla al número de flujos. Consulta la sección configuración de flujos múltiples para ver un ejemplo completo.

Link to this section¿Cuáles son los benchmarks de rendimiento para YOLO en NVIDIA Jetson Orin NX?#

El rendimiento de los modelos YOLO11 en NVIDIA Jetson Orin NX 16GB varía según los niveles de precisión de TensorRT. Por ejemplo, los modelos YOLO11s alcanzan:

• Precisión FP32: 14,53 ms/im, 68,8 FPS
• Precisión FP16: 7,91 ms/im, 126 FPS
• Precisión INT8: 6,05 ms/im, 165 FPS

Estos benchmarks subrayan la eficiencia y capacidad de usar modelos YOLO11 optimizados para TensorRT en hardware NVIDIA Jetson. Para más detalles, consulta nuestra sección de resultados de benchmarks.