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 des DeepStream SDK und TensorRT. Hier setzen wir TensorRT ein, um die Inferenzleistung auf der Jetson-Plattform zu maximieren.

Was ist NVIDIA DeepStream?

NVIDIA's DeepStream SDK ist ein komplettes Streaming-Analytics-Toolkit auf GStreamer-Basis für KI-gestützte Multi-Sensor-Verarbeitung, Video-, Audio- und Bildanalyse. 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 neuronale Netze und andere komplexe Verarbeitungsaufgaben wie Tracking, Videokodierung/-dekodierung und Videorendering integrieren. Diese Pipelines ermöglichen Echtzeitanalysen von Video-, Bild- und Sensordaten. DeepStreams plattformübergreifende Unterstützung bietet dir einen schnelleren und einfacheren Weg, Vision-KI-Anwendungen und -Dienste lokal (on-premise), am Edge und in der Cloud zu entwickeln.

Voraussetzungen

Bevor du diesem Leitfaden folgst:

• Besuche unsere Dokumentation, Quick Start Guide: NVIDIA Jetson with Ultralytics YOLO26, um dein NVIDIA Jetson-Gerät für Ultralytics YOLO26 einzurichten.
• Installiere das DeepStream SDK entsprechend deiner 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 NVIDIA DeepStream SDK-Unterstützung für YOLO-Modelle enthält. Wir danken marcoslucianops für seine Beiträge!

1. Installiere Ultralytics mit den notwendigen Abhängigkeiten

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

2. Klon das DeepStream-Yolo-Repository

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

3. Kopiere die export_yolo26.py-Datei aus dem 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 aus den YOLO26 releases herunter. Hier verwenden wir yolo26s.pt.

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

5. Modell in ONNX konvertieren

   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 die labels.txt-Datei in den DeepStream-Yolo-Ordner

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

7. Stelle die CUDA-Version entsprechend der installierten JetPack-Version ein

   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 gemäß 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

    ...
    [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 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. Lade für den COCO-Datensatz val2017 herunter, entpacke ihn und verschiebe ihn in den DeepStream-Yolo-Ordner

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

   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 in der deepstream_app_config.txt-Datei vor:

1. Ändere die Zeilen und Spalten, um ein Raster-Display 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. Setze 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 einem NVIDIA Jetson Orin NX 16GB abschneiden.

Vergleichstabelle

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 dein 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 für 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 Videoanalyse und autonome Maschinen ist.

Kann ich Ultralytics YOLO26 mit dem 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-Produktreihe kompatibel. Dies umfasst Geräte wie den Jetson Orin NX 16GB mit JetPack 5.1.3 und den Jetson Nano 4GB mit JetPack 4.6.4. Siehe den Abschnitt DeepStream Configuration for YOLO26 für detaillierte Schritte.

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

Weitere Details zur Modellkonvertierung findest du in unserem Modell-Export-Abschnitt.

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

Die Leistung von YOLO26-Modellen auf dem NVIDIA Jetson Orin NX 16GB variiert je nach TensorRT-Präzisionsstufen. 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 Details findest du in unserem Abschnitt Benchmark Results.