Schnellstartanleitung: NVIDIA Jetson mit Ultralytics YOLO11
Diese umfassende Anleitung bietet eine detaillierte exemplarische Vorgehensweise für die Bereitstellung von Ultralytics YOLO11 auf NVIDIA Jetson-Geräten. Darüber hinaus werden Leistungs-Benchmarks gezeigt, um die Fähigkeiten von YOLO11 auf diesen kleinen und leistungsstarken Geräten zu demonstrieren.
Neue Produktunterstützung
Wir haben diesen Leitfaden mit dem neuesten NVIDIA Jetson Orin Nano Super Developer Kit aktualisiert, das bis zu 67 TOPS an KI-Leistung liefert – eine 1,7-fache Verbesserung gegenüber seinem Vorgänger –, um die gängigsten KI-Modelle nahtlos auszuführen.
Ansehen: Wie man Ultralytics YOLO11 auf NVIDIA JETSON Geräten verwendet
Hinweis
Dieser Leitfaden wurde mit dem NVIDIA Jetson AGX Orin Developer Kit (64GB) mit der neuesten stabilen JetPack-Version von JP6.2, dem NVIDIA Jetson Orin Nano Super Developer Kit mit der JetPack-Version von JP6.1, dem Seeed Studio reComputer J4012 auf Basis des NVIDIA Jetson Orin NX 16GB mit der JetPack-Version von JP6.0/ JetPack-Version von JP5.1.3 und dem Seeed Studio reComputer J1020 v2 auf Basis des NVIDIA Jetson Nano 4GB mit der JetPack-Version von JP4.6.1 getestet. Es wird erwartet, dass es mit der gesamten NVIDIA Jetson Hardware-Palette funktioniert, einschließlich der neuesten und älteren Versionen.
Was ist NVIDIA Jetson?
NVIDIA Jetson ist eine Serie von Embedded-Computing-Boards, die entwickelt wurden, um beschleunigtes KI-Computing (künstliche Intelligenz) auf Edge-Geräte zu bringen. Diese kompakten und leistungsstarken Geräte basieren auf der GPU-Architektur von NVIDIA und sind in der Lage, komplexe KI-Algorithmen und Deep-Learning-Modelle direkt auf dem Gerät auszuführen, ohne auf Cloud-Computing-Ressourcen angewiesen zu sein. Jetson-Boards werden häufig in der Robotik, autonomen Fahrzeugen, industriellen Automatisierung und anderen Anwendungen eingesetzt, bei denen KI-Inferenz lokal mit geringer Latenz und hoher Effizienz durchgeführt werden muss. Darüber hinaus basieren diese Boards auf der ARM64-Architektur und verbrauchen weniger Strom als herkömmliche GPU-Computing-Geräte.
NVIDIA Jetson Serienvergleich
Jetson Orin ist die neueste Iteration der NVIDIA Jetson-Familie, die auf der NVIDIA Ampere-Architektur basiert und im Vergleich zu den vorherigen Generationen eine drastisch verbesserte KI-Leistung bietet. Die folgende Tabelle vergleicht einige der Jetson-Geräte im Ökosystem.
Jetson AGX Orin 64GB | Jetson Orin NX 16GB | Jetson Orin Nano Super | Jetson AGX Xavier | Jetson Xavier NX | Jetson Nano | |
---|---|---|---|---|---|---|
KI-Leistung | 275 TOPS | 100 TOPS | 67 TOPs | 32 TOPS | 21 TOPS | 472 GFLOPS |
GPU | 2048-Kern NVIDIA Ampere Architektur GPU mit 64 Tensor Cores | 1024-Kern NVIDIA Ampere Architektur GPU mit 32 Tensor Cores | 1024-Kern NVIDIA Ampere Architektur GPU mit 32 Tensor Cores | 512-Kern NVIDIA Volta Architektur GPU mit 64 Tensor-Kernen | 384-Kern NVIDIA Volta™ Architektur GPU mit 48 Tensor-Kernen | 128-Kern NVIDIA Maxwell™ Architektur GPU |
Maximale GPU-Frequenz | 1,3 GHz | 918 MHz | 1020 MHz | 1377 MHz | 1100 MHz | 921 MHz |
CPU | 12-Kern NVIDIA Arm® Cortex A78AE v8.2 64-Bit CPU 3MB L2 + 6MB L3 | 8-Kern NVIDIA Arm® Cortex A78AE v8.2 64-Bit CPU 2MB L2 + 4MB L3 | 6-Kern Arm® Cortex®-A78AE v8.2 64-bit CPU 1.5MB L2 + 4MB L3 | 8-Kern NVIDIA Carmel Arm®v8.2 64-Bit CPU 8MB L2 + 4MB L3 | 6-Kern NVIDIA Carmel Arm®v8.2 64-bit CPU 6MB L2 + 4MB L3 | Quad-Core Arm® Cortex®-A57 MPCore Prozessor |
Maximale CPU-Frequenz | 2,2 GHz | 2,0 GHz | 1,7 GHz | 2,2 GHz | 1,9 GHz | 1,43 GHz |
Arbeitsspeicher | 64 GB 256-Bit LPDDR5 204,8 GB/s | 16GB 128-bit LPDDR5 102.4GB/s | 8 GB 128-Bit LPDDR5 102 GB/s | 32GB 256-bit LPDDR4x 136.5GB/s | 8 GB 128-Bit LPDDR4x 59,7 GB/s | 4 GB 64-Bit LPDDR4 25,6 GB/s |
Eine detailliertere Vergleichstabelle finden Sie im Abschnitt Technische Daten der offiziellen NVIDIA Jetson-Seite.
Was ist NVIDIA JetPack?
Das NVIDIA JetPack SDK, das die Jetson-Module antreibt, ist die umfassendste Lösung und bietet eine vollständige Entwicklungsumgebung für die Erstellung durchgängig beschleunigter KI-Anwendungen und verkürzt die Markteinführungszeit. JetPack umfasst Jetson Linux mit Bootloader, Linux-Kernel, Ubuntu-Desktop-Umgebung und eine vollständige Reihe von Bibliotheken zur Beschleunigung von GPU-Computing, Multimedia, Grafik und Computer Vision. Es enthält auch Beispiele, Dokumentation und Entwicklertools für Host-Computer und Developer-Kit und unterstützt SDKs höherer Ebene wie DeepStream für Streaming-Videoanalysen, Isaac für Robotik und Riva für konversationelle KI.
Flash JetPack auf NVIDIA Jetson
Der erste Schritt, nachdem Sie ein NVIDIA Jetson-Gerät in die Hände bekommen haben, ist das Flashen von NVIDIA JetPack auf das Gerät. Es gibt verschiedene Möglichkeiten, NVIDIA Jetson-Geräte zu flashen.
- Wenn Sie ein offizielles NVIDIA Development Kit besitzen, wie z. B. das Jetson Orin Nano Developer Kit, können Sie ein Image herunterladen und eine SD-Karte mit JetPack vorbereiten, um das Gerät zu booten.
- Wenn Sie ein anderes NVIDIA Development Kit besitzen, können Sie JetPack mit dem SDK Manager auf das Gerät flashen.
- Wenn Sie ein Seeed Studio reComputer J4012-Gerät besitzen, können Sie JetPack auf die mitgelieferte SSD flashen, und wenn Sie ein Seeed Studio reComputer J1020 v2-Gerät besitzen, können Sie JetPack auf die eMMC/SSD flashen.
- Wenn Sie ein anderes Gerät eines Drittanbieters besitzen, das von einem NVIDIA Jetson-Modul angetrieben wird, wird empfohlen, Command-Line Flashing zu verwenden.
Hinweis
Für die oben genannten Methoden 3 und 4 geben Sie nach dem Flashen des Systems und dem Starten des Geräts bitte "sudo apt update && sudo apt install nvidia-jetpack -y" im Geräteterminal ein, um alle verbleibenden benötigten JetPack-Komponenten zu installieren.
JetPack-Unterstützung basierend auf Jetson-Gerät
Die folgende Tabelle hebt die von verschiedenen NVIDIA Jetson-Geräten unterstützten NVIDIA JetPack-Versionen hervor.
JetPack 4 | JetPack 5 | JetPack 6 | |
---|---|---|---|
Jetson Nano | ✅ | ❌ | ❌ |
Jetson TX2 | ✅ | ❌ | ❌ |
Jetson Xavier NX | ✅ | ✅ | ❌ |
Jetson AGX Xavier | ✅ | ✅ | ❌ |
Jetson AGX Orin | ❌ | ✅ | ✅ |
Jetson Orin NX | ❌ | ✅ | ✅ |
Jetson Orin Nano | ❌ | ✅ | ✅ |
Schnellstart mit Docker
Der schnellste Weg, um mit Ultralytics YOLO11 auf NVIDIA Jetson zu beginnen, ist die Ausführung mit vorgefertigten Docker-Images für Jetson. Beachten Sie die obige Tabelle und wählen Sie die JetPack-Version entsprechend Ihrem Jetson-Gerät aus.
t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
t=ultralytics/ultralytics:latest-jetson-jetpack5
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
t=ultralytics/ultralytics:latest-jetson-jetpack6
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
Danach fahren Sie mit dem Abschnitt Verwendung von TensorRT auf NVIDIA Jetson fort.
Starten Sie mit der nativen Installation
Für eine native Installation ohne Docker beachten Sie bitte die folgenden Schritte.
Ausführung auf JetPack 6.1
Ultralytics-Paket installieren
Hier installieren wir das Ultralytics-Paket auf dem Jetson mit optionalen Abhängigkeiten, damit wir die PyTorch-Modelle in andere Formate exportieren können. Wir werden uns hauptsächlich auf NVIDIA TensorRT-Exporte konzentrieren, da TensorRT sicherstellt, dass wir die maximale Leistung aus den Jetson-Geräten herausholen können.
-
Paketliste aktualisieren, pip installieren und auf die neueste Version aktualisieren
sudo apt update sudo apt install python3-pip -y pip install -U pip
-
Installieren
ultralytics
pip-Paket mit optionalen Abhängigkeitenpip install ultralytics[export]
-
Gerät neu starten
sudo reboot
PyTorch und Torchvision installieren
Die obige Ultralytics-Installation installiert Torch und Torchvision. Diese beiden über Pip installierten Pakete sind jedoch nicht mit der Jetson-Plattform kompatibel, die auf der ARM64-Architektur basiert. Daher müssen wir manuell ein vorgefertigtes PyTorch-Pip-Wheel installieren und Torchvision aus dem Quellcode kompilieren bzw. installieren.
Installieren torch 2.5.0
und torchvision 0.20
gemäß JP6.1
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.5.0a0+872d972e41.nv24.08-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.20.0a0+afc54f7-cp310-cp310-linux_aarch64.whl
Hinweis
Besuchen Sie die PyTorch für Jetson-Seite, um auf alle verschiedenen Versionen von PyTorch für verschiedene JetPack-Versionen zuzugreifen. Eine detailliertere Liste zur PyTorch-, Torchvision-Kompatibilität finden Sie auf der PyTorch- und Torchvision-Kompatibilitätsseite.
Installieren cuSPARSELt
um ein Abhängigkeitsproblem zu beheben mit torch 2.5.0
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/arm64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get -y install libcusparselt0 libcusparselt-dev
Installieren onnxruntime-gpu
Die onnxruntime-gpu In PyPI gehostetes Paket hat keine aarch64
Binärdateien für den Jetson. Daher müssen wir dieses Paket manuell installieren. Dieses Paket wird für einige der Exporte benötigt.
Sie können alle verfügbaren finden onnxruntime-gpu
packages – organisiert nach JetPack-Version, Python-Version und anderen Kompatibilitätsdetails – im Jetson Zoo ONNX Runtime KompatibilitätsmatrixHier werden wir herunterladen und installieren onnxruntime-gpu 1.20.0
mit Python3.10
Unterstützung.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl
Hinweis
onnxruntime-gpu
wird die Numpy-Version automatisch auf die neueste Version zurücksetzen. Daher müssen wir Numpy neu installieren, um 1.23.5
um ein Problem durch Ausführen von folgendem Befehl zu beheben:
pip install numpy==1.23.5
Ausführung auf JetPack 5.1.2
Ultralytics-Paket installieren
Hier installieren wir das Ultralytics-Paket auf dem Jetson mit optionalen Abhängigkeiten, damit wir die PyTorch-Modelle in andere Formate exportieren können. Wir werden uns hauptsächlich auf NVIDIA TensorRT-Exporte konzentrieren, da TensorRT sicherstellt, dass wir die maximale Leistung aus den Jetson-Geräten herausholen können.
-
Paketliste aktualisieren, pip installieren und auf die neueste Version aktualisieren
sudo apt update sudo apt install python3-pip -y pip install -U pip
-
Installieren
ultralytics
pip-Paket mit optionalen Abhängigkeitenpip install ultralytics[export]
-
Gerät neu starten
sudo reboot
PyTorch und Torchvision installieren
Die obige Ultralytics-Installation installiert Torch und Torchvision. Diese beiden über Pip installierten Pakete sind jedoch nicht mit der Jetson-Plattform kompatibel, die auf der ARM64-Architektur basiert. Daher müssen wir manuell ein vorgefertigtes PyTorch-Pip-Wheel installieren und Torchvision aus dem Quellcode kompilieren bzw. installieren.
-
Deinstallieren Sie die aktuell installierten Versionen von PyTorch und Torchvision
pip uninstall torch torchvision
-
Installieren
torch 2.2.0
undtorchvision 0.17.2
gemäß JP5.1.2pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl
Hinweis
Besuchen Sie die PyTorch für Jetson-Seite, um auf alle verschiedenen Versionen von PyTorch für verschiedene JetPack-Versionen zuzugreifen. Eine detailliertere Liste zur PyTorch-, Torchvision-Kompatibilität finden Sie auf der PyTorch- und Torchvision-Kompatibilitätsseite.
Installieren onnxruntime-gpu
Die onnxruntime-gpu In PyPI gehostetes Paket hat keine aarch64
Binärdateien für den Jetson. Daher müssen wir dieses Paket manuell installieren. Dieses Paket wird für einige der Exporte benötigt.
Sie können alle verfügbaren finden onnxruntime-gpu
packages – organisiert nach JetPack-Version, Python-Version und anderen Kompatibilitätsdetails – im Jetson Zoo ONNX Runtime KompatibilitätsmatrixHier werden wir herunterladen und installieren onnxruntime-gpu 1.17.0
mit Python3.8
Unterstützung.
wget https://nvidia.box.com/shared/static/zostg6agm00fb6t5uisw51qi6kpcuwzd.whl -O onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
pip install onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
Hinweis
onnxruntime-gpu
wird die Numpy-Version automatisch auf die neueste Version zurücksetzen. Daher müssen wir Numpy neu installieren, um 1.23.5
um ein Problem durch Ausführen von folgendem Befehl zu beheben:
pip install numpy==1.23.5
Verwenden Sie TensorRT auf NVIDIA Jetson
Unter allen von Ultralytics unterstützten Modellexportformaten bietet TensorRT die höchste Inferenzleistung auf NVIDIA Jetson-Geräten, was es zu unserer Top-Empfehlung für Jetson-Bereitstellungen macht. Anweisungen zur Einrichtung und fortgeschrittene Nutzung finden Sie in unserem dedizierten TensorRT-Integrationsleitfaden.
Modell in TensorRT konvertieren und Inferenz ausführen
Das YOLO11n-Modell im PyTorch-Format wird in TensorRT konvertiert, um Inferenz mit dem exportierten Modell auszuführen.
Beispiel
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model to TensorRT
model.export(format="engine") # creates 'yolo11n.engine'
# Load the exported TensorRT model
trt_model = YOLO("yolo11n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to TensorRT format
yolo export model=yolo11n.pt format=engine # creates 'yolo11n.engine'
# Run inference with the exported model
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'
Hinweis
Besuchen Sie die Export-Seite, um auf zusätzliche Argumente beim Exportieren von Modellen in verschiedene Modellformate zuzugreifen.
Verwenden Sie NVIDIA Deep Learning Accelerator (DLA)
NVIDIA Deep Learning Accelerator (DLA) ist eine spezialisierte Hardwarekomponente, die in NVIDIA Jetson-Geräte integriert ist und die Deep-Learning-Inferenz für Energieeffizienz und Leistung optimiert. Durch die Auslagerung von Aufgaben von der GPU (wodurch diese für intensivere Prozesse freigesetzt wird) ermöglicht DLA die Ausführung von Modellen mit geringerem Stromverbrauch bei gleichzeitiger Aufrechterhaltung eines hohen Durchsatzes, ideal für eingebettete Systeme und KI-Anwendungen in Echtzeit.
Die folgenden Jetson-Geräte sind mit DLA-Hardware ausgestattet:
Jetson Gerät | DLA-Kerne | Maximale DLA-Frequenz |
---|---|---|
Jetson AGX Orin Serie | 2 | 1,6 GHz |
Jetson Orin NX 16GB | 2 | 614 MHz |
Jetson Orin NX 8GB | 1 | 614 MHz |
Jetson AGX Xavier Serie | 2 | 1,4 GHz |
Jetson Xavier NX Serie | 2 | 1.1 GHz |
Beispiel
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model to TensorRT with DLA enabled (only works with FP16 or INT8)
model.export(format="engine", device="dla:0", half=True) # dla:0 or dla:1 corresponds to the DLA cores
# Load the exported TensorRT model
trt_model = YOLO("yolo11n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to TensorRT format with DLA enabled (only works with FP16 or INT8)
# Once DLA core number is specified at export, it will use the same core at inference
yolo export model=yolo11n.pt format=engine device="dla:0" half=True # dla:0 or dla:1 corresponds to the DLA cores
# Run inference with the exported model on the DLA
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'
Hinweis
Bei Verwendung von DLA-Exporten werden einige Layer möglicherweise nicht für die Ausführung auf DLA unterstützt und greifen zur Ausführung auf die GPU zurück. Dieser Fallback kann zusätzliche Latenz verursachen und die Gesamtleistung der Inferenz beeinträchtigen. Daher ist DLA nicht primär darauf ausgelegt, die Inferenzlatenz im Vergleich zu TensorRT, das vollständig auf der GPU ausgeführt wird, zu reduzieren. Stattdessen ist der Hauptzweck die Erhöhung des Durchsatzes und die Verbesserung der Energieeffizienz.
NVIDIA Jetson Orin YOLO11 Benchmarks
YOLO11-Benchmarks wurden vom Ultralytics-Team in 10 verschiedenen Modellformaten durchgeführt, wobei Geschwindigkeit und Genauigkeit gemessen wurden: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN. Die Benchmarks wurden auf NVIDIA Jetson AGX Orin Developer Kit (64GB), NVIDIA Jetson Orin Nano Super Developer Kit und Seeed Studio reComputer J4012 mit Jetson Orin NX 16GB Gerät bei FP32 Präzision mit einer Standard-Eingangsbildgröße von 640 durchgeführt.
Vergleichsdiagramme
Obwohl alle Modellexporte mit NVIDIA Jetson funktionieren, haben wir nur PyTorch, TorchScript, TensorRT in die Vergleichstabelle unten aufgenommen, da diese die GPU auf dem Jetson nutzen und garantiert die besten Ergebnisse liefern. Alle anderen Exporte nutzen nur die CPU, und die Leistung ist nicht so gut wie bei den oben genannten drei. Benchmarks für alle Exporte finden Sie im Abschnitt nach dieser Tabelle.
NVIDIA Jetson AGX Orin Developer Kit (64GB)

NVIDIA Jetson Orin Nano Super Developer Kit

NVIDIA Jetson Orin NX 16GB

Detaillierte Vergleichstabellen
Die folgende Tabelle stellt die Benchmark-Ergebnisse für fünf verschiedene Modelle (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) über zehn verschiedene Formate (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN) dar und gibt uns den Status, die Größe, die mAP50-95(B)-Metrik und die Inferenzzeit für jede Kombination.
NVIDIA Jetson AGX Orin Developer Kit (64GB)
Performance
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 9.40 |
TorchScript | ✅ | 10.5 | 0.5083 | 11.00 |
ONNX | ✅ | 10.2 | 0.5077 | 48.32 |
OpenVINO | ✅ | 10.4 | 0.5058 | 27.24 |
TensorRT (FP32) | ✅ | 12.1 | 0.5085 | 3.93 |
TensorRT (FP16) | ✅ | 8.3 | 0.5063 | 2.55 |
TensorRT (INT8) | ✅ | 5.4 | 0.4719 | 2.18 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 66.87 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 65.68 |
TF Lite | ✅ | 10.3 | 0.5077 | 272.92 |
MNN | ✅ | 10.1 | 0.5059 | 36.33 |
NCNN | ✅ | 10.2 | 0.5031 | 28.51 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5783 | 12.10 |
TorchScript | ✅ | 36.5 | 0.5782 | 11.01 |
ONNX | ✅ | 36.3 | 0.5782 | 107.54 |
OpenVINO | ✅ | 36.4 | 0.5810 | 55.03 |
TensorRT (FP32) | ✅ | 38.1 | 0.5781 | 6.52 |
TensorRT (FP16) | ✅ | 21.4 | 0.5803 | 3.65 |
TensorRT (INT8) | ✅ | 12.1 | 0.5735 | 2.81 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 132.73 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 134.96 |
TF Lite | ✅ | 36.3 | 0.5782 | 798.21 |
MNN | ✅ | 36.2 | 0.5777 | 82.35 |
NCNN | ✅ | 36.2 | 0.5784 | 56.07 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6265 | 22.20 |
TorchScript | ✅ | 77.3 | 0.6307 | 21.47 |
ONNX | ✅ | 76.9 | 0.6307 | 270.89 |
OpenVINO | ✅ | 77.1 | 0.6284 | 129.10 |
TensorRT (FP32) | ✅ | 78.8 | 0.6306 | 12.53 |
TensorRT (FP16) | ✅ | 41.9 | 0.6305 | 6.25 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 4.69 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 299.95 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 310.58 |
TF Lite | ✅ | 77.0 | 0.6307 | 2400.54 |
MNN | ✅ | 76.8 | 0.6308 | 213.56 |
NCNN | ✅ | 76.8 | 0.6284 | 141.18 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 27.70 |
TorchScript | ✅ | 97.6 | 0.6399 | 27.94 |
ONNX | ✅ | 97.0 | 0.6409 | 345.47 |
OpenVINO | ✅ | 97.3 | 0.6378 | 161.93 |
TensorRT (FP32) | ✅ | 99.1 | 0.6406 | 16.11 |
TensorRT (FP16) | ✅ | 52.6 | 0.6376 | 8.08 |
TensorRT (INT8) | ✅ | 30.8 | 0.6208 | 6.12 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 390.78 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 398.76 |
TF Lite | ✅ | 97.1 | 0.6409 | 3037.05 |
MNN | ✅ | 96.9 | 0.6372 | 265.46 |
NCNN | ✅ | 96.9 | 0.6364 | 179.68 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 44.40 |
TorchScript | ✅ | 218.1 | 0.6898 | 47.49 |
ONNX | ✅ | 217.5 | 0.6900 | 682.98 |
OpenVINO | ✅ | 217.8 | 0.6876 | 298.15 |
TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 28.50 |
TensorRT (FP16) | ✅ | 112.2 | 0.6887 | 13.55 |
TensorRT (INT8) | ✅ | 60.0 | 0.6574 | 9.40 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 749.85 |
TF GraphDef | ✅ | 217.7 | 0.6900 | 753.86 |
TF Lite | ✅ | 217.6 | 0.6900 | 6603.27 |
MNN | ✅ | 217.3 | 0.6868 | 519.77 |
NCNN | ✅ | 217.3 | 0.6849 | 298.58 |
Benchmarked mit Ultralytics 8.3.157
Hinweis
Die Inferenzzeit beinhaltet keine Vor- und Nachbearbeitung.
NVIDIA Jetson Orin Nano Super Developer Kit
Performance
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 13.70 |
TorchScript | ✅ | 10.5 | 0.5082 | 13.69 |
ONNX | ✅ | 10.2 | 0.5081 | 14.47 |
OpenVINO | ✅ | 10.4 | 0.5058 | 56.66 |
TensorRT (FP32) | ✅ | 12.0 | 0.5081 | 7.44 |
TensorRT (FP16) | ✅ | 8.2 | 0.5061 | 4.53 |
TensorRT (INT8) | ✅ | 5.4 | 0.4825 | 3.70 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 116.23 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 114.92 |
TF Lite | ✅ | 10.3 | 0.5077 | 340.75 |
MNN | ✅ | 10.1 | 0.5059 | 76.26 |
NCNN | ✅ | 10.2 | 0.5031 | 45.03 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5790 | 20.90 |
TorchScript | ✅ | 36.5 | 0.5781 | 21.22 |
ONNX | ✅ | 36.3 | 0.5781 | 25.07 |
OpenVINO | ✅ | 36.4 | 0.5810 | 122.98 |
TensorRT (FP32) | ✅ | 37.9 | 0.5783 | 13.02 |
TensorRT (FP16) | ✅ | 21.8 | 0.5779 | 6.93 |
TensorRT (INT8) | ✅ | 12.2 | 0.5735 | 5.08 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 250.65 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 252.69 |
TF Lite | ✅ | 36.3 | 0.5782 | 998.68 |
MNN | ✅ | 36.2 | 0.5781 | 188.01 |
NCNN | ✅ | 36.2 | 0.5784 | 101.37 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6266 | 46.50 |
TorchScript | ✅ | 77.3 | 0.6307 | 47.95 |
ONNX | ✅ | 76.9 | 0.6307 | 53.06 |
OpenVINO | ✅ | 77.1 | 0.6284 | 301.63 |
TensorRT (FP32) | ✅ | 78.8 | 0.6305 | 27.86 |
TensorRT (FP16) | ✅ | 41.7 | 0.6309 | 13.50 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.12 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 622.24 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 628.74 |
TF Lite | ✅ | 77.0 | 0.6307 | 2997.93 |
MNN | ✅ | 76.8 | 0.6299 | 509.96 |
NCNN | ✅ | 76.8 | 0.6284 | 292.99 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 56.50 |
TorchScript | ✅ | 97.6 | 0.6409 | 62.51 |
ONNX | ✅ | 97.0 | 0.6399 | 68.35 |
OpenVINO | ✅ | 97.3 | 0.6378 | 376.03 |
TensorRT (FP32) | ✅ | 99.2 | 0.6396 | 35.59 |
TensorRT (FP16) | ✅ | 52.1 | 0.6361 | 17.48 |
TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 11.87 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 807.47 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 822.88 |
TF Lite | ✅ | 97.1 | 0.6409 | 3792.23 |
MNN | ✅ | 96.9 | 0.6372 | 631.16 |
NCNN | ✅ | 96.9 | 0.6364 | 350.46 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 90.00 |
TorchScript | ✅ | 218.1 | 0.6901 | 113.40 |
ONNX | ✅ | 217.5 | 0.6901 | 122.94 |
OpenVINO | ✅ | 217.8 | 0.6876 | 713.1 |
TensorRT (FP32) | ✅ | 219.5 | 0.6904 | 66.93 |
TensorRT (FP16) | ✅ | 112.2 | 0.6892 | 32.58 |
TensorRT (INT8) | ✅ | 61.5 | 0.6612 | 19.90 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 1605.4 |
TF GraphDef | ✅ | 217.8 | 0.6900 | 2961.8 |
TF Lite | ✅ | 217.6 | 0.6900 | 8234.86 |
MNN | ✅ | 217.3 | 0.6893 | 1254.18 |
NCNN | ✅ | 217.3 | 0.6849 | 725.50 |
Benchmarked mit Ultralytics 8.3.157
Hinweis
Die Inferenzzeit beinhaltet keine Vor- und Nachbearbeitung.
NVIDIA Jetson Orin NX 16GB
Performance
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 12.90 |
TorchScript | ✅ | 10.5 | 0.5082 | 13.17 |
ONNX | ✅ | 10.2 | 0.5081 | 15.43 |
OpenVINO | ✅ | 10.4 | 0.5058 | 39.80 |
TensorRT (FP32) | ✅ | 11.8 | 0.5081 | 7.94 |
TensorRT (FP16) | ✅ | 8.1 | 0.5085 | 4.73 |
TensorRT (INT8) | ✅ | 5.4 | 0.4786 | 3.90 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 88.48 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 86.67 |
TF Lite | ✅ | 10.3 | 0.5077 | 302.55 |
MNN | ✅ | 10.1 | 0.5059 | 52.73 |
NCNN | ✅ | 10.2 | 0.5031 | 32.04 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5790 | 21.70 |
TorchScript | ✅ | 36.5 | 0.5781 | 22.71 |
ONNX | ✅ | 36.3 | 0.5781 | 26.49 |
OpenVINO | ✅ | 36.4 | 0.5810 | 84.73 |
TensorRT (FP32) | ✅ | 37.8 | 0.5783 | 13.77 |
TensorRT (FP16) | ✅ | 21.2 | 0.5796 | 7.31 |
TensorRT (INT8) | ✅ | 12.0 | 0.5735 | 5.33 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 185.06 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 186.45 |
TF Lite | ✅ | 36.3 | 0.5782 | 882.58 |
MNN | ✅ | 36.2 | 0.5775 | 126.36 |
NCNN | ✅ | 36.2 | 0.5784 | 66.73 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6266 | 45.00 |
TorchScript | ✅ | 77.3 | 0.6307 | 51.87 |
ONNX | ✅ | 76.9 | 0.6307 | 56.00 |
OpenVINO | ✅ | 77.1 | 0.6284 | 202.69 |
TensorRT (FP32) | ✅ | 78.7 | 0.6305 | 30.38 |
TensorRT (FP16) | ✅ | 41.8 | 0.6302 | 14.48 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.74 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 445.58 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 460.94 |
TF Lite | ✅ | 77.0 | 0.6307 | 2653.65 |
MNN | ✅ | 76.8 | 0.6308 | 339.38 |
NCNN | ✅ | 76.8 | 0.6284 | 187.64 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 56.60 |
TorchScript | ✅ | 97.6 | 0.6409 | 66.72 |
ONNX | ✅ | 97.0 | 0.6399 | 71.92 |
OpenVINO | ✅ | 97.3 | 0.6378 | 254.17 |
TensorRT (FP32) | ✅ | 99.2 | 0.6406 | 38.89 |
TensorRT (FP16) | ✅ | 51.9 | 0.6363 | 18.59 |
TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 12.60 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 575.98 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 583.79 |
TF Lite | ✅ | 97.1 | 0.6409 | 3353.41 |
MNN | ✅ | 96.9 | 0.6367 | 421.33 |
NCNN | ✅ | 96.9 | 0.6364 | 228.26 |
Format | Status | Größe auf der Festplatte (MB) | mAP50-95(B) | Inferenzzeit (ms/Bild) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 98.50 |
TorchScript | ✅ | 218.1 | 0.6901 | 123.03 |
ONNX | ✅ | 217.5 | 0.6901 | 129.55 |
OpenVINO | ✅ | 217.8 | 0.6876 | 483.44 |
TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 75.92 |
TensorRT (FP16) | ✅ | 112.1 | 0.6885 | 35.78 |
TensorRT (INT8) | ✅ | 61.6 | 0.6592 | 21.60 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 1120.43 |
TF GraphDef | ✅ | 217.7 | 0.6900 | 1172.35 |
TF Lite | ✅ | 217.6 | 0.6900 | 7283.63 |
MNN | ✅ | 217.3 | 0.6877 | 840.16 |
NCNN | ✅ | 217.3 | 0.6849 | 474.41 |
Benchmarked mit Ultralytics 8.3.157
Hinweis
Die Inferenzzeit beinhaltet keine Vor- und Nachbearbeitung.
Entdecken Sie weitere Benchmarking-Bemühungen von Seeed Studio, die auf verschiedenen Versionen der NVIDIA Jetson-Hardware laufen.
Unsere Ergebnisse reproduzieren
Um die oben genannten Ultralytics-Benchmarks auf allen Export-Formaten zu reproduzieren, führen Sie diesen Code aus:
Beispiel
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
yolo benchmark model=yolo11n.pt data=coco128.yaml imgsz=640
Beachten Sie, dass die Ergebnisse der Benchmarks je nach der genauen Hardware- und Softwarekonfiguration eines Systems sowie der aktuellen Auslastung des Systems zum Zeitpunkt der Ausführung der Benchmarks variieren können. Für die zuverlässigsten Ergebnisse verwenden Sie einen Datensatz mit einer großen Anzahl von Bildern, d. h. data='coco.yaml'
(5000 Validierungsbilder).
Best Practices bei der Verwendung von NVIDIA Jetson
Bei Verwendung von NVIDIA Jetson gibt es einige Best Practices, die Sie befolgen sollten, um die maximale Leistung auf dem NVIDIA Jetson mit YOLO11 zu erzielen.
-
MAX Power Mode aktivieren
Die Aktivierung des MAX Power Mode auf dem Jetson stellt sicher, dass alle CPU- und GPU-Kerne eingeschaltet sind.
sudo nvpmodel -m 0
-
Jetson Clocks aktivieren
Die Aktivierung von Jetson Clocks stellt sicher, dass alle CPU- und GPU-Kerne mit ihrer maximalen Frequenz getaktet werden.
sudo jetson_clocks
-
Jetson Stats-Anwendung installieren
Wir können die Jetson Stats-Anwendung verwenden, um die Temperaturen der Systemkomponenten zu überwachen und andere Systemdetails wie CPU-, GPU- und RAM-Auslastung anzuzeigen, Leistungsmodi zu ändern, maximale Taktraten einzustellen und JetPack-Informationen zu überprüfen.
sudo apt update sudo pip install jetson-stats sudo reboot jtop
Nächste Schritte
Herzlichen Glückwunsch zur erfolgreichen Einrichtung von YOLO11 auf Ihrem NVIDIA Jetson! Weitere Informationen und Unterstützung finden Sie im weiteren Leitfaden unter Ultralytics YOLO11 Docs!
FAQ
Wie stelle ich Ultralytics YOLO11 auf NVIDIA Jetson-Geräten bereit?
Die Bereitstellung von Ultralytics YOLO11 auf NVIDIA Jetson-Geräten ist ein unkomplizierter Prozess. Flashen Sie zunächst Ihr Jetson-Gerät mit dem NVIDIA JetPack SDK. Verwenden Sie dann entweder ein vorgefertigtes Docker-Image für eine schnelle Einrichtung oder installieren Sie die erforderlichen Pakete manuell. Detaillierte Schritte für jeden Ansatz finden Sie in den Abschnitten Schnellstart mit Docker und Start mit nativer Installation.
Welche Performance-Benchmarks kann ich von YOLO11-Modellen auf NVIDIA Jetson-Geräten erwarten?
YOLO11 Modelle wurden auf verschiedenen NVIDIA Jetson Geräten getestet und zeigen deutliche Leistungsverbesserungen. Das TensorRT-Format bietet beispielsweise die beste Inferenzleistung. Die Tabelle im Abschnitt Detaillierte Vergleichstabellen bietet einen umfassenden Überblick über Leistungskennzahlen wie mAP50-95 und Inferenzzeit über verschiedene Modellformate hinweg.
Warum sollte ich TensorRT für die Bereitstellung von YOLO11 auf NVIDIA Jetson verwenden?
TensorRT wird aufgrund seiner optimalen Leistung dringend für die Bereitstellung von YOLO11-Modellen auf NVIDIA Jetson empfohlen. Es beschleunigt die Inferenz, indem es die GPU-Funktionen des Jetson nutzt und so maximale Effizienz und Geschwindigkeit gewährleistet. Erfahren Sie mehr über die Konvertierung zu TensorRT und die Ausführung von Inferenz im Abschnitt TensorRT auf NVIDIA Jetson verwenden.
Wie kann ich PyTorch und Torchvision auf NVIDIA Jetson installieren?
Um PyTorch und Torchvision auf NVIDIA Jetson zu installieren, deinstalliere zuerst alle vorhandenen Versionen, die möglicherweise über pip installiert wurden. Installiere dann manuell die kompatiblen PyTorch- und Torchvision-Versionen für die ARM64-Architektur des Jetson. Detaillierte Anweisungen für diesen Prozess findest du im Abschnitt PyTorch und Torchvision installieren.
Welche Best Practices gibt es, um die Leistung auf NVIDIA Jetson bei der Verwendung von YOLO11 zu maximieren?
Um die Leistung auf NVIDIA Jetson mit YOLO11 zu maximieren, befolge diese Best Practices:
- Aktivieren Sie den MAX Power Mode, um alle CPU- und GPU-Kerne zu nutzen.
- Aktivieren Sie Jetson Clocks, damit alle Kerne mit ihrer maximalen Frequenz laufen.
- Installieren Sie die Jetson Stats-Anwendung zur Überwachung von Systemmetriken.
Befehle und weitere Details finden Sie im Abschnitt Bewährte Verfahren bei der Verwendung von NVIDIA Jetson.