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

Für die Bereitstellung von Computer-Vision-Modellen auf Qualcomm-Snapdragon-Geräten ist ein auf die Qualcomm AI Engine Direct (QNN)-Laufzeitumgebung abgestimmtes Modellformat erforderlich. Durch den Export von Ultralytics YOLO-Modellen in das QNN-Format kannst du beschleunigte Inferenz direkt auf dem Gerät über die Snapdragon-CPU, die Adreno-GPU und die Hexagon-NPU-Hardware ausführen, die in Milliarden von Mobiltelefonen, Laptops, Fahrzeugsystemen und IoT-Geräten zu finden ist. Dieser Leitfaden zeigt dir, wie du YOLO in das Qualcomm-QNN-Format exportierst und für schnelle, energieeffiziente Inferenz auf Snapdragon-Hardware bereitstellst.

Was ist Qualcomm QNN?#

Qualcomm AI Engine Direct – allgemein als QNN bezeichnet und als Teil des Qualcomm AI Runtime (QAIRT) SDK bereitgestellt – ist Qualcomms Inferenz-Stack auf niedriger Ebene für Snapdragon-Prozessoren. Er stellt eine einheitliche API mit backend-spezifischen Bibliotheken bereit, die auf die Snapdragon-CPU, die Adreno-GPU und den Hexagon Tensor Processor (HTP) abzielen, die dedizierte Neuronales Netzwerk-Verarbeitungseinheit (NPU) in modernen Snapdragon-SoCs. QNN ermöglicht Entwicklern den Zugriff auf den gesamten Stack dieser Snapdragon-KI-Beschleuniger und ist der moderne Nachfolger des älteren Snapdragon Neural Processing Engine (SNPE) SDK. Damit wird KI direkt auf dem Gerät auf den mobilen Plattformen Snapdragon 8 Gen 2, 8 Gen 3 und 8 Elite, auf Snapdragon-X-Laptops sowie in Fahrzeug- und XR-Produkten ausgeführt.

Warum in Qualcomm QNN exportieren?#

Snapdragon ist die weltweit am weitesten verbreitete mobile Computerplattform. Der Export von Ultralytics YOLO in das Qualcomm-QNN-Format erschließt die dedizierte KI-Hardware dieser Geräte:

• Beschleunigung durch die Hexagon-NPU: Die Ausführung von YOLO auf dem Hexagon Tensor Processor liefert einen deutlich höheren Durchsatz und einen geringeren Energieverbrauch als die Inferenz auf der CPU – ideal für Echtzeitinferenz und dauerhaft aktive Computer Vision auf Snapdragon.
• Direkt auf dem Gerät und offline: QNN-Inferenz läuft vollständig auf dem Snapdragon-Gerät. Dadurch gibt es keine Roundtrips zur Cloud, die Latenz bleibt niedrig und Daten verlassen das Gerät nie.
• Effizienz durch Quantisierung: Der QNN-Export quantisiert YOLO auf INT8-Gewichte mit 16-Bit-Aktivierungen – das von der Hexagon-NPU bevorzugte Gleichgewicht zwischen Genauigkeit und Leistung. Dadurch wird die Modellgröße verringert und die Bildrate pro Sekunde auf akkubetriebener Hardware maximiert.
• Ein Format für viele Geräte: Ein einzelner Qualcomm-QNN-Export zielt auf Snapdragon-CPU, Adreno-GPU und Hexagon-NPU in den Familien Snapdragon 8 Gen 2, 8 Gen 3 und 8 Elite sowie darüber hinaus.
• Produktionsreifer Qualcomm-KI-Stack: QNN (Qualcomm AI Engine Direct / QAIRT) ist Qualcomms aktuelle, aktiv gepflegte KI-Laufzeitumgebung für die Ausführung auf dem Gerät und der empfohlene Ersatz für SNPE.

QNN-Exportformat#

Ultralytics kompiliert YOLO-Modelle lokal mithilfe des QNN Execution Providers von ONNX Runtime (dem per pip installierbaren Paket onnxruntime-qnn, das die QAIRT-Bibliotheken bündelt). Der Exporter konvertiert dein Modell in ONNX, quantisiert es mit Kalibrierungsdaten auf 16-Bit-Aktivierungen und INT8-Gewichte (das empfohlene Gleichgewicht für die Hexagon-NPU) und initialisiert anschließend eine ONNX-Runtime-Sitzung mit aktiviertem Caching der Kontext-Binärdatei. Dabei wird der quantisierte Graph in eine QNN-Kontext-Binärdatei kompiliert, die in <model>_qnn.onnx eingebettet ist. Ein Qualcomm-Konto, ein Upload in die Cloud oder ein separater SDK-Download sind nicht erforderlich.

Im Gegensatz zur cloudbasierten Qualcomm AI Hub-Plattform, die 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 Aufruf von export(format="qnn", imgsz=640) (imgsz=224 für Klassifikation). Du erhältst dasselbe QNN/QAIRT-Laufzeitziel – Snapdragon-CPU, Adreno-GPU und Hexagon-NPU – ohne Registrierung, Upload-Limits oder Wartezeiten in einer Warteschlange. Außerdem fügt es sich direkt in den standardmäßigen YOLO-Exportablauf ein.

Die exportierte Datei *_qnn.onnx ist eigenständig: Sie enthält die QNN-Kontext-Binärdatei und ONNX-Metadaten wie Klassennamen, Bildgröße und Aufgabe.

Wichtige Merkmale von QNN-Modellen#

• Quantisierung: Das Modell wird mithilfe des ONNX-Runtime-QNN-QDQ-Ablaufs und eines Kalibrierungsdatensatzes auf 16-Bit-Aktivierungen und INT8-Gewichte quantisiert – das von der Hexagon-NPU empfohlene Gleichgewicht zwischen Genauigkeit und Leistung. Erfahre mehr über die Modellquantisierung.
• Vollständig lokale Kompilierung: Die Kontext-Binärdatei wird vollständig auf deinem Host-Rechner erzeugt – ohne Qualcomm-Konto, API-Token oder Cloud-Upload.
• Umfassende Snapdragon-Beschleunigung: Führe die Inferenz über eine einzige einheitliche Laufzeitumgebung auf der Hexagon-NPU (HTP), der Adreno-GPU oder der CPU aus.
• Breite Geräteunterstützung: Ziele auf die große Bandbreite an Snapdragon-Plattformen in Smartphones, PCs (Windows on Snapdragon), Fahrzeugen, XR- und eingebetteten Produkten.
• Vorkompilierte Kontext-Binärdatei: Die Bereitstellung einer Kontext-Binärdatei minimiert die Kompilierung des Graphen auf dem Gerät und verringert dadurch die Latenz beim Laden des Modells auf dem Zielgerät.
• Eigenständige Ausgabe: Die exportierte ONNX-Datei enthält die vorkompilierte QNN-Kontext-Binärdatei 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 Performance-Kerne mit bis zu 3,62 GHz), eine Adreno-GPU und eine Hexagon-NPU (HTP v81).

• Speed-Werte sind Burst-Latenzen für ein einzelnes Bild – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmdurchläufen auf bus.jpg, gemessen mit dem On-Device-Benchmark- Harness 0.6.10 des Flutter-Plugins und den standardisierten v0.6.6-Assets. Die Reihenfolge der Backends wechselte zwischen den Aufgaben in einem sequenziellen Durchlauf. 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 Benchmarkbericht befindet sich in der Flutter-Leistungsdokumentation.
• Vergleiche andere Android-Geräte in der LiteRT-Integration und Apple-Geräte in der CoreML-Integration.

Snapdragon-Laptop mit Windows#

Dieser historische Durchlauf verwendete QNN-Binärdateien vor dem Standard v73; für semantische Segmentierung und OBB wurden Eingaben mit 1024 Pixeln verwendet. Er lief auf einem Lenovo- Laptop mit 32 GB Speicher und Windows 11. Sein Snapdragon X Elite (X1E78100) verfügt über eine 12-Kern-Qualcomm-Oryon-CPU, eine Adreno-GPU und eine Hexagon-NPU (HTP v73); das genaue Lenovo-Modell wurde nicht aufgezeichnet. Dieser Vergleich unter Windows on Snapdragon stellt die native PyTorch-FP32-CPU-Baseline, mit der die meisten Desktop- Entwickler beginnen, dem ONNX-Runtime-QNN-Hexagon-HTP-Pfad gegenüber. Jede Zelle zeigt die vollständige Wandzeit von model.predict() mit den darunter angegebenen Zeiten für Vorverarbeitung / Inferenz / Nachverarbeitung; die Gesamtzeit kann Framework-Overhead außerhalb dieser drei Phasen enthalten. CPU-Werte sind PyTorch FP32 (torch==2.10.0+cpu), NPU-Werte sind ONNX Runtime QNN (onnxruntime-qnn==2.2.0, INT8-Gewichte / 16-Bit-Aktivierungen).

• Speed-Werte sind Burst-Latenzen für ein einzelnes Bild – der Mittelwert aus 100 Durchläufen nach 10 Aufwärmdurchläufen auf bus.jpg, gemessen mit time.perf_counter() rund um den vollständigen Aufruf von model.predict() auf einem thermisch stabilisierten Gerät (ultralytics==8.4.67, Python 3.12.10).
• Die Hexagon-NPU arbeitet bei den Aufgaben mit 640–1024 Pixeln ungefähr 2- bis 4-mal schneller als die PyTorch-CPU-Baseline (Erkennung etwa ~3,4-mal schneller); beim Klassifikator mit 224 Pixeln verringert sich der Vorteil auf etwa ~1,3-mal, da der feste Vorverarbeitungsaufwand die kleine 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 Modellfamilie, die diese Köpfe bereitstellt.

In QNN exportieren: Dein YOLO-Modell konvertieren#

Exportiere ein Ultralytics-YOLO-Modell für die Bereitstellung auf Qualcomm-Hardware in das QNN-Format. Die Kontext-Binärdatei wird für eine Zielarchitektur des Hexagon Tensor Processor (HTP) oder einen unterstützten SoC finalisiert. Das Ziel wählst du mit dem Argument name – demselben Argument, mit dem du beim RKNN-Export einen Chip auswählst.

Unterstützte HTP-Ziele#

Übergib die Zielarchitektur oder den SoC über name (z. B. name="73" oder name="iq-8275"). Die Unterstützung richtet sich nach dem HTP-Ziel. Die folgenden Snapdragon-Zeilen stellen daher repräsentative Plattformen und keine vollständige Liste aller SoCs dar. Dragonwing-Geräte sind ausdrücklich aufgeführt.

Dragonwing IQ-615 kann den Ultralytics-QNN-Export von Kontext-Binärdateien nicht verwenden, da ONNX Runtime seinen v66-DSP nicht als Offline-HTP-Ziel bereitstellt. Ein standardmäßiger ONNX-Export kann weiterhin separat mit einem CPU- oder GPU-Execution-Provider 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#

Führe zur Installation der erforderlichen Pakete Folgendes 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. Ausführliche Anweisungen und bewährte Vorgehensweisen zur Installation findest du in unserem Ultralytics-Installationsleitfaden. Falls bei der Installation der erforderlichen Pakete für YOLO Probleme auftreten, findest du Lösungen und Tipps in unserem Leitfaden zu häufigen Problemen.

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 Paket onnxruntime-qnn, das auch für den Export verwendet wird). Exportiere dein Modell und lade es anschließend auf ein Snapdragon-Gerät, um Inferenz auszuführen oder seine 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")

Exportargumente#

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Ausgabestruktur#

Nach einem erfolgreichen Export wird eine eigenständige ONNX-Datei erstellt:

Die Datei yolo26n_qnn.onnx enthält die QNN-Kontext-Binärdatei und wird auf dem Snapdragon-Gerät von ONNX Runtime mit dem QNN Execution Provider geladen. Außerdem enthält sie Modellmetadaten wie Klassennamen, Bildgröße und Aufgabe in ONNX metadata_props.

Bereitstellung exportierter YOLO-QNN-Modelle#

QNN-Modelle laufen auf unterstützter Qualcomm-Hardware, sodass die Bereitstellung von Modellen direkt auf dem Gerät unkompliziert ist. Installiere auf einem kompatiblen Gerät onnxruntime-qnn und führe das exportierte Modell direkt mit der Ultralytics API aus (yolo predict/yolo val, siehe oben unter Verwendung) — Ultralytics lädt die HTP-Kontext-Binärdatei über den ONNX Runtime QNN Execution Provider.

Für benutzerdefinierte Pipelines kannst du die Kontext-Binärdatei auch direkt mit ONNX Runtime als ONNX laden. onnxruntime-qnn ist ein Plugin-Execution-Provider, daher musst du ihn zur Laufzeit registrieren:

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-Kontext-Binärdatei vorkompiliert ist, wird die Sitzung schnell geladen, ohne den Graphen auf dem Gerät neu zu kompilieren.

Anforderungen für Linux und das Yocto-BSP#

Das Ziel-Board muss eine miteinander kompatible Qualcomm-Laufzeitumgebung und ein kompatibles 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, die FastRPC-Unterstützung im Userspace wie libcdsprpc.so, die DSP-Firmware sowie die entsprechenden FastRPC- und Kernel-Treiber. Die Skeleton-Bibliothek muss über den DSP-Bibliothekspfad des BSP gefunden werden können.

Diese Komponenten für das Zielgerät stammen vom Board-Hersteller-BSP mit QAIRT/QNN-Unterstützung; sie sind nicht im exportierten Modell enthalten. Die GPU-Ausführung erfordert stattdessen libQnnGpu.so und den passenden Adreno-Treiberstapel im Userspace. Die Ausgabe von Ultralytics format=qnn ist eine HTP-spezifische Kontext-Binärdatei. Für die Bereitstellung auf GPU oder CPU solltest du daher mit einem standardmäßigen ONNX-Export beginnen und nicht mit der vorkompilierten Datei *_qnn.onnx.

Empfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Trainingsmodus von Ultralytics.
2. Exportiere im QNN-Format mit 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 Datei *_qnn.onnx auf deinem Qualcomm-Gerät bereit.
4. Führe die Inferenz mit ONNX Runtime und dem QNN Execution Provider über das HTP-Backend aus.

Anwendungen in der Praxis#

YOLO-Modelle, die auf Qualcomm-Snapdragon-Hardware ausgeführt werden, eignen sich hervorragend für zahlreiche Edge-AI-Anwendungen:

• Smartphones: Echtzeit-Objekterkennung und Szenenverständnis in Kamera- und Foto-Apps mit NPU-Beschleunigung.
• Windows auf Snapdragon: Computer Vision auf dem Gerät in Copilot+-PCs, ohne Daten in die Cloud auszulagern.
• Automobilbereich: Fahrerüberwachung, Insassenerkennung und ADAS-Funktionen auf Snapdragon Digital Chassis-Plattformen.
• XR und Wearables: Energieeffiziente Wahrnehmung mit geringer Latenz für AR/VR-Headsets und intelligente Brillen.
• IoT und Robotik: Effiziente Bildverarbeitung auf Snapdragon-basierten Kameras, Drohnen und eingebetteten Systemen.

Zusammenfassung#

In diesem Leitfaden hast du gelernt, wie du Ultralytics-YOLO-Modelle lokal mit dem ONNX Runtime QNN Execution Provider in das Qualcomm-QNN-Format exportierst. Die Exportpipeline konvertiert dein Modell in ONNX und kompiliert es anschließend auf deinem Hostcomputer in eine QNN-Kontext-Binärdatei — ohne Qualcomm-Konto und ohne Cloud — und erzeugt eine für Snapdragon-CPU, Adreno-GPU und Hexagon-NPU optimierte Datei *_qnn.onnx, die über die QNN/QAIRT-Laufzeitumgebung genutzt wird.

Die Kombination aus Ultralytics YOLO und Qualcomms KI-Stapel für die Ausführung auf dem Gerät bietet eine effektive Lösung für anspruchsvolle Computer-Vision-Workloads im gesamten Snapdragon-Ökosystem.

Für weitere Ziele zur Ausführung auf dem Gerät und auf Mobilgeräten findest du die zugehörigen Exportleitfäden für ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 und TensorRT. Um Formate vor der Auslieferung zu vergleichen, verwende den Benchmark-Modus. Eine vollständige Liste der Formate und Optionen findest du in der Dokumentation zum Exportmodus und auf der Seite zum Integrationsleitfaden.

FAQ#