Ultralytics YOLO26 sur NVIDIA Jetson avec DeepStream SDK et TensorRT#

Ce guide complet détaille le déploiement d’Ultralytics YOLO26 sur les appareils NVIDIA Jetson avec DeepStream SDK et TensorRT. Nous utilisons ici TensorRT pour optimiser les performances d’inférence sur la plateforme Jetson.

Ce guide explique la configuration de DeepStream pour YOLO26, la calibration INT8, la configuration multi-flux et les résultats des benchmarks.

Qu’est-ce que NVIDIA DeepStream ?#

Le DeepStream SDK de NVIDIA est une boîte à outils complète d’analyse de flux basée sur GStreamer, destinée au traitement multi-capteurs et à la compréhension de vidéos, d’audio et d’images par l’IA. Elle est idéale pour les développeurs d’IA visuelle, les partenaires logiciels, les startups et les OEM qui conçoivent des applications et services d’IVA (analyse vidéo intelligente). Tu peux désormais créer des pipelines de traitement de flux intégrant des réseaux de neurones ainsi que d’autres tâches de traitement complexes, comme le suivi, l’encodage et le décodage vidéo, et le rendu vidéo. Ces pipelines permettent d’effectuer des analyses en temps réel sur des données vidéo, image et capteur. La prise en charge multiplateforme de DeepStream permet de développer plus rapidement et plus facilement des applications et services d’IA visuelle sur site, en périphérie et dans le cloud.

Prérequis#

Avant de suivre ce guide :

• Consulte notre documentation, le Guide de démarrage rapide : NVIDIA Jetson avec Ultralytics YOLO26, pour configurer ton appareil NVIDIA Jetson avec Ultralytics YOLO26.
• Installe DeepStream SDK en fonction de la version de JetPack.
  • Pour JetPack 4.6.4, installe DeepStream 6.0.1.
  • Pour JetPack 5.1.3, installe DeepStream 6.3.
  • Pour JetPack 6.1, installe DeepStream 7.1.
  • Pour JetPack 7.1, installe DeepStream 9.0.

Configuration de DeepStream pour YOLO26#

Nous utilisons ici le dépôt GitHub marcoslucianops/DeepStream-Yolo, qui prend en charge les modèles YOLO avec NVIDIA DeepStream SDK. Nous remercions marcoslucianops pour ses contributions !

1. Installe Ultralytics avec les dépendances nécessaires.

   pip install ultralytics onnx onnxslim

2. Clone le dépôt DeepStream-Yolo.

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

3. Télécharge le modèle de détection Ultralytics YOLO26 (.pt) de ton choix depuis le projet YOLO26. Nous utilisons ici yolo26s.pt.

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

4. Convertis le modèle au format ONNX et écris le fichier labels.txt à partir duquel DeepStream lit les noms de classes.

   from ultralytics import YOLO
   
   model = YOLO("yolo26s.pt")
   model.export(format="onnx", nms=False, agnostic_nms=True)  # crée 'yolo26s.onnx'
   with open("labels.txt", "w") as f:
       f.write("\n".join(model.names.values()))

5. Copie le fichier de modèle généré .onnx et le fichier labels.txt dans le dossier DeepStream-Yolo.

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

6. Définis la version de CUDA en fonction de la version de JetPack installée.

   Pour JetPack 4.6.4 :

   export CUDA_VER=10.2

   Pour JetPack 5.1.3 :

   export CUDA_VER=11.4

   Pour JetPack 6.1 :

   export CUDA_VER=12.6

   Pour JetPack 7.1 :

   export CUDA_VER=13.0

7. Compile la bibliothèque.

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

8. Modifie le fichier config_infer_primary_yolo26.txt en fonction de ton modèle (pour YOLO26s avec 80 classes).

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

9. Modifie le fichier deepstream_app_config.

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

10. Tu peux également modifier la source vidéo dans le fichier deepstream_app_config. Ici, un fichier vidéo par défaut est chargé.

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

Exécuter l’inférence#

deepstream-app -c deepstream_app_config.txt

Calibration INT8#

Pour utiliser la précision INT8 lors de l’inférence, suis les étapes ci-dessous :

1. Définis la variable d’environnement OPENCV.

   export OPENCV=1

2. Compile la bibliothèque.

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

3. Pour le jeu de données COCO, télécharge val2017, extrais-le et déplace-le dans le dossier DeepStream-Yolo.

4. Crée un nouveau répertoire pour les images de calibration.

   mkdir calibration

5. Exécute la commande suivante pour sélectionner 1 000 images aléatoires du jeu de données COCO et effectuer la calibration.

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

6. Crée le fichier calibration.txt contenant toutes les images sélectionnées.

   realpath calibration/*jpg > calibration.txt

7. Définis les variables d’environnement.

   export INT8_CALIB_IMG_PATH=calibration.txt
   export INT8_CALIB_BATCH_SIZE=1

8. Mets à jour le fichier config_infer_primary_yolo26.txt.

   De

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

   À

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

Exécuter l’inférence INT8#

Exécute la même commande pour créer le moteur INT8 et démarrer l’inférence :

deepstream-app -c deepstream_app_config.txt

Configuration multi-flux#

Pour configurer plusieurs flux dans une même application DeepStream, apporte les modifications suivantes au fichier deepstream_app_config.txt :

1. Modifie le nombre de lignes et de colonnes pour créer une grille d’affichage adaptée au nombre de flux souhaité. Par exemple, pour 4 flux, ajoute 2 lignes et 2 colonnes.

   [tiled-display]
   rows=2
   columns=2

2. Ajoute un groupe [sourceN] distinct pour chaque flux, chacun avec ses propres uri et 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

Exécuter l’inférence multi-flux#

Exécute la même commande pour lancer tous les flux dans l’affichage en mosaïque :

deepstream-app -c deepstream_app_config.txt

Résultats des benchmarks#

Les benchmarks suivants résument les performances des modèles YOLO11 avec différents niveaux de précision TensorRT, pour une taille d’entrée de 640x640 sur NVIDIA Jetson Orin NX 16 Go. YOLO26 utilise le même processus d’exportation et d’inférence DeepStream décrit ci-dessus.

Graphique comparatif#

Tableau comparatif détaillé#

Remerciements#

Ce guide a été créé à l’origine par nos amis Lakshantha et Elaine, de Seeed Studio.

FAQ#