DEEPX-Export für Ultralytics YOLO-Modelle#

Für die Bereitstellung von Computer-Vision-Modellen auf spezialisierter NPU-Hardware ist ein kompatibles und optimiertes Modellformat erforderlich. Der Export von Ultralytics YOLO-Modellen in das DEEPX-Format ermöglicht eine effiziente, INT8-quantisierte Inferenz auf DEEPX-NPU-Beschleunigern. Diese Anleitung führt dich durch die Konvertierung deiner YOLO-Modelle in das DEEPX-Format und deren Bereitstellung auf DEEPX-basierter Hardware.

Was ist DEEPX?#

DEEPX ist ein Halbleiterunternehmen für künstliche Intelligenz, das sich auf neuronale Verarbeitungseinheiten (NPUs) für energieeffiziente Deep-Learning-Inferenz am Rand des Netzwerks spezialisiert. DEEPX-NPUs wurden für anspruchsvolle eingebettete und industrielle KI-Anwendungen entwickelt und bieten hohen Durchsatz bei minimalem Energieverbrauch. Die Hardware eignet sich besonders für Bereitstellungsszenarien, in denen die Cloud-Anbindung unzuverlässig oder unerwünscht ist, etwa in der Robotik, bei intelligenten Kameras und in industriellen Automatisierungssystemen.

DEEPX-Exportformat#

Der DEEPX-Export erzeugt eine kompilierte .dxnn-Modelldatei, die für die Ausführung auf DEEPX-NPU-Hardware optimiert ist. Die Kompilierungspipeline verwendet das Toolkit dx_com für INT8-Quantisierung und hardwarespezifische Optimierung und erzeugt dabei ein eigenständiges Modellverzeichnis, das für die Bereitstellung bereit ist.

Wichtige Eigenschaften von DEEPX-Modellen#

DEEPX-Modelle bieten mehrere Vorteile für die Bereitstellung am Rand des Netzwerks:

• INT8-Quantisierung: Modelle werden während des Exports auf INT8-Genauigkeit quantisiert, wodurch sich die Modellgröße deutlich verringert und der NPU-Durchsatz maximiert wird. Weitere Informationen findest du unter Modellquantisierung.
• Für NPUs optimiert: Das Format .dxnn wird speziell für DEEPX-NPU-Hardware kompiliert und nutzt dedizierte Beschleunigungseinheiten für eine schnelle und effiziente Inferenz.
• Geringer Energieverbrauch: Durch die Auslagerung der Inferenz auf die NPU verbrauchen DEEPX-Modelle deutlich weniger Energie als eine vergleichbare Inferenz auf CPU oder GPU.
• Kalibrierungsbasierte Genauigkeit: Der Export verwendet eine EMA-basierte Kalibrierung mit echten Datensatzbildern, um Genauigkeitsverluste während der Quantisierung zu minimieren.
• Eigenständige Ausgabe: Das exportierte Modellverzeichnis enthält die kompilierte Binärdatei, die Kalibrierungskonfiguration und Metadaten für eine unkomplizierte Bereitstellung.

Unterstützte Aufgaben#

Der DEEPX-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Modellfamilie, die diese Ausgabeköpfe enthält.

Export nach DEEPX: Dein YOLO-Modell konvertieren#

Exportiere ein Ultralytics YOLO-Modell in das DEEPX-Format und führe mit dem exportierten Modell eine Inferenz aus.

Installation#

Führe zur Installation der erforderlichen Pakete Folgendes aus:

# Install the required package for YOLO
pip install ultralytics

Der dx_com-Compiler wird beim ersten Export automatisch aus dem DEEPX SDK repository installiert. Der aktuelle Export-Workflows verwendet DX-COM 2.3.0, der Wheels für Python 3.8–3.12 auf x86-64 Linux mit glibc 2.31 oder neuer bereitstellt.

Die PyPI-Releases des Compilers sind zurückgezogen (yanked). Um die Export-Abhängigkeiten vorab zu installieren, stelle die SDK-Wheel-Seite mit --find-links bereit; dies funktioniert sowohl mit pip als auch mit uv pip:

pip install "ultralytics[export-deepx]" --find-links https://sdk.deepx.ai/release/dxcom/v2.3.0/index.html

Ersetze für eine editierbare Repository-Installation "ultralytics[export-deepx]" durch -e ".[export-base,export-deepx]". Um die Python-3.12-Umgebung und den von CI verwendeten Test-Export zu reproduzieren, führe den bestehenden Umgebungsersteller vom Repository-Stammverzeichnis aus aus:

ULTRALYTICS_ISOLATED_VENVS="$PWD/.venvs" python .github/scripts/create-export-env.py --env isolated-deepx

Der Umgebungsersteller erfordert uv und einen installierten Ultralytics-Checkout. Er installiert den Compiler aus dem SDK-Quellcode und wendet die getesteten Abhängigkeitsbeschränkungen automatisch an.

Verwendung#

Das DEEPX-Format unterstützt die Modi Export, Predict und Validate. Inferenz und Validierung werden auf DEEPX-NPU-Hardware ausgeführt. Exportiere dein Modell und lade anschließend das exportierte Modell, um eine Inferenz auszuführen oder seine Genauigkeit zu validieren.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to DEEPX format (quantize=8 is enforced automatically)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Load the exported DEEPX model
model = YOLO("yolo26n_deepx_model")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported DEEPX model
model = YOLO("yolo26n_deepx_model")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Exportargumente#

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Ausgabestruktur#

Nach einem erfolgreichen Export wird ein Modellverzeichnis mit der folgenden Struktur erstellt:

yolo26n_deepx_model/
├── yolo26n.dxnn     # Compiled DEEPX model binary (NPU executable)
├── config.json      # Calibration and preprocessing configuration
└── metadata.yaml    # Model metadata (classes, image size, task, etc.)

Die Datei .dxnn ist die kompilierte Modellbinärdatei, die die Laufzeit dx_engine direkt auf der NPU lädt. Die Datei metadata.yaml enthält Klassennamen, Bildgröße und weitere Informationen, die von der Ultralytics-Inferenzpipeline verwendet werden.

Exportierte YOLO-DEEPX-Modelle bereitstellen#

Nachdem du dein Ultralytics YOLO-Modell erfolgreich in das DEEPX-Format exportiert hast, besteht der nächste Schritt darin, diese Modelle auf DEEPX-NPU-Hardware bereitzustellen.

Installation der Laufzeit#

Für die Inferenz benötigst du den DEEPX-NPU-Treiber, die Laufzeit libdxrt und das Python-Paket dx_engine.

# Install the NPU driver and libdxrt runtime
sudo apt update
wget https://github.com/DEEPX-AI/dx_rt_npu_linux_driver/raw/main/release/2.4.1/dxrt-driver-dkms_2.4.1-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.4.1-2_all.deb
wget https://github.com/DEEPX-AI/dx_rt/raw/main/release/3.3.2/libdxrt_3.3.2_all.deb
sudo apt install ./libdxrt_3.3.2_all.deb

# Create dx-engine wheel
cd /usr/share/libdxrt/python_package && sudo ./make_whl.sh

# Install the bundled dx_engine Python wheel
pip install dx_engine-*.whl

Überprüfe mit dxrt-cli --version, ob die Laufzeit korrekt installiert ist. Die Ausgabe sollte ungefähr so aussehen:

DXRT v3.3.2
Minimum Driver Versions
Device Driver: v2.4.0
PCIe Driver: v2.2.0
Firmware: v2.5.2
Minimum Compiler Versions
Compiler: v1.18.1
.dxnn File Format: v6

Sobald die Laufzeit installiert ist, führst du Inferenz und Validierung auf deinem DEEPX-Gerät genau wie im Abschnitt Verwendung oben aus – das exportierte _deepx_model wird direkt mit YOLO(...) geladen.

Visualisierung mit dxtron#

dxtron ist der DEEPX-Graphvisualisierer zur Untersuchung des kompilierten .dxnn-Modells.

Installiere dxtron unter x86-64-Linux, indem du das Paket .deb aus dem DEEPX-SDK herunterlädst und über dpkg installierst:

wget https://sdk.deepx.ai/release/dxtron/v2.0.1/dxtron_2.0.1_amd64.deb
sudo dpkg -i dxtron_2.0.1_amd64.deb

Öffne anschließend dein exportiertes Modell:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Benchmarks#

Das Ultralytics-Team hat YOLO26-Modelle einem Benchmark unterzogen und dabei Geschwindigkeit und Genauigkeit zwischen PyTorch und DEEPX verglichen.

Leistung

Raspberry Pi 5 + DX-M1-M.2-ModulWeitere Geräte folgen in Kürze!

Modell	Format	Status	Größe (MB)	metrics/mAP50-95(B)	Inferenzzeit (ms/Bild)
YOLO26n	PyTorch	✅	5.3	0.4760	315.2
YOLO26n	DEEPX	✅	6.6	0.4660	34.6
YOLO26n-seg	PyTorch	✅	6.5	0.4080	485.4
YOLO26n-seg	DEEPX	✅	7.9	0.3920	53.8
YOLO26n-pose	PyTorch	✅	7.6	0.4230	506.3
YOLO26n-pose	DEEPX	✅	8.8	0.4590	37.6
YOLO26n-obb	PyTorch	✅	5.7	0.817	1094.4
YOLO26n-obb	DEEPX	✅	7.3	0.783	56.4

Modell	Format	Status	Größe (MB)	Genauigkeit (Top-1)	Genauigkeit (Top-5)	Inferenzzeit (ms/Bild)
YOLO26n-cls	PyTorch	✅	5.6	0.431	0.716	23.8
YOLO26n-cls	DEEPX	✅	5.9	0.333	0.686	2.7

Hinweis

Die Validierung für die obigen Benchmarks wurde mit COCO128 für die Erkennung, COCO128-seg für die Segmentierung, COCO8-pose für die Pose-Schätzung, ImageNet100 für die Klassifizierung und DOTA128 für OBB-Modelle durchgeführt. Die Inferenzzeit beinhaltet keine Vor- und Nachbearbeitung.

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

sudo lspci -vvv | grep -iA 33 accelerators | grep -E "LnkCap|LnkSta"

Empfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Trainingsmodus von Ultralytics.
2. Export in das DEEPX-Format mit model.export(format="deepx")
3. Validiere die Genauigkeit mit yolo val, um einen minimalen Quantisierungsverlust zu überprüfen.
4. Führe Vorhersagen aus mit yolo predict zur qualitativen Validierung.
5. Stelle das exportierte Verzeichnis _deepx_model/ mithilfe der Laufzeit dx_engine auf DEEPX-NPU-Hardware bereit

Anwendungen in der Praxis#

Auf DEEPX-NPU-Hardware bereitgestellte YOLO-Modelle eignen sich für eine Vielzahl von Edge-KI-Anwendungen:

• Intelligente Überwachung: Echtzeit-Objekterkennung für Sicherheits- und Überwachungssysteme mit geringem Energieverbrauch und ohne Abhängigkeit von der Cloud.
• Industrielle Automatisierung: Qualitätskontrolle, Fehlererkennung und Prozessüberwachung direkt auf dem Gerät in Fabrikumgebungen.
• Robotik: Visionsbasierte Navigation, Hindernisvermeidung und Objekterkennung auf autonomen Robotern und Drohnen.
• Intelligente Landwirtschaft: Überwachung der Pflanzengesundheit, Schädlings­erkennung und Ertragsschätzung mithilfe von Computer Vision in der Landwirtschaft.
• Einzelhandelsanalysen: Analyse von Kundenströmen, Überwachung von Regalen und Bestandsverfolgung mit Echtzeit-Inferenz am Rand des Netzwerks.

Zusammenfassung#

In dieser Anleitung hast du gelernt, wie du Ultralytics YOLO-Modelle in das DEEPX-Format exportierst und auf DEEPX-NPU-Hardware bereitstellst. Die Exportpipeline verwendet eine INT8-Kalibrierung und den Compiler dx_com, um eine hardwareoptimierte Binärdatei .dxnn zu erzeugen, während die Laufzeit dx_engine die Inferenz auf dem Gerät übernimmt.

Die Kombination aus Ultralytics YOLO und der NPU-Technologie von DEEPX bietet eine effektive Lösung für die Ausführung anspruchsvoller Computer-Vision-Workloads auf eingebetteten Geräten und Edge-Geräten – mit hohem Durchsatz und geringem Energieverbrauch für Echtzeitanwendungen.

Weitere Informationen zur Verwendung findest du auf der offiziellen DEEPX-Website.

Wenn du außerdem mehr über andere Ultralytics-YOLO-Integrationen erfahren möchtest, besuche unsere Seite mit Integrationsanleitungen. Dort findest du zahlreiche nützliche Ressourcen und Informationen.

FAQ#