Link to this sectionEsportazione Qualcomm QNN per i modelli Ultralytics YOLO#

Il deployment di modelli di computer vision su dispositivi Qualcomm Snapdragon richiede un formato di modello ottimizzato per il runtime Qualcomm AI Engine Direct (QNN). Esportando i modelli Ultralytics YOLO nel formato QNN puoi eseguire inferenze accelerate on-device su hardware Snapdragon CPU, Adreno GPU e Hexagon NPU presente in miliardi di telefoni cellulari, laptop, sistemi automobilistici e dispositivi IoT. Questa guida ti accompagna attraverso la procedura di esportazione di YOLO verso Qualcomm QNN e il suo deployment per un'inferenza veloce e a basso consumo su hardware Snapdragon.

Link to this sectionCos'è Qualcomm QNN?#

Qualcomm AI Engine Direct — comunemente noto come QNN e distribuito come parte del 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 neurale (neural network processing unit - NPU) dedicata all'interno dei moderni SoC Snapdragon. QNN offre agli sviluppatori un accesso full-stack a questi acceleratori AI di Snapdragon ed è il moderno successore del precedente 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 sui prodotti per il settore automotive e XR.

Link to this sectionPerché 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: Eseguire YOLO sull'Hexagon Tensor Processor offre un throughput drasticamente superiore e un consumo energetico inferiore rispetto all'inferenza su CPU — ideale per l'inferenza in tempo reale e la computer vision sempre attiva 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 con pesi INT8 e attivazioni a 16-bit, il bilanciamento tra accuratezza e prestazioni preferito dall'Hexagon NPU, riducendo le dimensioni del modello e massimizzando i frame 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.

Link to this sectionFormato di esportazione QNN#

Ultralytics compila i modelli YOLO in QNN localmente utilizzando il QNN Execution Provider 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 in attivazioni a 16-bit e pesi INT8 (il bilanciamento raccomandato per l'Hexagon NPU), quindi inizializza una sessione ONNX Runtime con la memorizzazione nella cache del binario di contesto abilitata — questo compila il grafo quantizzato in un binario di contesto QNN incorporato in <model>_qnn.onnx. Non sono richiesti account Qualcomm, caricamenti sul cloud o download di SDK separati.

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 NPU Hexagon — senza registrazione, limiti di caricamento o tempi di attesa in coda, e si integra direttamente nel flusso di lavoro di esportazione YOLO standard.

Il file *_qnn.onnx esportato è autonomo: incorpora il binario di contesto QNN e i metadati ONNX come nomi delle classi, dimensioni dell'immagine e task.

Link to this sectionCaratteristiche chiave dei modelli QNN#

• Quantizzazione: Il modello viene quantizzato in attivazioni a 16-bit e pesi INT8 con il flusso QDQ di ONNX Runtime QNN e un set di dati di calibrazione, il bilanciamento accuratezza/prestazioni raccomandato dall'Hexagon NPU. Scopri di più sulla quantizzazione del modello.
• 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.

Link to this sectionPrestazioni misurate#

Link to this sectionTelefono Android#

Hardware: Xiaomi 17 con 12 GB di memoria LPDDR5X e Android 16 / API 36. Il suo Snapdragon 8 Elite Gen 5 (SM8850) a 3 nm 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 NPU Hexagon (HTP v81).

• Speed values are single-image burst latencies — the mean of 15 runs after 3 warmup runs on bus.jpg, measured with the Flutter plugin's 0.6.10 on-device benchmark harness and the standardized v0.6.6 assets. Backend order rotated between tasks in one sequential sweep. Native logs confirmed that every CPU row used LiteRT CPU/XNNPACK, every GPU row delegated the complete graph to LiteRT OpenCL (LITERT_CL), and every NPU row used the QNN Hexagon HTP backend.
• Il record dettagliato del benchmark si trova nella documentazione delle prestazioni di Flutter.
• Confronta altri dispositivi Android nell'integrazione LiteRT e i dispositivi Apple nell' integrazione CoreML.

Link to this sectionLaptop Windows su Snapdragon#

Questa scansione storica ha utilizzato i binari QNN v73 pre-standard; la semantica e l'OBB hanno utilizzato input da 1024px. È stata eseguita su un portatile 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 NPU Hexagon (HTP v73); il modello Lenovo esatto non è stato registrato. Questo confronto Windows-on-Snapdragon esegue la baseline CPU PyTorch FP32 nativa 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 (wall time) di model.predict() con i relativi tempi di pre-elaborazione / inferenza / post-elaborazione sottostanti; 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 Speed sono latenze di burst su singola immagine — la media di 100 esecuzioni dopo 10 esecuzioni di riscaldamento su bus.jpg, misurati con time.perf_counter() attorno alla chiamata completa model.predict() su un dispositivo a riposo termico (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.

Link to this sectionAttività supportate#

L'esportazione QNN supporta il set di task standard disponibile in ogni famiglia di modelli, inclusa la segmentazione semantica di YOLO26.

Link to this sectionEsportazione in QNN: Conversione del tuo modello YOLO#

Esporta un modello Ultralytics YOLO nel formato QNN per il deployment su hardware Snapdragon. Il binario di contesto viene finalizzato per un'architettura Hexagon Tensor Processor (HTP) di destinazione, che selezioni con l'argomento name — lo stesso argomento usato per puntare a un chip nell'esportazione RKNN.

Link to this sectionArchitetture HTP supportate#

Passa l'architettura target tramite name (ad esempio name="73"). Valori validi:

Link to this sectionInstallazione#

Per installare i pacchetti richiesti, esegui:

# Install the required package for YOLO
pip install ultralytics

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

Link to this sectionUtilizzo#

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

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 sectionArgomenti di esportazione#

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

Link to this sectionStruttura dell'output#

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

Il file yolo26n_qnn.onnx incorpora il binario di contesto QNN e viene caricato da ONNX Runtime con il QNN Execution Provider sul dispositivo Snapdragon. Trasporta anche metadati del modello come nomi delle classi, dimensioni dell'immagine e task nelle metadata_props di ONNX.

Link to this sectionDeployment di modelli YOLO QNN esportati#

I modelli QNN vengono eseguiti su hardware Qualcomm Snapdragon, rendendo il deployment del modello on-device semplice. Su un dispositivo Snapdragon con onnxruntime-qnn installato, esegui il modello esportato direttamente con l'API Ultralytics (yolo predict/yolo val, vedi Uso sopra) — Ultralytics carica il binario di contesto tramite il QNN Execution Provider di ONNX Runtime e seleziona il backend HTP (NPU), GPU o CPU.

Per pipeline personalizzate, puoi anche caricare direttamente il binario di contesto ONNX con ONNX Runtime. onnxruntime-qnn è un Execution Provider plug-in, quindi registralo al 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.

Link to this sectionFlusso di lavoro consigliato#

1. Addestra il tuo modello usando la Modalità Train di Ultralytics
2. Esporta al formato QNN usando model.export(format="qnn", imgsz=640) su una piattaforma supportata (usa imgsz=224 per la classificazione)
3. Distribuisci il file *_qnn.onnx esportato sul tuo dispositivo Snapdragon
4. Esegui l'inferenza con ONNX Runtime e il QNN Execution Provider, selezionando il backend HTP, GPU o CPU

Link to this sectionApplicazioni nel mondo reale#

I modelli YOLO in esecuzione su hardware Qualcomm Snapdragon sono adatti a un'ampia gamma di applicazioni di Edge AI:

• Smartphone: Object detection in tempo reale e comprensione della scena in app 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.

Link to this sectionRiepilogo#

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

La combinazione di Ultralytics YOLO e dello stack AI on-device di Qualcomm fornisce una soluzione efficace per eseguire carichi di lavoro avanzati di computer vision attraverso l'ampio ecosistema Snapdragon.

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

Link to this sectionFAQ#

Link to this sectionCome esporto il mio modello Ultralytics YOLO in formato QNN?#

Puoi esportare il tuo modello usando export(format="qnn", imgsz=640) (imgsz=224 per la classificazione) o gli argomenti CLI equivalenti. L'esportazione crea prima un modello ONNX, quindi lo compila localmente in un binario di contesto QNN usando l'execution provider ONNX Runtime QNN. Il pacchetto onnxruntime-qnn viene installato automaticamente alla prima esportazione.

from ultralytics import YOLO

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

Link to this sectionHo bisogno di un account Qualcomm o dell'accesso al cloud?#

No. L'esportazione QNN viene eseguita interamente sulla tua macchina locale usando il pacchetto onnxruntime-qnn, che include le librerie QAIRT. Non sono richiesti account Qualcomm, token API o accesso alla rete.

Link to this sectionCome si confronta l'esportazione QNN di Ultralytics con Qualcomm AI Hub?#

Qualcomm AI Hub è il servizio cloud di Qualcomm per compilare, profilare e testare modelli su dispositivi Snapdragon ospitati, e richiede un account Qualcomm. L'esportazione QNN di Ultralytics punta allo stesso runtime QNN/QAIRT (CPU Snapdragon, GPU Adreno e Hexagon NPU) ma compila il binario di contesto localmente con il QNN Execution Provider di ONNX Runtime — senza account, senza caricamenti e senza code. È il modo più veloce per passare da un modello .pt a una build pronta per Snapdragon direttamente all'interno del normale flusso di lavoro di esportazione di YOLO.

Link to this sectionSu quali piattaforme posso eseguire l'esportazione?#

onnxruntime-qnn fornisce ruote precompilate per Windows (x64 e ARM64) e Linux ARM64 (aarch64); su Linux x86-64 compila ONNX Runtime dal sorgente con --use_qnn (non viene pubblicata alcuna ruota precompilata e macOS non è un host QNN supportato). La generazione del binario di contesto viene eseguita su un host x64 — Windows x64 o Linux x86-64 — e non richiede un dispositivo Snapdragon fisico.

Link to this sectionCome eseguo YOLO su una NPU Qualcomm Snapdragon?#

Esporta con model.export(format="qnn", imgsz=640) (imgsz=224 per la classificazione), copia il file yolo26n_qnn.onnx risultante sul tuo dispositivo Snapdragon ed esegui yolo predict model=yolo26n_qnn.onnx source=image.jpg (o yolo val). Ultralytics carica il binario di contesto tramite l'execution provider ONNX Runtime QNN e lo esegue sulla NPU Hexagon — vedi Deploying Exported YOLO QNN Models.

Link to this sectionQual è la differenza tra QNN e SNPE?#

QNN (Qualcomm AI Engine Direct, parte dell'SDK QAIRT) è l'attuale stack di inferenza di Qualcomm e il sostituto raccomandato per il più vecchio SDK Snapdragon Neural Processing Engine (SNPE). I nuovi deployment dovrebbero puntare a QNN.

Link to this sectionPosso eseguire un modello QNN con yolo predict e yolo val?#

Sì, su un dispositivo Qualcomm Snapdragon con onnxruntime-qnn installato — YOLO("yolo26n_qnn.onnx") carica il binario di contesto tramite il QNN Execution Provider ed esegue predict/val come qualsiasi altro formato. Su un host x86 senza hardware QNN il modello non può essere eseguito, poiché il binario di contesto punta alla NPU Snapdragon.

Link to this sectionQual è l'output di un'esportazione QNN?#

L'esportazione crea un file ONNX binario di contesto autonomo (ad esempio yolo26n_qnn.onnx) con nomi delle classi, dimensioni dell'immagine, task e altri metadati del modello incorporati nelle metadata_props di ONNX.