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 en utilisant DeepStream SDK et TensorRT. Ici, nous utilisons TensorRT pour maximiser les performances d'inférence sur la plateforme Jetson.

Qu'est-ce que NVIDIA DeepStream ?

NVIDIA's DeepStream SDK est une boîte à outils complète d'analyse en streaming basée sur GStreamer pour le traitement multi-capteurs par IA, ainsi que pour la compréhension de la vidéo, de l'audio et de l'image. C'est l'outil idéal pour les développeurs en IA vision, les partenaires logiciels, les startups et les OEM concevant des applications et services d'IVA (Intelligent Video Analytics). Tu peux désormais créer des pipelines de traitement de flux intégrant des neural networks et d'autres tâches de traitement complexes comme le suivi, l'encodage/décodage vidéo et le rendu vidéo. Ces pipelines permettent une analyse en temps réel sur des données vidéo, images et capteurs. La prise en charge multi-plateforme de DeepStream te donne un moyen plus rapide et plus facile de développer des applications et services d'IA vision sur site, en périphérie et dans le cloud.

Prérequis

Avant de commencer à suivre ce guide :

• Visite notre documentation, Quick Start Guide: NVIDIA Jetson with Ultralytics YOLO26 pour configurer ton appareil NVIDIA Jetson avec Ultralytics YOLO26
• Installe le DeepStream SDK selon ta 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

Ici, nous utilisons 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. Installe Ultralytics avec les dépendances nécessaires

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

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

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

3. Copie le fichier export_yolo26.py du répertoire DeepStream-Yolo/utils vers le dossier ultralytics

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

4. Télécharge le modèle de détection Ultralytics YOLO26 (.pt) de ton choix depuis les YOLO26 releases. Ici, nous utilisons yolo26s.pt.

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

5. Convertis le modèle en 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. Copie le fichier de modèle .onnx généré et le fichier labels.txt dans le dossier DeepStream-Yolo

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

7. Définit 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

8. Compile la bibliothèque

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

9. Modifie le fichier config_infer_primary_yolo26.txt selon ton modèle (pour YOLO26s avec 80 classes)

   [property]
   ...
   onnx-file=yolo26s.pt.onnx
   ...
   num-detected-classes=80
   ...

10. Modifie le fichier deepstream_app_config

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

11. Tu peux également changer 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écute l'inférence

deepstream-app -c deepstream_app_config.txt

Calibrage INT8

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

1. Définit 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 dataset COCO, télécharge le val2017, extrais-le et déplace-le vers le dossier DeepStream-Yolo

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

   mkdir calibration

5. Exécute ce qui suit pour sélectionner 1000 images aléatoires du dataset COCO afin d'effectuer le calibrage

   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éfinit 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écute l'inférence

deepstream-app -c deepstream_app_config.txt

Configuration MultiStream

Pour configurer plusieurs flux sous une seule application DeepStream, effectue les modifications suivantes dans le fichier deepstream_app_config.txt :

1. Modifie les lignes et les colonnes pour construire un affichage en grille selon le nombre de flux que tu souhaites avoir. Par exemple, pour 4 flux, nous pouvons ajouter 2 lignes et 2 colonnes.

   [tiled-display]
   rows=2
   columns=2

2. Définit num-sources=4 et ajoute les entrées uri pour les quatre flux.

   [source0]
   enable=1
   type=3
   uri=path/to/video1.jpg
   uri=path/to/video2.jpg
   uri=path/to/video3.jpg
   uri=path/to/video4.jpg
   num-sources=4

Exécute l'inférence

deepstream-app -c deepstream_app_config.txt

Résultats des tests de performance

Les tests de performance suivants résument les performances des modèles YOLO26 à différents niveaux de précision TensorRT avec une taille d'entrée de 640x640 sur NVIDIA Jetson Orin NX 16 Go.

Tableau comparatif

Tableau de comparaison détaillé

Remerciements

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

FAQ

Comment configurer Ultralytics YOLO26 sur un appareil NVIDIA Jetson ?

Pour configurer Ultralytics YOLO26 sur un appareil NVIDIA Jetson, tu dois d'abord installer le DeepStream SDK compatible avec ta version de JetPack. Suis le guide étape par étape dans notre Quick Start Guide pour configurer ton NVIDIA Jetson pour le déploiement de YOLO26.

Quel est l'avantage d'utiliser TensorRT avec YOLO26 sur NVIDIA Jetson ?

Utiliser TensorRT avec YOLO26 optimise le modèle pour l'inférence, réduisant considérablement la latence et améliorant le débit sur les appareils NVIDIA Jetson. TensorRT fournit une inférence deep learning haute performance et à faible latence grâce à la fusion de couches, au calibrage de précision et à l'auto-réglage du noyau. Cela conduit à une exécution plus rapide et plus efficace, particulièrement utile pour les applications en temps réel comme l'analyse vidéo et les machines autonomes.

Puis-je exécuter Ultralytics YOLO26 avec DeepStream SDK sur différents matériels NVIDIA Jetson ?

Oui, le guide pour déployer Ultralytics YOLO26 avec le DeepStream SDK et TensorRT est compatible avec toute la gamme NVIDIA Jetson. Cela inclut des appareils comme le Jetson Orin NX 16 Go avec JetPack 5.1.3 et le Jetson Nano 4 Go avec JetPack 4.6.4. Reporte-toi à la section DeepStream Configuration for YOLO26 pour des étapes détaillées.

Comment puis-je convertir un modèle YOLO26 en ONNX pour DeepStream ?

Pour convertir un modèle YOLO26 au format ONNX en vue d'un déploiement avec DeepStream, utilise le script utils/export_yolo26.py du dépôt DeepStream-Yolo.

Voici un exemple de commande :

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

Pour plus de détails sur la conversion de modèles, consulte notre model export section.

Quels sont les tests de performance pour YOLO sur NVIDIA Jetson Orin NX ?

Les performances des modèles YOLO26 sur NVIDIA Jetson Orin NX 16 Go varient en fonction des niveaux de précision TensorRT. Par exemple, les modèles YOLO26s atteignent :

• Précision FP32 : 14,6 ms/im, 68,5 FPS
• Précision FP16 : 7,94 ms/im, 126 FPS
• Précision INT8 : 5,95 ms/im, 168 FPS

Ces tests soulignent l'efficacité et les capacités de l'utilisation de modèles YOLO26 optimisés par TensorRT sur le matériel NVIDIA Jetson. Pour plus de détails, consulte notre section Benchmark Results.