DeepX-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.

Was 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 hohen Durchsatz bei minimalem Stromverbrauch. Ihre Hardware eignet sich hervorragend für Einsatzszenarien, in denen die Cloud-Konnektivität unzuverlässig oder unerwünscht ist, wie etwa bei Robotik, Smart Cameras und industriellen Automatisierungssystemen.

DeepX-Exportformat

Der DeepX-Export erstellt eine kompilierte .dxnn-Modell-Binärdatei, die für die Ausführung auf DeepX-NPU-Hardware optimiert ist. Die Kompilierungspipeline verwendet das dx_com-Toolkit, um eine INT8-Quantisierung und hardwarespezifische Optimierung durchzuführen und ein in sich geschlossenes Modellverzeichnis für die Bereitstellung zu generieren.

Hauptmerkmale von DeepX-Modellen

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

• INT8-Quantisierung: Modelle werden während des Exports auf INT8-Präzision quantisiert, wodurch die Modellgröße erheblich reduziert und der NPU-Durchsatz maximiert wird. Erfahre mehr über model quantization.
• NPU-Optimiert: Das .dxnn-Format wurde speziell für DeepX-NPU-Hardware kompiliert und nutzt dedizierte Beschleunigungseinheiten für eine schnelle, effiziente Inferenz.
• Geringer Stromverbrauch: Durch das Auslagern der Inferenz auf die NPU verbrauchen DeepX-Modelle weitaus weniger Strom als eine vergleichbare CPU- oder GPU-Inferenz.
• Kalibrierungsbasierte Genauigkeit: Der Export nutzt eine EMA-basierte Kalibrierung mit echten Datensatzbildern, um den Genauigkeitsverlust während der Quantisierung zu minimieren.
• In sich geschlossene Ausgabe: Das exportierte Modellverzeichnis bündelt die kompilierte Binärdatei, die Kalibrierungskonfiguration und Metadaten für eine einfache Bereitstellung.

Unterstützte Aufgaben

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

Export nach DeepX: Konvertierung deines YOLO-Modells

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

Installation

Führe zur Installation der erforderlichen Pakete 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. Für detaillierte Anweisungen und Best Practices bezüglich des Installationsprozesses, schau dir unseren Ultralytics Installation guide an. Falls du bei der Installation der erforderlichen Pakete für YOLO Schwierigkeiten hast, konsultiere unseren Common Issues guide für Lösungen und Tipps.

Verwendung

from ultralytics import YOLO

# Load the 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/'

Export-Argumente

Für weitere Details zum Exportprozess besuche die Ultralytics documentation page on exporting.

Ausgabestruktur

Nach einem erfolgreichen Export wird ein Modellverzeichnis mit folgendem 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.)

Das .dxnn-Datei ist die kompilierte Modell-Binärdatei, die die dx_engine-Runtime 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.

Bereitstellung exportierter YOLO DeepX-Modelle

Sobald du dein Ultralytics YOLO-Modell erfolgreich in das DeepX-Format exportiert hast, besteht der nächste Schritt in der Bereitstellung dieser Modelle auf DeepX-NPU-Hardware.

Runtime-Installation

Die Inferenz erfordert den DeepX-NPU-Treiber, die libdxrt-Runtime und das dx_engine-Python-Paket.

# 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.0/dxrt-driver-dkms_2.4.0-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.4.0-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 Runtime 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

Verwendung

from ultralytics import YOLO

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

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

# Process results
for r in results:
    print(f"Detected {len(r.boxes)} objects")
    r.show()

Visualisierung 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 aus dem DeepX SDK herunterlädst und es über dpkg:

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

installierst. Öffne dann 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.

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

Empfohlener Arbeitsablauf

1. Train dein Modell mit Ultralytics Train Mode
2. Export in das DeepX-Format mit model.export(format="deepx")
3. Validate die Genauigkeit mit yolo val zur Überprüfung des minimalen Quantisierungsverlusts
4. Predict mit yolo predict für qualitative Validierung
5. Deploy das exportierte _deepx_model/ Verzeichnis auf DeepX NPU-Hardware mit der dx_engine Runtime

Anwendungen aus der Praxis

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

• Smart Surveillance: Echtzeit-Objekterkennung für Sicherheits- und Überwachungssysteme mit geringem Stromverbrauch und ohne Cloud-Abhängigkeit.
• Industrial Automation: On-Device Qualitätskontrolle, Fehlererkennung und Prozessüberwachung in Fabrikumgebungen.
• Robotics: Bildbasierte Navigation, Hinderniserkennung und Objekterkennung auf autonomen Robotern und Drohnen.
• Smart Agriculture: Überwachung der Pflanzengesundheit, Schädlingsbekämpfung und Ertragsschätzung mittels computer vision in agriculture.
• Retail Analytics: Kundenstromanalyse, Regalüberwachung und Bestandsverfolgung mit Echtzeit-Edge-Inferenz.

Zusammenfassung

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 nutzt INT8-Kalibrierung und den dx_com Compiler, um ein hardwareoptimiertes .dxnn Binary zu erzeugen, während die dx_engine Runtime die Inferenz auf dem Gerät abwickelt.

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 und Edge-Geräten – und liefert hohen Durchsatz bei geringem Stromverbrauch für Echtzeitanwendungen.

Für weitere Details zur Verwendung besuche die DeepX offizielle Website.

Falls du mehr über andere Ultralytics YOLO-Integrationen erfahren möchtest, besuche unsere Integrations-Leitfadenseite. Dort findest du viele nützliche Ressourcen und Einblicke.

FAQ

Wie exportiere ich mein Ultralytics YOLO-Modell in das DeepX-Format?

Du kannst dein Modell mit der export() Methode in Python oder über die CLI exportieren. Der Export aktiviert automatisch die INT8-Quantisierung und verwendet einen Kalibrierungsdatensatz, um den Genauigkeitsverlust 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")

Warum 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 von EMA-basierter 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.

Welche 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 Runtime unterstützt wird.

Was ist das Ergebnis eines DeepX-Exports?

Der Export erstellt ein Verzeichnis (z. B. yolo26n_deepx_model/) mit folgenden Inhalten:

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

Kann 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 Ebenenoperationen verwendet. Der Export unterstützt Aufgaben für Erkennung (Detection), Segmentierung, Pose Estimation, orientierte Bounding Boxes (OBB) und Klassifizierung.

Wie viele Kalibrierungsbilder sollte ich für den DeepX-Export verwenden?

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

Wie installiere ich die DeepX-Runtime für die Inferenz?

Die DeepX-Runtime ist nicht in ultralytics enthalten und muss separat installiert werden, bevor die Inferenz gestartet wird. Installiere auf x86-64 Linux-Rechnern und ARM64 Debian Trixie-Rechnern (Raspberry Pi 5) den NPU-Treiber (dxrt-driver-dkms) und die Runtime (libdxrt) aus den DEEPX-AI GitHub Releases und installiere anschließend das gebündelte dx_engine Python Wheel. Siehe den Abschnitt Runtime-Installation oben für Schritt-für-Schritt-Befehle.