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

Die Bereitstellung von Computer-Vision-Modellen auf spezieller 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. Dieser Leitfaden führt dich durch die Konvertierung deiner YOLO-Modelle in das DEEPX-Format und deren Bereitstellung auf DEEPX-basierter Hardware.

Link to this sectionWas ist DEEPX?#

DEEPX ist ein Unternehmen für KI-Halbleiter, das sich auf Neural Processing Units (NPUs) spezialisiert hat, die für energieeffiziente Deep Learning-Inferenz am Edge konzipiert sind. DEEPX-NPUs sind für anspruchsvolle eingebettete und industrielle KI-Anwendungen entwickelt und liefern einen hohen Durchsatz bei minimalem Stromverbrauch. Ihre Hardware eignet sich hervorragend für Einsatzszenarien, in denen Cloud-Konnektivität unzuverlässig oder unerwünscht ist, wie etwa bei Robotik, intelligenten Kameras 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 hardwarespezifische Optimierungen durchzuführen und ein in sich geschlossenes Modellverzeichnis zu erstellen, das für die Bereitstellung bereit ist.

Link to this sectionHauptmerkmale der DEEPX-Modelle#

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

• 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 ist speziell für DEEPX-NPU-Hardware kompiliert und nutzt dedizierte Beschleunigungseinheiten für eine schnelle und effiziente Inferenz.
• Geringer Stromverbrauch: Durch die Auslagerung der Inferenz auf die NPU verbrauchen DEEPX-Modelle deutlich weniger Strom als eine äquivalente CPU- oder GPU-Inferenz.
• Kalibrierungsbasierte Genauigkeit: Der Export verwendet eine EMA-basierte Kalibrierung mit echten Datensatzbildern, um Genauigkeitsverluste während der Quantisierung zu minimieren.
• In sich geschlossene Ausgabe: Das exportierte Modellverzeichnis bündelt das kompilierte Binärformat, 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: Dein YOLO-Modell konvertieren#

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 Folgendes 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 bewährte Verfahren zum Installationsprozess findest du in unserem Ultralytics-Installationsleitfaden. Solltest du während der Installation der erforderlichen Pakete für YOLO auf Schwierigkeiten stoßen, konsultiere unseren Leitfaden zu häufigen Problemen für Lösungen und Tipps.

Link to this sectionVerwendung#

Das DEEPX-Format unterstützt die Modi Export, Predict und Validate. Inferenz und Validierung laufen auf der DEEPX-NPU-Hardware. Exportiere dein Modell und lade dann das exportierte Modell, um die 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 (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#

Für weitere Details zum Exportprozess besuche die Ultralytics-Dokumentationsseite zum Thema Exportieren.

Link to this sectionAusgabestruktur#

Nach einem erfolgreichen Export wird ein Modellverzeichnis mit dem folgenden Layout 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-Laufzeit direkt auf der NPU lädt. Die metadata.yaml enthält Klassennamen, Bildgröße und andere Informationen, die von der Ultralytics-Inferenz-Pipeline verwendet werden.

Link to this sectionExportierte YOLO DEEPX-Modelle bereitstellen#

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

Die Inferenz erfordert den DEEPX-NPU-Treiber, die libdxrt-Laufzeit 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. 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 Laufzeit installiert ist, führe die Inferenz und Validierung auf deinem DEEPX-Gerät genau wie im Abschnitt Verwendung oben gezeigt aus – das exportierte _deepx_model wird direkt mit YOLO(...) geladen.

Link to this sectionVisualisierung mit dxtron#

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

Installiere dxtron unter x86-64 Linux, indem du das .deb-Paket aus dem DEEPX SDK herunterlädst und es via 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 Geschwindigkeit sowie 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)	metrics/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)	acc (top1)	acc (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 oben genannten 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- oder 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"

Link to this sectionEmpfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Ultralytics Train Mode
2. Exportiere in das DEEPX-Format mit model.export(format="deepx")
3. Validiere die Genauigkeit mit yolo val, um einen minimalen Quantisierungsverlust zu verifizieren
4. Sage voraus (Predict) mit yolo predict für eine qualitative Validierung
5. Bereitstellen (Deploy) des exportierten _deepx_model/-Verzeichnisses auf DEEPX NPU-Hardware unter Verwendung der dx_engine-Laufzeitumgebung

Link to this sectionPraxisanwendungen#

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

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

Link to this sectionZusammenfassung#

In diesem Leitfaden hast du gelernt, wie man Ultralytics YOLO-Modelle in das DEEPX-Format exportiert und auf DEEPX NPU-Hardware bereitstellt. Die Export-Pipeline verwendet INT8-Kalibrierung und den dx_com-Compiler, um ein hardwareoptimiertes .dxnn-Binärformat zu erzeugen, während die dx_engine-Laufzeitumgebung 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 fortschrittlicher Computer Vision-Workloads auf eingebetteten Geräten und Edge-Devices — und liefert hohen Durchsatz bei geringem Stromverbrauch für Echtzeitanwendungen.

Für weitere Details zur Nutzung besuche die offizielle DEEPX-Website.

Wenn du mehr über andere Ultralytics YOLO-Integrationen erfahren möchtest, besuche unsere Integrations-Leitfadenseite. Dort findest du viele 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 — falls 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-Rechnern 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-Laufzeitumgebung unterstützt wird.

Link to this sectionWas ist das Ergebnis eines DEEPX-Exports?#

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

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

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

Ja. Jedes Modell, das mit dem Ultralytics Train Mode 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 Aufgaben wie Erkennung, Segmentierung, Pose-Schätzung, orientierte Bounding Box (OBB) und Klassifizierung.

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

Die DEEPX-Export-Pipeline verwendet jedes Bild im Kalibrierungsdatensatz (nach fraction-Filterung) mit der EMA-Kalibrierungsmethode. Einige hundert Bilder reichen in der Regel für eine gute Quantisierungsgenauigkeit aus. Verweise data auf einen kleineren Datensatz (oder setze fraction unter 1.0), falls die Kompilierungszeit bei großen Datensätzen zum Problem wird.

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

Die DEEPX-Laufzeitumgebung ist nicht im ultralytics-Paket enthalten und muss separat installiert werden, bevor die Inferenz ausgeführt werden kann. Auf x86-64 Linux-Rechnern und ARM64 Linux-Rechnern (z. B. Raspberry Pi 5) installierst du den NPU-Treiber (dxrt-driver-dkms) und die Laufzeitumgebung (libdxrt) von den DEEPX-AI GitHub-Releases und installierst dann das mitgelieferte dx_engine Python-Wheel. Siehe den Abschnitt Runtime Installation oben für Schritt-für-Schritt-Befehle.