Link to this sectionExportation 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 via le CPU Snapdragon, le GPU Adreno et le matériel NPU Hexagon présents dans des milliards de téléphones mobiles, ordinateurs portables, systèmes automobiles et appareils IoT. Ce guide décrit comment exporter YOLO vers Qualcomm QNN et le déployer pour une inférence rapide et économe en énergie sur du matériel Snapdragon.

Link to this sectionQu'est-ce que Qualcomm QNN ?#

Qualcomm AI Engine Direct — couramment 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 processeur CPU Snapdragon, le GPU Adreno et le Hexagon Tensor Processor (HTP), l'unité de traitement de réseau neuronal (NPU) dédiée à l'intérieur des SoC Snapdragon modernes. QNN offre 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 sur l'appareil à travers les plateformes mobiles Snapdragon 8 Gen 2, 8 Gen 3 et 8 Elite, les ordinateurs portables Snapdragon X, ainsi que les produits automobiles et XR.

Link to this sectionPourquoi 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 NPU Hexagon : Exécuter YOLO sur le Hexagon Tensor Processor offre un débit considérablement plus élevé et une consommation d'énergie plus faible qu'une inférence CPU — idéal pour l'inférence en temps réel et la vision par ordinateur toujours active 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é de quantification : L'exportation QNN quantifie YOLO en poids INT8 avec des activations 16 bits, l'équilibre précision/performance préféré du NPU Hexagon, réduisant la taille du modèle et maximisant les images par seconde sur le 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.

Link to this sectionFormat d'exportation QNN#

Ultralytics compile les modèles YOLO vers QNN localement en utilisant le fournisseur d'exécution QNN d'ONNX Runtime (le package onnxruntime-qnn installable via pip, 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 NPU Hexagon), puis initialise une session ONNX Runtime avec la mise en cache binaire du 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 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 les modèles sur des appareils Snapdragon hébergés par Qualcomm et nécessite un compte Qualcomm, l'exportation QNN d'Ultralytics s'exécute entièrement sur ta propre machine avec un simple appel export(format="qnn"). Tu obtiens la même cible de runtime QNN/QAIRT — CPU Snapdragon, GPU Adreno et NPU Hexagon — sans inscription, limites de téléchargement ou files d'attente, et cela s'intègre directement dans le workflow d'exportation standard de YOLO.

Le fichier exporté *_qnn.onnx 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.

Link to this sectionCaractéristiques clés des modèles QNN#

• Quantification : Le modèle est quantifié en activations 16 bits et poids INT8 avec le flux QDQ d'ONNX Runtime QNN et un jeu de données de calibration, l'équilibre précision/performance recommandé pour le NPU Hexagon. Apprends-en davantage 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é.

Link to this sectionPerformances mesurées#

Inférence de bout en bout sur image unique pour les modèles officiels YOLO26n sur un téléphone Xiaomi 17 équipé du Qualcomm Snapdragon 8 Elite Gen 5 (SM8850) — CPU Qualcomm Oryon, GPU Adreno et NPU Hexagon (HTP v81). Chaque cellule affiche le temps total (prétraitement + inférence + post-traitement, annotation exclue) avec le détail par étape en dessous. Le CPU et le GPU exécutent TFLite en INT8 via LiteRT ; le NPU exécute les binaires de contexte QNN (poids INT8, activations 16 bits).

• Les valeurs de vitesse sont des latences en rafale sur image unique — la moyenne de 15 exécutions après 3 exécutions de chauffe sur bus.jpg, mesurées avec l'outil de benchmark intégré au plugin Flutter sur un appareil au repos thermique. Les temps d'image caméra en temps réel soutenu sont plus élevés (letterboxing de capture par image plus stabilisation thermique) ; utilise le détail pré/inférence/post affiché dans l'application pour obtenir des chiffres en régime permanent sur ton appareil.
• ¹ QNN sémantique utilise la sortie de classe-map ArgMax intégrée au graphe depuis cette version, qui a remplacé le décodage erratique des logits de 123-1065 ms par un temps stable d'environ 49 ms ; le GPU reste légèrement plus rapide pour la sémantique à 1024px.

Link to this sectionTâches prises en charge#

L'exportation QNN prend en charge l'ensemble de tâches standard disponible dans chaque famille de modèles, y compris la segmentation sémantique YOLO26.

Link to this sectionExporter vers QNN : Convertir ton modèle YOLO#

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

Link to this sectionArchitectures HTP prises en charge#

Passe l'architecture cible via name (par ex. name="73"). Valeurs valides :

Link to this sectionInstallation#

Pour installer les paquets requis, exécute :

# Install the required package for YOLO
pip install ultralytics

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

Link to this sectionUtilisation#

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 package onnxruntime-qnn utilisé pour l'exportation). 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), 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")  # creates 'yolo26n_qnn.onnx'

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 sectionArguments d'exportation#

Pour plus de détails sur le processus d'exportation, visite la page de documentation Ultralytics sur l'exportation.

Link to this sectionStructure 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 contient également les métadonnées du modèle telles que les noms de classes, la taille de l'image et la tâche dans les metadata_props d'ONNX.

Link to this sectionDéployer des modèles YOLO QNN exportés#

Les modèles QNN s'exécutent sur du matériel Qualcomm Snapdragon, rendant le déploiement de modèle sur appareil simple. Sur un appareil Snapdragon 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 via le fournisseur d'exécution QNN d'ONNX Runtime et sélectionne le backend HTP (NPU), GPU ou CPU.

Pour des pipelines personnalisés, tu peux également charger le binaire de contexte ONNX directement avec ONNX Runtime. onnxruntime-qnn est un fournisseur d'exécution en 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)
outputs = session.run(None, {"images": input_tensor})  # input_tensor: float32 NCHW

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

Link to this sectionFlux de travail recommandé#

1. Entraîne ton modèle en utilisant le Mode Entraînement d'Ultralytics
2. Exporte vers le format QNN en utilisant model.export(format="qnn") sur une plateforme prise en charge (Windows x64 ou ARM64, ou Linux ARM64)
3. Déploie le fichier *_qnn.onnx exporté sur ton appareil Snapdragon
4. Exécute l'inférence avec ONNX Runtime et le fournisseur d'exécution QNN, en sélectionnant le backend HTP, GPU ou CPU

Link to this sectionApplications concrètes#

Les modèles YOLO s'exécutant sur du matériel Qualcomm Snapdragon sont bien adaptés à une large gamme d'applications d'IA en périphérie :

• Smartphones : Détection d'objets en temps réel et compréhension de scène dans les applications photo et caméra 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.

Link to this sectionRésumé#

Dans ce guide, tu as appris comment exporter des modèles Ultralytics YOLO au format Qualcomm QNN localement 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 — aucun compte Qualcomm ou cloud requis — produisant 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 embarquée de Qualcomm fournit une solution efficace pour exécuter des charges de travail de vision par ordinateur avancées à travers le vaste écosystème Snapdragon.

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

Link to this sectionFAQ#

Link to this sectionComment exporter mon modèle Ultralytics YOLO au format QNN ?#

Tu peux exporter ton modèle en utilisant la méthode export() en Python ou via la CLI avec format="qnn". L'exportation crée d'abord un modèle ONNX, puis le compile localement en un binaire de contexte QNN en utilisant le fournisseur d'exécution QNN d'ONNX Runtime. Le package onnxruntime-qnn est installé automatiquement lors de la première exportation.

from ultralytics import YOLO

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

Link to this sectionAi-je besoin d'un compte Qualcomm ou d'un accès cloud ?#

Non. L'exportation QNN s'exécute entièrement sur ta machine locale en utilisant le package onnxruntime-qnn, qui regroupe les bibliothèques QAIRT. Aucun compte Qualcomm, jeton API ou accès réseau n'est requis.

Link to this sectionComment l'exportation Ultralytics QNN se compare-t-elle au Qualcomm AI Hub ?#

Qualcomm AI Hub est le service cloud de Qualcomm pour compiler, profiler et évaluer les modèles sur des appareils Snapdragon hébergés, et il nécessite un compte Qualcomm. L'exportation QNN d'Ultralytics cible le même runtime QNN/QAIRT (CPU Snapdragon, GPU Adreno et NPU Hexagon) mais compile le binaire de contexte localement avec le fournisseur d'exécution QNN d'ONNX Runtime — sans compte, sans téléchargement et sans file d'attente. C'est le moyen le plus rapide de passer d'un modèle .pt à une version prête pour Snapdragon directement dans le workflow d'exportation standard de YOLO.

Link to this sectionSur quelles plateformes puis-je exporter ?#

onnxruntime-qnn fournit des wheels précompilés pour Windows (x64 et ARM64) et Linux ARM64 (aarch64) ; sur Linux x86-64, compile ONNX Runtime à partir des sources avec --use_qnn (aucun wheel précompilé n'est publié, et macOS n'est pas un hôte QNN pris en charge). La génération du binaire de contexte s'exécute sur un hôte x64 — Windows x64 ou Linux x86-64 — et ne nécessite pas d'appareil Snapdragon physique.

Link to this sectionComment exécuter YOLO sur un NPU Qualcomm Snapdragon ?#

Exporte avec model.export(format="qnn"), copie le fichier yolo26n_qnn.onnx résultant sur ton appareil Snapdragon, et exécute yolo predict model=yolo26n_qnn.onnx source=image.jpg (ou yolo val). Ultralytics charge le binaire de contexte via le fournisseur d'exécution QNN d'ONNX Runtime et l'exécute sur le NPU Hexagon — voir Déployer des modèles YOLO QNN exportés.

Link to this sectionQuelle est la différence entre QNN et SNPE ?#

QNN (Qualcomm AI Engine Direct, faisant partie du SDK QAIRT) est la pile d'inférence actuelle de Qualcomm et le remplacement recommandé pour l'ancien SDK Snapdragon Neural Processing Engine (SNPE). Les nouveaux déploiements devraient cibler QNN.

Link to this sectionPuis-je exécuter un modèle QNN avec yolo predict et yolo val ?#

Oui, sur un appareil Qualcomm Snapdragon avec onnxruntime-qnn installé — YOLO("yolo26n_qnn.onnx") charge le binaire de contexte via le fournisseur d'exécution QNN et exécute predict/val comme n'importe quel autre format. Sur un hôte x86 sans matériel QNN, le modèle ne peut pas s'exécuter, car le binaire de contexte cible le NPU Snapdragon.

Link to this sectionQuel est le résultat d'une exportation QNN ?#

L'exportation crée un fichier ONNX de binaire de contexte autonome (par ex., yolo26n_qnn.onnx) avec les noms de classes, la taille de l'image, la tâche et d'autres métadonnées de modèle intégrées dans les metadata_props d'ONNX.