Export ST Edge AI des modèles Ultralytics YOLO
Exporte les modèles Ultralytics YOLO avec format="stedgeai" pour obtenir un modèle ONNX adapté à ST Edge AI Core, la chaîne d’outils STMicroelectronics qui compile les réseaux neuronaux pour les microcontrôleurs STM32, y compris le STM32N6 et son accélérateur Neural-ART. L’export écrit par défaut un modèle flottant et un modèle INT8 entièrement quantifié avec quantize=8. Ultralytics exécute chacun de ces fichiers sur ton ordinateur avec yolo predict et yolo val, pour que tu puisses mesurer la précision avant de compiler pour l’appareil.
Ultralytics valide ces modèles avec ONNX Runtime sur un ordinateur, et STMicroelectronics a compilé avec ST Edge AI Core les exports INT8 des sept tâches pour le STM32N6. La mesure de la précision, de la latence et de la mémoire sur une carte STM32 fait partie des étapes à effectuer avec les outils ST ; consulte Déployer sur STM32.
Pourquoi un format ST Edge AI dédié ?#
Les microcontrôleurs exécutent des modèles INT8, et un export ONNX standard ne se quantifie pas bien de bout en bout :
- Plages mixtes dans une même sortie. Une tête de détection YOLO regroupe les coordonnées des boîtes en pixels (environ
0à640) et les scores de classe (0à1) dans un seul tenseur. La quantification INT8 attribue une seule échelle à ce tenseur, si bien que les scores perdent presque toute leur résolution. L’export ST Edge AI normalise les coordonnées des boîtes et des points clés par rapport à la taille d’entrée pour les ramener à[0, 1], selon la même normalisation qu’Ultralytics utilise pour Edge TPU, ce qui permet de quantifier le graphe entier. - Sorties denses volumineuses. Les modèles de segmentation sémantique et de profondeur suréchantillonnent normalement leurs sorties à la résolution d’entrée dans le graphe. L’export ST Edge AI s’arrête avant ce suréchantillonnage : le tampon de sortie est ainsi 64 fois plus petit pour la segmentation sémantique et 16 fois plus petit pour la profondeur, qui reste dans le domaine logarithmique où les niveaux INT8 sont répartis uniformément.
- Post-traitement dans le graphe. La NMS intégrée et la tête sans NMS de YOLO26 ajoutent des opérateurs TopK et gather après la tête. L’export les omet et renvoie toujours les prédictions brutes ; la NMS est donc exécutée dans ton application.
Si tu préfères la disposition standard (coordonnées en pixels, cartes en pleine résolution, NMS intégrée facultative), utilise l’export ONNX.
Tâches prises en charge#
Toutes les tâches Ultralytics YOLO s’exportent et s’exécutent sur la machine hôte. Les formes des sorties correspondent à imgsz=640 :
| Tâche | Sortie |
|---|---|
| Détection | [1, 4 + nc, 8400] : boîtes normalisées par rapport à [0, 1], scores de classe |
| Segmentation d'instances | [1, 4 + nc + 32, 8400] avec des boîtes normalisées par rapport à [0, 1], plus les prototypes de masque [1, 32, 160, 160] |
| Segmentation sémantique | Logits de classe [1, nc, 80, 80] à une résolution de 1/8 ; suréchantillonne, puis prends l’argmax par pixel |
| Estimation de profondeur | Profondeur logarithmique [1, 1, 160, 160] à une résolution de 1/4 ; applique exp(x) pour obtenir la profondeur métrique, puis suréchantillonne |
| Classification | Probabilités de classe [1, nc] |
| Estimation de pose | [1, 4 + nc + nk, 8400] : boîtes et points clés normalisés par rapport à [0, 1] |
| Détection orientée | [1, 4 + nc + 1, 8400] : boîtes normalisées par rapport à [0, 1], angle en radians ; nécessite un imgsz carré |
Les modèles RT-DETR et YOLO-NAS ne sont pas pris en charge.
Utilisation#
from ultralytics import YOLO
# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")
# Exporter un modèle flottant
model.export(format="stedgeai") # crée 'yolo26n_stedgeai.onnx'
# Exporter un modèle INT8 calibré sur COCO8
model.export(format="stedgeai", quantize=8, data="coco8.yaml") # crée 'yolo26n_int8_stedgeai.onnx'from ultralytics import YOLO
# Charger le modèle ST Edge AI exporté
model = YOLO("yolo26n_int8_stedgeai.onnx")
# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")
# Mesurer la précision INT8 sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")Chaque export écrit un seul fichier. Ultralytics reconnaît les modèles ST Edge AI grâce au suffixe _stedgeai.onnx, puis remet les coordonnées à l’échelle des pixels, suréchantillonne les cartes sémantiques et de profondeur, et convertit la profondeur logarithmique en profondeur métrique. Conserve ce suffixe lorsque tu renommes un fichier ; un nom .onnx ordinaire charge le fichier comme un modèle ONNX standard et renvoie les boîtes en [0, 1].
Arguments d’exportation#
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
format | str | 'stedgeai' | Format cible du modèle exporté. |
imgsz | int ou tuple | 640 | Taille d’entrée du modèle, sous forme d’un entier pour les images carrées ou d’un tuple (height, width). Le modèle a une taille de lot fixe de 1 et des formes statiques. Les modèles OBB nécessitent un imgsz carré. |
quantize | int ou str | None | Précision. Si cette valeur est omise ou vaut 32, un modèle flottant est écrit ; 8 écrit un modèle INT8. |
data | str | None | Jeu de données utilisé pour le calibrage INT8 : un fichier YAML de jeu de données, ou un répertoire de jeu de données ou un nom de jeu de données intégré pour la classification. Sans cette valeur, quantize=8 utilise le jeu de données par défaut de la tâche, par exemple coco8.yaml pour la détection. |
fraction | float | 1.0 | Fraction du jeu de données d’étalonnage à utiliser. |
opset | int | None | Opset ONNX. Par défaut, il s’agit de l’opset le plus récent que ta version de PyTorch exporte de manière fiable. |
simplify | bool | True | Simplifie le graphe ONNX avec onnxslim. |
device | str | None | Appareil utilisé pour l’export : GPU (device=0) ou CPU (device=cpu). |
batch et dynamic=True sont refusés, et nms=True revient aux sorties brutes avec un avertissement.
Quantification INT8#
Avec quantize=8, Ultralytics quantifie le modèle au moyen de la quantification statique d’ONNX Runtime, selon la méthode recommandée par ST Edge AI Core et appliquée par les STM32 AI Model Zoo Services :
- Format QDQ (QuantizeLinear/DequantizeLinear) avec des entrées et sorties de modèle flottantes.
- Poids INT8 signés, symétriques et par canal, et activations INT8 signées et asymétriques.
- Calibrage MinMax sur les images
data, prétraitées exactement comme lors de la validation Ultralytics.
Contrairement à l’export ONNX quantize=8 standard, qui laisse la tête en flottant, chaque opérateur est quantifié. Pour effectuer la quantification avec les outils ST, exporte le modèle flottant et transmets-le aux STM32 AI Model Zoo Services.
La précision INT8 dépend de la ressemblance entre les images de calibrage et la scène de déploiement. Fournis à data= un jeu de données contenant au moins 300 images représentatives ; les jeux de données de calibrage par défaut ne contiennent que quelques exemples publics.
Le tableau ci-dessous compare YOLO26n avec la valeur par défaut de imgsz pour chaque modèle (640, 1024 pour la segmentation sémantique, 768 pour la profondeur), sur les petits jeux de données de validation par défaut, calibrés avec ces mêmes images. Ces jeux de données ne comportent que 4 à 8 images chacun : considère donc ces résultats comme une indication des tâches sensibles à INT8 et évalue ton propre modèle avec yolo val.
| Tâche | Mesure | ONNX flottant | ST Edge AI flottant | ST Edge AI INT8 |
|---|---|---|---|---|
| Détection | mAP50-95 | 0.686 | 0.686 | 0.639 |
| Segmentation | mAP50-95 des boîtes / masques | 0.638 / 0.540 | 0.638 / 0.540 | 0.356 / 0.401 |
| Sémantique | mIoU | 0.610 | 0.610 | 0.609 |
| Profondeur | delta1 | 0.852 | 0.852 | 0.840 |
| Pose | mAP50-95 des boîtes / poses | 0.697 / 0.459 | 0.697 / 0.459 | 0.650 / 0.267 |
| OBB | mAP50-95 | 0.894 | 0.894 | 0.806 |
L’export flottant correspond à l’export ONNX standard pour toutes les tâches. La segmentation d’instances et l’estimation de pose perdent le plus en précision avec la quantification INT8 de l’ensemble du graphe, car les coefficients de masque et les points clés partagent une seule échelle de sortie avec les boîtes ; valide soigneusement ces deux tâches sur tes propres données avant le déploiement.
Déployer sur STM32#
-
Exporte le modèle avec
format="stedgeai", en utilisant leimgszque tu exécuteras sur l’appareil. -
Valide les modèles flottant et INT8 sur ton jeu de données avec
yolo val. -
Compile le modèle avec ST Edge AI Core. Les commandes ci-dessous suivent la documentation de la ligne de commande de ST Edge AI Core et le guide de démarrage Neural-ART ; consulte ces ressources pour les profils mémoire et les options d’entrée.
# Report the model's memory and operator usage for an STM32 target stedgeai analyze -m yolo26n_int8_stedgeai.onnx --target stm32 # Generate the C model for an STM32N6 with the Neural-ART accelerator stedgeai generate -m yolo26n_int8_stedgeai.onnx --target stm32n6 --st-neural-art -
Déploie le modèle généré dans ton application STM32. Les STM32 AI Model Zoo Services fournissent du code d’application et des tutoriels pour les modèles Ultralytics YOLO sur le STM32N6.
Le code qui lit le modèle exporté en dehors d’Ultralytics, par exemple le post-traitement en C sur l’appareil, doit multiplier les valeurs x et w des boîtes et des points clés par la largeur de l’entrée, et les valeurs y et h par sa hauteur, exécuter la NMS, suréchantillonner les logits sémantiques avant l’argmax et appliquer exp à la sortie de profondeur avant de la suréchantillonner. Conserve imgsz à l’identique pendant l’entraînement, l’export et le déploiement.
FAQ#
Exécute
yolo export model=yolo26n.pt format=stedgeai quantize=8 data=coco8.yamlpour écrire le modèle INT8yolo26n_int8_stedgeai.onnx, ou ometsquantize=8pour écrire le modèle flottantyolo26n_stedgeai.onnx. Compile ensuite le fichier avec ST Edge AI Core, comme indiqué dans Déployer sur STM32.L’export ST Edge AI normalise les coordonnées des boîtes et des points clés par rapport à la taille d’entrée, afin qu’elles partagent la même plage
[0, 1]que les scores de classe et que le graphe entier puisse être quantifié en INT8. Multipliexetwpar la largeur de l’entrée, etyethpar sa hauteur pour retrouver les pixels. Ultralytics effectue cette opération automatiquement lorsqu’il charge un modèle_stedgeai.onnx.Non. L’export renvoie toujours les prédictions brutes : exécute donc la NMS dans ton application ou utilise le post-traitement des STM32 AI Model Zoo Services.
L’export ONNX standard renvoie des coordonnées en pixels et des cartes sémantiques et de profondeur en pleine résolution, peut intégrer la NMS et, avec
quantize=8, ne quantifie que les couches de convolution et de multiplication matricielle. L’export ST Edge AI renvoie des coordonnées normalisées, des logits sémantiques à basse résolution et une profondeur logarithmique, a une taille de lot fixe de 1, n’intègre jamais la NMS et, avecquantize=8, quantifie l’ensemble du graphe.Oui.
yolo val model=yolo26n_int8_stedgeai.onnx data=coco8.yamlexécute le modèle quantifié avec ONNX Runtime sur ton ordinateur et indique les mêmes métriques que tout autre modèle Ultralytics. La précision sur l’appareil peut toutefois différer légèrement : vérifie-la avec les outils ST après la compilation.
Commentaires
Pose une question, partage tes résultats ou aide quelqu’un d’autre.