Ultralytics YOLO26 sur NVIDIA Jetson avec DeepStream SDK et TensorRT#

Ce guide complet fournit une procédure détaillée pour déployer Ultralytics YOLO26 sur des appareils NVIDIA Jetson à l'aide de DeepStream SDK et de TensorRT. Nous utilisons ici TensorRT pour maximiser les performances d'inférence sur la plateforme Jetson.

Ce guide présente la configuration de DeepStream pour YOLO26, la calibration INT8, la configuration mult 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 multisensoriel par IA et à la compréhension des vidéos, des fichiers audio et des images. Elle est idéale pour les développeurs en IA visuelle, les partenaires logiciels, les startups et les fabricants OEM qui créent des applications et des services d'IVA (Intelligence vidéo). Tu peux désormais créer des pipelines de traitement de flux intégrant des réseaux neuronaux et d'autres tâches de traitement complexes comme le suivi, l'encodage et le décodage vidéo, ainsi que le rendu vidéo. Ces pipelines permettent d'effectuer des analyses en temps réel sur des données vidéo, d'image et de capteurs. La prise en charge multiplateforme de DeepStream te permet de développer plus rapidement et plus facilement des applications et des services d'IA visuelle sur site, en périphérie et dans le cloud.

Prérequis#

Avant de commencer 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 selon 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 inclut la prise en charge de NVIDIA DeepStream SDK pour les modèles YOLO. Nous remercions marcoslucianops pour ses contributions !

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

   pip install ultralytics onnx onnxslim

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

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

3. Télécharge un 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 en ONNX et écris le fichier labels.txt duquel DeepStream lit les noms des classes

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

5. Copie le fichier de modèle .onnx généré 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 selon 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. Compiler 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 selon 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#

Si tu veux utiliser la précision INT8 pour l'inférence, tu dois suivre les étapes ci-dessous :

1. Définis la variable d'environnement OPENCV

   export OPENCV=1

2. Compiler 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 1000 images aléatoires du jeu de données COCO afin d'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 avec 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 multistream#

Pour configurer plusieurs flux dans une seule 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 correspondant au nombre de flux souhaité. Par exemple, pour 4 flux, tu peux ajouter 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 multistream#

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 à différents niveaux de précision TensorRT, avec une taille d'entrée de 640x640 sur NVIDIA Jetson Orin NX 16GB. YOLO26 utilise le même flux d'exportation et d'inférence DeepStream que celui décrit ci-dessus.

Graphique comparatif#

Tableau comparatif détaillé#

Remerciements#

Ce guide a été initialement créé par nos amis de Seeed Studio, Lakshantha et Elaine.

FAQ#