Exportation Qualcomm QNN pour les modèles YOLO d'Ultralytics#

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

Qu'est-ce que Qualcomm QNN ?#

Qualcomm AI Engine Direct — communément 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. Il fournit une API unifiée avec des bibliothèques spécifiques au backend qui ciblent le Snapdragon CPU, l'Adreno GPU et le Hexagon Tensor Processor (HTP), l'unité de traitement de réseaux de neurones (NPU) dédiée au sein des SoC Snapdragon modernes. QNN donne aux développeurs un accès complet à ces accélérateurs d'IA Snapdragon et succède au plus ancien SDK Snapdragon Neural Processing Engine (SNPE). Il alimente l'IA sur l'appareil à travers les plates-formes mobiles Snapdragon 8 Gen 2, 8 Gen 3 et 8 Elite, les ordinateurs portables Snapdragon X, ainsi que les produits automobiles et XR.

Pourquoi exporter vers Qualcomm QNN ?#

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

• Accélération par Hexagon NPU : Exécuter YOLO sur le Hexagon Tensor Processor offre un débit nettement supérieur et une consommation d'énergie inférieure à l'inférence sur processeur — idéal pour l'inférence en temps réel et la vision par ordinateur permanente sur Snapdragon.
• Sur l'appareil et hors ligne : L'inférence QNN s'exécute entièrement sur l'appareil Snapdragon ; il n'y a donc pas d'aller-retour avec le cloud, la latence reste faible et les données ne quittent jamais l'appareil.
• Efficacité quantifiée : L'export QNN quantifie YOLO en poids INT8 avec des activations sur 16 bits, l'équilibre précision/performance privilégié par le Hexagon NPU, réduisant la taille du modèle et maximisant les images par seconde sur du matériel alimenté par batterie.
• Un format, plusieurs appareils : Une seule exportation Qualcomm QNN cible le CPU Snapdragon, le GPU Adreno et le NPU Hexagon sur les familles Snapdragon 8 Gen 2, 8 Gen 3, 8 Elite et au-delà.
• Pile logicielle Qualcomm IA prête pour la production : QNN (Qualcomm AI Engine Direct / QAIRT) est l'actuel runtime IA embarqué de Qualcomm, activement maintenu et recommandé en remplacement de SNPE.

Format d'exportation QNN#

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

Contrairement au Qualcomm AI Hub basé sur le cloud, qui compile et profile des modèles sur des appareils 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 de runtime QNN/QAIRT — Snapdragon CPU, Adreno GPU et Hexagon NPU — sans inscription, sans limites de téléchargement ni temps d'attente, et il s'intègre directement dans le flux de travail d'export YOLO standard.

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

Caractéristiques clés des modèles QNN#

• Quantification : Le modèle est quantifié en activations 16 bits et poids INT8 avec le flux QDQ ONNX Runtime QNN et un jeu de données de calibration, l'équilibre précision/performance recommandé par le Hexagon NPU. En savoir plus sur la quantification de modèle.
• Compilation entièrement locale : Le binaire de contexte est généré entièrement sur ta machine hôte — aucun compte Qualcomm, jeton API ou téléchargement cloud requis.
• 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 portée d'appareils : Cible la vaste gamme de plateformes Snapdragon présentes dans les téléphones, PC (Windows on Snapdragon), systèmes automobiles, XR et produits embarqués.
• Binaire de contexte précompilé : Fournir un binaire de contexte minimise la compilation du graphe sur l'appareil, réduisant la latence de chargement du modèle sur la cible.
• Sortie autonome : Le fichier ONNX exporté inclut le binaire de contexte QNN précompilé et 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 3 nm (SM8850) dispose d'un processeur Qualcomm Oryon à 8 cœurs (2 cœurs Prime jusqu'à 4,6 GHz et 6 cœurs Performance jusqu'à 3,62 GHz), d'un Adreno GPU et d'un Hexagon NPU (HTP v81).

• Les valeurs de vitesse sont des latences en rafale pour une seule image — la moyenne de 15 exécutions après 3 exécutions d'échauffement sur bus.jpg, mesurées avec l'outil de benchmark sur l'appareil du plugin Flutter 0.6.10 et les composants standardisés v0.6.6. L'ordre des backends a alterné entre les tâches en un balayage séquentiel. Les journaux natifs ont confirmé que chaque ligne de processeur utilisait LiteRT CPU/XNNPACK, que chaque ligne de GPU déléguait le graphe complet à LiteRT OpenCL (LITERT_CL), et que chaque ligne de NPU utilisait le backend QNN Hexagon HTP.
• Le rapport de benchmark détaillé se trouve dans la documentation sur les performances de 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 a utilisé des binaires QNN v73 pré-standardisés ; la sémantique et l'OBB ont utilisé des entrées de 1024 px. Il a été exécuté sur un ordinateur portable Lenovo avec 32 Go de mémoire et Windows 11. Son Snapdragon X Elite (X1E78100) possède un processeur Qualcomm Oryon à 12 cœurs, un Adreno GPU et un Hexagon NPU (HTP v73) ; le modèle Lenovo exact n'a pas été enregistré. Cette comparaison Windows-sur-Snapdragon exécute la base de référence CPU PyTorch FP32 native que la plupart des développeurs de bureau utilisent par rapport au chemin ONNX Runtime QNN Hexagon HTP. Chaque cellule montre le temps total model.predict() avec les temps de prétraitement / inférence / post-traitement signalés en dessous ; le total peut inclure la surcharge du framework en dehors de ces trois étapes. Les chiffres du CPU sont PyTorch FP32 (torch==2.10.0+cpu) et les chiffres du NPU sont ONNX Runtime QNN (onnxruntime-qnn==2.2.0, poids INT8 / activations 16 bits).

• Les valeurs de vitesse sont des latences en rafale pour une seule image — la moyenne de 100 exécutions après 10 exécutions d'échauffement sur bus.jpg, mesurées avec time.perf_counter() autour de l'appel complet model.predict() sur un appareil au repos thermique (ultralytics==8.4.67, Python 3.12.10).
• Le NPU Hexagon s'exécute environ 2-4 fois plus vite que la référence PyTorch CPU sur les tâches de 640-1024 px (détection ~3.4x), pour se réduire à ~1.3x sur le classificateur 224 px où la surcharge fixe de prétraitement domine la charge de travail minuscule.

Tâches prises en charge#

L'export Qualcomm QNN prend en charge les sept t%u00e2ches Ultralytics. La segmentation s%u00e9mantique et l'estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui int%u00e8gre ces t%u00eates.

Exporter vers QNN : Convertir ton modèle YOLO#

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

Cibles HTP prises en charge#

Passe l'architecture ou le SoC cible via name (par exemple, name="73" ou name="iq-8275"). La prise en charge est déterminée par la cible HTP, de sorte que les lignes Snapdragon ci-dessous sont des plates-formes représentatives plutôt qu'une liste exhaustive de chaque SoC. Les appareils Dragonwing sont listés explicitement.

Dragonwing IQ-615 ne peut pas utiliser l'export de binaire de contexte Ultralytics QNN car ONNX Runtime n'expose pas son DSP v66 en tant que cible HTP hors ligne. Un export ONNX standard peut toujours ê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 paquets requis, exécute :

# Install the required package for YOLO
pip install ultralytics

Le paquet onnxruntime-qnn (qui fournit le fournisseur d'exécution ONNX Runtime QNN et regroupe les bibliothèques QAIRT) est installé automatiquement lors du premier export. Pour des instructions détaillées et les meilleures pratiques relatives 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 le matériel Qualcomm Snapdragon via le fournisseur d'exécution QNN d'ONNX Runtime (le même paquet onnxruntime-qnn 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, visite la page de documentation d'Ultralytics sur l'exportation.

Structure de sortie#

Après une exportation réussie, 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 transporte également des métadonnées du modèle telles que les noms de classes, la taille de l'image et la tâche dans metadata_props ONNX.

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

Les modèles QNN s'exécutent sur du 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 le modèle exporté directement 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 fichier ONNX du binaire de contexte avec ONNX Runtime. onnxruntime-qnn est un fournisseur d'exécution de plugin, alors enregistre-le au moment 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

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

Exigences du BSP Linux et Yocto#

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 de stub et squelette HTP v75 pour IQ-8275, la prise en charge de l'espace utilisateur FastRPC telle que libcdsprpc.so, le firmware DSP et les pilotes FastRPC/noyau correspondants. La bibliothèque squelette doit pouvoir être découverte via le chemin de la bibliothèque DSP du BSP.

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

Flux de travail recommandé#

1. Entraîne ton modèle en utilisant le Mode Entraînement d'Ultralytics
2. Exporte au format QNN en utilisant model.export(format="qnn", name="iq-8275", imgsz=640) sur une plate-forme 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 de scènes dans les applications d'appareil photo et de photos avec accélération NPU.
• Windows on Snapdragon : Vision par ordinateur sur appareil dans les PC Copilot+ sans déchargement 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 puissance et basse latence pour les casques AR/VR et lunettes intelligentes.
• IoT et robotique : Inférence de vision efficace sur les caméras, drones et systèmes embarqués alimentés par Snapdragon.

Résumé#

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

La combinaison d'Ultralytics YOLO et de la pile d'IA sur l'appareil de Qualcomm constitue une solution efficace pour exécuter des charges de travail avancées de vision par ordinateur à travers l'écosystème Snapdragon étendu.

Pour d'autres cibles de déploiement mobile et sur l'appareil, consulte les guides d'exportation associés ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 et TensorRT. Pour comparer les formats avant le déploiement, utilise le mode Benchmark. Pour obtenir la liste complète des formats et des options, consulte la documentation du mode Export et la page du guide des intégrations.

FAQ#