Link to this sectionDEEPX-Export für Ultralytics YOLO-Modelle#

Die Bereitstellung von Computer-Vision-Modellen auf spezialisierter NPU-Hardware erfordert ein kompatibles und optimiertes Modellformat. 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 Hardware, die von DEEPX betrieben wird.

Link to this sectionWas ist DEEPX?#

DEEPX ist ein KI-Halbleiterunternehmen, das sich auf Neural Processing Units (NPUs) spezialisiert hat, die für energieeffiziente Deep Learning-Inferenz am Edge konzipiert sind. DEEPX NPUs wurden für anspruchsvolle eingebettete und industrielle KI-Anwendungen entwickelt und bieten einen hohen Durchsatz bei minimalem Stromverbrauch. Ihre Hardware eignet sich hervorragend für Bereitstellungsszenarien, in denen eine Cloud-Verbindung unzuverlässig oder unerwünscht ist, wie etwa bei Robotik, Smart Cameras und industriellen Automatisierungssystemen.

Link to this sectionDEEPX-Exportformat#

Der DEEPX-Export erzeugt ein kompiliertes .dxnn-Modell-Binärformat, das für die Ausführung auf DEEPX-NPU-Hardware optimiert ist. Die Kompilierungspipeline verwendet das dx_com-Toolkit, um eine INT8-Quantisierung und hardware-spezifische Optimierungen durchzuführen, wodurch ein in sich geschlossenes Modellverzeichnis erstellt wird, das für die Bereitstellung bereit ist.

Link to this sectionHauptmerkmale von DEEPX-Modellen#

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

• INT8-Quantisierung: Modelle werden während des Exports auf INT8-Präzision quantisiert, was die Modellgröße erheblich reduziert und den NPU-Durchsatz maximiert. Erfahre mehr über Modellquantisierung.
• NPU-optimiert: Das .dxnn-Format wird spezifisch für DEEPX-NPU-Hardware kompiliert und nutzt dedizierte Beschleunigungseinheiten für eine schnelle und effiziente Inferenz.
• Geringer Stromverbrauch: Durch das Auslagern der Inferenz auf die NPU verbrauchen DEEPX-Modelle weitaus weniger Strom 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.

Link to this sectionUnterstützte Aufgaben#

Alle Standard-Ultralytics-Aufgaben werden für den DEEPX-Export über die Modellfamilien YOLO26, YOLO11 und YOLOv8 hinweg unterstützt.

Link to this sectionExport nach DEEPX: Konvertiere dein YOLO-Modell#

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

Link to this sectionInstallation#

Um die erforderlichen Pakete zu installieren, führe aus:

# Install the required package for YOLO
pip install ultralytics

Das dx_com-Compiler-Paket wird beim ersten Export automatisch aus dem DEEPX-SDK-Repository installiert. Detaillierte Anweisungen und Best Practices zur Installation findest du in unserer Ultralytics-Installationsanleitung. Falls bei der Installation der erforderlichen Pakete für YOLO Schwierigkeiten auftreten, konsultiere unseren Leitfaden für häufige Probleme für Lösungen und Tipps.

Link to this sectionVerwendung#

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

from ultralytics import YOLO

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

# Export the model to DEEPX format (int8=True 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")

Link to this sectionExport-Argumente#

Weitere Details zum Exportprozess findest du auf der Ultralytics-Dokumentationsseite zum Exportieren.

Link to this sectionAusgabestruktur#

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 .dxnn-Datei ist das kompilierte Modell-Binärformat, das die dx_engine-Laufzeitumgebung direkt auf der NPU lädt. Die metadata.yaml enthält Klassennamen, Bildgröße und weitere Informationen, die von der Ultralytics-Inferenzpipeline verwendet werden.

Link to this sectionBereitstellung exportierter YOLO DEEPX-Modelle#

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

Link to this sectionInstallation der Laufzeitumgebung#

Die Inferenz erfordert den DEEPX-NPU-Treiber, die libdxrt-Laufzeitumgebung 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 Laufzeitumgebung korrekt installiert ist. Du solltest eine Ausgabe ähnlich der folgenden sehen:

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 Nutzung oben beschrieben durch – das exportierte _deepx_model wird direkt mit YOLO(...) geladen.

Link to this sectionVisualisierung mit dxtron#

dxtron ist der Graph-Visualisierer von DEEPX zur Untersuchung des kompilierten .dxnn-Modells.

Installiere dxtron auf x86-64 Linux, indem du das .deb-Paket vom DEEPX SDK herunterlädst und es ü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 dann dein exportiertes Modell:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Link to this sectionBenchmarks#

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

Modell	Format	Status	Größe (MB)	Metriken/mAP50-95(B)	Inferenzzeit (ms/im)
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)	Gen (top1)	Gen (top5)	Inferenzzeit (ms/im)
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 Detektion, coco128-seg für Segmentierung, coco8-pose für Pose-Schätzung, imagenet100 für Klassifizierung und dota128 für OBB-Modelle durchgeführt. Die Inferenzzeit beinhaltet keine Vor- oder 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"

Link to this sectionEmpfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Ultralytics Train-Modus
2. Exportiere es in das DEEPX-Format mit model.export(format="deepx")
3. Validiere die Genauigkeit mit yolo val, um einen minimalen Quantisierungsverlust sicherzustellen
4. Prognostiziere (Predict) mit yolo predict für eine qualitative Validierung
5. Stelle das exportierte _deepx_model/-Verzeichnis auf DEEPX NPU-Hardware mit der dx_engine-Runtime bereit

Link to this sectionAnwendungen in der Praxis#

YOLO-Modelle, die auf DEEPX NPU-Hardware bereitgestellt werden, eignen sich hervorragend für eine breite Palette von Edge AI-Anwendungen:

• Intelligente Überwachung: Objekterkennung in Echtzeit für Sicherheits- und Überwachungssysteme bei geringem Stromverbrauch und ohne Cloud-Abhängigkeit.
• Industrielle Automatisierung: Qualitätskontrolle direkt auf dem Gerät, Fehlererkennung und Prozessüberwachung in Fabrikumgebungen.
• Robotik: Kamerabasierte Navigation, Hindernisvermeidung und Objekterkennung auf autonomen Robotern und Drohnen.
• Intelligente Landwirtschaft: Überwachung der Pflanzengesundheit, Schädlingserkennung und Ertragsschätzung mittels Computer Vision in der Landwirtschaft.
• Einzelhandelsanalytik: Kundenstromanalyse, Regalüberwachung und Bestandsverfolgung mit Inferenz in Echtzeit an der Edge.

Link to this sectionZusammenfassung#

In dieser Anleitung hast du gelernt, wie du Ultralytics YOLO-Modelle in das DEEPX-Format exportierst und auf DEEPX NPU-Hardware bereitstellst. Die Export-Pipeline nutzt INT8-Kalibrierung und den dx_com-Compiler, um eine hardwareoptimierte .dxnn-Binärdatei zu erzeugen, während die dx_engine-Runtime 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 fortgeschrittener Computer Vision-Workloads auf Embedded- und Edge-Geräten – und liefert hohen Durchsatz bei geringem Stromverbrauch für Echtzeitanwendungen.

Weitere Details zur Nutzung findest du auf der offiziellen DEEPX-Website.

Wenn du mehr über andere Ultralytics YOLO-Integrationen erfahren möchtest, besuche unsere Integrations-Übersichtsseite. Dort findest du zahlreiche nützliche Ressourcen und Einblicke.

Link to this sectionFAQ#

Link to this sectionWie exportiere ich mein Ultralytics YOLO-Modell in das DEEPX-Format?#

Du kannst dein Modell mit der export()-Methode in Python oder über das CLI exportieren. Der Export aktiviert automatisch die INT8-Quantisierung und verwendet einen Kalibrierungsdatensatz, um Genauigkeitsverluste zu minimieren. Das dx_com-Compiler-Paket wird automatisch installiert, falls es noch nicht vorhanden ist.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="deepx")

Link to this sectionWarum erfordert der DEEPX-Export eine INT8-Quantisierung?#

DEEPX NPUs sind darauf ausgelegt, INT8-Berechnungen mit maximaler Effizienz auszuführen. Der dx_com-Compiler quantisiert das Modell während des Exports mithilfe einer EMA-basierten Kalibrierung mit echten Datensatzbildern, wodurch die NPU ihre volle Leistung entfalten kann. INT8 ist für DEEPX-Exporte immer zwingend erforderlich – wenn du int8=False übergibst, wird dies mit einer Warnung überschrieben.

Link to this sectionWelche Plattformen werden für den DEEPX-Export unterstützt?#

Der DEEPX-Modelexport (Kompilierung) erfordert einen x86-64 Linux-Host. Der Export-Schritt wird auf ARM64 (aarch64) und Windows-Maschinen nicht unterstützt. Die Inferenz mit dem exportierten .dxnn-Modell kann auf jeder Linux-Plattform (x86-64 und ARM64) ausgeführt werden, die von der dx_engine-Runtime unterstützt wird.

Link to this sectionWas ist die Ausgabe eines DEEPX-Exports?#

Der Export erstellt ein Verzeichnis (z. B. yolo26n_deepx_model/), das Folgendes enthält:

• yolo26n.dxnn — die kompilierte NPU-Binärdatei
• config.json — Kalibrierungs- und Vorverarbeitungseinstellungen
• metadata.yaml — Modell-Metadaten einschließlich Klassennamen und Bildgröße

Link to this sectionKann ich benutzerdefinierte Modelle auf DEEPX-Hardware bereitstellen?#

Ja. Jedes Modell, das mit dem Ultralytics Train-Modus trainiert und mit format="deepx" exportiert wurde, kann auf DEEPX NPU-Hardware bereitgestellt werden, sofern es unterstützte Layer-Operationen verwendet. Der Export unterstützt Detektions-, Segmentierungs-, Pose-Schätzungs-, OBB- (Oriented Bounding Box) und Klassifizierungsaufgaben.

Link to this sectionWie viele Kalibrierungsbilder sollte ich für den DEEPX-Export verwenden?#

Die DEEPX-Export-Pipeline verwendet jedes Bild im Kalibrierungsdatensatz mit der EMA-Kalibrierungsmethode. Ein paar hundert Bilder reichen normalerweise für eine gute Quantisierungsgenauigkeit aus. Zeige mit data auf einen kleineren Datensatz, falls die Kompilierungszeit bei großen Datensätzen ein Problem darstellt.

Link to this sectionWie installiere ich die DEEPX-Runtime für die Inferenz?#

Die DEEPX-Runtime ist nicht in ultralytics enthalten und muss vor der Inferenz separat installiert werden. Auf x86-64 Linux-Maschinen und ARM64 Linux-Maschinen (z. B. Raspberry Pi 5) installiere den NPU-Treiber (dxrt-driver-dkms) und die Runtime (libdxrt) aus den DEEPX-AI GitHub-Releases, dann installiere das gebündelte dx_engine Python-Wheel. Siehe den Abschnitt Runtime-Installation oben für Schritt-für-Schritt-Befehle.