DEEPX-Export für Ultralytics-YOLO-Modelle

Der Einsatz von Computer-Vision-Modellen auf spezialisierter NPU-Hardware erfordert ein kompatibles und optimiertes Modellformat. Durch den Export von Ultralytics YOLO-Modellen in das DEEPX-Format ist eine effiziente, INT8-quantisierte Inferenz auf DEEPX-NPU-Beschleunigern möglich. Diese Anleitung führt dich durch die Konvertierung deiner YOLO-Modelle in das DEEPX-Format und ihre Bereitstellung auf DEEPX-Hardware.

Was ist DEEPX?#

DEEPX ist ein Halbleiterunternehmen im Bereich KI und ein Ultralytics-Partner, der sich auf Neural Processing Units (NPUs) für energieeffiziente Deep-Learning-Inferenz am Edge spezialisiert hat. DEEPX-NPUs sind für anspruchsvolle eingebettete und industrielle KI-Anwendungen ausgelegt und bieten hohen Durchsatz bei minimalem Stromverbrauch. Die Hardware eignet sich besonders für Einsatzszenarien, 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-Modellbinärdatei, 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 hardwarebezogene Optimierungen. Das Ergebnis ist ein eigenständiges Modellverzeichnis, das sofort bereitgestellt werden kann.

Wichtige Merkmale von DEEPX-Modellen#

DEEPX-Modelle bieten mehrere Vorteile für den Einsatz am Edge:

• INT8-Quantisierung: Modelle werden beim Export auf INT8-Genauigkeit quantisiert. Dadurch wird die Modellgröße deutlich verringert und der NPU-Durchsatz maximiert. Mehr über 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 Energieverbrauch: Indem die Inferenz auf die NPU ausgelagert wird, verbrauchen DEEPX-Modelle deutlich weniger Energie als vergleichbare CPU- oder GPU-Inferenz.
• Kalibrierungsbasierte Genauigkeit: Beim Export wird eine EMA-basierte Kalibrierung mit echten Datensatzbildern verwendet, um Genauigkeitsverluste durch die 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 Köpfe enthält.

Export nach DEEPX: Dein 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 Folgendes aus:

# Install the required package for YOLO
pip install ultralytics

Der Compiler dx_com wird beim ersten Export automatisch von PyPI installiert. DX-COM 2.5.0 stellt Wheels für Python 3.8–3.14 auf x86-64-Linux mit glibc 2.31 oder neuer bereit und benötigt mindestens 16 GB RAM. So installierst du die Exportabhängigkeiten vorab:

pip install "ultralytics[export-deepx]"

Für eine bearbeitbare Repository-Installation ersetze "ultralytics[export-deepx]" durch -e ".[export-base,export-deepx]". Um die Python-3.14-Umgebung und den Smoke-Test-Export aus CI 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 einen installierten Ultralytics-Checkout. Er wendet die getesteten Abhängigkeitsvorgaben automatisch an.

Verwendung#

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

from ultralytics import YOLO

# Ein 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")

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

from ultralytics import YOLO

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

# Die Genauigkeit anhand des COCO8-Datensatzes validieren
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 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 Modellbinärdatei, 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, besteht der nächste Schritt darin, diese Modelle auf DEEPX-NPU-Hardware bereitzustellen.

Installation der Laufzeitumgebung#

Für die Inferenz benötigst du den DEEPX-NPU-Treiber (v2.7.0 oder neuer), die DX-RT-Laufzeitumgebung (v3.5.0 oder neuer), NPU-Firmware v2.7.6 oder neuer sowie das Python-Paket dx_engine. Dies sind die erforderlichen Versionen, um mit DX-COM 2.5.0 kompilierte Modelle auszuführen.

Installiere den NPU-Treiber und das Laufzeitpaket libdxrt-bin mit einer der folgenden Optionen.

Option A: Installation über GitHub-Release-Pakete#

Lade die Treiber- und Laufzeitpakete .deb aus den DEEPX-AI-GitHub-Repositories herunter und installiere sie. Das Laufzeitpaket wird je CPU-Architektur bereitgestellt (amd64 oder arm64):

# Install the NPU driver and DX-RT runtime
sudo apt update
wget https://github.com/DEEPX-AI/dx_rt_npu_linux_driver/raw/main/release/2.7.0/dxrt-driver-dkms_2.7.0-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.7.0-2_all.deb
wget https://github.com/DEEPX-AI/dx_rt/raw/main/release/3.5.0/libdxrt-bin_3.5.0_$(dpkg --print-architecture).deb
sudo apt install ./libdxrt-bin_3.5.0_$(dpkg --print-architecture).deb

Option B: Installation über das DEEPX-apt-Repository#

Binde das DEEPX-apt-Repository einmalig ein und installiere oder aktualisiere anschließend den Treiber und die Laufzeitumgebung mit apt:

# Add the DEEPX apt repository
wget -O - https://apt.releases.deepx.ai/gpg | sudo gpg --dearmor -o /usr/share/keyrings/deepx-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/deepx-archive-keyring.gpg] https://apt.releases.deepx.ai $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") main" | sudo tee /etc/apt/sources.list.d/deepx.list

# Install the NPU driver and DX-RT runtime
sudo apt update
sudo apt install dxrt-driver-dkms libdxrt-bin

Starte den Host nach der Treiberinstallation neu, damit das neue Kernelmodul geladen wird, bevor du dxcli ausführst.

Python-Paket und Firmware#

libdxrt-bin enthält Wheel-Dateien von dx_engine für Python 3.8–3.14 im Verzeichnis /usr/share/libdxrt-bin/python/, installiert sie jedoch nicht. Installiere in der Umgebung, in der Ultralytics und NumPy installiert sind, die Wheel-Datei, die zu deiner Python-Version passt:

python -m pip install --upgrade --no-index --find-links /usr/share/libdxrt-bin/python dx_engine

DX-RT 3.5.0 erfordert NPU-Firmware v2.7.6 oder neuer. Prüfe die Firmwareversion und Geräte-ID mit dxcli -s und aktualisiere bei einer älteren Version die Firmware mit dem Image für dein Modul. Für die M.2-Module DX-M1 und DX-M1M werden unterschiedliche Firmware-Images verwendet. Lade daher nur das Image herunter, das zu deinem Modul passt; dxcli -s gibt das Modul in den Geräteinformationen als M1 oder M1M aus:

# Download the firmware image matching your module (DX-M1 shown)
wget -O dx-m1-2.7.6.bin https://github.com/DEEPX-AI/dx_fw/raw/main/m1/2.7.6/mdot2/fw.bin
# wget -O dx-m1m-2.7.6.bin https://github.com/DEEPX-AI/dx_fw/raw/main/m1m/2.7.6/mdot2/fw.bin # DX-M1M

# Update the selected device; replace DEVICE_ID with its ID from dxcli -s
sudo systemctl stop dxrt.service
dxcli -d DEVICE_ID -u dx-m1-2.7.6.bin # for DX-M1M use dx-m1m-2.7.6.bin instead

Schalte den Host nach dem Flashen vollständig aus und starte ihn erneut, bevor du die Firmwareversion prüfst. Wenn eine physische Trennung von der Stromversorgung nicht möglich ist, starte den Host wie im DEEPX-Leitfaden zur Fehlerbehebung beschrieben neu.

Überprüfe die Installation mit dxcli -s, das die Versionen der Laufzeitumgebung, des Treibers und der Firmware für jedes Gerät ausgibt. import dx_engine löst einen RuntimeError-Fehler aus, wenn sich die Versionen des dx_engine-Wheels und der installierten libdxrt-Laufzeitumgebung unterscheiden. Installiere daher nach dem Upgrade der Laufzeitumgebung das Wheel aus /usr/share/libdxrt-bin/python/ erneut.

Sobald die Laufzeitumgebung installiert ist, führe die Inferenz und Validierung auf deinem DEEPX-Gerät wie im obigen Abschnitt Verwendung gezeigt aus – das exportierte _deepx_model wird direkt mit YOLO(...) geladen.

Das kompilierte Modell prüfen#

DX-COM 2.5.0 ersetzt den DX-TRON-Graph-Visualisierer durch einen interaktiven HTML-Bericht zur Kompilierungsübersicht, der die Struktur des kompilierten Modells und die Aufteilung der CPU-/NPU-Arbeitslast anzeigt. Bei Bedarf kannst du den Bericht erstellen, indem du das beim Export erzeugte ONNX-Zwischenmodell mit der CLI dxcom auf dem x86-64-Export-Host erneut kompilierst:

dxcom -m yolo26n.onnx -c yolo26n_deepx_model/config.json -o yolo26n_deepx_report --export_html

Öffne yolo26n_deepx_report/yolo26n_summary.html in einem Browser, um den Bericht anzuzeigen.

Benchmarks#

Das Ultralytics-Team hat YOLO26-Modelle getestet 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)	acc (top1)	acc (top5)	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 der oben genannten Benchmarks erfolgte mit COCO128 für die Erkennung, COCO128-seg für die Segmentierung, ImageNet100 für die Klassifizierung, COCO8-pose für die Posenschätzung 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 Arbeitsablauf#

1. Trainiere dein Modell mit dem Ultralytics-Trainingsmodus
2. Ins DEEPX-Format exportieren mit model.export(format="deepx")
3. Überprüfe die Genauigkeit mit yolo val, um Quantisierungsverluste möglichst gering zu halten
4. Führe Vorhersagen aus mit yolo predict, um die Ergebnisse qualitativ zu überprüfen
5. Das exportierte Verzeichnis _deepx_model/ mit der Laufzeitumgebung dx_engine auf DEEPX-NPU-Hardware bereitstellen

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 geringem Stromverbrauch und ohne Abhängigkeit von einer Cloud.
• Industrielle Automatisierung: Qualitätskontrolle, Fehlererkennung und Prozessüberwachung direkt auf dem Gerät in Fabrikumgebungen.
• Robotik: Visionsgestützte Navigation, Hindernisvermeidung und Objekterkennung auf autonomen Robotern und Drohnen.
• Intelligente Landwirtschaft: Überwachung des Pflanzengesundheitszustands, Schädlingsbekämpfung und Ertragsschätzung mithilfe von maschinellem Sehen in der Landwirtschaft.
• Einzelhandelsanalysen: Analyse von Kundenströmen, Regalüberwachung und Bestandsverfolgung mit Edge-Inferenz in Echtzeit.

Zusammenfassung#

In dieser Anleitung hast du gelernt, Ultralytics-YOLO-Modelle ins DEEPX-Format zu exportieren und auf DEEPX-NPU-Hardware bereitzustellen. 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 übernimmt die Inferenz auf dem Gerät.

Ultralytics YOLO und DEEPX-NPUs führen gemeinsam Computer-Vision-Workloads auf eingebetteten Geräten und Edge-Geräten mit hohem Durchsatz und geringem Stromverbrauch für Echtzeitanwendungen aus.

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

Häufig gestellte Fragen#