Qualcomm QNN-Export für Ultralytics YOLO-Modelle#

Das Bereitstellen von Computer-Vision-Modellen auf Qualcomm Snapdragon-Geräten erfordert ein Modellformat, das auf die Laufzeitumgebung der Qualcomm AI Engine Direct (QNN) abgestimmt ist. Das Exportieren von Ultralytics YOLO-Modellen in das QNN-Format ermöglicht dir eine beschleunigte On-Device-Inferenz über Snapdragon-CPU-, Adreno-GPU- und Hexagon-NPU-Hardware hinweg, die in Milliarden von Mobiltelefonen, Laptops, Automobilsystemen und IoT-Geräten zu finden ist. Diese Anleitung zeigt dir, wie du YOLO nach Qualcomm QNN exportierst und für eine schnelle, stromsparende Inferenz auf Snapdragon-Hardware bereitstellst.

Was ist Qualcomm QNN?#

Qualcomm AI Engine Direct – im Allgemeinen als QNN bezeichnet und als Teil des Qualcomm AI Runtime (QAIRT) SDK vertrieben – ist Qualcomms Low-Level-Inferenz-Stack für Snapdragon-Prozessoren. Es bietet eine einheitliche API mitbackendspezifischen Bibliotheken, die auf die Snapdragon-CPU, die Adreno-GPU und den Hexagon Tensor Processor (HTP) abzielen, die dedizierte neuronales Netz-Verarbeitungseinheit (NPU) in modernen Snapdragon SoCs. QNN gibt Entwicklern Full-Stack-Zugriff auf diese Snapdragon-KI-Beschleuniger und ist der moderne Nachfolger des älteren Snapdragon Neural Processing Engine (SNPE) SDK. Es treibt On-Device-KI auf den mobilen Plattformen Snapdragon 8 Gen 2, 8 Gen 3 und 8 Elite, Snapdragon X-Laptops sowie Automobil- und XR-Produkten an.

Warum in Qualcomm QNN exportieren?#

Snapdragon ist die am weitesten verbreitete mobile Computerplattform der Welt. Der Export von Ultralytics YOLO in das Qualcomm QNN-Format erschließt die dedizierte KI-Hardware auf diesen Geräten:

• Hexagon-NPU-Beschleunigung: Das Ausführen von YOLO auf dem Hexagon Tensor Processor liefert einen drastisch höheren Durchsatz und einen geringeren Stromverbrauch als die CPU-Inferenz – ideal für Echtzeit-Inferenz und Always-On-Computer-Vision auf Snapdragon.
• On-Device und offline: QNN-Inferenz läuft vollständig auf dem Snapdragon-Gerät, sodass keine Cloud-Roundtrips erforderlich sind, die Latenz niedrig bleibt und Daten das Gerät nie verlassen.
• Quantisierte Effizienz: Der QNN-Export quantisiert YOLO auf INT8-Gewichte mit 16-Bit-Aktivierungen, der von der Hexagon-NPU bevorzugten Balance aus Genauigkeit und Leistung, wodurch die Modellgröße verringert und die Bilder pro Sekunde auf batteriebetriebener Hardware maximiert werden.
• Ein Format, viele Geräte: Ein einzelner Qualcomm QNN-Export zielt auf Snapdragon CPU, Adreno GPU und Hexagon NPU über die Familien Snapdragon 8 Gen 2, 8 Gen 3, 8 Elite und darüber hinaus ab.
• Produktionsbereiter Qualcomm KI-Stack: QNN (Qualcomm AI Engine Direct / QAIRT) ist Qualcomms aktuelle, aktiv gepflegte On-Device-KI-Runtime und der empfohlene Ersatz für SNPE.

QNN-Exportformat#

Ultralytics kompiliert YOLO-Modelle lokal nach QNN unter Verwendung des ONNX Runtime QNN Execution Provider (dem über pip installierbaren onnxruntime-qnn-Paket, das die QAIRT-Bibliotheken bündelt). Der Exporter konvertiert dein Modell in ONNX, quantisiert es mit Kalibrierungsdaten auf 16-Bit-Aktivierungen und INT8-Gewichte (die empfohlene Balance für die Hexagon-NPU), initialisiert dann eine ONNX Runtime-Sitzung mit aktiviertem Context-Binary-Caching – dies kompiliert den quantisierten Graph in ein QNN-Kontext-Binärfile, das in <model>_qnn.onnx eingebettet ist. Es sind kein Qualcomm-Konto, kein Cloud-Upload und kein separater SDK-Download erforderlich.

Im Gegensatz zum Cloud-basierten Qualcomm AI Hub, der Modelle auf von Qualcomm gehosteten Snapdragon-Geräten kompiliert und profiliert und ein Qualcomm-Konto erfordert, läuft der Ultralytics QNN-Export vollständig auf deinem eigenen Rechner mit einem einzigen export(format="qnn", imgsz=640)-Aufruf (imgsz=224 für die Klassifizierung). Du erhältst dasselbe QNN/QAIRT-Laufzeitziel – Snapdragon-CPU, Adreno-GPU und Hexagon-NPU – ohne Registrierung, Upload-Limits oder Warteschlangenzeiten, und es fügt sich nahtlos in den standardmäßigen YOLO-Export-Workflow ein.

Die exportierte *_qnn.onnx-Datei ist in sich geschlossen: Sie bettet das QNN-Kontext-Binärfile und ONNX-Metadaten wie Klassennamen, Bildgröße und Aufgabe ein.

Hauptmerkmale von QNN-Modellen#

• Quantisierung: Das Modell wird mit dem ONNX Runtime QNN QDQ-Flow und einem Kalibrierungsdatensatz auf 16-Bit-Aktivierungen und INT8-Gewichte quantisiert, der empfohlenen Genauigkeits-/Leistungsbalance der Hexagon-NPU. Erfahre mehr über Modellquantisierung.
• Vollständig lokale Kompilierung: Die context binary wird vollständig auf deinem Host-Rechner generiert – kein Qualcomm-Konto, API-Token oder Cloud-Upload erforderlich.
• Vollständige Snapdragon-Beschleunigung: Führe Inferenz auf der Hexagon NPU (HTP), Adreno GPU oder CPU über eine einzige, vereinheitlichte Runtime aus.
• Breite Gerätereichweite: Ziele auf die breite Palette von Snapdragon-Plattformen ab, die in Telefonen, PCs (Windows on Snapdragon), Automobilen, XR und eingebetteten Produkten eingesetzt werden.
• Vorkompilierte Context Binary: Das Ausliefern einer context binary minimiert die Graphenkompilierung auf dem Gerät und reduziert die Modellladelatenz auf dem Zielsystem.
• In sich geschlossene Ausgabe: Die exportierte ONNX-Datei enthält die vorkompilierte QNN context binary und Metadaten für eine unkomplizierte Bereitstellung.

Gemessene Leistung#

Android-Telefon#

Hardware: Xiaomi 17 mit 12 GB LPDDR5X-Speicher und Android 16 / API 36. Sein 3-nm-Snapdragon 8 Elite Gen 5 (SM8850) verfügt über eine 8-Kern Qualcomm Oryon-CPU (2 Prime-Kerne mit bis zu 4,6 GHz und 6 Leistungskerne mit bis zu 3,62 GHz), Adreno-GPU und Hexagon-NPU (HTP v81).

• Geschwindigkeitswerte sind Einzelbild-Burst-Latenzen – der Mittelwert von 15 Durchläufen nach 3 Aufwärmläufen auf bus.jpg, gemessen mit dem Flutter-Plugin 0.6.10-On-Device-Benchmark -Testgerüst und den standardisierten v0.6.6-Assets. Die Reihenfolge der Backends wurde zwischen den Aufgaben in einem sequenziellen Durchlauf rotiert. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete, jede GPU-Zeile den vollständigen Graphen an LiteRT OpenCL (LITERT_CL) delegierte und jede NPU-Zeile das QNN Hexagon HTP-Backend verwendete.
• Der detaillierte Benchmark-Datensatz befindet sich im Flutter-Leistungsdokument.
• Vergleiche andere Android-Geräte in der LiteRT-Integration und Apple-Geräte in der CoreML-Integration.

Laptop mit Windows on Snapdragon#

Dieser historische Durchlauf verwendete vorstandardisierte v73-QNN-Binärdateien; semantische und OBB-Modelle verwendeten 1024-px-Eingaben. Er wurde auf einem Lenovo- Laptop mit 32 GB Speicher und Windows 11 ausgeführt. Dessen Snapdragon X Elite (X1E78100) verfügt über eine 12-Kern Qualcomm Oryon-CPU, Adreno-GPU und Hexagon-NPU (HTP v73); das genaue Lenovo-Modell wurde nicht aufgezeichnet. Dieser Windows-on-Snapdragon-Vergleich lässt die native PyTorch-FP32-CPU-Baseline, von der die meisten Desktop- Entwickler ausgehen, gegen den ONNX Runtime QNN Hexagon HTP-Pfad antreten. Jede Zelle zeigt die volle model.predict()-Wanduhrzeit mit den darunter angegebenen Zeiten für Vorverarbeitung / Inferenz / Nachverarbeitung; das Total kann Framework-Overhead außerhalb dieser drei Phasen umfassen. CPU-Zahlen sind PyTorch FP32 (torch==2.10.0+cpu) und NPU-Zahlen sind ONNX Runtime QNN (onnxruntime-qnn==2.2.0, INT8-Gewichte / 16-Bit-Aktivierungen).

• Geschwindigkeitswerte sind Einzelbild-Burst-Latenzen – der Mittelwert von 100 Durchläufen nach 10 Aufwärmläufen auf bus.jpg, gemessen mit time.perf_counter() um den vollständigen model.predict()-Aufruf auf einem thermisch ruhenden Gerät (ultralytics==8.4.67, Python 3.12.10).
• Die Hexagon NPU läuft bei den 640-1024 px-Aufgaben etwa 2-4x schneller als die PyTorch CPU-Baseline (Detektion ~3.4x), was sich bei dem 224 px-Klassifizierer auf ~1.3x verengt, wo der feste Vorverarbeitungs-Overhead die winzige Arbeitslast dominiert.

Unterstützte Aufgaben#

Der Qualcomm QNN-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Familie, die diese Heads enthält.

Export zu QNN: Konvertierung deines YOLO-Modells#

Exportiere ein Ultralytics YOLO-Modell in das QNN-Format zur Bereitstellung auf Qualcomm-Hardware. Das Kontext-Binärfile ist für eine Ziel-Hexagon-Tensor-Processor-Architektur (HTP) oder ein unterstütztes SoC finalisiert, das du mit dem Argument name auswählst – dasselbe Argument, das verwendet wird, um einen Chip beim RKNN-Export anzusprechen.

Unterstützte HTP-Ziele#

Übergebe die Zielarchitektur oder das SoC über name (z. B. name="73" oder name="iq-8275"). Die Unterstützung wird durch das HTP-Ziel bestimmt, sodass die Snapdragon-Zeilen unten repräsentative Plattformen und keine vollständige Liste aller SoCs darstellen. Dragonwing-Geräte werden explizit aufgeführt.

Dragonwing IQ-615 kann den Ultralytics QNN-Kontext-Binärexport nicht verwenden, da ONNX Runtime seinen v66 DSP nicht als Offline-HTP-Ziel bereitstellt. Ein standardmäßiger ONNX-Export kann dennoch separat mit einem CPU- oder GPU-Ausführungsprovider integriert werden, der vom Board-BSP unterstützt wird.

from ultralytics import YOLO

model = YOLO("best.pt")
model.export(format="qnn", name="iq-8275", imgsz=640)

Installation#

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

# Install the required package for YOLO
pip install ultralytics

Das Paket onnxruntime-qnn (das den ONNX Runtime QNN Execution Provider bereitstellt und die QAIRT-Bibliotheken bündelt) wird beim ersten Export automatisch installiert. Detaillierte Anweisungen und Best Practices bezüglich des Installationsprozesses findest du in unserem Ultralytics-Installationshandbuch. Solltest du beim Installieren der erforderlichen Pakete für YOLO auf Schwierigkeiten stoßen, konsultiere unseren Leitfaden für häufige Probleme für Lösungen und Tipps.

Verwendung#

Das QNN-Format unterstützt die Modi Export, Predict und Validate. Inferenz und Validierung laufen auf Qualcomm Snapdragon-Hardware über den QNN Execution Provider von ONNX Runtime (dasselbe onnxruntime-qnn-Paket, das für den Export verwendet wird). Exportiere dein Modell und lade das exportierte Modell dann auf einem Snapdragon-Gerät, um Inferenz auszuführen oder dessen Genauigkeit zu validieren.

from ultralytics import YOLO

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

# Export to Qualcomm QNN format (INT8, enforced automatically) for the default v73 HTP target
model.export(format="qnn", name="73", imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

# Load the exported QNN model (on a Snapdragon device with onnxruntime-qnn)
model = YOLO("yolo26n_qnn.onnx")

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

from ultralytics import YOLO

# Load the exported QNN model (on a Snapdragon device with onnxruntime-qnn)
model = YOLO("yolo26n_qnn.onnx")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Export-Argumente#

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

Ausgabestruktur#

Nach einem erfolgreichen Export wird eine in sich geschlossene ONNX-Datei erstellt:

Die Datei yolo26n_qnn.onnx bettet das QNN-Kontext-Binärfile ein und wird von ONNX Runtime mit dem QNN Execution Provider auf dem Snapdragon-Gerät geladen. Sie enthält außerdem Modellmetadaten wie Klassennamen, Bildgröße und Aufgabe in ONNX metadata_props.

Bereitstellung exportierter YOLO QNN-Modelle#

QNN-Modelle laufen auf unterstützter Qualcomm-Hardware, was die Modellbereitstellung auf dem Gerät unkompliziert macht. Führe auf einem kompatiblen Gerät mit installierter onnxruntime-qnn das exportierte Modell direkt mit der Ultralytics-API (yolo predict/yolo val, siehe Verwendung oben) aus – Ultralytics lädt das HTP-Kontext-Binärfile über den ONNX Runtime QNN Execution Provider.

Für benutzerdefinierte Pipelines kannst du das Kontext-Binärfile ONNX auch direkt mit ONNX Runtime laden. onnxruntime-qnn ist ein Plugin Execution Provider, registriere ihn daher zur Laufzeit:

import onnxruntime as ort
import onnxruntime_qnn as qnn_ep

# On the Snapdragon device, register the QNN plugin EP and select its device(s)
ort.register_execution_provider_library("QNNExecutionProvider", qnn_ep.get_library_path())
devices = [d for d in ort.get_ep_devices() if d.ep_name == "QNNExecutionProvider"]

options = ort.SessionOptions()
options.add_provider_for_devices(devices, {"backend_path": qnn_ep.get_qnn_htp_path()})
session = ort.InferenceSession("yolo26n_qnn.onnx", sess_options=options)
input_info = session.get_inputs()[0]
outputs = session.run(None, {input_info.name: input_tensor})  # input_tensor: float32 NHWC

Da die QNN context binary vorkompiliert ist, lädt die Sitzung schnell, ohne den Graphen auf dem Gerät neu kompilieren zu müssen.

Linux- und Yocto-BSP-Anforderungen#

Das Zielboard muss eine zueinander kompatible Qualcomm-Laufzeit und ein BSP bereitstellen. Für die HTP-Inferenz umfasst dies den ONNX Runtime QNN Execution Provider, libQnnSystem.so, libQnnHtp.so, die v75-HTP-Stub- und -Skeleton-Bibliotheken für IQ-8275, FastRPC-Userspace-Unterstützung wie libcdsprpc.so, die DSP-Firmware und die entsprechenden FastRPC-/Kernel-Treiber. Die Skeleton-Bibliothek muss über den DSP-Bibliothekspfad des BSP auffindbar sein.

Diese zielseitigen Komponenten stammen aus dem QAIRT-/QNN-fähigen BSP des Board-Herstellers; sie sind nicht in das exportierte Modell eingebettet. Die GPU-Ausführung erfordert stattdessen libQnnGpu.so und den passenden Adreno-Userspace-Treiber-Stack. Die Ultralytics format=qnn-Ausgabe ist ein HTP-spezifisches Kontext-Binärfile, daher sollte die GPU- oder CPU-Bereitstellung von einem Standard-ONNX-Export anstelle der vorkompilierten *_qnn.onnx-Datei aus gestartet werden.

Empfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Ultralytics Train-Modus
2. Exportiere in das QNN-Format unter Verwendung von model.export(format="qnn", name="iq-8275", imgsz=640) auf einer unterstützten Plattform (verwende imgsz=224 für die Klassifizierung)
3. Stelle die exportierte *_qnn.onnx-Datei auf deinem Qualcomm-Gerät bereit
4. Führe die Inferenz mit ONNX Runtime und dem QNN Execution Provider unter Verwendung des HTP-Backends aus

Anwendungen in der Praxis#

YOLO-Modelle, die auf Qualcomm Snapdragon-Hardware laufen, eignen sich gut für eine Vielzahl von Edge-KI-Anwendungen:

• Smartphones: Echtzeit-Objekterkennung und Szenenerkennung in Kamera- und Foto-Apps mit NPU-Beschleunigung.
• Windows on Snapdragon: On-Device Computer Vision in Copilot+ PCs, ohne auf die Cloud auslagern zu müssen.
• Automobil: Fahrermonitoring, Insassenerkennung und ADAS-Funktionen auf Snapdragon Digital Chassis-Plattformen.
• XR und Wearables: Stromsparende Wahrnehmung mit geringer Latenz für AR/VR-Headsets und intelligente Brillen.
• IoT und Robotik: Effiziente Vision-Inferenz auf Snapdragon-betriebenen Kameras, Drohnen und eingebetteten Systemen.

Zusammenfassung#

In dieser Anleitung hast du gelernt, wie du Ultralytics YOLO-Modelle lokal mit dem ONNX Runtime QNN Execution Provider in das Qualcomm QNN-Format exportierst. Die Export-Pipeline konvertiert dein Modell in ONNX und kompiliert es dann auf deinem Host-Rechner in ein QNN-Kontext-Binärfile – ganz ohne Qualcomm-Konto oder Cloud – und erzeugt so eine *_qnn.onnx-Datei, die für Snapdragon-CPU-, Adreno-GPU- und Hexagon-NPU-Hardware über die QNN/QAIRT-Laufzeit optimiert ist.

Die Kombination aus Ultralytics YOLO und Qualcomms On-Device-KI-Stack bietet eine effektive Lösung zum Ausführen fortgeschrittener Computer-Vision-Workloads im gesamten breiten Snapdragon-Ökosystem.

Für andere On-Device- und mobile Bereitstellungsziele siehe die verwandten Export-Anleitungen für ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 und TensorRT. Um Formate vor der Auslieferung zu vergleichen, verwende den Benchmark-Modus. Die vollständige Liste der Formate und Optionen findest du in der Dokumentation zum Export-Modus und auf der Seite des Integrationshandbuchs.

FAQ#