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 ins DEEPX-Format ermöglicht effiziente, INT8-quantisierte Inferenz auf DEEPX-NPU-Beschleunigern. Diese Anleitung führt dich durch die Konvertierung deiner YOLO-Modelle ins DEEPX-Format und ihre Bereitstellung auf DEEPX-Hardware.

Was ist DEEPX?#

DEEPX ist ein Halbleiterunternehmen für KI, das sich auf neuronale Verarbeitungseinheiten (NPUs) spezialisiert hat, die für energieeffiziente Deep-Learning-Inferenz am Netzwerkrand entwickelt wurden. DEEPX-NPUs sind für anspruchsvolle eingebettete und industrielle KI-Anwendungen ausgelegt und bieten einen hohen Durchsatz bei minimalem Stromverbrauch. Die Hardware eignet sich besonders für Bereitstellungsszenarien, in denen die Cloud-Verbindung unzuverlässig oder unerwünscht ist, etwa in der Robotik, bei intelligenten Kameras und in industriellen Automatisierungssystemen.

DEEPX-Exportformat#

Beim DEEPX-Export entsteht 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 die INT8-Quantisierung und hardwarespezifische Optimierungen. Dabei entsteht ein eigenständiges Modellverzeichnis, das für die Bereitstellung bereit ist.

Wichtige Merkmale von DEEPX-Modellen#

DEEPX-Modelle bieten mehrere Vorteile für die Bereitstellung am Netzwerkrand:

• INT8-Quantisierung: Beim Export werden die Modelle auf INT8-Genauigkeit quantisiert. Dadurch wird die Modellgröße deutlich verringert und der Durchsatz der NPU maximiert. Erfahre mehr über die Modellquantisierung.
• Für NPUs optimiert: Das Format .dxnn wird speziell für DEEPX-NPU-Hardware kompiliert und nutzt dedizierte Beschleunigungseinheiten für schnelle, effiziente Inferenz.
• Niedriger Stromverbrauch: Indem die Inferenz auf die NPU ausgelagert wird, verbrauchen DEEPX-Modelle deutlich weniger Strom als vergleichbare Inferenz auf CPU oder GPU.
• Genauigkeit durch Kalibrierung: Beim Export wird eine EMA-basierte Kalibrierung mit Bildern aus echten Datensätzen verwendet, um Genauigkeitsverluste während der Quantisierung zu minimieren.
• Eigenständige Ausgabe: Das exportierte Modellverzeichnis enthält die kompilierte Binärdatei, die Kalibrierungskonfiguration und Metadaten, sodass sich das Modell unkompliziert bereitstellen lässt.

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: YOLO-Modell konvertieren#

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

Installation#

Führe zum Installieren der erforderlichen Pakete folgenden Befehl aus:

# Install the required package for YOLO
pip install ultralytics

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

Die PyPI-Versionen des Compilers wurden zurückgezogen. Um die Exportabhängigkeiten vorab zu installieren, gib die SDK-Wheel-Seite mit --find-links an. 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

Für eine bearbeitbare Installation aus dem Repository ersetze "ultralytics[export-deepx]" durch -e ".[export-base,export-deepx]". Um die Python-3.12-Umgebung und den von CI verwendeten kurzen Exporttest nachzustellen, führe den vorhandenen Umgebungs-Builder im Stammverzeichnis des Repositorys aus:

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

Der Umgebungs-Builder benötigt uv und eine installierte Ultralytics-Arbeitskopie. Er installiert den Compiler aus der SDK-Quelle und wendet automatisch die getesteten Abhängigkeitsbeschränkungen 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 es anschließend, um Inferenz auszuführen oder seine Genauigkeit zu validieren.

from ultralytics import YOLO

# YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Modell ins DEEPX-Format exportieren (quantize=8 wird automatisch erzwungen)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Das exportierte DEEPX-Modell laden
model = YOLO("yolo26n_deepx_model")

# Inference ausführen
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Das exportierte DEEPX-Modell laden
model = YOLO("yolo26n_deepx_model")

# Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")

Exportargumente#

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

Ausgabestruktur#

Nach einem erfolgreichen Export wird ein Modellverzeichnis mit folgender 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 Modelldatei, die die Laufzeitumgebung dx_engine direkt auf der NPU lädt. 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 ins DEEPX-Format exportiert hast, kannst du es als Nächstes auf DEEPX-NPU-Hardware bereitstellen.

Laufzeitumgebung installieren#

Für die Inferenz benötigst du den DEEPX-NPU-Treiber, die Laufzeitumgebung 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

Prüfe mit dxrt-cli --version, ob die Laufzeitumgebung korrekt installiert ist. Die Ausgabe sollte in etwa 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 Laufzeitumgebung installiert ist, führe Inferenz und Validierung auf deinem DEEPX-Gerät genau wie im Abschnitt Verwendung oben beschrieben aus – das exportierte _deepx_model lässt sich direkt mit YOLO(...) laden.

Visualisierung mit dxtron#

dxtron ist der DEEPX-Graph-Visualisierer zum Untersuchen des kompilierten Modells .dxnn.

Installiere dxtron unter x86-64 Linux, indem du das Paket .deb vom DEEPX-SDK herunterlädst und mit 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 getestet und dabei Geschwindigkeit und Genauigkeit von 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 Benchmark-Ergebnisse erfolgte mit COCO128 für die Objekterkennung, COCO128-seg für die Segmentierung, COCO8-pose für die Posenschätzung, ImageNet100 für die Klassifizierung und DOTA128 für OBB-Modelle. Die Inferenzzeit umfasst keine Vor- und Nachverarbeitung.

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

1. Trainiere dein Modell mit dem Train-Modus von Ultralytics.
2. Exportiere mit model.export(format="deepx") ins DEEPX-Format
3. Überprüfe die Genauigkeit mit yolo val, um minimale Quantisierungsverluste zu bestätigen.
4. Führe Vorhersagen aus mit yolo predict, um die Ergebnisse qualitativ zu überprüfen.
5. Stelle das exportierte Verzeichnis _deepx_model/ mithilfe der Laufzeitumgebung dx_engine auf DEEPX-NPU-Hardware bereit

Anwendungen in der Praxis#

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

• Intelligente Überwachung: Echtzeit-Objekterkennung für Sicherheits- und Überwachungssysteme bei niedrigem Stromverbrauch und ohne Abhängigkeit von der Cloud.
• Industrielle Automatisierung: Qualitätskontrolle direkt auf dem Gerät, Fehlererkennung und Prozessüberwachung in Fabriken.
• Robotik: Visionsgestützte Navigation, Hindernisvermeidung und Objekterkennung auf autonomen Robotern und Drohnen.
• Intelligente Landwirtschaft: Überwachung des Pflanzenzustands, Erkennung von Schädlingen und Ertragsschätzung mithilfe von Computer Vision in der Landwirtschaft.
• Einzelhandelsanalysen: Analyse von Kundenströmen, Überwachung von Regalen und Bestandsverfolgung mit Echtzeit-Inferenz am Netzwerkrand.

Zusammenfassung#

In dieser Anleitung hast du erfahren, wie du Ultralytics-YOLO-Modelle ins DEEPX-Format exportierst und auf DEEPX-NPU-Hardware bereitstellst. Die Exportpipeline verwendet die INT8-Kalibrierung und den Compiler dx_com, um eine für die Hardware optimierte Binärdatei .dxnn zu erstellen. Die Laufzeitumgebung dx_engine führt die Inferenz auf dem Gerät aus.

Die Kombination aus Ultralytics YOLO und der NPU-Technologie von DEEPX bietet eine effektive Lösung für anspruchsvolle Computer-Vision-Aufgaben auf eingebetteten Geräten und Edge-Geräten – mit hohem Durchsatz und niedrigem Stromverbrauch für Echtzeitanwendungen.

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

Wenn du mehr über andere Ultralytics-YOLO-Integrationen erfahren möchtest, findest du auf unserer Seite mit Integrationsanleitungen zahlreiche hilfreiche Ressourcen und Einblicke.

Häufig gestellte Fragen#