Esportazione Qualcomm QNN per i modelli Ultralytics YOLO#

La distribuzione di modelli di computer vision su dispositivi Qualcomm Snapdragon richiede un formato di modello ottimizzato per il runtime Qualcomm AI Engine Direct (QNN). L'esportazione dei modelli Ultralytics YOLO nel formato QNN consente di eseguire un'inferenza accelerata on-device su CPU Snapdragon, GPU Adreno e hardware Hexagon NPU presenti in miliardi di telefoni cellulari, laptop, sistemi automobilistici e dispositivi IoT. Questa guida illustra come esportare YOLO su Qualcomm QNN e distribuirlo per un'inferenza rapida e a basso consumo su hardware Snapdragon.

Cos'è Qualcomm QNN?#

Qualcomm AI Engine Direct — comunemente indicato come QNN e distribuito come parte dell'SDK Qualcomm AI Runtime (QAIRT) — è lo stack di inferenza di basso livello di Qualcomm per i processori Snapdragon. Fornisce un'API unificata con librerie specifiche per il backend che mirano alla CPU Snapdragon, alla GPU Adreno e all'Hexagon Tensor Processor (HTP), l'unità di elaborazione di reti neurali (NPU) dedicata all'interno dei moderni SoC Snapdragon. QNN offre agli sviluppatori accesso completo a questi acceleratori AI Snapdragon ed è il successore moderno del vecchio SDK Snapdragon Neural Processing Engine (SNPE). Alimenta l'IA on-device sulle piattaforme mobili Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite, sui laptop Snapdragon X e su prodotti automotive e XR.

Perché esportare in Qualcomm QNN?#

Snapdragon è la piattaforma di elaborazione mobile più ampiamente distribuita al mondo. Esportare Ultralytics YOLO nel formato Qualcomm QNN sblocca l'hardware AI dedicato su questi dispositivi:

• Accelerazione Hexagon NPU: L'esecuzione di YOLO sull'Hexagon Tensor Processor offre un throughput notevolmente superiore e un consumo energetico inferiore rispetto all'inferenza su CPU, ideale per l'inferenza in tempo reale e la computer vision always-on su Snapdragon.
• On-device e offline: L'inferenza QNN viene eseguita interamente sul dispositivo Snapdragon, quindi non ci sono round-trip verso il cloud, la latenza rimane bassa e i dati non lasciano mai il dispositivo.
• Efficienza quantizzata: L'esportazione QNN quantizza YOLO a pesi INT8 con attivazioni a 16 bit, il bilanciamento ideale tra accuratezza e prestazioni per l'Hexagon NPU, riducendo le dimensioni del modello e massimizzando i fotogrammi al secondo su hardware alimentato a batteria.
• Un formato, molti dispositivi: Una singola esportazione Qualcomm QNN punta a CPU Snapdragon, GPU Adreno e Hexagon NPU attraverso le famiglie Snapdragon 8 Gen 2, 8 Gen 3, 8 Elite e oltre.
• Stack AI Qualcomm pronto per la produzione: QNN (Qualcomm AI Engine Direct / QAIRT) è l'attuale runtime AI on-device di Qualcomm, attivamente mantenuto e il sostituto raccomandato per SNPE.

Formato di esportazione QNN#

Ultralytics compila i modelli YOLO per QNN localmente utilizzando l'Execution Provider QNN di ONNX Runtime (il pacchetto onnxruntime-qnn installabile tramite pip, che include le librerie QAIRT). L'esportatore converte il tuo modello in ONNX, lo quantizza con dati di calibrazione ad attivazioni a 16 bit e pesi INT8 (il bilanciamento consigliato per l'Hexagon NPU), quindi avvia una sessione ONNX Runtime con la memorizzazione nella cache del context-binary abilitata: questo compila il grafo quantizzato in un context binary QNN incorporato in <model>_qnn.onnx. Non sono richiesti account Qualcomm, caricamento su cloud o download separati di SDK.

A differenza del Qualcomm AI Hub basato su cloud, che compila e profila i modelli su dispositivi Snapdragon ospitati da Qualcomm e richiede un account Qualcomm, l'esportazione QNN di Ultralytics viene eseguita interamente sulla tua macchina con una singola chiamata export(format="qnn", imgsz=640) (imgsz=224 per la classificazione). Ottieni lo stesso target di runtime QNN/QAIRT — CPU Snapdragon, GPU Adreno e Hexagon NPU — senza registrazione, limiti di upload o tempi di attesa in coda, e si integra direttamente nel flusso di lavoro standard di esportazione YOLO.

Il file *_qnn.onnx esportato è autonomo: incorpora il context binary QNN e i metadati ONNX come nomi delle classi, dimensioni delle immagini e task.

Caratteristiche chiave dei modelli QNN#

• Quantizzazione: Il modello viene quantizzato a attivazioni a 16 bit e pesi INT8 con il flusso QDQ QNN di ONNX Runtime e un dataset di calibrazione, il bilanciamento accuratezza/prestazioni consigliato dall'Hexagon NPU. Scopri di più sulla quantizzazione dei modelli.
• Compilazione completamente locale: Il binario di contesto viene generato interamente sulla tua macchina host — nessun account Qualcomm, token API o caricamento cloud richiesti.
• Accelerazione completa Snapdragon: Esegui l'inferenza sull'Hexagon NPU (HTP), sulla GPU Adreno o sulla CPU tramite un unico runtime unificato.
• Ampia portata sui dispositivi: Punta all'ampia gamma di piattaforme Snapdragon presenti in telefoni, PC (Windows on Snapdragon), settore automobilistico, XR e prodotti integrati.
• Binario di contesto precompilato: Distribuire un binario di contesto riduce al minimo la compilazione del grafo on-device, abbassando la latenza di caricamento del modello sul target.
• Output autonomo: Il file ONNX esportato include il binario di contesto QNN precompilato e i metadati per un deployment semplice.

Prestazioni misurate#

Telefono Android#

Hardware: Xiaomi 17 con 12 GB di memoria LPDDR5X e Android 16 / API 36. Il suo Snapdragon 8 Elite Gen 5 a 3 nm (SM8850) ha una CPU Qualcomm Oryon a 8 core (2 core Prime fino a 4,6 GHz e 6 core Performance fino a 3,62 GHz), GPU Adreno e Hexagon NPU (HTP v81).

• I valori di velocità sono latenze di burst su singola immagine — la media di 15 esecuzioni dopo 3 esecuzioni di riscaldamento su bus.jpg, misurate con il modulo di benchmark on-device 0.6.10 del plugin Flutter e le risorse standardizzate v0.6.6. L'ordine dei backend è stato alternato tra i task in una singola scansione sequenziale. I log nativi hanno confermato che ogni riga CPU utilizzava LiteRT CPU/XNNPACK, ogni riga GPU delegava l'intero grafo a LiteRT OpenCL (LITERT_CL) e ogni riga NPU utilizzava il backend QNN Hexagon HTP.
• Il record dettagliato del benchmark è disponibile nella documentazione delle prestazioni di Flutter.
• Confronta altri dispositivi Android nell'integrazione LiteRT e i dispositivi Apple nell'integrazione CoreML.

Laptop Windows su Snapdragon#

Questa scansione preliminare ha utilizzato binari QNN v73 pre-standard; semantic e OBB hanno utilizzato input da 1024px. È stata eseguita su un laptop Lenovo con 32 GB di memoria e Windows 11. Il suo Snapdragon X Elite (X1E78100) ha una CPU Qualcomm Oryon a 12 core, GPU Adreno e Hexagon NPU (HTP v73); il modello esatto Lenovo non è stato registrato. Questo confronto Windows-on-Snapdragon esegue il baseline CPU PyTorch FP32 nativo da cui partono la maggior parte degli sviluppatori desktop rispetto al percorso ONNX Runtime QNN Hexagon HTP. Ogni cella mostra il tempo totale di esecuzione (model.predict()) con i relativi tempi di pre-elaborazione / inferenza / post-elaborazione riportati sotto; il totale può includere l'overhead del framework al di fuori di queste tre fasi. I numeri della CPU sono PyTorch FP32 (torch==2.10.0+cpu) e i numeri della NPU sono ONNX Runtime QNN (onnxruntime-qnn==2.2.0, pesi INT8 / attivazioni a 16 bit).

• I valori di velocità sono latenze di burst su singola immagine — la media di 100 esecuzioni dopo 10 esecuzioni di riscaldamento su bus.jpg, misurate con time.perf_counter() attorno alla chiamata completa model.predict() su un dispositivo termicamente a riposo (ultralytics==8.4.67, Python 3.12.10).
• La NPU Hexagon esegue le attività circa 2-4 volte più velocemente rispetto alla baseline della CPU PyTorch su attività da 640-1024 px (rilevamento ~3.4x), riducendosi a ~1.3x sul classificatore da 224 px dove l'overhead di preelaborazione fisso domina il carico di lavoro ridotto.

Attività supportate#

L'esportazione Qualcomm QNN supporta tutti e sette i task di Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include tali teste.

Esportazione in QNN: Conversione del tuo modello YOLO#

Esporta un modello Ultralytics YOLO nel formato QNN per la distribuzione su hardware Qualcomm. Il context binary viene finalizzato per un'architettura Hexagon Tensor Processor (HTP) di destinazione o un SoC supportato, che selezioni con l'argomento name, lo stesso argomento utilizzato per mirare a un chip nell'esportazione RKNN.

Target HTP supportati#

Passa l'architettura di destinazione o il SoC tramite name (ad es. name="73" o name="iq-8275"). Il supporto è determinato dall'obiettivo HTP, quindi le righe Snapdragon sottostanti rappresentano piattaforme di esempio anziché un elenco esaustivo di ogni SoC. I dispositivi Dragonwing sono elencati esplicitamente.

Dragonwing IQ-615 non può usare l'export del binario di contesto QNN di Ultralytics perché ONNX Runtime non espone il suo DSP v66 come target HTP offline. Un export ONNX standard può comunque essere integrato separatamente con un execution provider CPU o GPU supportato dal BSP della scheda.

from ultralytics import YOLO

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

Installazione#

Per installare i pacchetti richiesti, esegui:

# Install the required package for YOLO
pip install ultralytics

Il pacchetto onnxruntime-qnn (che fornisce l'Execution Provider QNN di ONNX Runtime e include le librerie QAIRT) viene installato automaticamente al primo export. Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione di Ultralytics. Se riscontri difficoltà durante l'installazione dei pacchetti richiesti per YOLO, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Utilizzo#

Il formato QNN supporta le modalità Esporta, Prevedi e Valida. L'inferenza e la validazione vengono eseguite su hardware Qualcomm Snapdragon tramite l'Execution Provider QNN di ONNX Runtime (lo stesso pacchetto onnxruntime-qnn utilizzato per l'esportazione). Esporta il tuo modello, quindi carica il modello esportato su un dispositivo Snapdragon per eseguire l'inferenza o validarne l'accuratezza.

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")

Argomenti di esportazione#

Per ulteriori dettagli sul processo di esportazione, visita la pagina della documentazione di Ultralytics sull'esportazione.

Struttura dell'output#

Dopo un'esportazione riuscita, viene creato un file ONNX autonomo:

Il file yolo26n_qnn.onnx incorpora il context binary QNN e viene caricato da ONNX Runtime con l'Execution Provider QNN sul dispositivo Snapdragon. Contiene anche metadati del modello come nomi delle classi, dimensioni delle immagini e task in ONNX metadata_props.

Deployment di modelli YOLO QNN esportati#

I modelli QNN vengono eseguiti su hardware Qualcomm supportato, rendendo semplice la distribuzione del modello on-device. Su un dispositivo compatibile con onnxruntime-qnn installato, esegui il modello esportato direttamente con l'API Ultralytics (yolo predict/yolo val, vedi Utilizzo sopra) — Ultralytics carica il context binary HTP tramite l'Execution Provider QNN di ONNX Runtime.

Per pipeline personalizzate, puoi anche caricare il context-binary ONNX direttamente con ONNX Runtime. onnxruntime-qnn è un Execution Provider plugin, quindi registralo a runtime:

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

Poiché il binario di contesto QNN è precompilato, la sessione si carica rapidamente senza ricompilare il grafo on-device.

Requisiti BSP per Linux e Yocto#

La scheda di destinazione deve fornire un runtime Qualcomm e un BSP reciprocamente compatibili. Per l'inferenza HTP questo include l'Execution Provider QNN di ONNX Runtime, libQnnSystem.so, libQnnHtp.so, le librerie di stub e skeleton HTP v75 per IQ-8275, il supporto userspace FastRPC come libcdsprpc.so, il firmware DSP e i relativi driver FastRPC/kernel. La libreria skeleton deve essere individuabile tramite il percorso delle librerie DSP del BSP.

Questi componenti lato target provengono dal BSP abilitato QAIRT/QNN del fornitore della scheda; non sono incorporati nel modello esportato. L'esecuzione su GPU richiede invece libQnnGpu.so e lo stack di driver userspace Adreno corrispondente. L'output format=qnn di Ultralytics è un context binary specifico per HTP, quindi la distribuzione su GPU o CPU dovrebbe iniziare da un'esportazione ONNX standard anziché dal file *_qnn.onnx precompilato.

Flusso di lavoro consigliato#

1. Allena il tuo modello utilizzando la modalità di training di Ultralytics
2. Esporta nel formato QNN utilizzando model.export(format="qnn", name="iq-8275", imgsz=640) su una piattaforma supportata (usa imgsz=224 per la classificazione)
3. Distribuisci il file *_qnn.onnx esportato sul tuo dispositivo Qualcomm
4. Esegui l'inferenza con ONNX Runtime e l'Execution Provider QNN utilizzando il backend HTP

Applicazioni nel mondo reale#

I modelli YOLO in esecuzione su hardware Qualcomm Snapdragon sono ideali per un'ampia gamma di applicazioni di edge AI:

• Smartphone: Rilevamento di oggetti in tempo reale e comprensione della scena nelle app di fotocamera e foto con accelerazione NPU.
• Windows on Snapdragon: Computer vision on-device in PC Copilot+ senza scaricare dati sul cloud.
• Settore automobilistico: Monitoraggio del conducente, rilevamento degli occupanti e funzionalità ADAS sulle piattaforme Snapdragon Digital Chassis.
• XR e Wearable: Percezione a basso consumo e bassa latenza per visori AR/VR e smart glass.
• IoT e robotica: Efficiente inferenza visiva su fotocamere, droni e sistemi embedded basati su Snapdragon.

Riepilogo#

In questa guida hai imparato come esportare i modelli Ultralytics YOLO nel formato Qualcomm QNN localmente con l'Execution Provider QNN di ONNX Runtime. La pipeline di esportazione converte il tuo modello in ONNX, quindi lo compila in un context binary QNN sulla tua macchina host — senza account Qualcomm o cloud richiesti — producendo un file *_qnn.onnx ottimizzato per CPU Snapdragon, GPU Adreno e hardware Hexagon NPU tramite il runtime QNN/QAIRT.

La combinazione di Ultralytics YOLO e dello stack IA on-device di Qualcomm offre una soluzione efficace per l'esecuzione di carichi di lavoro avanzati di computer vision nell'ampio ecosistema Snapdragon.

Per altri target di distribuzione mobile e on-device, consulta le relative guide all'esportazione per ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 e TensorRT. Per confrontare i formati prima del rilascio, usa la modalità Benchmark. Per l'elenco completo di formati e opzioni, visita la documentazione della modalità Esportazione e la pagina della guida alle integrazioni.

FAQ#