Ultralytics YOLO26 auf NVIDIA Jetson mit DeepStream SDK und TensorRT#

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

Dieser Leitfaden führt durch die DeepStream-Konfiguration für YOLO26, die INT8-Kalibrierung, die Einrichtung mehrerer Streams und die Benchmark-Ergebnisse.

Was ist NVIDIA DeepStream?#

Das DeepStream SDK von NVIDIA ist ein vollständiges Toolkit für Streaming-Analysen auf GStreamer-Basis zur KI-gestützten Verarbeitung mehrerer Sensoren sowie zur Analyse von Video, Audio und Bildern. Es eignet sich ideal für Entwickler von Computer-Vision-KI, Softwarepartner, Start-ups und OEMs, die IVA-Anwendungen (Intelligente Videoanalyse) und -Dienste entwickeln. Du kannst jetzt Pipelines zur Streamverarbeitung erstellen, die neuronale Netze und weitere komplexe Verarbeitungsschritte wie Tracking, Videokodierung und -dekodierung sowie Videorendering integrieren. Diese Pipelines ermöglichen Echtzeitanalysen von Video-, Bild- und Sensordaten. Die plattformübergreifende Unterstützung von DeepStream bietet dir eine schnellere und einfachere Möglichkeit, Anwendungen und Dienste für Computer-Vision-KI lokal, am Edge und in der Cloud zu entwickeln.

Voraussetzungen#

Bevor du mit diesem Leitfaden beginnst:

• Besuche unsere Dokumentation, den Schnellstartleitfaden: NVIDIA Jetson mit Ultralytics YOLO26, um dein NVIDIA Jetson-Gerät mit Ultralytics YOLO26 einzurichten.
• Installiere 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 Unterstützung für YOLO-Modelle im NVIDIA DeepStream SDK enthält. Wir schätzen die Arbeit von marcoslucianops und die geleisteten Beiträge sehr!

1. Ultralytics mit den erforderlichen Abhängigkeiten installieren

   pip install ultralytics onnx onnxslim

2. Das DeepStream-Yolo-Repository klonen

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

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

4. Konvertiere das Modell in ONNX und schreibe die Datei labels.txt, aus der DeepStream die Klassennamen liest.

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

6. Lege die CUDA-Version entsprechend der installierten JetPack-Version fest.

   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

   Für JetPack 7.1:

   export CUDA_VER=13.0

7. Die Bibliothek kompilieren

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

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

9. Bearbeite die Datei deepstream_app_config.

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

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

Inferenz ausführen#

deepstream-app -c deepstream_app_config.txt

INT8-Kalibrierung#

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

1. Setze die Umgebungsvariable OPENCV.

   export OPENCV=1

2. Die Bibliothek kompilieren

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

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

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

   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 erstellen und die Inferenz zu starten:

deepstream-app -c deepstream_app_config.txt

Einrichtung mehrerer Streams#

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

1. Ändere die Zeilen und Spalten, um eine Rasteransicht entsprechend der gewünschten Stream-Anzahl zu erstellen. Für 4 Streams kannst du beispielsweise 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 einem 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 gekachelten Ansicht zu starten:

deepstream-app -c deepstream_app_config.txt

Benchmark-Ergebnisse#

Die folgenden Benchmarks fassen zusammen, wie sich YOLO11-Modelle bei verschiedenen TensorRT-Genauigkeitsstufen mit einer Eingabegröße von 640x640 auf NVIDIA Jetson Orin NX 16GB verhalten. YOLO26 verwendet denselben oben beschriebenen DeepStream-Export- und Inferenzworkflow.

Vergleichsdiagramm#

Detaillierte Vergleichstabelle#

Danksagungen#

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

FAQ#