Export Qualcomm QNN pour les modèles Ultralytics YOLO#

Le déploiement de modèles de vision par ordinateur sur les appareils Qualcomm Snapdragon nécessite un format de modèle optimisé pour le runtime Qualcomm AI Engine Direct (QNN). Exporter les modèles Ultralytics YOLO au format QNN te permet d'exécuter une inférence accélérée directement sur l'appareil, sur les processeurs Snapdragon, les GPU Adreno et les NPU Hexagon présents dans des milliards de téléphones mobiles, d'ordinateurs portables, de systèmes automobiles et d'appareils IoT. Ce guide explique comment exporter YOLO vers Qualcomm QNN et le déployer pour obtenir une inférence rapide et économe en énergie sur du matériel Snapdragon.

Qu'est-ce que Qualcomm QNN ?#

Qualcomm AI Engine Direct — généralement appelé QNN et distribué dans le cadre du SDK Qualcomm AI Runtime (QAIRT) — est la pile d'inférence bas niveau de Qualcomm pour les processeurs Snapdragon. Elle fournit une API unifiée avec des bibliothèques spécifiques à chaque backend, ciblant le processeur Snapdragon, le GPU Adreno et le Hexagon Tensor Processor (HTP), l'unité de traitement des réseaux neuronaux (NPU) dédiée intégrée aux SoC Snapdragon modernes. QNN donne aux développeurs un accès complet à ces accélérateurs d'IA Snapdragon et constitue le successeur moderne de l'ancien SDK Snapdragon Neural Processing Engine (SNPE). Il alimente l'IA directement sur l'appareil des plateformes mobiles Snapdragon 8 Gen 2, 8 Gen 3 et 8 Elite, des ordinateurs portables Snapdragon X, ainsi que des produits automobiles et XR.

Pourquoi exporter vers Qualcomm QNN ?#

Snapdragon est la plateforme de calcul mobile la plus déployée au monde. Exporter Ultralytics YOLO au format Qualcomm QNN permet d'exploiter le matériel d'IA dédié de ces appareils :

• Accélération par le NPU Hexagon : exécuter YOLO sur le Hexagon Tensor Processor offre un débit nettement supérieur et une consommation d'énergie plus faible qu'une inférence sur CPU — idéal pour l'inférence en temps réel et la vision par ordinateur permanente sur Snapdragon.
• Directement sur l'appareil et hors ligne : l'inférence QNN s'exécute entièrement sur l'appareil Snapdragon. Il n'y a donc aucun aller-retour vers le cloud, la latence reste faible et les données ne quittent jamais l'appareil.
• Efficacité de la quantification : l'export QNN quantifie YOLO avec des poids INT8 et des activations 16 bits, le compromis précision/performances privilégié du NPU Hexagon, ce qui réduit la taille du modèle et maximise le nombre d'images par seconde sur le matériel alimenté par batterie.
• Un format, de nombreux appareils : un seul export Qualcomm QNN cible le CPU Snapdragon, le GPU Adreno et le NPU Hexagon sur les familles Snapdragon 8 Gen 2, 8 Gen 3 et 8 Elite, et au-delà.
• Pile d'IA Qualcomm prête pour la production : QNN (Qualcomm AI Engine Direct / QAIRT) est le runtime d'IA actuel de Qualcomm, activement maintenu pour l'exécution sur appareil, et le remplacement recommandé de SNPE.

Format d'export QNN#

Ultralytics compile localement les modèles YOLO vers QNN à l'aide du fournisseur d'exécution QNN d'ONNX Runtime (le paquet installable avec pip onnxruntime-qnn, qui regroupe les bibliothèques QAIRT). L'exporteur convertit ton modèle en ONNX, le quantifie avec des données d'étalonnage en activations 16 bits et poids INT8 (le compromis recommandé pour le NPU Hexagon), puis initialise une session ONNX Runtime avec la mise en cache du contexte binaire activée — ce qui compile le graphe quantifié dans un contexte binaire QNN intégré à <model>_qnn.onnx. Aucun compte Qualcomm, téléversement vers le cloud ou téléchargement d'un SDK distinct n'est requis.

Contrairement à Qualcomm AI Hub, qui repose sur le cloud, compile et profile les modèles sur des appareils Snapdragon hébergés par Qualcomm et nécessite un compte Qualcomm, l'export QNN d'Ultralytics s'exécute entièrement sur ta propre machine avec un seul appel export(format="qnn", imgsz=640) (imgsz=224 pour la classification). Tu obtiens la même cible d'exécution QNN/QAIRT — CPU Snapdragon, GPU Adreno et NPU Hexagon — sans inscription, limites de téléversement ni temps d'attente en file, tout en l'intégrant directement au workflow d'export YOLO standard.

Le fichier *_qnn.onnx exporté est autonome : il intègre le contexte binaire QNN et les métadonnées ONNX telles que les noms de classes, la taille des images et la tâche.

Fonctionnalités clés des modèles QNN#

• Quantification : le modèle est quantifié avec des activations 16 bits et des poids INT8 à l'aide du flux QDQ QNN d'ONNX Runtime et d'un jeu de données d'étalonnage, conformément au compromis précision/performances recommandé pour le NPU Hexagon. En savoir plus sur la quantification des modèles.
• Compilation entièrement locale : le contexte binaire est généré entièrement sur ta machine hôte — aucun compte Qualcomm, jeton API ou téléversement vers le cloud.
• Accélération Snapdragon complète : exécute l'inférence sur le NPU Hexagon (HTP), le GPU Adreno ou le CPU via un runtime unifié unique.
• Large couverture des appareils : cible la vaste gamme de plateformes Snapdragon utilisées dans les téléphones, les PC (Windows on Snapdragon), les produits automobiles, XR et embarqués.
• Contexte binaire précompilé : fournir un contexte binaire réduit la compilation du graphe sur l'appareil et diminue la latence de chargement du modèle sur la cible.
• Sortie autonome : le fichier ONNX exporté inclut le contexte binaire QNN précompilé ainsi que les métadonnées pour un déploiement simplifié.

Performances mesurées#

Téléphone Android#

Matériel : Xiaomi 17 avec 12 Go de mémoire LPDDR5X et Android 16 / API 36. Son Snapdragon 8 Elite Gen 5 de 3 nm (SM8850) possède un CPU Qualcomm Oryon à 8 cœurs (2 cœurs Prime jusqu'à 4,6 GHz et 6 cœurs Performance jusqu'à 3,62 GHz), un GPU Adreno et un NPU Hexagon (HTP v81).

• Les valeurs de vitesse correspondent à des latences en rafale sur une image unique — la moyenne de 15 exécutions après 3 exécutions d'échauffement sur bus.jpg, mesurée avec le banc de test sur appareil 0.6.10 du plugin Flutter et les ressources standardisées v0.6.6. L'ordre des backends a alterné entre les tâches au cours d'un balayage séquentiel. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK, que chaque ligne GPU déléguait le graphe complet à LiteRT OpenCL (LITERT_CL) et que chaque ligne NPU utilisait le backend QNN Hexagon HTP.
• Le relevé détaillé des benchmarks se trouve dans la documentation sur les performances Flutter.
• Compare d'autres appareils Android dans l'intégration LiteRT et les appareils Apple dans l' intégration CoreML.

Ordinateur portable Windows on Snapdragon#

Ce balayage historique utilisait des binaires QNN v73 antérieurs à la standardisation ; la segmentation sémantique et OBB utilisaient des entrées de 1024 px. Il a été réalisé sur un ordinateur portable Lenovo doté de 32 Go de mémoire et de Windows 11. Son Snapdragon X Elite (X1E78100) possède un CPU Qualcomm Oryon à 12 cœurs, un GPU Adreno et un NPU Hexagon (HTP v73) ; le modèle Lenovo exact n'a pas été consigné. Cette comparaison Windows-on-Snapdragon confronte la référence native CPU PyTorch FP32, avec laquelle commencent la plupart des développeurs desktop, au chemin Hexagon HTP QNN d'ONNX Runtime. Chaque cellule affiche le temps total model.predict() avec les durées de prétraitement / inférence / post-traitement indiquées en dessous ; le total peut inclure une surcharge du framework en dehors de ces trois étapes. Les chiffres CPU sont ceux de PyTorch FP32 (torch==2.10.0+cpu) et ceux du NPU sont ceux d'ONNX Runtime QNN (onnxruntime-qnn==2.2.0, poids INT8 / activations 16 bits).

• Les valeurs de vitesse correspondent à des latences en rafale sur une image unique — la moyenne de 100 exécutions après 10 exécutions d'échauffement sur bus.jpg, mesurée avec time.perf_counter() autour de l'appel complet model.predict() sur un appareil thermiquement stabilisé (ultralytics==8.4.67, Python 3.12.10).
• Le NPU Hexagon est environ 2 à 4 fois plus rapide que la référence CPU PyTorch pour les tâches de 640 à 1024 px (détection : ~3.4x), l'écart se réduisant à ~1.3x sur le classifieur de 224 px, où la surcharge fixe du prétraitement domine la charge de travail réduite.

Tâches prises en charge#

L'export Qualcomm QNN prend en charge les sept tâches Ultralytics. La segmentation sémantique et l'estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui fournisse ces têtes.

Exporter vers QNN : convertir ton modèle YOLO#

Exporte un modèle Ultralytics YOLO au format QNN pour le déployer sur du matériel Qualcomm. Le contexte binaire est finalisé pour une architecture Hexagon Tensor Processor (HTP) cible ou un SoC pris en charge, que tu sélectionnes avec l'argument name — le même argument que celui utilisé pour cibler une puce lors de l'export RKNN.

Cibles HTP prises en charge#

Transmets l'architecture cible ou le SoC via name (par exemple name="73" ou name="iq-8275"). La prise en charge dépend de la cible HTP ; les lignes Snapdragon ci-dessous représentent donc des plateformes indicatives plutôt qu'une liste exhaustive de chaque SoC. Les appareils Dragonwing sont répertoriés explicitement.

Dragonwing IQ-615 ne peut pas utiliser l'export de contexte binaire QNN d'Ultralytics, car ONNX Runtime n'expose pas son DSP v66 comme cible HTP hors ligne. Un export ONNX standard peut néanmoins être intégré séparément avec un fournisseur d'exécution CPU ou GPU pris en charge par le BSP de la carte.

from ultralytics import YOLO

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

Installation#

Pour installer les packages requis, exécute :

# Install the required package for YOLO
pip install ultralytics

Le paquet onnxruntime-qnn (qui fournit le fournisseur d'exécution QNN d'ONNX Runtime et regroupe les bibliothèques QAIRT) est installé automatiquement lors du premier export. Pour obtenir des instructions détaillées et les bonnes pratiques liées au processus d'installation, consulte notre guide d'installation Ultralytics. Si tu rencontres des difficultés lors de l'installation des paquets requis pour YOLO, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.

Utilisation#

Le format QNN prend en charge les modes Export, Predict et Validate. L'inférence et la validation s'exécutent sur du matériel Qualcomm Snapdragon via le fournisseur d'exécution QNN d'ONNX Runtime (le même paquet onnxruntime-qnn que celui utilisé pour l'export). Exporte ton modèle, puis charge le modèle exporté sur un appareil Snapdragon pour exécuter l'inférence ou valider sa précision.

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

Arguments d'exportation#

Pour plus de détails sur le processus d’exportation, consulte la page de la documentation Ultralytics consacrée à l’exportation.

Structure de sortie#

Après un export réussi, un fichier ONNX autonome est créé :

Le fichier yolo26n_qnn.onnx intègre le binaire de contexte QNN et est chargé par ONNX Runtime avec le fournisseur d’exécution QNN sur l’appareil Snapdragon. Il contient également des métadonnées du modèle, telles que les noms des classes, la taille des images et la tâche, dans l’ONNX metadata_props.

Déployer des modèles YOLO QNN exportés#

Les modèles QNN s’exécutent sur le matériel Qualcomm pris en charge, ce qui simplifie le déploiement de modèles sur l’appareil. Sur un appareil compatible avec onnxruntime-qnn installé, exécute directement le modèle exporté avec l’API Ultralytics (yolo predict/yolo val, voir Utilisation ci-dessus) — Ultralytics charge le binaire de contexte HTP via le fournisseur d’exécution QNN d’ONNX Runtime.

Pour les pipelines personnalisés, tu peux également charger directement le binaire de contexte ONNX avec ONNX Runtime. onnxruntime-qnn est un fournisseur d’exécution sous forme de plug-in : enregistre-le donc lors de l’exécution :

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

Comme le binaire de contexte QNN est précompilé, la session se charge rapidement sans recompiler le graphe sur l’appareil.

Prérequis Linux et Yocto BSP#

La carte cible doit fournir un runtime Qualcomm et un BSP mutuellement compatibles. Pour l’inférence HTP, cela inclut le fournisseur d’exécution QNN d’ONNX Runtime, libQnnSystem.so, libQnnHtp.so, les bibliothèques stub et skeleton HTP v75 pour IQ-8275, la prise en charge de FastRPC dans l’espace utilisateur telle que libcdsprpc.so, le firmware DSP ainsi que les pilotes FastRPC/noyau correspondants. La bibliothèque skeleton doit être détectable via le chemin des bibliothèques DSP du BSP.

Ces composants côté cible proviennent du BSP compatible QAIRT/QNN du fabricant de la carte ; ils ne sont pas intégrés au modèle exporté. L’exécution sur GPU nécessite à la place libQnnGpu.so et la pile de pilotes Adreno correspondante dans l’espace utilisateur. La sortie Ultralytics format=qnn est un binaire de contexte spécifique à HTP : pour un déploiement sur GPU ou CPU, pars donc d’un export ONNX standard plutôt que du fichier précompilé *_qnn.onnx.

Flux de travail recommandé#

1. Entraîne ton modèle avec le mode Entraînement d'Ultralytics
2. Exporte au format QNN avec model.export(format="qnn", name="iq-8275", imgsz=640) sur une plateforme prise en charge (utilise imgsz=224 pour la classification)
3. Déploie le fichier *_qnn.onnx exporté sur ton appareil Qualcomm
4. Exécute l’inférence avec ONNX Runtime et le fournisseur d’exécution QNN en utilisant le backend HTP

Applications concrètes#

Les modèles YOLO exécutés sur du matériel Qualcomm Snapdragon conviennent parfaitement à un large éventail d’applications d’IA en périphérie :

• Smartphones : Détection d’objets en temps réel et compréhension des scènes dans les applications d’appareil photo et de photos, avec accélération NPU.
• Windows sur Snapdragon : vision par ordinateur sur l’appareil dans les PC Copilot+, sans transfert vers le cloud.
• Automobile : surveillance du conducteur, détection des occupants et fonctionnalités ADAS sur les plateformes Snapdragon Digital Chassis.
• XR et appareils portables : perception basse consommation et à faible latence pour les casques AR/VR et les lunettes connectées.
• IoT et robotique : inférence visuelle efficace sur les caméras, drones et systèmes embarqués fonctionnant avec Snapdragon.

Résumé#

Dans ce guide, tu as appris à exporter localement des modèles Ultralytics YOLO au format Qualcomm QNN avec le fournisseur d’exécution QNN d’ONNX Runtime. Le pipeline d’export convertit ton modèle en ONNX, puis le compile en binaire de contexte QNN sur ta machine hôte — sans compte Qualcomm ni cloud — et produit un fichier *_qnn.onnx optimisé pour le CPU Snapdragon, le GPU Adreno et le matériel NPU Hexagon via le runtime QNN/QAIRT.

La combinaison d’Ultralytics YOLO et de la pile d’IA sur appareil de Qualcomm fournit une solution efficace pour exécuter des charges de travail avancées de vision par ordinateur dans l’ensemble de l’écosystème Snapdragon.

Pour d’autres cibles de déploiement sur appareil et mobiles, consulte les guides d’export associés ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 et TensorRT. Pour comparer les formats avant la mise en production, utilise le mode Benchmark. Pour consulter la liste complète des formats et options, consulte la documentation du mode Export et la page du guide des intégrations.

FAQ#