Ultralytics YOLO26 auf NVIDIA Jetson mit dem DeepStream SDK und TensorRT#

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

Dieser Leitfaden behandelt die DeepStream-Konfiguration für YOLO26, die INT8-Kalibrierung, das Multi-Stream-Setup und die Benchmark-Ergebnisse.

Was ist NVIDIA DeepStream?#

NVIDIAs DeepStream SDK ist ein vollständiges Streaming-Analysetoolkit auf Basis von GStreamer für KI-basierte Erfassung von Multisensoren, Video-, Audio- und Bildverständnis. Es ist ideal für Vision-KI-Entwickler, Softwarepartner, Start-ups und OEMs, die IVA-Apps und -Dienste (Intelligent Video Analytics) entwickeln. Du kannst jetzt Stream-Verarbeitungspipelines erstellen, die neuronale Netze und andere komplexe Verarbeitungsaufgaben wie Tracking, Videokodierung/-dekodierung und Video-Rendering integrieren. Diese Pipelines ermöglichen Echtzeitanalysen von Video-, Bild- und Sensordaten. Die plattformübergreifende Unterstützung von DeepStream bietet dir einen schnelleren und einfacheren Weg, Vision-KI-Anwendungen und -Dienste vor Ort (on-premise), am 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 das DeepStream SDK entsprechend der JetPack-Version.
  • Installiere für JetPack 4.6.4 DeepStream 6.0.1.
  • Installiere für JetPack 5.1.3 DeepStream 6.3.
  • Installiere für JetPack 6.1 DeepStream 7.1.
  • Installiere für JetPack 7.1 DeepStream 9.0.

DeepStream-Konfiguration für YOLO26#

Hier verwenden wir das GitHub-Repository marcoslucianops/DeepStream-Yolo, das die Unterstützung des NVIDIA DeepStream SDK für YOLO-Modelle enthält. Wir schätzen die Bemühungen 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. Kone das DeepStream-Yolo Repository.

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

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

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

4. Lade ein Ultralytics YOLO26-Erkennungsmodell (.pt) deiner Wahl aus dem YOLO26-Projekt 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 Modelldatei .onnx und die Datei labels.txt in den Ordner DeepStream-Yolo.

   cp yolo26s.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 Datei config_infer_primary_yolo26.txt entsprechend deinem Modell (für YOLO26s mit 80 Klassen).

   [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. Bearbeite die Datei deepstream_app_config.

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

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

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

Führe die Inferenz aus.#

deepstream-app -c deepstream_app_config.txt

INT8-Kalibrierung#

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

1. Setze die Umgebungsvariable OPENCV.

   export OPENCV=1

2. Kompiliere die Bibliothek.

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

3. Lade für den COCO-Datensatz val2017 herunter, entpacke es und verschiebe es in den Ordner DeepStream-Yolo.

4. Erstelle ein neues Verzeichnis für Kalibrierungsbilder.

   mkdir calibration

5. Führe Folgendes aus, um 1000 zufällige Bilder aus dem COCO-Datensatz 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 Datei calibration.txt 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 Datei config_infer_primary_yolo26.txt.

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

INT8-Inferenz ausführen#

Führe denselben Befehl aus, um die INT8-Engine zu bauen und die Inferenz zu starten:

deepstream-app -c deepstream_app_config.txt

MultiStream-Einrichtung#

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

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

   [tiled-display]
   rows=2
   columns=2

2. Füge für jeden Stream eine separate Gruppe [sourceN] hinzu, jeweils mit ihren eigenen uri und 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

Multi-Stream-Inferenz ausführen#

Führe denselben Befehl aus, um alle Streams in der Kachelanzeige zu starten:

deepstream-app -c deepstream_app_config.txt

Benchmark-Ergebnisse#

Die folgenden Benchmarks fassen zusammen, wie YOLO11-Modelle bei verschiedenen TensorRT-Präzisionsstufen mit einer Eingabegröße von 640x640 auf einem NVIDIA Jetson Orin NX 16GB abschneiden. YOLO26 verwendet denselben DeepStream-Export- und Inferenz-Workflow wie oben beschrieben.

Vergleichsdiagramm#

Detaillierte Vergleichstabelle#

Danksagungen#

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

FAQ#