Esportazione Qualcomm QNN per i modelli Ultralytics YOLO#

La distribuzione di modelli di computer vision sui dispositivi Qualcomm Snapdragon richiede un formato del modello ottimizzato per il runtime Qualcomm AI Engine Direct (QNN). L'esportazione dei modelli Ultralytics YOLO nel formato QNN ti consente di eseguire inferenze accelerate direttamente sul dispositivo, sfruttando l'hardware CPU Snapdragon, GPU Adreno e NPU Hexagon presente in miliardi di telefoni cellulari, laptop, sistemi automobilistici e dispositivi IoT. Questa guida illustra come esportare YOLO in Qualcomm QNN e distribuirlo per eseguire inferenze rapide e a basso consumo sull'hardware Snapdragon.

Che 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 backend destinate alla CPU Snapdragon, alla GPU Adreno e all'Hexagon Tensor Processor (HTP), l'unità di elaborazione delle reti neurali (NPU) dedicata all'interno dei moderni SoC Snapdragon. QNN offre agli sviluppatori accesso full-stack a questi acceleratori AI Snapdragon ed è il moderno successore del precedente SDK Snapdragon Neural Processing Engine (SNPE). Alimenta l'AI direttamente sul dispositivo sulle piattaforme mobili Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite, sui laptop Snapdragon X e sui prodotti automobilistici e XR.

Perché esportare in Qualcomm QNN?#

Snapdragon è la piattaforma di elaborazione mobile più diffusa al mondo. L'esportazione di Ultralytics YOLO nel formato Qualcomm QNN sblocca l'hardware AI dedicato di questi dispositivi:

• Accelerazione NPU Hexagon: eseguire YOLO sull'Hexagon Tensor Processor offre un throughput notevolmente superiore e un consumo energetico inferiore rispetto all'inferenza sulla CPU: è ideale per l'inferenza in tempo reale e la computer vision sempre attiva su Snapdragon.
• Sul dispositivo e offline: l'inferenza QNN viene eseguita interamente sul dispositivo Snapdragon, quindi non ci sono andate e ritorni verso il cloud, la latenza rimane bassa e i dati non lasciano mai il dispositivo.
• Efficienza con quantizzazione: l'esportazione QNN quantizza YOLO in pesi INT8 con attivazioni a 16 bit, il compromesso preferito dall'NPU Hexagon tra accuratezza e prestazioni, riducendo le dimensioni del modello e massimizzando i fotogrammi al secondo sull'hardware alimentato a batteria.
• Un formato, molti dispositivi: una singola esportazione Qualcomm QNN supporta CPU Snapdragon, GPU Adreno e NPU Hexagon nelle famiglie Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite e oltre.
• Stack AI Qualcomm pronto per la produzione: QNN (Qualcomm AI Engine Direct / QAIRT) è l'attuale runtime AI di Qualcomm per l'esecuzione sul dispositivo, mantenuto attivamente e consigliato come sostituto di SNPE.

Formato di esportazione QNN#

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

A differenza di Qualcomm AI Hub basato sul cloud, che compila e analizza 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 runtime QNN/QAIRT — CPU Snapdragon, GPU Adreno e NPU Hexagon — senza registrazione, limiti di caricamento o tempi di coda, integrandolo 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 i nomi delle classi, le dimensioni dell'immagine e il task.

Caratteristiche principali dei modelli QNN#

• Quantizzazione: il modello viene quantizzato in attivazioni a 16 bit e pesi INT8 mediante il flusso QNN QDQ di ONNX Runtime e un dataset di calibrazione, il compromesso consigliato dall'NPU Hexagon tra accuratezza e prestazioni. Scopri di più sulla quantizzazione dei modelli.
• Compilazione completamente locale: il context binary viene generato interamente sulla tua macchina host, senza account Qualcomm, token API o caricamento sul cloud.
• Accelerazione completa Snapdragon: esegui l'inferenza sull'NPU Hexagon (HTP), sulla GPU Adreno o sulla CPU tramite un singolo runtime unificato.
• Ampia compatibilità con i dispositivi: supporta l'ampia gamma di piattaforme Snapdragon presenti in telefoni, PC (Windows su Snapdragon), prodotti automobilistici, XR ed embedded.
• Context binary precompilato: distribuire un context binary riduce al minimo la compilazione del grafo sul dispositivo, diminuendo la latenza di caricamento del modello sul dispositivo di destinazione.
• Output autonomo: il file ONNX esportato include il context binary QNN precompilato e i metadati per una distribuzione 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) dispone di 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).

• I valori di velocità sono latenze burst su immagini singole: la media di 15 esecuzioni dopo 3 esecuzioni di riscaldamento su bus.jpg, misurata con l'har­ness di benchmark sul dispositivo 0.6.10 del plugin Flutter e gli asset standardizzati v0.6.6. L'ordine dei backend è stato alternato tra i task in un'unica sequenza. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK, ogni riga GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL) e ogni riga NPU usava il backend QNN Hexagon HTP.
• Il record dettagliato del benchmark è disponibile nella documentazione sulle prestazioni Flutter.
• Confronta altri dispositivi Android nell'integrazione LiteRT e i dispositivi Apple nell' integrazione CoreML.

Laptop Windows su Snapdragon#

Questa analisi storica ha utilizzato file binari QNN v73 precedenti alla standardizzazione; la segmentazione semantica e l'OBB utilizzavano input da 1024 px. È stata eseguita su un laptop Lenovo con 32 GB di memoria e Windows 11. Il suo Snapdragon X Elite (X1E78100) dispone di una CPU Qualcomm Oryon a 12 core, GPU Adreno e NPU Hexagon (HTP v73); il modello Lenovo esatto non è stato registrato. Questo confronto Windows su Snapdragon mette a confronto la baseline nativa CPU PyTorch FP32, da cui parte la maggior parte degli sviluppatori desktop, con il percorso Hexagon HTP QNN di ONNX Runtime. Ogni cella mostra il tempo totale model.predict() con i tempi di preprocessing / inferenza / postprocessing riportati sotto; il totale può includere l'overhead del framework al di fuori di queste tre fasi. I valori CPU sono PyTorch FP32 (torch==2.10.0+cpu) e i valori NPU sono ONNX Runtime QNN (onnxruntime-qnn==2.2.0, pesi INT8 / attivazioni a 16 bit).

• I valori di velocità sono latenze burst su immagini singole: la media di 100 esecuzioni dopo 10 esecuzioni di riscaldamento su bus.jpg, misurata con time.perf_counter() intorno alla chiamata completa model.predict() su un dispositivo termicamente stabilizzato (ultralytics==8.4.67, Python 3.12.10).
• L'NPU Hexagon è circa 2-4 volte più veloce della baseline CPU PyTorch nei task da 640-1024 px (rilevamento ~3.4x), riducendo il vantaggio a ~1.3x sul classificatore da 224 px, dove l'overhead fisso del preprocessing 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 queste head.

Esportazione in QNN: conversione del modello YOLO#

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

Target HTP supportati#

Passa l'architettura target o il SoC tramite name (ad esempio name="73" o name="iq-8275"). Il supporto è determinato dal target HTP, quindi le righe Snapdragon seguenti rappresentano piattaforme esemplificative e non un elenco esaustivo di ogni SoC. I dispositivi Dragonwing sono elencati esplicitamente.

Dragonwing IQ-615 non può utilizzare l'esportazione del context binary QNN di Ultralytics perché ONNX Runtime non espone il suo DSP v66 come target HTP offline. Un'esportazione ONNX standard può comunque essere integrata 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 il QNN Execution Provider di ONNX Runtime e include le librerie QAIRT) viene installato automaticamente alla prima esportazione. Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione di Ultralytics. Se durante l'installazione dei pacchetti richiesti per YOLO riscontri difficoltà, consulta la nostra guida ai problemi comuni per trovare soluzioni e suggerimenti.

Utilizzo#

Il formato QNN supporta le modalità Esporta, Predici e Valida. L'inferenza e la validazione 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 modello, quindi carica il modello esportato su un dispositivo Snapdragon per eseguire l'inferenza o verificarne 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 Ultralytics sull'esportazione.

Struttura dell'output#

Dopo un'esportazione completata correttamente, 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. Contiene inoltre i metadati del modello, come i nomi delle classi, le dimensioni delle immagini e il task, in ONNX metadata_props.

Distribuzione dei modelli YOLO QNN esportati#

I modelli QNN vengono eseguiti sull'hardware Qualcomm supportato, rendendo semplice la distribuzione dei modelli sul dispositivo. Su un dispositivo compatibile con onnxruntime-qnn installato, esegui direttamente il modello esportato con l'API Ultralytics (yolo predict/yolo val, vedi Utilizzo sopra): Ultralytics carica il binario di contesto HTP tramite ONNX Runtime QNN Execution Provider.

Per le pipeline personalizzate, puoi anche caricare direttamente il binario di contesto ONNX con ONNX Runtime. onnxruntime-qnn è un Execution Provider aggiuntivo, quindi registralo durante l'esecuzione:

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 viene caricata rapidamente senza ricompilare il grafo sul dispositivo.

Requisiti per Linux e Yocto BSP#

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

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

Flusso di lavoro consigliato#

1. Addestra il tuo modello usando la modalità Addestra di Ultralytics
2. Esporta nel formato QNN usando 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 il QNN Execution Provider usando il backend HTP

Applicazioni nel mondo reale#

I modelli YOLO eseguiti sull'hardware Qualcomm Snapdragon sono adatti a un'ampia gamma di applicazioni di AI edge:

• Smartphone: Rilevamento degli oggetti in tempo reale e comprensione della scena nelle app fotocamera e foto con accelerazione NPU.
• Windows su Snapdragon: computer vision sul dispositivo nei PC Copilot+ senza trasferire i dati al cloud.
• Automotive: monitoraggio del conducente, rilevamento degli occupanti e funzionalità ADAS sulle piattaforme Snapdragon Digital Chassis.
• XR e dispositivi indossabili: percezione a basso consumo e bassa latenza per visori AR/VR e occhiali smart.
• IoT e robotica: inferenza visiva efficiente su videocamere, droni e sistemi embedded basati su Snapdragon.

Riepilogo#

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

La combinazione di Ultralytics YOLO e dello stack AI on-device di Qualcomm offre una soluzione efficace per eseguire carichi di lavoro avanzati di [computer vision](https://ultralytics-translation-1.invalid nell'ampio ecosistema Snapdragon.

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

FAQ#