Ultralytics YOLO26 auf NVIDIA Jetson mit DeepStream SDK und TensorRT

Dieser umfassende Leitfaden bietet eine detaillierte Anleitung für die Bereitstellung von Ultralytics YOLO26 auf NVIDIA Jetson Geräten unter Verwendung von DeepStream SDK und TensorRT. Hier nutzen wir TensorRT, um die Inferenzleistung auf der Jetson-Plattform zu maximieren.

Was ist NVIDIA DeepStream?

NVIDIA's DeepStream SDK ist ein komplettes Streaming-Analytics-Toolkit, das auf GStreamer für KI-basierte Multi-Sensor-Verarbeitung, Video-, Audio- und Bildanalyse basiert. Es ist ideal für Vision-KI-Entwickler, Software-Partner, Startups und OEMs, die IVA-Apps (Intelligent Video Analytics) und Dienste entwickeln. Du kannst jetzt Stream-Processing-Pipelines erstellen, die neuronalen Netzen und andere komplexe Verarbeitungsschritte wie Tracking, Videokodierung/-dekodierung und Videorendering einbinden. Diese Pipelines ermöglichen Echtzeitanalysen von Video-, Bild- und Sensordaten. Die Multi-Plattform-Unterstützung von DeepStream bietet dir einen schnelleren und einfacheren Weg, Vision-KI-Anwendungen und -Dienste lokal, an der Edge und in der Cloud zu entwickeln.

Voraussetzungen

Bevor du diesem Leitfaden folgst:

• Besuche unsere Dokumentation, Schnellstartanleitung: NVIDIA Jetson mit Ultralytics YOLO26 um dein NVIDIA Jetson Gerät mit Ultralytics YOLO26 einzurichten
• Installiere DeepStream SDK entsprechend der JetPack-Version
  • Für JetPack 4.6.4, installiere DeepStream 6.0.1
  • Für JetPack 5.1.3, installiere DeepStream 6.3
  • Für JetPack 6.1, installiere DeepStream 7.1
  • Für JetPack 7.1, installiere DeepStream 9.0

DeepStream-Konfiguration für YOLO26

Hier verwenden wir das marcoslucianops/DeepStream-Yolo GitHub-Repository, das die NVIDIA DeepStream SDK-Unterstützung für YOLO-Modelle enthält. Wir schätzen die Arbeit von marcoslucianops für seine Beiträge!

1. Installiere Ultralytics mit den erforderlichen Abhängigkeiten

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

2. Klonen das DeepStream-Yolo Repository

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

3. Kopiere die export_yolo26.py Datei vom DeepStream-Yolo/utils Verzeichnis in den ultralytics Ordner

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

4. Lade das Ultralytics YOLO26 Erkennungsmodell (.pt) deiner Wahl von den YOLO26-Releases herunter. Hier verwenden wir yolo26s.pt.

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

5. Konvertiere das Modell in 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. Kopiere die generierte .onnx Modelldatei und labels.txt Datei in den DeepStream-Yolo Ordner

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

7. Setze die CUDA-Version entsprechend der installierten JetPack-Version

   Für JetPack 4.6.4:

   export CUDA_VER=10.2

   Für JetPack 5.1.3:

   export CUDA_VER=11.4

   Für JetPack 6.1:

   export CUDA_VER=12.6

8. Kompiliere die Bibliothek

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

9. Bearbeite die config_infer_primary_yolo26.txt Datei entsprechend deinem Modell (für YOLO26s mit 80 Klassen)

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

10. Bearbeite die deepstream_app_config Datei ist

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

11. Du kannst auch die Videoquelle in der deepstream_app_config Datei ändern. Hier wird eine Standard-Videodatei geladen

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

Inferenz ausführen

deepstream-app -c deepstream_app_config.txt

INT8-Kalibrierung

Wenn du die INT8-Präzision für die Inferenz verwenden möchtest, musst du die folgenden Schritte ausführen:

1. Setze die OPENCV Umgebungsvariable

   export OPENCV=1

2. Kompiliere die Bibliothek

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

3. Für das COCO-Dataset, lade val2017 herunter, entpacke es und verschiebe es in DeepStream-Yolo Ordner

4. Erstelle ein neues Verzeichnis für Kalibrierungsbilder

   mkdir calibration

5. Führe den folgenden Befehl aus, um 1000 zufällige Bilder aus dem COCO-Dataset für die Kalibrierung auszuwählen

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

6. Erstelle die calibration.txt Datei mit allen ausgewählten Bildern

   realpath calibration/*jpg > calibration.txt

7. Setze die Umgebungsvariablen

   export INT8_CALIB_IMG_PATH=calibration.txt
   export INT8_CALIB_BATCH_SIZE=1

8. Aktualisiere die config_infer_primary_yolo26.txt Datei ist

   Von

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

   Zu

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

Inferenz ausführen

deepstream-app -c deepstream_app_config.txt

MultiStream-Einrichtung

Um mehrere Streams unter einer einzigen DeepStream-Anwendung einzurichten, nimm die folgenden Änderungen an der deepstream_app_config.txt-Datei an:

1. Ändere die Zeilen und Spalten, um eine Rasteranzeige entsprechend der Anzahl der Streams zu erstellen, die du haben möchtest. Für 4 Streams können wir zum Beispiel 2 Zeilen und 2 Spalten hinzufügen.

   [tiled-display]
   rows=2
   columns=2

2. Setze die num-sources=4 und füge die uri Einträge für alle vier Streams hinzu.

   [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

Inferenz ausführen

deepstream-app -c deepstream_app_config.txt

Benchmark-Ergebnisse

Die folgenden Benchmarks fassen zusammen, wie YOLO26-Modelle bei verschiedenen TensorRT-Präzisionsstufen mit einer Eingabegröße von 640x640 auf NVIDIA Jetson Orin NX 16GB abschneiden.

Vergleichsdiagramm

Detaillierte Vergleichstabelle

Danksagungen

Dieser Leitfaden wurde ursprünglich von unseren Freunden bei Seeed Studio, Lakshantha und Elaine, erstellt.

FAQ

Wie richte ich Ultralytics YOLO26 auf einem NVIDIA Jetson Gerät ein?

Um Ultralytics YOLO26 auf einem NVIDIA Jetson Gerät einzurichten, musst du zuerst das DeepStream SDK installieren, das mit deiner JetPack-Version kompatibel ist. Folge der Schritt-für-Schritt-Anleitung in unserem Quick Start Guide um deinen NVIDIA Jetson für die YOLO26-Bereitstellung zu konfigurieren.

Was ist der Vorteil der Verwendung von TensorRT mit YOLO26 auf NVIDIA Jetson?

Die Verwendung von TensorRT mit YOLO26 optimiert das Modell für die Inferenz, was die Latenz erheblich reduziert und den Durchsatz auf NVIDIA Jetson Geräten verbessert. TensorRT bietet eine leistungsstarke Inferenz mit geringer Latenz Deep Learning durch Layer-Fusion, Präzisionskalibrierung und Kernel-Auto-Tuning. Dies führt zu einer schnelleren und effizienteren Ausführung, was besonders nützlich für Echtzeitanwendungen wie Videoanalysen und autonome Maschinen ist.

Kann ich Ultralytics YOLO26 mit DeepStream SDK auf verschiedener NVIDIA Jetson Hardware ausführen?

Ja, der Leitfaden für die Bereitstellung von Ultralytics YOLO26 mit dem DeepStream SDK und TensorRT ist über die gesamte NVIDIA Jetson Reihe hinweg kompatibel. Dies beinhaltet Geräte wie den Jetson Orin NX 16GB mit JetPack 5.1.3 und den Jetson Nano 4GB mit JetPack 4.6.4. Sieh dir den Abschnitt DeepStream-Konfiguration für YOLO26 für detaillierte Schritte an.

Wie kann ich ein YOLO26-Modell für DeepStream in ONNX konvertieren?

Um ein YOLO26-Modell für die Bereitstellung mit DeepStream in das ONNX-Format zu konvertieren, verwende das utils/export_yolo26.py Skript aus dem DeepStream-Yolo Repository.

Hier ist ein Beispielbefehl:

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

Für weitere Details zur Modellkonvertierung, schau dir unseren Abschnitt zur Modellexportierung.

Was sind die Leistungs-Benchmarks für YOLO auf NVIDIA Jetson Orin NX?

Die Leistung von YOLO26-Modellen auf NVIDIA Jetson Orin NX 16GB variiert je nach TensorRT-Präzisionsstufe. Zum Beispiel erreichen YOLO26s-Modelle:

• FP32-Präzision: 14.6 ms/im, 68.5 FPS
• FP16-Präzision: 7.94 ms/im, 126 FPS
• INT8-Präzision: 5.95 ms/im, 168 FPS

Diese Benchmarks unterstreichen die Effizienz und Leistungsfähigkeit der Verwendung von TensorRT-optimierten YOLO26-Modellen auf NVIDIA Jetson Hardware. Weitere Einzelheiten findest du in unserem Benchmark-Ergebnisse.