Esportazione Qualcomm QNN per modelli YOLO di Ultralytics

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). Esportare i modelli Ultralytics YOLO nel formato QNN ti consente di eseguire inferenza accelerata on-device su hardware Snapdragon CPU, Adreno GPU e Hexagon NPU, presenti in miliardi di telefoni cellulari, laptop, sistemi automobilistici e dispositivi IoT. Questa guida illustra come esportare YOLO su Qualcomm QNN e come effettuarne il deployment per un'inferenza rapida e a basso consumo su hardware Snapdragon.

Cos'è Qualcomm QNN?

Qualcomm AI Engine Direct — commonly referred to as QNN and distributed as part of the Qualcomm AI Runtime (QAIRT) SDK — is Qualcomm's low-level inference stack for Snapdragon processors. It provides a unified API with backend-specific libraries that target the Snapdragon CPU, the Adreno GPU, and the Hexagon Tensor Processor (HTP), the dedicated neural network processing unit (NPU) inside modern Snapdragon SoCs. QNN gives developers full-stack access to these Snapdragon AI accelerators and is the modern successor to the older Snapdragon Neural Processing Engine (SNPE) SDK. It powers on-device AI across the Snapdragon 8 Gen 2, 8 Gen 3, and 8 Elite mobile platforms, Snapdragon X laptops, and automotive and XR products.

Perché esportare in Qualcomm QNN?

Snapdragon è la piattaforma di calcolo 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 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 INT8: L'esportazione QNN quantizza YOLO in INT8, la precisione nativa dell'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 consigliato per SNPE.

Formato di esportazione QNN

Ultralytics compila i modelli YOLO in QNN localmente utilizzando il QNN Execution Provider di ONNX Runtime (il pacchetto installabile tramite pip onnxruntime-qnn, che include le librerie QAIRT). L'exporter converte il tuo modello in ONNX, lo quantizza in INT8 con dati di calibrazione (l'Hexagon NPU è un acceleratore int8), quindi inizializza una sessione di ONNX Runtime con il caching del contesto binario abilitato — 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 di Qualcomm AI Hub basato sul 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"). Ottieni lo stesso target runtime QNN/QAIRT — CPU Snapdragon, GPU Adreno e Hexagon NPU — senza registrazione, limiti di caricamento o tempi di attesa in coda, e si integra direttamente nel flusso di lavoro di esportazione standard di YOLO.

La directory esportata _qnn_model/ include il binario di contesto ONNX e un file metadata.yaml che descrive i nomi delle classi, la dimensione dell'immagine e il task.

Caratteristiche principali dei modelli QNN

• Quantizzazione INT8: Il modello viene quantizzato in INT8 con il flusso QDQ di ONNX Runtime QNN e un dataset di calibrazione, corrispondente alla precisione nativa dell'Hexagon NPU per il massimo throughput e dimensioni minime. 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 sul cloud.
• Piena accelerazione Snapdragon: Esegui l'inferenza sull'Hexagon NPU (HTP), sulla GPU Adreno o sulla CPU tramite un unico runtime unificato.
• Ampia copertura di dispositivi: Punta all'ampia gamma di piattaforme Snapdragon presenti in telefoni, PC (Windows on Snapdragon), automotive, XR e prodotti embedded.
• Binario di contesto precompilato: Distribuire un binario di contesto minimizza la compilazione del grafo on-device, riducendo la latenza di caricamento del modello sul target.
• Output self-contained: La directory esportata include il binario di contesto ONNX e i metadati per un deployment immediato.

Attività supportate

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

Esportazione 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) target, che selezioni con l'argomento name — lo stesso argomento utilizzato per puntare a un chip nell'esportazione RKNN.

Architetture HTP supportate

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

Installazione

Per installare i pacchetti necessari, 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 necessari per YOLO riscontri difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Utilizzo

Il formato QNN supporta le modalità Esporta, Predici e Valida. L'inferenza e la convalida vengono eseguite sull'hardware Qualcomm Snapdragon tramite il QNN Execution Provider di ONNX Runtime (lo stesso pacchetto onnxruntime-qnn utilizzato per l'esportazione). Esporta il tuo modello, quindi caricalo 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 (Snapdragon 865, 888/8 Gen 1, 8 Gen 2, 8 Gen 3, 8 Elite)
model.export(format="qnn", name="73")  # creates 'yolo26n_qnn_model/'

from ultralytics import YOLO

# Load the exported QNN model (on a Snapdragon device with onnxruntime-qnn)
model = YOLO("yolo26n_qnn_model")

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

# 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 creata una directory del modello con il seguente layout:

yolo26n_qnn_model/
├── yolo26n_qnn.onnx   # ONNX wrapping the precompiled QNN context binary
└── metadata.yaml      # Model metadata (classes, image size, task, etc.)

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. Il metadata.yaml contiene nomi delle classi, dimensione dell'immagine e altre informazioni utilizzate dalla pipeline di Ultralytics.

Deployment di modelli YOLO QNN esportati

I modelli QNN vengono eseguiti sull'hardware Qualcomm Snapdragon, rendendo il deployment del modello on-device immediato. Su un dispositivo Snapdragon con onnxruntime-qnn installato, esegui il modello esportato direttamente con l'API Ultralytics (yolo predict/yolo val, vedi Utilizzo 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 plugin, 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_model/yolo26n_qnn.onnx", sess_options=options)
outputs = session.run(None, {"images": input_tensor})  # input_tensor: float32 NCHW

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

Flusso di lavoro consigliato

1. Addestra il tuo modello utilizzando la Modalità Training di Ultralytics
2. Esporta nel formato QNN utilizzando model.export(format="qnn") su una piattaforma supportata (Windows o Linux ARM64)
3. Esegui il deployment della directory _qnn_model/ esportata sul tuo dispositivo Snapdragon
4. Esegui l'inferenza con ONNX Runtime e il QNN Execution Provider, selezionando il backend HTP, GPU o CPU

Applicazioni 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 nelle app fotocamera e foto con accelerazione NPU.
• Windows on Snapdragon: Computer vision on-device nei PC Copilot+ senza scaricare dati sul cloud.
• Automotive: 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: Inferenza di visione efficiente su fotocamere, droni e sistemi embedded alimentati da Snapdragon.

Riepilogo

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 — nessun account Qualcomm o cloud richiesto — producendo un _qnn.onnx ottimizzato per hardware CPU Snapdragon, GPU Adreno 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 in tutto l'ampio ecosistema Snapdragon.

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

FAQ

Come esporto il mio modello Ultralytics YOLO nel formato QNN?

Puoi esportare il tuo modello utilizzando il metodo export() in Python o tramite CLI con format="qnn". L'esportazione crea prima un modello ONNX, quindi lo compila localmente in un binario di contesto QNN utilizzando il QNN Execution Provider di ONNX Runtime. Il pacchetto onnxruntime-qnn viene installato automaticamente alla prima esportazione.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="qnn")

Ho bisogno di un account Qualcomm o di accesso al cloud?

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

Come si confronta l'esportazione QNN di Ultralytics con Qualcomm AI Hub?

Qualcomm AI Hub è il servizio cloud di Qualcomm per compilare, profilare e benchmarkare 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 — nessun account, nessun caricamento e nessuna coda. È il modo più veloce per passare da un modello .pt a una build pronta per Snapdragon direttamente all'interno del flusso di lavoro standard di esportazione YOLO.

Su quali piattaforme posso esportare?

onnxruntime-qnn fornisce wheel stabili per Windows (x64 e ARM64) e Linux ARM64 (aarch64), più un wheel Linux x86-64 sul feed nightly di ONNX Runtime. macOS non ha wheel — compila ONNX Runtime dai sorgenti con --use_qnn o esporta su una piattaforma supportata. La generazione del binario di contesto viene eseguita su un host x64 e non richiede un dispositivo Snapdragon fisico.

Come eseguo YOLO su una NPU Qualcomm Snapdragon?

Esporta con model.export(format="qnn"), copia la directory risultante yolo26n_qnn_model sul tuo dispositivo Snapdragon ed esegui yolo predict model=yolo26n_qnn_model source=image.jpg (o yolo val). Ultralytics carica il binario di contesto tramite il QNN Execution Provider di ONNX Runtime ed esegue il tutto sull'Hexagon NPU — vedi Deployment di modelli YOLO QNN esportati.

Qual è 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 consigliato per il vecchio SDK Snapdragon Neural Processing Engine (SNPE). I nuovi deployment dovrebbero puntare a QNN.

Posso eseguire un modello QNN con yolo predict e yolo val?

Sì, su un dispositivo Qualcomm Snapdragon con onnxruntime-qnn installato — YOLO("yolo26n_qnn_model") 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.

Qual è l'output di un'esportazione QNN?

L'esportazione crea una directory (es. yolo26n_qnn_model/) contenente il binario di contesto ONNX (yolo26n_qnn.onnx) e un metadata.yaml con nomi delle classi, dimensione dell'immagine e informazioni sul task.