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

Die Bereitstellung von Computer-Vision-Modellen auf Qualcomm Snapdragon-Geräten erfordert ein Modellformat, das auf die Qualcomm AI Engine Direct (QNN) Runtime abgestimmt ist. Durch den Export von Ultralytics YOLO-Modellen in das QNN-Format kannst du beschleunigte On-Device-Inferenz auf Snapdragon CPU-, Adreno GPU- und Hexagon NPU-Hardware ausführen, die in Milliarden von Mobiltelefonen, Laptops, Automobilsystemen und IoT-Geräten zu finden ist. Dieser Leitfaden führt dich durch den Export von YOLO zu Qualcomm QNN und die Bereitstellung für eine schnelle, stromsparende Inferenz auf Snapdragon-Hardware.

Link to this sectionWas ist Qualcomm QNN?#

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

Link to this sectionWarum 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 deutlich höheren Durchsatz und geringeren Stromverbrauch als CPU-Inferenz – ideal für Real-time 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: QNN-Export quantisiert YOLO auf INT8-Gewichte mit 16-Bit-Aktivierungen, dem bevorzugten Genauigkeits-/Leistungsverhältnis der Hexagon NPU, was die Modellgröße verringert und die Bilder pro Sekunde auf batteriebetriebener Hardware maximiert.
• 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.

Link to this sectionQNN-Exportformat#

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

Im Gegensatz zum cloudbasierten 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 Wartezeiten in der Warteschlange, und es fügt sich nahtlos in den Standard-YOLO-Export-Workflow ein.

Die exportierte *_qnn.onnx-Datei ist in sich geschlossen: Sie bettet die QNN context binary sowie ONNX-Metadaten wie Klassennamen, Bildgröße und Aufgabe ein.

Link to this sectionHauptmerkmale 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, dem empfohlenen Genauigkeits-/Leistungsverhältnis der Hexagon NPU. Erfahre mehr über Model Quantization.
• 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.

Link to this sectionGemessene Leistung#

Link to this sectionAndroid-Telefon#

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

• Geschwindigkeitswerte sind Einzelbild-Burst-Latenzen – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmdurchläufen auf bus.jpg, gemessen mit dem On-Device-Benchmark-Tool des Flutter plugin's 0.6.10 und den standardisierten v0.6.6-Assets. Die Reihenfolge der Backends wurde bei 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 nutzte.
• Der detaillierte Benchmark-Datensatz befindet sich in der Flutter performance doc.
• Vergleiche andere Android-Geräte in der LiteRT integration und Apple-Geräte in der CoreML integration.

Link to this sectionLaptop mit Windows on Snapdragon#

Dieser historische Durchlauf verwendete vorstandardisierte v73 QNN-Binärdateien; semantische und OBB-Modelle verwendeten 1024px-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 Qualcomm Oryon CPU mit 12 Kernen, eine Adreno GPU und eine Hexagon NPU (HTP v73); das genaue Lenovo-Modell wurde nicht aufgezeichnet. Dieser Windows-on-Snapdragon-Vergleich lässt die native PyTorch FP32 CPU-Basislinie, von der die meisten Desktop- Entwickler ausgehen, gegen den ONNX Runtime QNN Hexagon HTP-Pfad antreten. Jede Zelle zeigt die gesamte model.predict()-Wanduhrzeit mit den angegebenen Vorverarbeitungs-, Inferenz- und Nachbearbeitungszeiten darunter; das Total kann Framework-Overhead außerhalb dieser drei Phasen beinhalten. Die CPU-Zahlen sind PyTorch FP32 (torch==2.10.0+cpu) und die NPU-Zahlen sind ONNX Runtime QNN (onnxruntime-qnn==2.2.0, INT8-Gewichte / 16-Bit-Aktivierungen).

• Geschwindigkeitswerte sind Latenzen bei Einzelbild-Bursts – der Mittelwert aus 100 Durchläufen nach 10 Aufwärmläufen auf bus.jpg, gemessen mit time.perf_counter() rund um den vollständigen model.predict()-Aufruf auf einem thermisch ausgekühlten 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.

Link to this sectionUnterstützte Aufgaben#

QNN-Export unterstützt den Standard-Aufgabensatz, der in jeder Modellfamilie verfügbar ist, einschließlich YOLO26 semantischer Segmentierung.

Link to this sectionExport zu QNN: Konvertierung deines YOLO-Modells#

Exportiere ein Ultralytics YOLO-Modell in das QNN-Format zur Bereitstellung auf Snapdragon-Hardware. Die context binary wird für eine Ziel-Hexagon Tensor Processor (HTP)-Architektur finalisiert, die du mit dem name-Argument auswählst – dasselbe Argument, das auch für den Zielchip beim RKNN export verwendet wird.

Link to this sectionUnterstützte HTP-Architekturen#

Übergebe die Zielarchitektur via name (z.B. name="73"). Gültige Werte:

Link to this sectionInstallation#

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

# Install the required package for YOLO
pip install ultralytics

Das onnxruntime-qnn Paket (das den ONNX Runtime QNN Execution Provider bereitstellt und die QAIRT-Bibliotheken bündelt) wird beim ersten Export automatisch installiert. Für detaillierte Anweisungen und Best Practices bezüglich des Installationsprozesses, schau in unserem Ultralytics Installation Guide nach. Wenn du bei der Installation der erforderlichen Pakete für YOLO auf Schwierigkeiten stößt, konsultiere unseren Common Issues guide für Lösungen und Tipps.

Link to this sectionVerwendung#

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 es dann auf ein 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), targeting an HTP architecture via 'name'
# 'name' can be one of 68, 69, 73, 75, 79, 81 (Snapdragon 888, 8 Gen 1, 8 Gen 2, 8 Gen 3, 8 Elite, 8 Elite Gen 5)
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")

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 eine in sich geschlossene ONNX-Datei erstellt:

Die yolo26n_qnn.onnx-Datei bettet die QNN context binary ein und wird von ONNX Runtime mit dem QNN Execution Provider auf dem Snapdragon-Gerät geladen. Sie führt zudem Modell-Metadaten wie Klassennamen, Bildgröße und Aufgabe in den ONNX metadata_props mit sich.

Link to this sectionBereitstellung exportierter YOLO QNN-Modelle#

QNN-Modelle laufen auf Qualcomm Snapdragon-Hardware, was die Model Deployment auf dem Gerät unkompliziert macht. Führe auf einem Snapdragon-Gerät mit installiertem onnxruntime-qnn das exportierte Modell direkt mit der Ultralytics API (yolo predict/yolo val, siehe Usage oben) aus – Ultralytics lädt die context binary über den ONNX Runtime QNN Execution Provider und wählt das HTP (NPU)-, GPU- oder CPU-Backend aus.

Für benutzerdefinierte Pipelines kannst du die context binary auch direkt mit ONNX Runtime ONNX laden. onnxruntime-qnn ist ein Plugin Execution Provider, also registriere ihn 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.

Link to this sectionEmpfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Ultralytics Train-Modus
2. Exportiere in das QNN-Format mit model.export(format="qnn", imgsz=640) auf einer unterstützten Plattform (verwende imgsz=224 für die Klassifizierung)
3. Stelle die exportierte *_qnn.onnx-Datei auf deinem Snapdragon-Gerät bereit
4. Führe Inferenz mit ONNX Runtime und dem QNN Execution Provider aus und wähle das HTP-, GPU- oder CPU-Backend

Link to this sectionAnwendungen in der Praxis#

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

• Smartphones: Echtzeit-Object Detection und Szenenverständnis 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.

Link to this sectionZusammenfassung#

In diesem Leitfaden hast du gelernt, wie man Ultralytics YOLO-Modelle lokal mit dem ONNX Runtime QNN Execution Provider in das Qualcomm QNN-Format exportiert. Die Export-Pipeline konvertiert dein Modell zu ONNX und kompiliert es dann auf deinem Host-Rechner in eine QNN context binary – kein Qualcomm-Konto oder Cloud erforderlich – wodurch eine *_qnn.onnx-Datei entsteht, die für Snapdragon CPU-, Adreno GPU- und Hexagon NPU-Hardware über die QNN/QAIRT-Runtime optimiert ist.

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

Für weitere On-Device- und mobile Bereitstellungsziele siehe die zugehörigen Exportanleitungen für ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 und TensorRT. Um Formate vor der Auslieferung zu vergleichen, verwende den Benchmark-Modus. Für die vollständige Liste der Formate und Optionen besuche die Dokumentation zum Export-Modus und die Integrations-Übersichtsseite.

Link to this sectionFAQ#

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

Du kannst dein Modell mit export(format="qnn", imgsz=640) (imgsz=224 für die Klassifizierung) oder den entsprechenden CLI-Argumenten exportieren. Der Export erstellt zuerst ein ONNX-Modell und kompiliert dieses dann lokal mithilfe des ONNX Runtime QNN Execution Provider in eine QNN-Kontextbinärdatei. Das Paket onnxruntime-qnn wird beim ersten Export automatisch installiert.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="qnn", imgsz=640)  # use imgsz=224 for classification

Link to this sectionBenötige ich ein Qualcomm-Konto oder Cloud-Zugang?#

Nein. Der QNN-Export läuft vollständig auf deinem lokalen Rechner unter Verwendung des onnxruntime-qnn Pakets, das die QAIRT-Bibliotheken bündelt. Es ist kein Qualcomm-Konto, API-Token oder Netzwerkzugriff erforderlich.

Link to this sectionWie ist der Ultralytics QNN-Export im Vergleich zum Qualcomm AI Hub?#

Der Qualcomm AI Hub ist Qualcomms Cloud-Dienst zum Kompilieren, Profilieren und Benchmarking von Modellen auf gehosteten Snapdragon-Geräten, wofür ein Qualcomm-Konto erforderlich ist. Der Ultralytics QNN-Export zielt auf dieselbe QNN/QAIRT-Runtime (Snapdragon CPU, Adreno GPU und Hexagon NPU) ab, kompiliert die context binary jedoch lokal mit dem ONNX Runtime QNN Execution Provider – kein Konto, kein Upload und keine Warteschlange. Es ist der schnellste Weg, um direkt im Standard-YOLO-Export-Workflow von einem .pt-Modell zu einem Snapdragon-bereiten Build zu gelangen.

Link to this sectionAuf welchen Plattformen kann ich exportieren?#

onnxruntime-qnn stellt vorgefertigte Wheels für Windows (x64 und ARM64) und Linux ARM64 (aarch64) bereit; baue auf Linux x86-64 ONNX Runtime aus dem Quellcode mit --use_qnn (kein vorgefertigtes Wheel wird veröffentlicht, und macOS ist kein unterstützter QNN-Host). Die Generierung der context binary läuft auf einem x64-Host – Windows x64 oder Linux x86-64 – und erfordert kein physisches Snapdragon-Gerät.

Link to this sectionWie führe ich YOLO auf einer Qualcomm Snapdragon NPU aus?#

Exportiere mit model.export(format="qnn", imgsz=640) (imgsz=224 für die Klassifizierung), kopiere die resultierende yolo26n_qnn.onnx-Datei auf dein Snapdragon-Gerät und führe yolo predict model=yolo26n_qnn.onnx source=image.jpg (oder yolo val) aus. Ultralytics lädt die Kontextbinärdatei über den ONNX Runtime QNN Execution Provider und führt sie auf der Hexagon NPU aus – siehe Deploying Exported YOLO QNN Models.

Link to this sectionWas ist der Unterschied zwischen QNN und SNPE?#

QNN (Qualcomm AI Engine Direct, Teil des QAIRT SDK) ist Qualcomms aktueller Inferenz-Stack und der empfohlene Ersatz für das ältere Snapdragon Neural Processing Engine (SNPE) SDK. Neue Bereitstellungen sollten auf QNN abzielen.

Link to this sectionKann ich ein QNN-Modell mit yolo predict und yolo val ausführen?#

Ja, auf einem Qualcomm Snapdragon-Gerät mit installiertem onnxruntime-qnn – YOLO("yolo26n_qnn.onnx") lädt die context binary über den QNN Execution Provider und führt predict/val wie jedes andere Format aus. Auf einem x86-Host ohne QNN-Hardware kann das Modell nicht ausgeführt werden, da die context binary auf die Snapdragon NPU abzielt.

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

Der Export erstellt eine in sich geschlossene ONNX-Datei mit context binary (z. B. yolo26n_qnn.onnx), wobei Klassennamen, Bildgröße, Aufgabe und andere Modell-Metadaten in den ONNX metadata_props eingebettet sind.