Exportation de modèles avec Ultralytics YOLO
Introduction#
L’objectif de l’entraînement d’un modèle est généralement de le déployer dans des applications réelles. Le mode Export d’Ultralytics YOLO26 convertit ton modèle entraîné dans différents formats afin qu’il puisse fonctionner sur diverses plateformes et divers appareils. Ce guide couvre l’utilisation de l’exportation, ses arguments, les formats pris en charge et les options de quantification.
Consulte l’aperçu de YOLO27 non encore publié pour découvrir les formats d’exportation prévus.
Regarder : Comment exporter Ultralytics YOLO26 dans différents formats pour le déploiement | ONNX, TensorRT, CoreML 🚀
Pourquoi choisir le mode d’exportation de YOLO26 ?#
- Polyvalence : exportation vers plusieurs formats, notamment ONNX, TensorRT, CoreML et bien d’autres.
- Performances : jusqu’à 5 fois plus de vitesse sur GPU avec TensorRT et 3 fois plus de vitesse sur CPU avec ONNX ou OpenVINO.
- Compatibilité : déploie ton modèle dans un large éventail d’environnements matériels et logiciels.
- Simplicité d’utilisation : exporte ton modèle avec une seule commande CLI ou un appel Python.
Exemples d'utilisation#
Exporte un modèle YOLO26n dans un autre format, comme ONNX ou TensorRT.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt") # charger un modèle officiel
model = YOLO("path/to/best.pt") # charger un modèle entraîné personnalisé
# Exporter le modèle
model.export(format="onnx")Arguments#
Ce tableau répertorie les arguments disponibles pour exporter les modèles YOLO dans différents formats. Ils contrôlent les performances et la taille du modèle exporté, ainsi que sa compatibilité avec la plateforme et l’environnement cibles.
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
format | str | 'torchscript' | Format cible du modèle exporté, par exemple 'onnx', 'torchscript', 'engine' (TensorRT) ou autres. Chaque format permet la compatibilité avec différents environnements de déploiement. |
name | str | None | Nom du matériel cible pour les formats qui en ont besoin : architecture Hailo ('hailo8', 'hailo8l', 'hailo10h', 'hailo15h', 'hailo15l' ; valeur par défaut : 'hailo8l'), puce Rockchip RKNN (valeur par défaut : 'rk3588'), SoC Huawei Ascend (un CANN --soc_version ; valeur par défaut : 'Ascend310B4'), cible Qualcomm QNN HTP (valeur par défaut : '73') ou appareil AMD Xilinx Versal AI Edge Series Gen 2 (valeur par défaut : 've2-xc2ve3858', le kit d’évaluation VEK385). Différent de la paire de nommage d’exécution project/name utilisée par les autres modes. |
imgsz | int ou tuple | 640 | Taille d’image souhaitée pour l’entrée du modèle. Peut être un entier pour des images carrées (par ex. 640 pour 640×640) ou un tuple (height, width) pour des dimensions spécifiques. Si cette valeur n’est pas fournie, l’export réutilise la taille d’entraînement enregistrée dans le point de contrôle chargé : les points de contrôle YOLO26 officiels indiquent 1024 pour les modèles sémantiques préentraînés sur Cityscapes (yolo26n-sem.pt), 768 pour la profondeur, 224 pour la classification, 1024 pour OBB et 640 pour les autres tâches, y compris les modèles sémantiques préentraînés sur ADE20K (yolo26n-sem-ade20k.pt), tandis qu’un modèle affiné enregistre la valeur imgsz utilisée lors de son entraînement. Un modèle créé à partir d’un YAML ne possède aucune taille d’entraînement enregistrée et utilise 640. |
optimize | bool | False | Active une optimisation plus poussée du compilateur pour DEEPX, ce qui réduit la latence d'inférence tout en augmentant le temps de compilation. |
quantize | int ou str | None | Précision de quantification : 16 (FP16, réduit la taille du modèle et peut accélérer l’inférence sur le matériel compatible) ou 8 (INT8/PTQ, compresse davantage le modèle avec une perte minimale de précision, principalement pour les appareils en périphérie ; nécessite une calibration data/fraction) ; 32 sélectionne FP32 si cette option est prise en charge ; si ce paramètre n’est pas défini, FP32 est utilisé, sauf si la cible exige une quantification, par exemple INT8 pour NXP. Un checkpoint entraîné avec quantize=8 est toujours exporté en INT8 : onnx et engine sont exportés à partir des plages qu’il contient, sans calibration, et les autres formats ou précisions sont refusés. 'w8a8' et 'w16a16' sont des alias de 8 et 16 ; les précisions mixtes 'w8a16' (poids INT8 et activations 16 bits : CoreML, LiteRT, QNN) et 'w8a32' (INT8 dynamique : LiteRT) sont acceptées uniquement par ces formats. Remplace les options obsolètes half/int8 (half=True → 16, int8=True → 8, toujours acceptées avec un avertissement de dépréciation). Seules les précisions prises en charge par le format cible sont autorisées (voir ci-dessous). |
dynamic | bool | False | Permet d'utiliser des tailles d'entrée dynamiques pour les exportations TorchScript, ONNX, OpenVINO, TensorRT, CoreML et MNN, offrant une plus grande flexibilité pour traiter des images de dimensions variées. |
simplify | bool | True | Simplifie le graphe ONNX intermédiaire avec onnxslim pour les exportations qui en génèrent un (voir Formats d'exportation), ce qui peut améliorer les performances et la compatibilité avec les moteurs d'inférence. |
opset | int | None | Indique la version de l'opset ONNX pour les exports qui construisent un graphe ONNX (voir Formats d'export), afin d'assurer la compatibilité avec différents analyseurs et moteurs d'exécution ONNX. Si elle n'est pas définie, utilise l'opset 18 (une version inférieure avec PyTorch < 2.4), sans dépasser la version onnx installée. Les exports RKNN, Ascend, AMD Xilinx, Hailo et RT-DETR TensorFlow définissent leur propre opset. |
workspace | float ou None | None | Définit la taille maximale de l'espace de travail, en Gio, pour les optimisations TensorRT, afin d'équilibrer l'utilisation mémoire et les performances. Utilise None pour laisser TensorRT allouer automatiquement jusqu'à la mémoire maximale de l'appareil. |
nms | bool, facultatif | None | None exporte des prédictions brutes à correspondance un-vers-plusieurs pour une NMS externe (YOLO26 conserve sa tête sans NMS sur Axelera) ; True intègre la NMS lorsque celle-ci est prise en charge ; False sélectionne la tête sans NMS lorsqu'elle est disponible. La NMS intégrée de CoreML prend en charge la détection, la segmentation et la pose avec des dimensions statiques. Consulte le guide de détection de bout en bout. |
conf | float | None | Seuil de confiance utilisé partout où une NMS est générée lors de l'exportation : les exportations nms=True ; les exportations de détection Hailo non exécutées de bout en bout ; et les exportations de détection, de pose et de segmentation IMX, qui imposent en interne nms=True. La valeur par défaut est 0.25 si aucune valeur n'est définie. |
iou | float | 0.5 | Seuil d'IoU utilisé partout où une NMS est générée lors de l'exportation : les exportations nms=True ; les exportations de détection Hailo non exécutées de bout en bout ; et les exportations de détection, de pose et de segmentation IMX, qui imposent en interne nms=True. |
max_det | int | 300 | Nombre maximal de détections conservées dans la sortie du modèle exporté. S'applique aux exportations nms=True dans tous les formats, sauf à la détection CoreML, dont le pipeline NMS natif ne limite pas le nombre de détections, ainsi qu'aux exportations de détection de bout en bout sans NMS (YOLO26, YOLOv10, limitées au nombre d'ancres disponibles) et aux exportations de détection, de pose et de segmentation IMX. |
agnostic_nms | bool | False | Active la NMS indépendante des classes partout où une NMS est générée à l'exportation via le pipeline standard nms=True, y compris à l'étape NMS propre à CoreML ; les boîtes qui se chevauchent et dont le score est inférieur sont ainsi supprimées même si elles appartiennent à des classes différentes, plutôt qu'uniquement au sein d'une même classe. Cette option n'est pas prise en compte par les configurations NMS générées par Hailo ou IMX, qui ne proposent pas d'option indépendante des classes et restent sensibles aux classes, quelle que soit la valeur de cet indicateur. Elle est également intégrée aux exportations de bout en bout sans NMS (YOLO26, YOLOv10), où elle empêche uniquement la même détection d'apparaître sous plusieurs étiquettes de classe (doublons IoU=1.0), sans appliquer de suppression fondée sur un seuil IoU entre des boîtes distinctes. |
batch | int | 1 | Spécifie la taille du lot d'inférence du modèle exporté ou le nombre maximal d'images que le modèle exporté traitera simultanément en mode predict. Les formats dont les arguments d'exportation ne comprennent pas batch exportent avec un lot de taille 1 et rejettent les autres valeurs. |
device | str | None | Indique l'appareil utilisé pour l'exportation : GPU (device=0), CPU (device=cpu), MPS pour les puces Apple (device=mps), NPU Huawei Ascend (device=npu ou device=npu:0) ou DLA pour NVIDIA Jetson (device=dla:0 ou device=dla:1). Les exportations TensorRT utilisent automatiquement le GPU, mais TensorRT 11 ne prend pas en charge DLA. Les exportations OpenVINO INT8 avec device=npu sont optimisées pour les NPU Intel. |
verbose | bool | False | Augmente le niveau de détail des journaux du constructeur TensorRT à VERBOSE pendant l'exportation format='engine'. Les autres formats d'exportation ignorent cette option. |
data | str | None | Calibration du jeu de données : un chemin YAML (hors classification), un chemin ou une URL NDJSON, ou un URI de jeu de données de la plateforme (ul://owner/datasets/name) ou une URL Web. Les jeux de données de la plateforme nécessitent une clé API et Python 3.11 ou une version ultérieure. Pour la classification, tu peux aussi utiliser un répertoire de jeu de données ou le nom d’un jeu de données intégré. Si la quantification INT8 est activée sans jeu de données spécifié, Ultralytics sélectionne un jeu de données d’étalonnage adapté à la tâche, si nécessaire, ou utilise le jeu de données par défaut correspondant à la tâche du modèle. Un checkpoint entraîné avec quantize=8 contient ses propres plages INT8 et ne nécessite aucune donnée d’étalonnage. |
split | str | 'val' | Partition du jeu de données ('train', 'val' ou 'test') utilisée pour créer le chargeur de données de calibration de la quantification INT8 à partir de data. |
fraction | float, int ou list | 1.0 | Sous-ensemble du jeu de données utilisé pour la calibration INT8 : un ratio, un nombre d'images ou des valeurs [train, val, test]. 1 représente la partition complète ; les entiers supérieurs à 1 correspondent à des nombres d'images ; seules les entrées de test facultatives acceptent 0/0.0 pour signifier aucune image. Les listes de deux éléments conservent la partition test complète. |
Choisis le format et les paramètres adaptés à ton environnement de déploiement, aux contraintes matérielles et aux objectifs de performance afin d’obtenir le meilleur équilibre entre la taille du modèle, sa vitesse et sa précision.
Formats d’exportation#
Les formats d’exportation disponibles pour YOLO26 figurent dans le tableau ci-dessous. Tu peux exporter vers n’importe quel format à l’aide de l’argument format, par exemple format='onnx' ou format='engine'. Tu peux effectuer des prédictions ou valider directement sur les modèles exportés, par exemple avec yolo predict model=yolo26n.onnx. Des exemples d’utilisation de ton modèle s’affichent une fois l’exportation terminée. Les modèles peuvent également être exportés directement depuis le navigateur sur Ultralytics Platform, sans configuration locale.
| Format | Argument format | Modèle | Métadonnées | Arguments |
|---|---|---|---|---|
| PyTorch | - | yolo26n.pt | ✅ | - |
| TorchScript | torchscript | yolo26n.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| Apple Core AI | coreai | yolo26n.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n_saved_model/ | ✅ | imgsz, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| LiteRT | litert | yolo26n.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n_ncnn_model/ | ✅ | imgsz, quantize, device |
| IMX500 | imx | yolo11n_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n_executorch_model/ | ✅ | imgsz, quantize, batch, data, fraction, device |
| Axelera | axelera | yolo26n_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| Hailo | hailo | yolo26n_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n_xilinx_model/ | ✅ | imgsz, name, quantize, data, fraction, opset, simplify, device |
| NXP | nxp | yolo26n_nxp.tflite | ✅ | imgsz, quantize, data, fraction, device |
| ST Edge AI | stedgeai | yolo26n_stedgeai.onnx | ✅ | imgsz, quantize, data, fraction, opset, simplify, device |
nms=None utilise par défaut les sorties brutes pour une NMS externe (YOLO26 conserve sa tête sans NMS sur Axelera). Définis nms=False pour sélectionner une tête sans NMS disponible ; les formats non pris en charge reviennent à leur chemin de sortie natif. Les entrées nms ci-dessus identifient les formats qui peuvent intégrer la NMS avec nms=True.
La plupart des formats nécessitent des packages qui ne sont pas installés avec ultralytics. Si un package est manquant, l’exportation l’installe à l’exécution avec uv ou pip, et sous Linux avec apt pour les packages système tels que Java pour IMX. Le compilateur Edge TPU est téléchargé sans apt ni sudo. Pour conserver un environnement fixe, par exemple dans une image de conteneur, une tâche CI ou un service de production, définis YOLO_AUTOINSTALL=False. L’exportation vérifie alors toujours la présence des packages manquants et les signale, mais ne modifie pas l’environnement et échoue tant que ces packages ne sont pas installés.
export YOLO_AUTOINSTALL=FalseOptions de quantification#
Utilise l’argument quantize pour définir la précision de l’exportation. Les valeurs textuelles ne sont pas sensibles à la casse, et Ultralytics normalise les alias acceptés avant l’exportation :
| Valeurs demandées | Valeur canonique | Signification |
|---|---|---|
8, "8", "int8", "w8a8" | 8 | Poids et activations INT8 |
16, "16", "fp16", "w16a16" | 16 | Poids et activations FP16 |
32, "32", "fp32", "w32a32" | 32 | Exportation FP32 ; identique à une valeur non définie, sauf pour les programmes ML NMS de CoreML, qui utilisent FP16 par défaut |
"w8a16" | "w8a16" | Poids INT8 avec activations 16 bits (FP16 ; INT16 sur LiteRT) |
"w8a32" | "w8a32" | Poids INT8 avec activations FP32 (INT8 dynamique LiteRT, sans calibration nécessaire) |
Les anciens indicateurs half=True et int8=True sont toujours acceptés avec des avertissements de dépréciation et redirigés vers quantize=16 et quantize=8.
Tous les formats d’exportation ne prennent pas en charge toutes les précisions. Les demandes explicites quantize produisent la précision demandée ou échouent avant l’exportation :
| Format | FP32 (32/non défini) | FP16 (16) | INT8 (8) | W8A16 ("w8a16") | Remarques |
|---|---|---|---|---|---|
| PyTorch | ✅ | S. O. | S. O. | S. O. | Format natif d’entraînement et de point de contrôle. |
| TorchScript | ✅ | ✅ GPU uniquement | ❌ | ❌ | L’exportation TorchScript en FP16 nécessite device=0 ; l’exportation sur CPU est en FP32. |
| ONNX | ✅ | ✅ | ✅ | ❌ | INT8 utilise la quantification statique d’ONNX Runtime et des données de calibration. |
| OpenVINO | ✅ | ✅ | ✅ | ❌ | INT8 utilise la quantification post-entraînement de NNCF. |
| TensorRT | ✅ | ✅ | ✅ | ❌ | INT8 nécessite des données de calibration représentatives. |
| CoreML | ✅¹ | ✅ | ✅ | ✅ | La quantification INT8 de CoreML porte sur les poids ; W8A16 utilise des poids INT8 avec des activations FP16. ¹ Les programmes ML NMS non définis utilisent FP16 par défaut, et les exportations nms=True pour la segmentation et la pose sont toujours en FP16. |
| Core AI | ✅ | ✅ | ❌ | ❌ | FP32 par défaut ou ressource FP16 .aimodel avec quantize=16 ; aucune option INT8. |
| TF SavedModel | ✅ | ❌ | ✅ | ❌ | Les fichiers INT8 sont enregistrés dans .tflite, à côté d'un SavedModel FP32. |
| TF GraphDef | ✅ | ❌ | ❌ | ❌ | Aucune conversion de précision lors de l’exportation. |
| Edge TPU | ❌ | ❌ | ✅ automatique | ❌ | Edge TPU nécessite INT8 ; cette option est activée automatiquement si elle n’est pas définie. |
| LiteRT | ✅ | ❌ | ✅ | ✅ | INT8 statique (8) et "w8a16" (poids int8 + activations int16) utilisent des données de calibration ; LiteRT prend également en charge l’INT8 dynamique "w8a32" (sans calibration). quantize=16 ne correspond pas à une exportation distincte ; un modèle FP32 s’exécute en FP16 à l’exécution via le délégué GPU. |
| PaddlePaddle | ✅ | ❌ | ❌ | ❌ | Aucune conversion de précision lors de l’exportation. |
| MNN | ✅ | ✅ | ✅ | ❌ | INT8 correspond à une quantification des poids effectuée lors de la conversion MNN. |
| NCNN | ✅ | ✅ | ❌ | ❌ | Format d’exécution pour mobile et systèmes embarqués. |
| IMX500 | ❌ | ❌ | ✅ automatique | ❌ | IMX500 nécessite une quantification ; INT8 est activé automatiquement si l’option n’est pas définie. |
| RKNN | ❌ | ✅ selon la puce | ✅ | ❌ | RK3588/RK3576/RK3566/RK3568/RK3562/RK2118/RV1126B prennent en charge FP16 ou INT8 ; les variantes RV1103/RV1106 sont limitées à INT8. |
| ExecuTorch | ✅ | ❌ | ✅ | ❌ | La quantification statique INT8 (8) utilise des données d'étalonnage et conserve la tête de détection, de segmentation, de pose et OBB en FP32. |
| Axelera | ❌ | ❌ | ✅ automatique | ❌ | L’exportation Axelera nécessite INT8 ; cette option est activée automatiquement si elle n’est pas définie. |
| DEEPX | ❌ | ❌ | ✅ automatique | ❌ | L’exportation DEEPX nécessite INT8 ; cette option est activée automatiquement si elle n’est pas définie. |
| Qualcomm QNN | ❌ | ❌ | ❌ | ✅ automatique | L’exportation QNN HTP utilise toujours des poids INT8 avec des activations 16 bits. |
| Hailo | ❌ | ❌ | ✅ automatique | ❌ | L’exportation Hailo nécessite INT8 ; cette option est activée automatiquement si elle n’est pas définie. |
| Huawei Ascend | ❌ | ✅ automatique | ❌ | ❌ | Les convolutions Ascend AI Core n’acceptent que des entrées FP16/INT8 ; ATC compile donc en FP16. Cette option est activée automatiquement si elle n’est pas définie. |
| AMD Xilinx | ❌ | ❌ | ✅ automatique | ❌ | L’export AMD Xilinx nécessite Vitis AI INT8 (VINT8) ; cette option est activée automatiquement si elle n’est pas définie. |
| NXP | ❌ | ❌ | ✅ automatique | ❌ | L’export NXP i.MX95 nécessite INT8 avec Neutron SDK 3.3.0 ; l’option est activée automatiquement si elle n’est pas définie. |
| ST Edge AI | ✅ | ❌ | ✅ | ❌ | INT8 quantifie l’ensemble du graphe au format QDQ d’ONNX Runtime ; les sorties des boîtes et des points clés sont normalisées par rapport à [0, 1] afin que la tête soit elle aussi quantifiée. |
Pour les exportations INT8 et W8A16, fournis des données de calibration représentatives avec data, par exemple data="coco8.yaml", sauf si l’intégration cible documente un comportement par défaut ou une activation automatique. Le mode LiteRT "w8a32" (INT8 dynamique) ne nécessite pas de données de calibration.
Entraînement sensible à la quantification#
Les exportations INT8 ci-dessus utilisent la quantification après entraînement (PTQ) : les plages sont observées au cours d’un seul passage de calibration sur data. La quantification sensible à l’entraînement (QAT) apprend plutôt des poids qui tolèrent INT8 en affinant le modèle avec une fausse quantification dans la boucle, ce qui permet de récupérer la précision perdue par la seule calibration. Transmets quantize=8 à train pour affiner un point de contrôle préentraîné, puis exporte-le comme d’habitude :
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="coco.yaml",
quantize=8,
epochs=5,
batch=64,
optimizer="AdamW",
lr0=0.00001,
lrf=0.1,
warmup_epochs=0.5,
cos_lr=True,
mosaic=0.0,
)
model.export(format="engine", quantize=8) # les plages sont conservées avec le point de contrôle, aucune donnée de calibration n’est nécessaireUtilise un faible taux d’apprentissage pour affiner un point de contrôle préentraîné. Le QAT peut d’abord réduire la précision, et son avantage par rapport à la quantification post-entraînement dépend du modèle, du jeu de données et du budget d’entraînement. Valide le modèle exporté en le comparant au point de contrôle d’origine et à une exportation quantifiée après entraînement ; les scores de fausse quantification obtenus pendant l’entraînement ne permettent pas d’établir la précision en déploiement.
L’intérêt de la QAT dépend de la qualité de la calibration intégrée au backend d’exportation pour le modèle. Les valeurs ci-dessous correspondent à mAP50-95 sur COCO val2017, mesuré avec des moteurs TensorRT 10.16 à imgsz=640 et avec une taille de lot de 1 ; chaque checkpoint QAT a été entraîné avec epochs=20 patience=3 :
| Modèle | Moteur FP32 | Moteur INT8 PTQ | Moteur INT8 QAT |
|---|---|---|---|
yolo26n | 0.4032 | 0.3934 | 0.3935 |
yolo26s | 0.4794 | 0.4412 | 0.4711 |
yolo26m | 0.5269 | 0.4696 | 0.5137 |
yolo26l | 0.5440 | 0.4889 | 0.5307 |
yolo26x | 0.5701 | 0.5138 | 0.5527 |
La QAT coûte de 0.008 à 0.017 mAP50-95 par rapport à FP32 sur toute la gamme, tandis que la quantification après entraînement coûte 0.010 sur yolo26n et de 0.038 à 0.057 sur les modèles plus grands. La QAT apporte donc presque rien sur le plus petit modèle, pour lequel la calibration fonctionne déjà bien, et de 0.030 à 0.044 sur les autres. Les valeurs seront différentes avec un autre jeu de données, un autre format d’exportation ou une autre version de TensorRT : mesure-les sur ton propre cas.
Les modèles QAT nécessitent compile=False ; les modules quantifiés de ModelOpt ne prennent pas en charge torch.compile.
Les couches de sortie de la tête, les convolutions et les couches linéaires sans enveloppe situées hors de ses blocs Conv, restent volontairement en virgule flottante afin de limiter la perte de précision INT8 ; TensorRT active la précision mixte FP16 pour ses couches non quantifiées. La QAT s’exécute via NVIDIA TensorRT Model Optimizer, installé automatiquement lors de la première utilisation, et le point de contrôle obtenu nécessite que cet outil soit installé pour être chargé. Ces plages sont conservées avec le point de contrôle, et les exports onnx et engine les émettent sous forme de nœuds Q/DQ ; les autres formats utilisent plutôt les données d’étalonnage et rejettent un point de contrôle QAT.
Et ensuite ?#
Consulte le guide d’intégration correspondant à ta cible de déploiement — ONNX, TensorRT, CoreML et bien d’autres figurent dans la liste complète des intégrations — pour savoir comment exécuter le modèle exporté.
FAQ#
Exporte un modèle YOLO26 au format ONNX avec l’API Python ou la CLI :
Exemplefrom ultralytics import YOLO # Charger un modèle model = YOLO("yolo26n.pt") # charger un modèle officiel model = YOLO("path/to/best.pt") # charger un modèle entraîné personnalisé # Exporter le modèle model.export(format="onnx")Pour en savoir plus sur le processus, notamment sur les options avancées comme la gestion de différentes tailles d’entrée, consulte le guide d’intégration ONNX.
L’exportation d’un modèle avec TensorRT améliore considérablement les performances sur les GPU NVIDIA. Les modèles YOLO26 exportés vers TensorRT peuvent atteindre une accélération GPU jusqu’à 5 fois supérieure, ce qui rend TensorRT particulièrement adapté aux applications d’inférence en temps réel.
- Polyvalence : optimise les modèles pour une configuration matérielle précise.
- Vitesse : accélère l’inférence grâce à des optimisations avancées.
- Compatibilité : s’intègre facilement au matériel NVIDIA.
Pour en savoir plus sur l’intégration de TensorRT, consulte le guide d’intégration TensorRT.
La quantification INT8 compresse le modèle et accélère l’inférence, en particulier sur les appareils périphériques. Active-la avec
quantize=8:Exemplefrom ultralytics import YOLO model = YOLO("yolo26n.pt") # Charger un modèle model.export(format="onnx", quantize=8, data="coco8.yaml")La quantification INT8 peut être appliquée à des formats comme ONNX, TensorRT, OpenVINO, CoreML, Rockchip RKNN et AMD Xilinx. Pour obtenir des résultats de quantification optimaux, fournis un jeu de données représentatif avec le paramètre
data. Consulte les options de quantification pour connaître les valeursquantizeacceptées et les formats pris en charge.La taille d’entrée dynamique permet au modèle exporté de gérer des dimensions d’image variables, ce qui offre de la souplesse et optimise l’efficacité du traitement pour différents cas d’usage. Lors de l’exportation vers des formats comme ONNX ou TensorRT, l’activation de la taille d’entrée dynamique permet au modèle d’accepter différentes formes d’entrée.
Pour activer cette fonctionnalité, utilise l’indicateur
dynamic=Truelors de l’exportation :Exemplefrom ultralytics import YOLO model = YOLO("yolo26n.pt") model.export(format="onnx", dynamic=True)La taille d’entrée dynamique est particulièrement utile pour les applications où les dimensions d’entrée peuvent varier, comme le traitement vidéo ou l’analyse d’images provenant de différentes sources.
Un export dynamique chargé avec
YOLO()effectue les prédictions et la validation à la tailleimgszde son export (le côté le plus long d’un export non carré), tandis qu’un modèle PyTorch utilise la tailleimgszde son entraînement. Passeimgszpour l’exécuter à une autre taille.Par défaut, les modèles PyTorch et les exportations dynamiques utilisent le rembourrage en rectangle minimal, tandis que les exportations statiques ajoutent du rembourrage jusqu’à atteindre le
imgszcomplet ; les détections proches du seuil de confiance peuvent donc différer. Utiliserect=Falsepour effectuer l’inférence native et obtenir des résultats similaires à une exportation statique, ou exporte avecdynamic=Truelorsque cette option est prise en charge.Ces arguments d’exportation ont le plus d’impact sur les performances du modèle :
format:Format cible du modèle exporté (par exemple,onnx,torchscript,saved_model).imgsz:Taille d’image souhaitée pour l’entrée du modèle (par exemple,640ou(height, width)).quantize:Précision de quantification, par exemple8/"int8",16/"fp16",32/"fp32", ou les modes mixtes poids/activations"w8a16"et"w8a32"(INT8 dynamique LiteRT) pour les formats pris en charge. Consulte les options de quantification.dynamic:Accepte des tailles d’entrée variables dans les formats prenant en charge les formes dynamiques, comme ONNX, OpenVINO et TensorRT.nms:Sélectionne les sorties brutes pour une NMS externe (None; YOLO26 conserve sa tête sans NMS sur Axelera), la NMS intégrée (True) ou la tête sans NMS (False).device:Appareil utilisé pour tracer le modèle pendant l’exportation, par exemplecpuou0pour le premier GPU CUDA ; TorchScript FP16 nécessite un GPU.
Pour un déploiement sur des plateformes matérielles spécifiques, pense à utiliser des formats d’exportation spécialisés comme TensorRT pour les GPU NVIDIA, CoreML pour les appareils Apple ou Edge TPU pour les appareils Google Coral.
Lorsque tu exportes un modèle YOLO vers des formats comme ONNX ou TensorRT, la structure du tenseur de sortie dépend de la tâche du modèle. Il est important de comprendre ces sorties pour implémenter des inférences personnalisées.
Pour les modèles de détection YOLO26 (p. ex.
yolo26n.pt) exportés avecnms=False, les formats pris en charge produisent une sortie sans NMS de forme(batch_size, max_detections, 6)avec[x1, y1, x2, y2, confidence, class_id]valeurs. Avec lemax_det=300par défaut, cette sortie est généralement(batch_size, 300, 6). Certains formats soumis à des contraintes reviennent automatiquement à la disposition de sortie traditionnelle lorsque les opérateurs de bout en bout ne sont pas pris en charge.Par défaut (
nms=None), les modèles de détection, y compris YOLO26, exportent des prédictions brutes à correspondance un-vers-plusieurs (YOLO26 conserve sa tête sans NMS sur Axelera). La sortie est généralement un tenseur unique de forme(batch_size, 4 + num_classes, num_predictions), dont les canaux représentent les coordonnées des boîtes et les scores par classe, etnum_predictionsdépend de la résolution d'entrée de l'export (et peut être dynamique). Le guide de détection de bout en bout indique les formats qui conservent la sortie de bout en bout.Pour les modèles de segmentation (p. ex.
yolo26n-seg.pt), tu obtiendras généralement deux sorties : le premier tenseur, de forme(batch_size, 4 + num_classes + mask_dim, num_predictions)(boîtes, scores par classe et coefficients de masque), et le second tenseur, de forme(batch_size, mask_dim, proto_h, proto_w), qui contient les prototypes de masque utilisés avec les coefficients pour générer les masques d'instance. Les tailles dépendent de la résolution d'entrée de l'exportation (et peuvent être dynamiques).Pour les modèles de pose (p. ex.
yolo26n-pose.pt), le tenseur de sortie a généralement la forme(batch_size, 4 + num_classes + keypoint_dims, num_predictions), oùkeypoint_dimsdépend de la spécification de pose (p. ex. du nombre de points clés et de l'inclusion ou non de la confiance), etnum_predictionsdépend de la résolution d'entrée de l'exportation (et peut être dynamique).Les exemples de la page Exemples d'inférence ONNX montrent comment traiter ces sorties pour chaque type de modèle.
Ultralytics ne fournit actuellement pas d'API d'inférence C++ dédiée aux modèles YOLO. Pour les déploiements en C++, exporte le modèle vers un format d'exécution comme ONNX, TensorRT, TorchScript ou MNN, puis charge l'artefact exporté avec l'API C++ native de ce moteur d'exécution.
Par exemple, exporte un modèle de détection avec
yolo export model=yolo26n.pt format=onnxet exécute le fichier.onnxavec ONNX Runtime C++, ou exporte avecformat=engineet exécute le moteur TensorRT depuis une application C++ TensorRT. Lorsque tu utilises un post-traitement C++ personnalisé, veille à ce que la disposition du tenseur de sortie corresponde à la tâche et aux paramètres d'exportation ; les exportations de détection YOLO26 par défaut renvoient des tenseurs de prédiction bruts qui nécessitent une NMS externe. Exporte avecnms=Falsepour obtenir des détections sans NMS de forme(batch, max_det, 6), ou avecnms=Truepour intégrer la NMS dans les formats pris en charge.Lors d'une exportation avec
quantize=16(FP16) ouquantize=8(INT8), la plupart des tenseurs sont convertis en précision réduite afin de diminuer la taille du modèle et d'améliorer ses performances. Toutefois, lorsquenms=Falseest activé, le post-traitement (y compris les indices de classe) est intégré directement au graphe exporté.Le tenseur
output0contient les indices de classe, qui sont représentés en interne sous forme de nombres à virgule flottante. En raison de la précision limitée de sa mantisse, FP16 ne peut pas représenter de manière fiable les valeurs entières supérieures à 2048. Pour éviter une éventuelle perte de précision ou des ID de classe incorrects,output0est volontairement conservé en FP32.Si tu as besoin de sorties entièrement en FP16, exporte avec
nms=Nonesur un GPU et effectue le post-traitement à l'extérieur. Les exportations ONNX FP16 sur CPU conservent dans tous les cas des entrées et des sorties FP32 ; seule la représentation interne du graphe est convertie.
Commentaires447
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
yubaobao-GPU
你好,请问为什么我转onnx的时候会显示end2end参数非法 (ywh_26) root@ai-avcon:/data/ywh_folder/yolo/yolo26# python to_onnx.py WARNING ⚠️ Ultralytics settings reset to default values. This may be due to a possible problem with your settings or a recent ultralytics package update. View Ultralytics Settings with 'yolo settings' or at '/root/.config/Ultralytics/settings.json' Update Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings. Traceback (most recent call last): File "/data/ywh_folder/yolo/yolo26/to_onnx.py", line 12, in model.export( File "/data/ywh_folder/yolo/yolo26/ultralytics/engine/model.py", line 710, in export return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model) File "/data/ywh_folder/yolo/yolo26/ultralytics/engine/exporter.py", line 312, in init self.args = get_cfg(cfg, overrides) File "/data/ywh_folder/yolo/yolo26/ultralytics/cfg/init.py", line 308, in get_cfg check_dict_alignment(cfg, overrides) File "/data/ywh_folder/yolo/yolo26/ultralytics/cfg/init.py", line 505, in check_dict_alignment raise SyntaxError(string + CLI_HELP_MSG) from e SyntaxError: 'end2end' is not a valid YOLO argument.
我是用的8.4.6版本的ultralytics
1
Glenn JocherUltralyticsultralytics==8.4.6还不支持end2end这个导出参数(它是给支持 NMS-free 的新模型/新版本用的),所以你这边要么把model.export()里的end2end=...去掉,要么升级到最新 Ultralytics;另外你的报错路径显示实际导入的是本地仓库.../yolo26/ultralytics,建议先跑一次yolo checks并把文本输出贴上来确认是否存在多套安装/路径冲突(参数列表可参考 Model.export() 参考文档)。pip install -U ultralytics yolo checks
qcname
您好,使用.pt和导出为.onnx进行yolov8模型的图片中目标检测时,参数设置一致,但是最终检测框数量,位置不完全一致。比如.onnx比.pt多画一个或者检测到.pt检测不出来的类别,请问是什么问题导致的呢?
1
Paula DerrengerUltralytics@nacenace 您好,
感谢您提出这个问题!在导出模型时遇到检测结果不一致的情况确实令人困惑。以下是一些可能的原因和解决方法:
-
版本一致性:请确保您使用的是最新版本的
torch和ultralytics。您可以通过以下命令进行升级:pip install --upgrade torch ultralytics -
模型导出参数:导出为 ONNX 时,某些参数可能会影响模型的行为。请确保在导出时使用了适当的参数,例如
dynamic、simplify等。以下是一个导出为 ONNX 的示例:from ultralytics import YOLO # 加载模型 model = YOLO("path/to/best.pt") # 导出模型 model.export(format="onnx", dynamic=True, simplify=True) -
推理设置:在进行推理时,确保使用相同的图像尺寸和其他推理参数。以下是一个推理示例:
# 使用 .pt 模型进行推理 results_pt = model.predict(source="path/to/image.jpg", imgsz=640) # 使用 .onnx 模型进行推理 model_onnx = YOLO("path/to/model.onnx") results_onnx = model_onnx.predict(source="path/to/image.jpg", imgsz=640) -
最小可复现示例:为了更好地帮助您解决问题,请提供一个最小可复现的代码示例。您可以参考我们的最小可复现示例指南来创建一个示例。
请尝试以上建议,如果问题仍然存在,请提供更多详细信息和代码示例,以便我们进一步调查。
希望这些信息对您有所帮助!如果有任何其他问题,请随时告知。
祝好, Ultralytics 团队
-
Lbj4175
你好,我和你有相同的问题,问题解决了吗
qcname
没有
Glenn JocherUltralytics您好,感谢您的反馈。导出为不同格式(如ONNX)时,检测结果可能会有所不同,通常是由于模型转换过程中精度损失或推理引擎差异导致的。建议您确保使用最新版本的Ultralytics和相关库,并尝试调整导出参数,如
dynamic=True或half=True。更多详情请参考导出文档。
Ibraheem-Ahmad
Hello! Would anyone be able to tell me why this code does not work: model.export(format=='onnx', int8 = True, dyamic = True, imgsz = (width,height))
the error I get is "TypeError: Model.export() takes 1 positional argument but 2 were given"
1
Glenn JocherUltralytics@Ibraheem-Ahmad hello! It looks like there's a small typo in your code that's causing the issue. In Python, when you're calling a function and passing arguments, you should use
=for assignment rather than==, which is used for comparison. Also, there's a typo indyamic, it should bedynamic. Here's the corrected line of code:model.export(format='onnx', int8=True, dynamic=True, imgsz=(width, height))This should work without any errors. If you have any more questions or run into issues, feel free to ask. Happy coding! 😊
Aisha-Hassan1
How can I path pictures and how many pictures?
Glenn JocherUltralytics@Aisha-Hassan1 hey there! 🌟 To pass multiple pictures for processing, you can use a directory, list, or wildcard as your
source. For example:# For a directory full of images model.predict(source='path/to/images/') # For specific images model.predict(source=['path/to/image1.jpg', 'path/to/image2.jpg']) # Using a wildcard model.predict(source='path/to/images/*.jpg')As for how many pictures, there's no strict limit—it depends on your system's capabilities. Just ensure your images comply with the model's input size, which you can adjust with the
imgszparameter if necessary. Happy coding! 😊1Aisha-Hassan1
When I don't put batch_size, the result is batch_size=1 .... code => [ Ultralytics YOLOv8.1.29 🚀 Python-3.11.5 torch-2.2.1+cpu CPU (Intel Core(TM) i5-3320M 2.60GHz) YOLOv8n summary (fused): 168 layers, 3151904 parameters, 0 gradients, 8.7 GFLOPs
PyTorch: starting from 'yolov8n.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 84, 8400) (6.2 MB)
ONNX: starting export with onnx 1.15.0 opset 17... ONNX: export success ✅ 2.1s, saved as 'yolov8n.onnx' (12.1 MB)
Export complete (5.9s) Results saved to C:\Users\shosho Predict: yolo predict task=detect model=yolov8n.onnx imgsz=640 int8 Validate: yolo val task=detect model=yolov8n.onnx imgsz=640 data=coco.yaml int8 Visualize: https://netron.app
] .........batch_size = 4 model.export(format='onnx', int8=True, dynamic=True, batch=batch_size) res=>[Ultralytics YOLOv8.1.29 🚀 Python-3.11.5 torch-2.2.1+cpu CPU (Intel Core(TM) i5-3320M 2.60GHz) YOLOv8n summary (fused): 168 layers, 3151904 parameters, 0 gradients, 8.7 GFLOPs
PyTorch: starting from 'yolov8n.pt' with input shape (4, 3, 640, 640) BCHW and output shape(s) (4, 84, 8400) (6.2 MB)
ONNX: starting export with onnx 1.15.0 opset 17... ONNX: export success ✅ 3.6s, saved as 'yolov8n.onnx' (12.1 MB)
Export complete (11.2s) Results saved to C:\Users\shosho Predict: yolo predict task=detect model=yolov8n.onnx imgsz=640 int8 Validate: yolo val task=detect model=yolov8n.onnx imgsz=640 data=coco.yaml int8 Visualize: https://netron.app 'yolov8n.onnx'] Is this the number of photos I should enter?
Aisha-Hassan1
import cv2 from ultralytics import YOLO
model = YOLO('yolov8n.pt') model.export(format='onnx', int8=True, dynamic=True) predicted_images = model.predict(source='G:/img') for i, result in enumerate(predicted_images): print(result) image = result.orig_img save_path = f'predicted_image_{i}.jpg'
cv2.imwrite(save_path, image)
print(f"Done{save_path}")The code works for me and saves the images, but I have two questions
1- How will i deal with an onnx file with JS and send it an array of images? 2- I want to export yolov5n-seg.pt to onnx to put a mask on the images?
Glenn JocherUltralytics@Aisha-Hassan1 hey there! 😊
- To deal with an ONNX file in JS and send it an array of images, you can use onnxjs for browser environments or onnxruntime-node for Node.js. Here’s an example using onnxjs:
async function runModel(inputImages) { const session = new onnx.InferenceSession(); await session.loadModel("path/to/your/model.onnx"); const inputTensors = inputImages.map(image => // convert your images to tensors); // Assuming you're working with one input named 'input' const feeds = { input: inputTensors }; const results = await session.run(feeds); return results; }- For exporting
yolov5n-seg.ptto ONNX with a mask, ensure your model supports segmentation tasks, then follow similar steps to exporting a detection model but make sure the output includes the segmentation masks. Your export code seems fine, but replaceyolov8n.ptwithyolov5n-seg.pt. Check model compatibility and output processing as per your needs!
If you need any more guidance, don't hesitate to ask. Have fun coding! ✨
1Aisha-Hassan1
The yolov5n-seg.pt export part show this error........[ ModuleNotFoundError Traceback (most recent call last) File G:\anaconda3\Lib\site-packages\ultralytics\nn\tasks.py:714, in torch_safe_load(weight) 707 with temporary_modules( 708 { 709 "ultralytics.yolo.utils": "ultralytics.utils", (...) 712 } 713 ): # for legacy 8.0 Classify and Pose models --> 714 ckpt = torch.load(file, map_location="cpu") 716 except ModuleNotFoundError as e: # e.name is missing module name
File G:\anaconda3\Lib\site-packages\torch\serialization.py:1026, in load(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args) 1025 raise pickle.UnpicklingError(UNSAFE_MESSAGE + str(e)) from None -> 1026 return _load(opened_zipfile, 1027 map_location, 1028 pickle_module, 1029 overall_storage=overall_storage, 1030 **pickle_load_args) 1031 if mmap:
File G:\anaconda3\Lib\site-packages\torch\serialization.py:1438, in _load(zip_file, map_location, pickle_module, pickle_file, overall_storage, **pickle_load_args) 1437 unpickler.persistent_load = persistent_load -> 1438 result = unpickler.load() 1440 torch._utils._validate_loaded_sparse_tensors()
File G:\anaconda3\Lib\site-packages\torch\serialization.py:1431, in _load..UnpicklerWrapper.find_class(self, mod_name, name) 1430 mod_name = load_module_mapping.get(mod_name, mod_name) -> 1431 return super().find_class(mod_name, name)
ModuleNotFoundError: No module named 'models'
The above exception was the direct cause of the following exception:
TypeError Traceback (most recent call last) Cell In[2], line 1 ----> 1 model = YOLO('yolov5n-seg.pt')
File G:\anaconda3\Lib\site-packages\ultralytics\models\yolo\model.py:23, in YOLO.init(self, model, task, verbose) 20 self.dict = new_instance.dict 21 else: 22 # Continue with default YOLO initialization ---> 23 super().init(model=model, task=task, verbose=verbose)
File G:\anaconda3\Lib\site-packages\ultralytics\engine\model.py:142, in Model.init(self, model, task, verbose) 140 self._new(model, task=task, verbose=verbose) 141 else: --> 142 self._load(model, task=task) 144 self.model_name = model
File G:\anaconda3\Lib\site-packages\ultralytics\engine\model.py:229, in Model._load(self, weights, task) 227 suffix = Path(weights).suffix 228 if suffix == ".pt": --> 229 self.model, self.ckpt = attempt_load_one_weight(weights) 230 self.task = self.model.args["task"] 231 self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)
File G:\anaconda3\Lib\site-packages\ultralytics\nn\tasks.py:788, in attempt_load_one_weight(weight, device, inplace, fuse) 786 def attempt_load_one_weight(weight, device=None, inplace=True, fuse=False): 787 """Loads a single model weights.""" --> 788 ckpt, weight = torch_safe_load(weight) # load ckpt 789 args = {**DEFAULT_CFG_DICT, **(ckpt.get("train_args", {}))} # combine model and default args, preferring model args 790 model = (ckpt.get("ema") or ckpt["model"]).to(device).float() # FP32 model
File G:\anaconda3\Lib\site-packages\ultralytics\nn\tasks.py:718, in torch_safe_load(weight) 716 except ModuleNotFoundError as e: # e.name is missing module name 717 if e.name == "models": --> 718 raise TypeError( 719 emojis( 720 f"ERROR ❌️ {weight} appears to be an Ultralytics YOLOv5 model originally trained " 721 f"with https://github.com/ultralytics/yolov5.\nThis model is NOT forwards compatible with " 722 f"YOLOv8 at https://github.com/ultralytics/ultralytics." 723 f"\nRecommend fixes are to train a new model using the latest 'ultralytics' package or to " 724 f"run a command with an official YOLOv8 model, i.e. 'yolo predict model=yolov8n.pt'" 725 ) 726 ) from e 727 LOGGER.warning( 728 f"WARNING ⚠️ {weight} appears to require '{e.name}', which is not in ultralytics requirements." 729 f"\nAutoInstall will run now for '{e.name}' but this feature will be removed in the future." 730 f"\nRecommend fixes are to train a new model using the latest 'ultralytics' package or to " 731 f"run a command with an official YOLOv8 model, i.e. 'yolo predict model=yolov8n.pt'" 732 ) 733 check_requirements(e.name) # install missing module
TypeError: ERROR yolov5n-seg.pt appears to be an Ultralytics YOLOv5 model originally trained with https://github.com/ultralytics/yolov5. This model is NOT forwards compatible with YOLOv8 at https://github.com/ultralytics/ultralytics. Recommend fixes are to train a new model using the latest 'ultralytics' package or to run a command with an official YOLOv8 model, i.e. 'yolo predict model=yolov8n.pt'
] part of the code in JS ...[
] show erro .........Access to fetch at 'file:///G:/pg_betch/yolov8n.onnx' from origin 'null' has been blocked by CORS policy: Cross origin requests are only supported for protocol schemes: http, data, isolated-app, chrome-extension, chrome, https, chrome-untrusted. session.ts:61GET file:///G:/pg_betch/yolov8n.onnx net::ERR_FAILED(anonymous) @ session.ts:61 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 a @ onnx.min.js:14 Promise.then (async) s @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 r @ onnx.min.js:14 (anonymous) @ session.ts:48 t.event @ instrument.ts:294 (anonymous) @ session.ts:48 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 r @ onnx.min.js:14 e.loadModel @ onnx.min.js:14 t.loadModel @ inference-session-impl.ts:27 runModel @ index.html:11 (anonymous) @ index.html:27 session.ts:61
Uncaught (in promise) TypeError: Failed to fetch at e.<anonymous> (session.ts:61:34) at onnx.min.js:14:255680 at Object.next (onnx.min.js:14:255785) at a (onnx.min.js:14:254499)(anonymous) @ session.ts:61 (anonymous) @ onnx.min.js:14 (anonymous) @ onnx.min.js:14 a @ onnx.min.js:14 Promise.then (async) (anonymous) @ index.html:27
Glenn JocherUltralyticsHey there! It looks like you're encountering two different issues here:
-
Using an ONNX model with JavaScript: For running ONNX models in a browser with JavaScript, you're on the right track with onnx.js. However, loading local files directly can lead to CORS policy violations, as seen in your error. To fix this, serve your ONNX model from a server or use a cloud storage URL with proper CORS settings. Ensure your server or cloud storage is configured to allow such requests.
-
Exporting YOLOv5n-seg.pt to ONNX: The error suggests that the file
yolov5n-seg.ptmight be confused as a YOLOv5 model and you're trying to load it using YOLOv8, which leads to compatibility issues. Ifyolov5n-seg.ptis indeed a YOLOv5 model, ensure you're using the correct toolchain for export. For segmentation models with YOLOv8 (assumingyolov8n-seg.ptexists and it's what you meant), the export command you've used seems correct. Make sure you're within the Ultralytics ecosystem for YOLOv8 and its segmentation models, and check if there's a typo in the filename or a version mismatch. Correct model paths and compatible Ultralytics YOLO versions are crucial.
For working with segmentation models and applying masks to images post-export, you'll typically handle the output tensors from the ONNX model to extract segmentation masks and overlay them on the original images. This step will heavily depend on the output structure of your specific model.
Hope that helps! Keep experimenting, and feel free to reach out if you hit more snags. 😊
1-
Aisha-Hassan1
Can you help me how to handle the output tensors from the ONNX model to extract segmentation masks and overlay them on the original images ?
Glenn JocherUltralyticsHey there! 🙌 To handle output tensors from an ONNX model for segmentation tasks, you'll typically:
-
Run the Model: First, feed your input image to the ONNX model using your preferred ONNX runtime environment. This step returns the output tensors.
-
Process Output Tensors: For segmentation models, the output tensor usually represents either a pixel-wise class prediction or a set of masks for each detected object. You'll need to decode these tensors to get the segmentation masks. The exact processing will depend on your model's output format.
-
Overlay Masks on Original Images: Once you have the segmentation masks, you can overlay them on your original images. Here's a quick example in Python, assuming you have a mask:
import cv2 import numpy as np # Assuming 'image' is your original image and 'mask' is the segmentation mask # Ensure the mask is a binary mask (0 or 1) where 1 represents the segmented object overlay = cv2.addWeighted(image, 1, np.dstack((mask, mask, mask)) * 255, 0.5, 0) cv2.imwrite('segmented_image.jpg', overlay)For exporting
yolov5n-seg.ptor similar models to ONNX, you seem to have encountered an incompatibility issue indicating that you might be trying to load a YOLOv5 model with a YOLOv8 setup. Ensure you're using the proper version and tools for your specific YOLO model. YOLOv8 now has its dedicated ecosystem and might not directly support models trained with previous versions without conversion or specific handling.If YOLOv5 segmentation is what you need and you're dealing with
yolov5n-seg.pt, consider checking the YOLOv5 documentation for the precise export guidance. For segmentation tasks, you might need to adjust your approach tailored to the model's specific output layer design.Hope this helps! Let me know if there's anything else I can do for you. 😊
-
Aisha-Hassan1
Thank you very much for your help 1-Using an ONNX model with JavaScript:
Document<script> const labels = [ "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush", ]; const modelName = "yolov8n-seg.onnx"; const modelInputShape = [4, 3, 640, 640]; let mySession; const useState = (defaultValue) => { let value = defaultValue; const getValue = () => value; const setValue = (newValue) => (value = newValue); return [getValue, setValue]; }; const numClass = labels.length; const [session, setSession] = useState(null); cv["onRuntimeInitialized"] = async () => { // create session const [yolov8] = await Promise.all([ ort.InferenceSession.create(modelName), ]); mySession = setSession({ net: yolov8 }); const inputImages = [ "img/bb.jpg", "img/iam.jpg" ]; const inputTensors = await Promise.all(inputImages.map(async (imageUrl) => { const response = await fetch(imageUrl); if (!response.ok) { throw new Error(`Failed to fetch image: ${imageUrl}`); } const blob = await response.blob(); const image = await cv.imreadAsync(blob); const tensor = cv.tensorFromImageData(image); image.delete(); return tensor; })); // Assuming you're working with one input named 'input' const feeds = { input: inputTensors }; const results = await yolov8.run(feeds); console.log(results); // Assuming you need to handle the results here // Handle results... }; </script>problem of code In partial convert your images to tensors
Do you have a solution to the problem?
Glenn JocherUltralytics@Aisha-Hassan1 hey there! Thanks for reaching out 🌟. It looks like you're having a bit of trouble converting images to tensors in your JavaScript code while working with an ONNX model.
For the conversion part, using OpenCV.js to convert images to tensors might not directly align with the expected input format for ONNX models. Instead, you'll typically need to preprocess the images into a format that matches the expected input tensor of your ONNX model, including resizing images and normalizing pixel values if required.
A simplified approach (without OpenCV.js) could involve using standard JavaScript or browser APIs to load and preprocess your images before converting them into tensors. Unfortunately, detailed code for image preprocessing highly depends on the specific requirements of your ONNX model, such as input dimensions and pixel-value scaling.
Regarding overlaying segmentation masks (like from
yolov5n-seg.ptexported as ONNX) onto images using JavaScript:- Once you have your segmentation output from the model, it'll typically be a tensor where each value corresponds to a class prediction per pixel or a probability distribution across classes for each pixel.
- Convert this segmentation mask tensor back into an image format, applying any necessary thresholding to identify your classes of interest.
- Overlay this processed mask onto your original image. You can achieve this by manipulating the DOM directly in JavaScript or using canvas operations to blend images.
Both the conversion and overlay steps are somewhat intricate and depend heavily on the details of your model's output format as well as the web environment you're working in (pure JavaScript in the browser, Node.js, etc.).
For precise assistance, we might need more details on the output format of your segmentation model and the specific environment you're working in. Meanwhile, the Ultralytics Docs and YOLOv8's export mode provide a great starting point for deploying models efficiently across various platforms 🚀.
Hope this helps a bit! Keep exploring and don't hesitate to share more details or ask further questions. Happy coding!
Aisha-Hassan1
I would like answers to two other questions, please
1- If I want to enter an array of images in js to use batch, should I export onnx this way ? model.export(format='onnx', int8=True, dynamic=True) or Do I have to limit the number of photos like this? model.export(format='onnx', int8=True, dynamic=True, batch =number of images)
2- I want to run onnx in the GPU, what should I do?
Glenn JocherUltralyticsHey there! 😀 Glad you're exploring YOLOv8's capabilities. Let's dive into your questions:
-
Array of Images for Batch Inference in JS:
- Utilizing
dynamic=Trueduring export is the way to go if you plan on varying the batch size dynamically. There's no need to specify the batch size at export time for ONNX models, asdynamic=Trueenables the model to handle variable batch sizes. So, your first export command is spot on:model.export(format='onnx', int8=True, dynamic=True) - This setup allows you to feed different batch sizes at runtime without having to re-export the model for each specific batch size.
- Utilizing
-
Running ONNX on GPU:
- To run ONNX models on the GPU, ensure you have an ONNX runtime that supports GPU inference, such as ONNX Runtime-GPU. When initializing your inference session in your code, specify the GPU device. Here's a quick example if you're using Python:
import onnxruntime as ort # Specify the GPU device ort_session = ort.InferenceSession("your_model.onnx", providers=['CUDAExecutionProvider']) # Now you can run inference with ort_session and it should use the GPU - For JavaScript, the availability of GPU inference might be limited and typically runs on the CPU. ONNX.js primarily supports WebGL for some level of GPU acceleration in the browser, but true GPU computing might not be feasible directly in JS as it depends on the browser's capabilities and the onnxruntime-web package's support.
- To run ONNX models on the GPU, ensure you have an ONNX runtime that supports GPU inference, such as ONNX Runtime-GPU. When initializing your inference session in your code, specify the GPU device. Here's a quick example if you're using Python:
I hope this clears up your questions! Keep experimenting with YOLOv8, and don't hesitate to reach out if you have more questions. Happy coding! 🚀
-
Aisha-Hassan1
thank you so much code
 <script> var inputTensors=[]; const modelInputShape = [1, 3, 640, 640]; const divStride = (stride, width, height) => { if (width % stride !== 0) { if (width % stride >= stride / 2) width = (Math.floor(width / stride) + 1) * stride; else width = Math.floor(width / stride) * stride; } if (height % stride !== 0) { if (height % stride >= stride / 2) height = (Math.floor(height / stride) + 1) * stride; else height = Math.floor(height / stride) * stride; } return [width, height]; }; const preprocessing = (source, modelWidth, modelHeight, stride = 32) => { //const mat = cv.imread(source); // read from img tag const mat = cv.imread(document.getElementById(source)); const matC3 = new cv.Mat(mat.rows, mat.cols, cv.CV_8UC3); // new image matrix cv.cvtColor(mat, matC3, cv.COLOR_RGBA2BGR); // RGBA to BGR const [w, h] = divStride(stride, matC3.cols, matC3.rows); cv.resize(matC3, matC3, new cv.Size(w, h)); // padding image to [n x n] dim const maxSize = Math.max(matC3.rows, matC3.cols); // get max size from width and height const xPad = maxSize - matC3.cols, // set xPadding xRatio = maxSize / matC3.cols; // set xRatio const yPad = maxSize - matC3.rows, // set yPadding yRatio = maxSize / matC3.rows; // set yRatio const matPad = new cv.Mat(); // new mat for padded image cv.copyMakeBorder( matC3, matPad, 0, yPad, 0, xPad, cv.BORDER_CONSTANT, [0, 0, 0, 255] ); // padding black const input = cv.blobFromImage( matPad, 1 / 255.0, // normalize new cv.Size(modelWidth, modelHeight), // resize to model input size new cv.Scalar(0, 0, 0), true, // swapRB false // crop ); // preprocessing image matrix // release mat opencv mat.delete(); matC3.delete(); matPad.delete(); return [input, xRatio, yRatio]; }; const inputImages = [ "image1", "image2" ]; async function runModel(inputImages) { const [yolov8] = await Promise.all([ ort.InferenceSession.create("yolov8n-seg.onnx") ]); const [modelWidth, modelHeight] = modelInputShape.slice(2); for(let i=0 ; i<inputImages.length; i++){ const [input, xRatio, yRatio] = preprocessing( inputImages[i], modelWidth, modelHeight ); const tensor = new ort.Tensor("float32", input.data32F, modelInputShape); inputTensors[i]=tensor; console.log(inputTensors) } const { output0, output1 } = await yolov8.run({images:inputTensors}); console.log(output0); }; runModel(inputImages) </script>In the runModel function, I send it an array of images, and it makes an error in part
const { output0, output1 } = await yolov8.run({images:inputTensors})
Because inputTensors is an array
This is the form of error Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'byteLength') at t.run (wasm-core-impl.ts:219:31) at t.run (proxy-wrapper.ts:215:17) at t.OnnxruntimeWebAssemblySessionHandler.run (session-handler.ts:84:15) at i.run (inference-session-impl.js:94:44) at runModel (main.html:94:55) t.run@wasm-core-impl.ts:219 t.run@proxy-wrapper.ts:215 run@session-handler.ts:84 run@inference-session-impl.js:94 runModel@main.html:94 await in runModel (async) (anonymous)@main.html:97
What is the solution to enter an array of images into the model?
Aisha-Hassan1
When using a array of objects, the first is taken only object
Glenn JocherUltralyticsHey there! Thanks for bringing this to our attention 🌟. When using an array of objects for inference with YOLOv8 in JavaScript, you'd typically batch the input images before sending them to the model. If you find that only the first object in your array is being processed, it might be related to how you're structuring the input data for the ONNX model.
For batch processing, ensure all your images are preprocessed (resized and normalized) correctly and then stacked into a single tensor that matches the ONNX model's expected input shape. The shape for a batch of images usually follows the format
[batch_size, channels, height, width]. It sounds like you might need to adjust how you're constructinginputTensorsto fit this expectation.Regarding running ONNX on a GPU, note that ONNX.js primarily targets web environments where direct access to the GPU through Web APIs (e.g., WebGL) might not fully leverage all GPU capabilities like a desktop environment would. If you're using ONNX in a server-side JavaScript environment (like with Node.js and onnxruntime-node), specifying the GPU for inference would depend on the capabilities of your specific backend setup and the ONNX runtime you're using. Onnxruntime-web currently doesn't offer direct control over executing models on GPU vs. CPU—it automatically utilizes available hardware acceleration like WebGL.
Here's a simplified structure for how you might handle batching:
async function runBatchModel(session, inputTensors) { // Ensure inputTensors is a batched tensor of the right shape const results = await session.run({input: inputTensors}); // Process results... }Remember to adjust the
runBatchModelfunction based on how your specific model expects inputs. Happy coding and don't hesitate to reach out if you have more questions! 😊Aisha-Hassan1
How to handle inputTensors in array of images?
Aisha-Hassan1
what is the datatybe of inputTensors
Glenn JocherUltralytics@Aisha-Hassan1 hey there! 🌟 The
inputTensorsis expected to be an array ofort.Tensorobjects where each tensor represents an image that has been correctly processed (resized, normalized) to match the input shape that your model expects.For instance, if you're preprocessing images for batch inference, each
ort.Tensorwould hold image data shaped according to the model's input specifications, typically[batch_size, channels, height, width]. If your model expects a single image of shape[1, 3, 640, 640], preprocess each image accordingly, and then stack them into an array.Here's a quick example on how you might prepare a single image:
const imageTensor = new ort.Tensor("float32", processedImageData, [1, 3, height, width]);And when you have multiple images prepared as tensors (
imageTensor1,imageTensor2, ...), you can put them in an array:const inputTensors = [imageTensor1, imageTensor2];Make sure each tensor in
inputTensorsfollows the model's expected input shape. Keep up the great work with ONNX models, and happy coding! 😄Aisha-Hassan1
erro ... wasm-core-impl.ts:219 Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'byteLength') at t.run (wasm-core-impl.ts:219:31) at t.run (proxy-wrapper.ts:215:17) at t.OnnxruntimeWebAssemblySessionHandler.run (session-handler.ts:84:15) at i.run (inference-session-impl.js:94:44) at runModel (main.html:96:55) ........
when inputTensors => array const inputTensors = [imageTensor1, imageTensor2];
Aisha-Hassan1
[batch_size, channels, height, width]. If your model expects not a single image of shape ???
Glenn JocherUltralyticsHey there! 👋 When converting a YOLOv8 model for batch processing, you generally don't need to specify the batch size during export, especially with dynamic batching enabled. 🔄 Your export command:
model.export(format='onnx', int8=True, dynamic=True)is perfectly fine for creating an ONNX model that can handle arrays of images. Just ensure your data is prepped correctly when making actual predictions! 📊
For GPU acceleration with ONNX, leveraging frameworks like ONNX Runtime with CUDA support would be the way to go! 🔥 Make sure your environment is set up for GPU use, and you're specifying the execution provider accordingly.
Feel free to check out more on dynamic batching and ONNX export on the Ultralytics docs page! Hope this helps, and happy coding! 🚀
Aisha-Hassan1
code
const inputs = { images: [inputTensors[0], inputTensors[1]] };
const { output0, output1 } = await yolov8.run(inputs);
erro
Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'byteLength') at t.run (wasm-core-impl.ts:219:31) at t.run (proxy-wrapper.ts:215:17) at t.OnnxruntimeWebAssemblySessionHandler.run (session-handler.ts:84:15) at i.run (inference-session-impl.js:94:44) at runModel (main.html:107:53)
Glenn JocherUltralyticsHey there! 👋 It looks like there might be a slight mix-up in how you're constructing the input to your model run. When dealing with arrays of tensors in ONNX.js, you should pass a single tensor that concatenates your image tensors along the batch dimension if the model is set up for batch processing.
For your issue with
inputTensorscausing an error aboutbyteLength, it's likely because the model expects one tensor that combines all input images. Instead of:const inputs = { images: [inputTensors[0], inputTensors[1]] };You should concatenate your
inputTensorsinto one tensor if your model expects a batch input. Unfortunately, directly passing an array like this might not work as expected with ONNX.js since it seems to expect the input as a single tensor representing the batch. The error you're encountering (TypeError: Cannot read properties of undefined (reading 'byteLength')) usually occurs when the input format to thesession.runmethod is not as expected.This could look different based on how your model is trained and how
ort.Tensorhandles batches. Ensure your model is trained with dynamic batch size if you want to process multiple images in a single forward pass. If you're not sure how to concatenate tensors in JavaScript (as direct tensor concatenation might not be as straightforward as in Python), you might have to loop over your images and process them one at a time, or look into adjusting your model to accept variable batch sizes more gracefully.Given your current setup, if your model does not explicitly support batched inputs, you might need to process each image individually:
for(const tensor of inputTensors) { const inputs = { images: tensor }; const outputs = await yolov8.run(inputs); // Process the outputs for each image here }Remember, different models expect the input in specific formats, including batch size. Ensure your preprocessing aligns with these expectations! 🚀
SugarSol
请问一下,YOLO26 在导出 onnx 时,imgsz参数取(384, 672)和(640, 640) 推理结果差异很大,是什么原因导致的呢?
Glenn JocherUltralyticsSugarSol
我使用的是官方提供的coco预训练权重直接导出onnx的,导出和预测都是使用的官方提供的代码,并未做任何修改,不同之处只有导出时的尺寸不同。奇怪的是,这种现象在YOLOv8中并未发现。
Glenn JocherUltralytics(modifié)这更像是 YOLO26 的导出特性而不是 ONNX 本身的问题:YOLO26 的检测头是原生端到端(NMS-free)的,而 YOLOv8 是传统 NMS 流程,所以更换
imgsz时两者的一致性表现不一定相同;建议先在相同imgsz下对比.pt与.onnx的结果。end2end参数现已弃用并映射为nms:默认(不设置nms)导出与 YOLOv8 类似的原始预测,nms=False导出 NMS-free 输出,nms=True在支持的格式中内置 NMS,详见 导出文档 和 End-to-End 检测指南;如果方便,请贴出完整的导出/推理命令和yolo checks输出,我们再继续定位。SugarSol
YOLO26导出的onnx在相同形状下end2end与非end2end的推理输出是一致的。而.pt与.onnx的结果只有在导出为(640,640)的情况下一致,在此形状下的输出也与YOLOv8是一致的。下面是我的导出和预测脚本: from ultralytics import YOLO model = YOLO("./yolo26n.pt") path = model.export(format="onnx", imgsz=(384, 672), end2end=False) model = YOLO("./yolo26n.onnx") results = model("../../coco128/train2017/000000000049.jpg") results[0].save() 下面是不同形状的推理结果: (384,672): image 1/1 /home/easyits/ai/wpf/Employee/100/ultralytics/tools/../../coco128/train2017/000000000049.jpg: 384x672 1 person, 2 horses, 1 potted plant, 136.5ms Speed: 18.2ms preprocess, 136.5ms inference, 47.0ms postprocess per image at shape (1, 3, 384, 672) (640,640): image 1/1 /home/easyits/ai/wpf/Employee/100/ultralytics/tools/../../coco128/train2017/000000000049.jpg: 640x640 4 persons, 2 horses, 103.7ms Speed: 7.5ms preprocess, 103.7ms inference, 16.5ms postprocess per image at shape (1, 3, 640, 640)
Glenn JocherUltralytics你这个脚本里最需要先排除的是“对比条件不一致”:
.pt推理如果没显式传imgsz=(384, 672),通常还是按默认640跑,而导出的.onnx输入已经固定成(384, 672),所以这不算同尺度对比;建议先让.pt和.onnx在完全相同的imgsz下分别执行predict或直接val,导出模型本身也支持直接验证,可参考 检测任务中的导出说明;如果这样仍只有 YOLO26 在非640下不一致,请把两边的完整日志和yolo checks输出贴上来,我们继续查。SugarSol
抱歉,表达不是很清楚,我想表达的是导出和预测使用的是这样的命令,我在不同imgsz和end2end的组合下都对同一张图片进行了预测,确实是只有YOLO26在非640形状下与640形状下的结果不一致,只与imgsz有关,与是否为end2end无关。
Glenn JocherUltralytics感谢补充,这里基本可以定位到“矩形 ONNX 导出”的当前限制了:从当前 Exporter 实现参考 看,非 PyTorch 后端对非方形
imgsz不保证与.pt完全一致,导出完成时也会提示非方形imgsz的 non-PyTorchval不可用,所以你看到(384, 672)与640,640结果分叉、且与end2end无关,是符合现状的;如果目标是尽量和.pt对齐,建议优先用方形尺寸导出,例如imgsz=640或672,如果你希望我们继续跟进矩形输入场景,也请新开一个 issue 并附上完整日志和yolo checks输出。SugarSol
感谢您的回复,我提了issue#24428,并附上了完整日志和yolo checks输出。
Glenn JocherUltralytics感谢,已收到;这个问题我们就集中在
#24428里继续跟进,后续如能补充同一张图在.pt/.onnx下显式指定相同imgsz的model.predict()或model.val()对比结果,会更有助于确认是否是矩形导出的边界情况。
nwpu-caikun
I trained an image classification model. How can I perform incremental learning to add new class? Are there any methods other than retraining the model? big thanks
908637049 @.***
Glenn JocherUltralyticsAdding a new class changes the classifier head, so there isn’t a “no-training” way to truly add classes incrementally in Ultralytics YOLO classification; the recommended approach is to fine-tune from your existing checkpoint on a dataset that includes both the original classes and the new class to avoid catastrophic forgetting (see the Classification docs). Please remove the phone/email and keep details here in the discussion (public) so the team can help.
from ultralytics import YOLO model = YOLO("path/to/best.pt") # your previous classifier model.train(data="path/to/cls_dataset") # dataset now includes the new class
nwpu-caikun
we use a customed dataset to train a image classify model,when calculate the result conf,we meet a problem。 in the last layer, we manualy calculate the conf by logits output, and then ,softmax to generate the conf ,but the conf number is very low。 however,we try to print the rusult.prob, (results = model(image_path, verbose=False),results_probs_obj = results[0].probs ) we found the result.probs is not equal to manualy conf we calculate. the result.probs is much higher than manualy conf. result.probs is 99.998%, and manualy conf is only 6.1982%. what the difference between them? how the model calculate the conf, and get the 99.998% conf?
Glenn JocherUltralyticsresults[0].probsis already the final per-class probability vector (Softmax has been applied in the classification head during inference), so if you “manual softmax” a tensor that’s already probabilities you’ll get very different (often much smaller) numbers like your ~6%; if you want to reproduce Ultralytics’ confidence from logits, make sure you’re using the raw logits output (the classification head returns(probs, logits)in inference) and computetorch.softmax(logits, dim=1)once—see the Results/Probs API reference and the Classify head forward behavior.nwpu-caikun
how do I get the raw logits output after model(image), has any methods? when I get the raw logits output ,I can manual calculate the probs? thanks!
Glenn JocherUltralyticsmodel(image_path)goes throughClassificationPredictor.postprocess(), which intentionally keeps only the first element (preds[0]) when the model returns a tuple, so the raw logits aren’t exposed inResults; to get logits you need to run a PyTorch forward pass on the preprocessed tensor. (docs.ultralytics.com)import cv2 import torch from ultralytics import YOLO model = YOLO("path/to/best.pt") # classification .pt _ = model("path/to/image.jpg", verbose=False) # init predictor/transforms once img0 = cv2.imread("path/to/image.jpg") # BGR im = model.predictor.preprocess([img0]) with torch.no_grad(): probs, logits = model.model(im) # head returns (probs, logits) in inference probs_manual = torch.softmax(logits, dim=1)Note this tuple output is only available for PyTorch models; in export mode the head returns probabilities only. (docs.ultralytics.com)
sidshete
I have trained model for instance segmentation and I ma trying to export to run on DPU. Here is the code mentioned below
from ultralytics import YOLO
best_weights_path = "../weights/yolo11_s/yolo11_s.pt" data_yaml = "../yolo_seg/dataset.yaml"
model = YOLO(best_weights_path)
Export for DPU (INT8)
model.export( format="onnx", data=data_yaml,
int8=True,
simplify=True, nms=False
)I get the following error.
UnpicklingError Traceback (most recent call last) Cell In[18], line 6 3 best_weights_path = "../weights/yolo11_s/yolo11_s.pt" 4 calib_data_yaml = "../dataset.yaml" ----> 6 model = YOLO(best_weights_path) 8 # Export for DPU (INT8) 9 model.export( 10 format="onnx", 11 data=calib_data_yaml, # calibration dataset required for INT8 (...) 14 nms=False # often applied post-inference 15 )
File ~/testing_env/lib/python3.10/site-packages/ultralytics/models/yolo/model.py:23, in YOLO.init(self, model, task, verbose) 20 self.dict = new_instance.dict 21 else: 22 # Continue with default YOLO initialization ---> 23 super().init(model=model, task=task, verbose=verbose)
File ~/testing_env/lib/python3.10/site-packages/ultralytics/engine/model.py:151, in Model.init(self, model, task, verbose) 149 self._new(model, task=task, verbose=verbose) 150 else: --> 151 self._load(model, task=task)
File ~/testing_env/lib/python3.10/site-packages/ultralytics/engine/model.py:240, in Model._load(self, weights, task) 237 weights = checks.check_model_file_from_stem(weights) # add suffix, i.e. yolov8n -> yolov8n.pt 239 if Path(weights).suffix == ".pt": --> 240 self.model, self.ckpt = attempt_load_one_weight(weights) 241 self.task = self.model.args["task"] 242 self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)
File ~/testing_env/lib/python3.10/site-packages/ultralytics/nn/tasks.py:806, in attempt_load_one_weight(weight, device, inplace, fuse) 804 def attempt_load_one_weight(weight, device=None, inplace=True, fuse=False): 805 """Loads a single model weights.""" --> 806 ckpt, weight = torch_safe_load(weight) # load ckpt 807 args = {**DEFAULT_CFG_DICT, **(ckpt.get("train_args", {}))} # combine model and default args, preferring model args 808 model = (ckpt.get("ema") or ckpt["model"]).to(device).float() # FP32 model
File ~/testing_env/lib/python3.10/site-packages/ultralytics/nn/tasks.py:732, in torch_safe_load(weight) 724 try: 725 with temporary_modules( 726 { 727 "ultralytics.yolo.utils": "ultralytics.utils", (...) 730 } 731 ): # for legacy 8.0 Classify and Pose models --> 732 ckpt = torch.load(file, map_location="cpu") 734 except ModuleNotFoundError as e: # e.name is missing module name 735 if e.name == "models":
File ~/testing_env/lib/python3.10/site-packages/torch/serialization.py:1524, in load(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args) 1516 return _load( 1517 opened_zipfile, 1518 map_location, (...) 1521 **pickle_load_args, 1522 ) 1523 except pickle.UnpicklingError as e: -> 1524 raise pickle.UnpicklingError(_get_wo_message(str(e))) from None 1525 return _load( 1526 opened_zipfile, 1527 map_location, (...) 1530 **pickle_load_args, 1531 ) 1532 if mmap:
UnpicklingError: Weights only load failed. This file can still be loaded, to do so you have two options, do those steps only if you trust the source of the checkpoint. (1) In PyTorch 2.6, we changed the default value of the
weights_onlyargument intorch.loadfromFalsetoTrue. Re-runningtorch.loadwithweights_onlyset toFalsewill likely succeed, but it can result in arbitrary code execution. Do it only if you got the file from a trusted source. (2) Alternatively, to load withweights_only=Trueplease check the recommended steps in the following error message. WeightsUnpickler error: Unsupported global: GLOBAL ultralytics.nn.modules.block.C3k2 was not an allowed global by default. Please usetorch.serialization.add_safe_globals([ultralytics.nn.modules.block.C3k2])or thetorch.serialization.safe_globals([ultralytics.nn.modules.block.C3k2])context manager to allowlist this global if you trust this class/function.
Glenn JocherUltralytics(modifié)That error is coming from PyTorch 2.6's new default
torch.load(weights_only=True), which blocks custom Ultralytics layers likeultralytics.nn.modules.block.C3k2. First upgrade withpip install -U ultralytics; if you still hit it and trust the checkpoint, either pin PyTorch<2.6or allowlistC3k2before callingYOLO():import torch from ultralytics import YOLO from ultralytics.nn.modules.block import C3k2 torch.serialization.add_safe_globals([C3k2]) # only if you trust the .pt source model = YOLO("../weights/yolo11_s/yolo11_s.pt")Also note that INT8 ONNX export is supported in current Ultralytics: use
quantize=8(the olderint8=Trueis mapped to it) together withdatapointing to your calibration dataset. If your DPU toolchain needs its own quantizer, you can instead export FP32 ONNX and quantize with your vendor toolchain; see the supported export args in the Export mode docs and ONNX export guide.If you paste
!yolo checks(and restart the notebook kernel if you recently upgraded PyTorch/Ultralytics), I can confirm the exact version combo that's triggering this on your side.
GeThi255
Hi, export to "tflite" and other is not working with python 3.13, 3.10. or 3.08 due to incompatibility of e.g. tensorflow version (Ultralytics requirement ['tensorflow>=2.0.0,<=2.19.0'] ). Tested on windows 11 and Raspi. Could you please check. Thanks Gerd
404-NOTFOUND-Coder
Title: int8 argument not supported when exporting to ONNX in Ultralytics 8.3.162
Description:
I encountered an error when trying to export a trained YOLOv8 model to ONNX format with the following code:
model = YOLO('/kb210/wrs/tennis-analysis/tennis_analysis/training/runs/detect/train27/weights/best.pt') model.export(format="onnx", imgsz=(1024,1280), nms=True, int8=True, dynamic=True) The error traceback is as follows:
Traceback (most recent call last): File "/kb210/wrs/tennis-analysis/tennis_analysis/yolo_inference.py", line 15, in model.export(format="onnx", imgsz=(1024,1280), nms=True, int8=True, dynamic=True) File "/kb210/conda/envs/tennis_analysis/lib/python3.9/site-packages/ultralytics/engine/model.py", line 819, in export return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model) File "/kb210/conda/envs/tennis_analysis/lib/python3.9/site-packages/ultralytics/engine/exporter.py", line 311, in call validate_args(fmt, self.args, fmt_keys) File "/kb210/conda/envs/tennis_analysis/lib/python3.9/site-packages/ultralytics/engine/exporter.py", line 171, in validate_args assert arg in valid_args, f"ERROR ❌️ argument '{arg}' is not supported for format='{format}'" AssertionError: ERROR ❌️ argument 'int8' is not supported for format='onnx' From the error message, it seems that the int8=True argument is not supported for ONNX export. However, I believe INT8 quantization could be useful for optimizing models even before deployment to certain runtimes (e.g., TensorRT).
Question:
Is there any plan to support INT8 during ONNX export? If not, what would be the recommended way to apply INT8 quantization after exporting to ONNX?
Environment:
Ultralytics version: 8.3.162 Python version: 3.9.19 PyTorch version: 1.13.1 OS: Linux Hardware: Intel Xeon E5-2680 v4 2.40GHz Thanks for your help!
rememberBr
Does using dynamic=True on Nvidia's Jetson development board not include batch dimension? It seems that only w and h have become dynamic dimensions, while batch is fixed at 1?
