Exportation Qualcomm QNN pour les modèles Ultralytics YOLO

Le déploiement de 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). L'exportation de modèles Ultralytics YOLO au format QNN te permet d'exécuter des inférences accélérées sur appareil, sur les processeurs Snapdragon CPU, Adreno GPU et Hexagon NPU présents dans des milliards de téléphones mobiles, d'ordinateurs portables, de systèmes automobiles et d'appareils IoT. Ce guide t'explique comment exporter YOLO vers Qualcomm QNN et le déployer pour une inférence rapide et économe en énergie sur le 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. Elle fournit une API unifiée avec des bibliothèques spécifiques au backend qui ciblent le CPU Snapdragon, le GPU Adreno et le processeur Hexagon Tensor (HTP), l'unité de traitement de réseaux neuronaux (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 est le successeur moderne de l'ancien SDK Snapdragon Neural Processing Engine (SNPE). Il alimente l'IA sur appareil pour les plateformes mobiles Snapdragon 8 Gen 2, 8 Gen 3 et 8 Elite, les ordinateurs portables Snapdragon X, ainsi que pour 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 d'IA dédié sur ces appareils :

• Accélération Hexagon NPU : Exécuter YOLO sur le processeur Hexagon Tensor offre un débit nettement plus élevé 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 toujours active sur Snapdragon.
• Sur appareil et hors ligne : L'inférence QNN s'exécute entièrement sur l'appareil Snapdragon ; il n'y a donc pas d'allers-retours vers le cloud, la latence reste faible et les données ne quittent jamais l'appareil.
• Efficacité INT8 : L'exportation QNN quantifie YOLO en INT8, la précision native 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 : 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 d'IA Qualcomm prête pour la production : QNN (Qualcomm AI Engine Direct / QAIRT) est l'actuel runtime d'IA sur appareil de Qualcomm, activement maintenu et recommandé en remplacement de SNPE.

Format d'exportation QNN

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

Le répertoire exporté _qnn_model/ regroupe le binaire de contexte ONNX et un metadata.yaml décrivant les noms de classes, la taille de l'image et la tâche.

Fonctionnalités clés des modèles QNN

• Quantification INT8 : Le modèle est quantifié en INT8 avec le flux QDQ de ONNX Runtime QNN et un jeu de données de calibration, correspondant à la précision native du NPU Hexagon pour un débit maximal et une taille minimale. Apprends-en 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 — pas de compte Qualcomm, de jeton API ou de téléchargement 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 portée des appareils : Cible la vaste gamme de plateformes Snapdragon présentes dans les téléphones, les PC (Windows on Snapdragon), les produits automobiles, XR et embarqués.
• Binaire de contexte précompilé : L'utilisation d'un binaire de contexte minimise la compilation de graphe sur l'appareil, réduisant ainsi la latence de chargement du modèle sur la cible.
• Sortie autonome : Le répertoire exporté inclut le binaire de contexte ONNX et les métadonnées pour un déploiement simplifié.

Tâ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.

Exporter 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 processeur Hexagon Tensor (HTP) cible, que tu sélectionnes avec l'argument name — le même argument utilisé pour cibler une puce dans l'exportation RKNN.

Architectures HTP prises en charge

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

Installation

Pour installer les packages requis, exécute :

# Install the required package for YOLO
pip install ultralytics

Le package onnxruntime-qnn (qui fournit le fournisseur d'exécution QNN de 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 des solutions et des astuces.

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

Arguments d'exportation

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

Structure de sortie

Après une exportation réussie, un répertoire de modèle est créé avec la disposition suivante :

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

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. Le metadata.yaml contient les noms de classes, la taille de l'image et d'autres informations utilisées par le pipeline Ultralytics.

Déploiement des modèles YOLO QNN exportés

Les modèles QNN s'exécutent sur le matériel Qualcomm Snapdragon, ce qui rend 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 de ONNX Runtime et sélectionne le backend HTP (NPU), GPU ou CPU.

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

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

Workflow 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 ou Linux ARM64)
3. Déploie le répertoire _qnn_model/ 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

Applications concrètes

Les modèles YOLO s'exécutant sur du matériel Qualcomm Snapdragon sont bien adaptés à 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è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 wearables : Perception à faible consommation et faible latence pour les casques AR/VR et les 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 au format Qualcomm QNN localement avec le fournisseur d'exécution QNN de 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 _qnn.onnx optimisé pour le matériel CPU Snapdragon, GPU Adreno et NPU Hexagon via le runtime QNN/QAIRT.

La combinaison d'Ultralytics YOLO et de la pile d'IA sur appareil de Qualcomm offre 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 mobiles, consulte les guides d'exportation associés ONNX, CoreML, NCNN, TFLite, ExecuTorch, RKNN, Sony IMX500 et TensorRT. Pour comparer les formats avant de publier, utilise le Mode Benchmark. Pour la liste complète des formats et options, visite la documentation du Mode Export et la page du guide des intégrations.

FAQ

Comment 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 l'interface 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 de 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")

Ai-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.

Comment 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 comparer des modèles sur des appareils Snapdragon hébergés, et il nécessite un compte Qualcomm. L'exportation Ultralytics QNN 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 de 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.

Sur quelles plateformes puis-je exporter ?

onnxruntime-qnn fournit des wheels stables pour Windows (x64 et ARM64) et Linux ARM64 (aarch64), ainsi qu'un wheel Linux x86-64 sur le flux nightly de ONNX Runtime. macOS n'a pas de wheel — construis ONNX Runtime à partir du code source avec --use_qnn ou effectue l'exportation sur une plateforme prise en charge. La génération du binaire de contexte s'exécute sur un hôte x64 et ne nécessite pas d'appareil Snapdragon physique.

Comment exécuter YOLO sur un NPU Qualcomm Snapdragon ?

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

Quelle est la différence entre QNN et SNPE ?

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

Puis-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_model") 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.

Quel est le résultat d'une exportation QNN ?

L'exportation crée un répertoire (par ex. yolo26n_qnn_model/) contenant le binaire de contexte ONNX (yolo26n_qnn.onnx) et un metadata.yaml avec les noms de classes, la taille de l'image et les informations de tâche.