Exportation au format Intel OpenVINO
OpenVINO est la boîte à outils open source d’Intel pour optimiser et exécuter l’inférence IA. L’exportation d’un modèle Ultralytics YOLO26 avec format="openvino" crée un répertoire yolo26n_openvino_model/ contenant un modèle OpenVINO IR (fichiers .xml et .bin) pour les CPU Intel, les GPU Intel intégrés et discrets, ainsi que les NPU Intel, en précision FP32, FP16 ou INT8.
En bref#
| Propriété | Détails |
|---|---|
Argument format | openvino |
| Sortie | yolo26n_openvino_model/, un répertoire contenant yolo26n.xml, yolo26n.bin et metadata.yaml ; yolo26n_int8_openvino_model/ pour une exportation quantize=8 |
| Fonctionne sur | CPU Intel, GPU Intel intégrés et discrets, et NPU Intel. Le périphérique CPU fonctionne également sur d’autres processeurs x86-64 et ARM64, comme ceux d’AMD et les puces Apple |
| Environnement d’exécution | OpenVINO Runtime 2024.0.0 ou version ultérieure (le paquet Python openvino) |
| Précision | FP32, FP16, INT8. YOLO26n fait 10,1 Mo en FP32, 5,3 Mo en FP16 et 3,3 Mo en INT8 |
| Machine d’exportation | Linux, macOS ou Windows. L’exportation s’exécute sur le CPU et ne nécessite pas de GPU |
La plateforme Ultralytics peut exporter pour toi un modèle entraîné vers OpenVINO ; tu n’as donc pas besoin d’un environnement d’exportation local.
Démarrage rapide#
Installe le paquet Ultralytics avec les dépendances d’exportation OpenVINO :
pip install "ultralytics[export-openvino]"Cela installe openvino et, avec Python 3.9 ou version ultérieure, nncf pour la quantification INT8. Avec un simple pip install ultralytics, la première exportation installe les paquets manquants. L’exportation requiert les versions suivantes :
| Paquet | Version requise |
|---|---|
torch | 2.1 ou version ultérieure |
openvino | 2024.0.0 ou version ultérieure ; 2025.2.0 ou version ultérieure sur macOS 15.4 et les versions ultérieures |
nncf | 2.14.0 ou version ultérieure, uniquement pour quantize=8 ; version antérieure à 3.0.0 avec PyTorch antérieur à 2.3 |
Pour les autres méthodes d’installation, consulte le guide d’installation. Exporte ensuite ton modèle et charge le répertoire exporté pour exécuter l’inférence ou valider sa précision. Le cours OpenVINO sur CPU présente les mêmes étapes.
from ultralytics import YOLO
# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")
# Exporter le modèle au format OpenVINO
model.export(format="openvino") # creates 'yolo26n_openvino_model/'
# Exporter un modèle OpenVINO quantifié en INT8 avec des données d’étalonnage
model.export(format="openvino", quantize=8, data="coco8.yaml") # creates 'yolo26n_int8_openvino_model/'from ultralytics import YOLO
# Charger le modèle OpenVINO exporté
model = YOLO("yolo26n_openvino_model/")
# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")
# Exécuter l’inférence sur le GPU Intel ; utiliser « npu » pour le NPU Intel ou « cpu » pour le CPU
results = model("https://ultralytics.com/images/bus.jpg", device="xpu")from ultralytics import YOLO
# Charger le modèle OpenVINO exporté
model = YOLO("yolo26n_openvino_model/")
# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")Tâches prises en charge#
L’exportation OpenVINO prend en charge les sept tâches Ultralytics avec les modèles YOLOv8, YOLO11 et YOLO26 : détection, segmentation, segmentation sémantique, estimation de profondeur, classification, estimation de pose et OBB. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui intègre ces têtes.
Arguments d’exportation#
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
format | str | 'openvino' | Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement. |
imgsz | int ou tuple | 640 | Taille d’image de l’entrée du modèle : un entier pour les images carrées ou un tuple (height, width). Si elle n’est pas fournie, l’export utilise la taille à laquelle le point de contrôle a été entraîné. Les points de contrôle YOLO26 officiels utilisent 640 pour la détection, la segmentation, la pose et les modèles sémantiques préentraînés sur ADE20K, 1024 pour OBB et les modèles sémantiques préentraînés sur Cityscapes, 768 pour la profondeur et 224 pour la classification. |
quantize | int ou str | None | Précision de quantification : 16 (FP16 : les poids sont stockés en demi-précision, tandis que les entrées et les sorties restent en FP32) ou 8 (quantification INT8 après entraînement avec NNCF, à partir d’images d’étalonnage de data, enregistrée dans un répertoire _int8_openvino_model/) ; 32/non défini correspond à FP32. Un checkpoint entraîné avec quantize=8 ne peut pas être exporté vers OpenVINO ; consulte Limitations et dépannage. Remplace les options obsolètes half/int8. |
data | str | None | Fichier YAML du jeu de données utilisé pour l’étalonnage INT8 ; pour la classification, indique plutôt un répertoire de jeu de données ou le nom d’un jeu de données intégré. L’étalonnage utilise la partition val, sauf si split est défini. Si cette valeur est omise avec quantize=8, Ultralytics utilise le petit jeu de données par défaut pour la tâche du modèle, par exemple coco8.yaml pour la détection. |
fraction | float, int ou list | 1.0 | Sous-ensemble de calibration exprimé en ratio, en nombre d’images ou en listes [train, val, test] de ratios/de nombres. Les listes de deux éléments laissent test complet, tandis que 0 l’ignore. |
dynamic | bool | False | Rend dynamiques la taille du lot, la hauteur et la largeur de l’entrée, afin qu’un même modèle accepte différentes tailles de lot et d’image. Sur un NPU Intel, un modèle dynamique s’exécute toujours avec la valeur imgsz de l’exportation ; consulte Déploiement. |
nms | bool, facultatif | None | Sélectionne la sortie brute (None, par défaut), la NMS intégrée (True) ou la tête sans NMS (False). Consulte le format de sortie. |
batch | int | 1 | Taille de lot du modèle exporté. Pour une exportation statique, cette taille de lot est fixée dans la forme d’entrée. C’est aussi la taille de lot utilisée pour l’étalonnage INT8. |
device | str | None | L’exportation s’exécute toujours sur le CPU. Avec quantize=8, device=npu sélectionne des activations INT8 symétriques pour les modèles YOLO de détection, de segmentation, de pose et OBB, qui s’exécutent jusqu’à 2 fois plus vite sur les NPU Intel. |
Pour les arguments communs à tous les formats, consulte la documentation du mode Export.
Quantification INT8#
quantize=8 applique une quantification après entraînement avec NNCF : l’exportation fait passer les images d’étalonnage dans le modèle et stocke les poids et les activations sous forme d’entiers sur 8 bits lorsque c’est possible.
- Données d’étalonnage : l’exportation effectue l’étalonnage sur chaque lot complet de la partition
valdedata, ou de la partition indiquée parsplit. Utilisefractionpour limiter le nombre d’images. L’exportation affiche un avertissement si le nombre est inférieur à 300 images. - Tête de détection : pour les modèles dotés d’une tête de détection YOLO (détection, segmentation, pose et OBB) ainsi que pour RT-DETR, les opérations de décodage des sorties de la tête (reshape, concaténation, décodage des boîtes et DFL) et toutes les opérations sigmoid restent en virgule flottante, tandis que les convolutions de la tête sont quantifiées. Les modèles de classification, de segmentation sémantique et de profondeur n’ont aucune opération exclue.
- Entrées et sorties : un modèle INT8 conserve l’entrée
float32et les sorties du modèle FP32, de sorte que le code d’inférence écrit pour le modèle FP32 s’exécute sans modification. - NPU Intel : ajoute
device=npuà une exportation INT8 destinée à être exécutée sur un NPU Intel. Cette option fait passer les modèles YOLO de détection, de segmentation, de pose et OBB d’une quantification asymétrique à une quantification symétrique des activations.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Étalonne sur 10 % des images de validation COCO (500 images) ; remplace coco.yaml par ton propre jeu de données
model.export(format="openvino", quantize=8, data="coco.yaml", fraction=0.1)
# Charger le modèle INT8 exporté et exécuter l’inférence
model = YOLO("yolo26n_int8_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg")Dans les benchmarks, les modèles INT8 ont été de 1,02 à 1,33 fois plus rapides que les modèles FP32 sur un CPU de serveur et ont perdu de 0,5 à 0,9 mAP sur COCO val2017. Sur les processeurs Intel Core Ultra, les modèles INT8 ont été de 1,2 à 3,8 fois plus rapides que les modèles FP32. Valide un modèle INT8 sur tes propres données avant de le déployer.
Format de sortie#
L’exportation crée un répertoire contenant trois fichiers :
| Fichier | Contenu |
|---|---|
yolo26n.xml | Le graphe du réseau au format OpenVINO IR |
yolo26n.bin | Les poids |
metadata.yaml | Les noms de classes, la tâche, la taille d’image, la taille de lot, le stride et les arguments d’exportation, qu’Ultralytics lit lors du chargement du modèle |
Le modèle prend une entrée de forme (batch, 3, height, width), en RGB et ramenée à l’intervalle 0-1. L’entrée et les sorties sont au format float32 dans les modèles FP32, FP16 et INT8, à l’exception de la sortie de segmentation sémantique, qui est une carte de classes uint8 (int32 pour les modèles comptant plus de 256 classes). Les tenseurs ne portent pas les noms images et output0 de l’exportation ONNX ; dans ton code, accède donc à l’entrée et aux sorties par leur index.
Les formes des sorties sont les mêmes que pour l’exportation ONNX et dépendent de la tâche et de l’argument nms : un modèle de détection YOLO26n exporté avec imgsz=640 renvoie (1, 84, 8400) avec la valeur par défaut nms=None et (1, 300, 6) avec nms=False ou nms=True. Consulte le format de sortie ONNX pour connaître les formes et le contenu de chaque tâche. Avec nms=True, le seuil de confiance conf (valeur par défaut 0.25), le seuil IoU iou, agnostic_nms et max_det sont fixés dans le graphe au moment de l’exportation. Une valeur conf plus faible lors de la prédiction ou de la validation ne peut pas rétablir les détections déjà supprimées par le graphe ; effectue donc une nouvelle exportation pour modifier ces valeurs.
Déployer#
YOLO("yolo26n_openvino_model/") exécute le modèle avec OpenVINO Runtime et associe l’argument device à un périphérique OpenVINO :
device | Périphérique OpenVINO |
|---|---|
| non défini | AUTO, qui laisse OpenVINO choisir entre le CPU et les GPU Intel (sa liste de priorités par défaut exclut le NPU), ou CPU lorsque le CPU est le seul périphérique détecté par OpenVINO |
cpu | CPU |
xpu ou xpu:0 | GPU ou GPU.0, le GPU Intel intégré ou discret. xpu:1 sélectionne GPU.1 sur une machine équipée de deux GPU Intel |
npu | NPU, l’unité de traitement neuronal des processeurs Intel Core Ultra |
Les autres valeurs, comme 0 ou mps, sont traitées comme si device n’était pas défini. Les anciens noms intel:cpu, intel:gpu et intel:npu fonctionnent toujours et affichent un avertissement de dépréciation. Le tableau des périphériques d’inférence compare ces noms entre les formats. La ligne de journal Using OpenVINO LATENCY mode for batch=1 inference on CPU... indique le périphérique signalé par OpenVINO lors du chargement du modèle. Avec AUTO, il peut s’agir du CPU alors qu’un GPU Intel compile encore le modèle ; définis donc device pour en être certain. Pour un modèle .pt, device="xpu" sélectionne plutôt le backend GPU Intel de PyTorch, qui sert aussi de périphérique pour l’entraînement sur les GPU Intel, et device="npu" sélectionne un NPU Huawei Ascend, et non le NPU Intel.
Le comportement pendant l’inférence dépend de la méthode d’exportation du modèle :
- Exportation statique (par défaut) : le modèle s’exécute toujours avec les valeurs
imgszetbatchde son exportation, qu’Ultralytics lit dansmetadata.yaml. Une valeurimgszpassée àpredictest ignorée. Les lots plus grands sont divisés en segments de la taille de lot de l’exportation et les plus petits sont complétés ; le modèle peut donc traiter n’importe quel nombre d’images. - Exportation dynamique (
dynamic=True) :predictaccepte différentes tailles de lot et toute valeurimgszmultiple du stride du modèle. Les NPU Intel et les modèles INT8 sur les CPU Intel AMX font exception ; consulte Limitations et dépannage. - Mode latence : Ultralytics compile le modèle avec l’indication de performance OpenVINO
LATENCYet exécute l’inférence de manière synchrone. Pour traiter de nombreuses requêtes en parallèle avec l’indicationTHROUGHPUT, utilise l’API OpenVINO Runtime, comme l’explique le guide sur la latence et le débit. - NPU Intel : Ultralytics compile le modèle pour une taille de lot de 1 sur un NPU et divise les lots plus grands en images individuelles. Sur un NPU, une exportation dynamique est figée à la valeur
imgszde l’exportation.
Exécuter avec l’API OpenVINO Runtime#
Pour exécuter le modèle en dehors du paquet Ultralytics, charge le fichier .xml avec le paquet openvino. Le modèle attend une image prétraitée et renvoie les sorties brutes décrites dans le format de sortie ; le letterboxing et, pour une exportation par défaut, la NMS relèvent donc de ton code :
# Exporter d’abord : yolo export model=yolo26n.pt format=openvino nms=False
import numpy as np
import openvino as ov
import yaml
core = ov.Core()
model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
compiled = core.compile_model(model, "AUTO") # ou « CPU », « GPU », « NPU »
image = np.zeros((1, 3, 640, 640), dtype=np.float32) # ton image prétraitée : RGB, NCHW, 0-1
detections = compiled(image)[0][0] # première sortie, première image : forme (300, 6)
detections = detections[detections[:, 4] > 0.25] # conserver les lignes au-dessus du seuil de confiance
with open("yolo26n_openvino_model/metadata.yaml") as f:
names = yaml.safe_load(f)["names"] # {0: 'person', 1: 'bicycle', ...}Guides de déploiement#
- Modes latence et débit d’OpenVINO : choisis entre la latence la plus faible pour un flux et le débit le plus élevé pour plusieurs flux.
- Intel DL Streamer : exécute des modèles exportés dans des pipelines d’analyse vidéo GStreamer sur les CPU, GPU et NPU Intel Core Ultra.
- Périphériques d’inférence OpenVINO : les périphériques CPU, GPU et NPU, ainsi que le mode
AUTOdans la documentation OpenVINO. - Notebooks OpenVINO : les notebooks de tutoriels d’Intel, notamment l’optimisation de YOLO26.
Limites et dépannage#
- Version de PyTorch : l’exportation échoue avec
OpenVINO export requires torch>=2.1sur les anciennes versions de PyTorch. - macOS 15.4 et versions ultérieures : OpenVINO 2025.1.0 et les versions antérieures échouent sur ces versions de macOS ; l’exportation nécessite donc
openvino>=2025.2.0et met à jour un ancien paquet. - Checkpoints entraînés avec
quantize=8: un checkpoint affiné par apprentissage conscient de la quantification échoue avecformat='openvino' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Exporte plutôt le checkpoint utilisé au début de l’affinage avecquantize=8, ou exporte le checkpoint affiné vers ONNX ou TensorRT. - Exportation INT8 sans
data: l’exportation consigneINT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'.et effectue l’étalonnage avec le petit jeu de données par défaut pour la tâche. Indiquedataavec des images représentatives des données de déploiement. - Taille de l’étalonnage INT8 : l’exportation consigne
>300 images recommended for INT8 calibration, found 4 images.lorsque la partition d’étalonnage contient moins de 300 images.coco8.yamlne comprend que 4 images de validation, ce qui suffit pour tester l’exportation, mais pas pour étalonner un modèle destiné au déploiement. - Répertoire de sortie : chaque exportation d’un checkpoint, sauf en INT8, écrit dans le même répertoire
yolo26n_openvino_model/, quels que soient ses paramètresquantize,imgsz,dynamic,nmsoubatch; l’exportation suivante remplace donc la précédente. Toutes les exportations INT8, avec ou sansdevice=npu, utilisent le même répertoireyolo26n_int8_openvino_model/. - Périphérique indisponible : si le périphérique demandé est introuvable, Ultralytics consigne
OpenVINO device 'GPU' not available. Using 'AUTO' instead.(ouUsing 'CPU' instead.sur une machine où OpenVINO ne détecte que le CPU) et poursuit l’exécution sur ce périphérique. Vérifie que ton processeur est compatible avec OpenVINO et installe le pilote Intel GPU ou NPU. - NPU Intel : Ultralytics exécute un NPU avec une taille de lot de 1 et des formes d’entrée fixes ; consulte Déploiement. Passe
device=npupour l’utiliser : sidevicen’est pas défini, le NPU n’est pas sélectionné. - Formes dynamiques avec NMS : une exportation avec
dynamic=Trueetnms=Trueconsigne'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'.lorsquebatchconserve la valeur1. Ultralytics traite les lots plus grands par segments de la taillebatchde l’exportation. - Modèles INT8 dynamiques sur les CPU Intel AMX : sous Linux, sur un CPU prenant en charge AMX (Intel Sapphire Rapids et modèles plus récents), Ultralytics exécute un modèle INT8 dynamique sur le périphérique
CPUouAUTOavec la valeurimgszde son exportation, comme pour un modèle statique : une valeurimgszpassée àpredictouvalest ignorée, etvalutilise la valeurbatchde l’exportation.predictaccepte toujours d’autres tailles de lot et recompile le modèle pour chaque nouvelle taille de lot ; la première inférence avec une nouvelle taille est donc plus lente. - Windows : sous Windows, Ultralytics définit l’indication de précision d’inférence du CPU sur FP32, ce qui empêche OpenVINO d’utiliser des noyaux flottants de précision inférieure (les modèles INT8 s’exécutent toujours en INT8), et limite oneDNN aux jeux d’instructions antérieurs à AMX. Définis la variable d’environnement
ONEDNN_MAX_CPU_ISAavant de charger le modèle pour appliquer une autre limite. - Linux sur ARM64 : Ultralytics exécute le périphérique
CPUen mode d’exécution OpenVINO axé sur la précision, avec une précision d’inférence FP32. - NMS intégrée :
nms=Truedéclenche'nms=True' is not valid for classification models.pour la classification et est ignoré avec un avertissement pour les modèles de segmentation sémantique et d’estimation de profondeur ('nms=True' is not valid for semantic models. Forcing 'nms=None'.), ainsi que pour les modèles RT-DETR ('nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.). - Tête sans NMS :
nms=Falsenécessite un modèle doté d’une tête sans NMS, comme YOLO26 ou YOLOv10. Pour les autres modèles, par exemple YOLO11, l’exportation affiche l’avertissementThis model has no one-to-one head; using one-to-many outputs.et écrit la sortie brute(1, 84, 8400).
Pour les autres erreurs, consulte le guide des problèmes courants.
Évaluations comparatives de YOLO26 avec OpenVINO#
Les tableaux ci-dessous comparent PyTorch aux modèles OpenVINO FP32, FP16 et INT8 pour chacun des modèles de détection YOLO26. Le premier ensemble a été mesuré sur un CPU de serveur avec la précision COCO val2017, et le second sur trois processeurs Intel Core Ultra avec leur CPU et leur GPU, ainsi que le NPU de deux d’entre eux. La page des modèles YOLO26 répertorie la précision, la vitesse CPU ONNX et la vitesse T4 TensorRT de chaque modèle.
FP32, FP16 et INT8 sur un CPU de serveur#
Toutes les valeurs de cette section ont été mesurées sur le CPU d’un serveur équipé de deux processeurs AMD EPYC 9655 à 96 cœurs, et non sur un CPU Intel. PyTorch a utilisé 8 threads et OpenVINO 96 threads, les valeurs par défaut choisies respectivement par Ultralytics et OpenVINO sur ce serveur ; les colonnes PyTorch et OpenVINO diffèrent donc par le nombre de threads autant que par le moteur d’exécution. PyTorch a également effectué la validation avec une inférence rectangulaire, chaque image étant complétée jusqu’à un rectangle respectant son rapport hauteur/largeur (512x672 pour une image de 480x640), tandis que les modèles OpenVINO statiques se sont toujours exécutés en 640x640.
Millisecondes par image, plus bas est préférable. Le format le plus rapide pour chaque modèle est en gras.
| Modèle | imgsz | PyTorch | OpenVINO FP32 | OpenVINO FP16 | OpenVINO INT8 |
|---|---|---|---|---|---|
| YOLO26n | 640 | 13.31 | 3.41 | 3.33 | 3.35 |
| YOLO26s | 640 | 24.28 | 5.18 | 5.18 | 4.51 |
| YOLO26m | 640 | 49.94 | 8.39 | 8.34 | 6.60 |
| YOLO26l | 640 | 63.75 | 10.92 | 11.05 | 8.94 |
| YOLO26x | 640 | 115.11 | 17.12 | 17.16 | 12.83 |
YOLO26n sur les mêmes 8 CPU (PyTorch et OpenVINO tous deux limités aux CPU 0-7 de ce serveur avec taskset) :
| Mesure | PyTorch | OpenVINO FP32 | OpenVINO FP16 | OpenVINO INT8 |
|---|---|---|---|---|
| Latence (ms/image) | 9.28 | 7.13 | 7.14 | 6.71 |
| mAPval 50-95 | 40.8 | 40.9 | 40.9 | 40.3 |
- OpenVINO FP32 a été de 3,9 à 6,7 fois plus rapide que PyTorch avec les nombres de threads par défaut indiqués ci-dessus, pour une précision équivalente à 0,1 mAP près. Lorsque les deux moteurs étaient limités aux mêmes 8 CPU, configuration où PyTorch lui-même était plus rapide qu’avec le réglage par défaut, OpenVINO FP32 a exécuté YOLO26n 1,3 fois plus vite que PyTorch et INT8 1,06 fois plus vite que FP32.
- FP16 a réduit de moitié la taille du modèle, avec une différence de précision inférieure à 0,1 mAP par rapport à FP32 et une latence équivalente à FP32 (à 3 % près).
- INT8 a été de 1,02 à 1,33 fois plus rapide que FP32, a réduit la taille du modèle d’un facteur de 3,1 à 3,9 et a entraîné une perte de 0,5 à 0,9 mAP.
Mesures effectuées avec ultralytics 8.4.212, OpenVINO 2026.4.1, NNCF 3.4.0 et PyTorch 2.15.0 avec batch=1, le 14 novembre 2026. La latence correspond à l’étape d’inférence rapportée par val et n’inclut pas le prétraitement ni le post-traitement. Les valeurs PyTorch, FP32 et FP16 sont la moyenne de trois exécutions, dont les résultats différaient jusqu’à 26 % pour PyTorch et 6 % pour OpenVINO. Les modèles INT8 ont été étalonnés sur 591 images COCO train2017 (split=train fraction=0.005) et construits trois fois ; les valeurs INT8 correspondent à la moyenne des trois versions. Le tableau à 8 CPU utilise une seule version INT8 exécutée trois fois.
CPU, GPU et NPU Intel Core Ultra#
Ces tableaux ont été mesurés sur trois processeurs Intel Core Ultra avec openvino 2026.2.1 en mode benchmark : model.benchmark(data="coco128.yaml", format="openvino", device=...), avec device défini sur cpu, xpu ou npu. La précision correspond au mAP50-95 sur le jeu de données COCO128 de 128 images ; elle n’est donc pas comparable aux valeurs COCO val2017 ci-dessus. PyTorch s’est exécuté sur le CPU du même processeur. Les modèles YOLO26 s’exécutent uniquement sur le NPU des processeurs Intel Core Ultra série 2xxV, série 3xx et plus récents.
Intel Core Ultra X7 358H#
L’Intel Core Ultra X7 358H (Panther Lake) associe des cœurs CPU, un GPU Intel Arc intégré et un NPU Intel AI Boost.
Millisecondes par image ; plus la valeur est faible, mieux c’est. La colonne la plus rapide de chaque modèle est en gras.
| Modèle | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 | NPU FP32 | NPU FP16 | NPU INT8 |
|---|---|---|---|---|---|---|---|---|---|---|
| YOLO26n | 29.28 | 14.35 | 14.23 | 9.99 | 4.09 | 4.03 | 4.24 | 7.68 | 7.71 | 8.60 |
| YOLO26s | 59.32 | 35.03 | 33.55 | 16.68 | 5.08 | 5.14 | 4.47 | 9.89 | 9.94 | 10.69 |
| YOLO26m | 143.21 | 90.53 | 88.82 | 33.33 | 7.10 | 7.06 | 5.61 | 13.02 | 13.13 | 14.84 |
| YOLO26l | 181.16 | 112.83 | 111.31 | 43.27 | 8.45 | 8.49 | 6.25 | 14.53 | 14.55 | 15.64 |
| YOLO26x | 379.75 | 241.21 | 236.87 | 78.92 | 13.03 | 12.98 | 8.74 | 23.48 | 23.41 | 21.56 |
Processeurs Intel Core Ultra des générations précédentes#
Intel Core Ultra 7 258V (Lunar Lake)
Millisecondes par image ; plus la valeur est faible, mieux c’est. La colonne la plus rapide de chaque modèle est en gras.
| Modèle | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 | NPU FP32 | NPU FP16 | NPU INT8 |
|---|---|---|---|---|---|---|---|---|---|---|
| YOLO26n | 27.33 | 16.84 | 16.73 | 8.62 | 3.33 | 3.34 | 3.46 | 23.71 | 23.70 | 23.96 |
| YOLO26s | 60.20 | 54.71 | 54.45 | 20.19 | 4.66 | 4.65 | 3.99 | 26.62 | 26.62 | 25.89 |
| YOLO26m | 152.87 | 178.59 | 179.25 | 53.07 | 9.03 | 8.98 | 5.70 | 32.94 | 33.01 | 30.95 |
| YOLO26l | 201.57 | 238.15 | 233.70 | 67.73 | 11.32 | 11.36 | 7.45 | 36.02 | 35.77 | 32.64 |
| YOLO26x | 431.04 | 567.22 | 561.39 | 151.11 | 19.08 | 19.63 | 13.69 | 49.64 | 49.69 | 41.75 |
Intel Core Ultra 7 155H (Meteor Lake)
Millisecondes par image ; plus la valeur est faible, mieux c’est. La colonne la plus rapide de chaque modèle est en gras.
| Modèle | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 |
|---|---|---|---|---|---|---|---|
| YOLO26n | 33.19 | 13.43 | 13.20 | 11.40 | 9.13 | 9.07 | 5.79 |
| YOLO26s | 70.92 | 36.16 | 36.07 | 15.54 | 16.37 | 16.65 | 9.27 |
| YOLO26m | 192.45 | 102.52 | 101.88 | 35.72 | 34.47 | 35.71 | 15.46 |
| YOLO26l | 239.19 | 129.24 | 128.50 | 45.38 | 43.24 | 43.40 | 19.72 |
| YOLO26x | 511.89 | 293.40 | 296.48 | 85.24 | 79.49 | 79.45 | 34.66 |
Sur les trois processeurs :
- CPU : INT8 a été 1,2 à 3,8 fois plus rapide que FP32 et 2,9 à 6,0 fois plus rapide que PyTorch. FP32 a été 1,6 à 2,5 fois plus rapide que PyTorch sur le X7 358H et le 155H, mais plus lent que PyTorch pour YOLO26m, YOLO26l et YOLO26x sur le 258V.
- GPU : le GPU intégré a exécuté les modèles FP32 3,6 à 29,1 fois plus rapidement que PyTorch sur le CPU. INT8 a été plus rapide que FP32 pour tous les modèles sauf YOLO26n sur le X7 358H et le 258V, avec un gain pouvant atteindre 2,3 fois.
- NPU (X7 358H et 258V) : les modèles FP32 ont été exécutés 1,2 à 16,2 fois plus rapidement que PyTorch sur le CPU, et INT8 a atteint une vitesse de 0,88 à 1,19 fois celle de FP32. Ces modèles INT8 ont été exportés avant que
device=npusélectionne des activations symétriques ; les tableaux ne présentent donc pas l'export INT8 optimisé pour le NPU. - La latence FP16 était à moins de 5 % de celle de FP32 sur chaque appareil, et INT8 a entraîné une baisse de 0,1 à 2,7 points de mAP50-95.
À propos d'OpenVINO#
OpenVINO, abréviation de « Open Visual Inference and Neural Network Optimization », convertit les modèles issus de frameworks tels que PyTorch au format IR et les exécute via une API unique sur les CPU, GPU et NPU Intel. Pour consulter la référence complète, consulte la documentation OpenVINO.
À regarder : Comment exporter Ultralytics YOLO26 au format Intel OpenVINO pour accélérer l’inférence 🚀
FAQ#
Oui, sur le CPU. Le périphérique OpenVINO
CPUfonctionne sur les processeurs x86-64 et ARM64 : les benchmarks des CPU serveur de cette page ont été réalisés sur des processeurs AMD EPYC, et le même export fonctionne sur les puces Apple. Les périphériquesGPUetNPUnécessitent du matériel Intel ; sur les autres machines,device=xpuetdevice=npuutilisent une solution de repli et affichent un avertissement. Pour d'autres cibles, consulte le guide des options de déploiement des modèles.Cela dépend de l'appareil. FP16 (
quantize=16) ne nécessite aucune donnée d'étalonnage, réduit de moitié la taille du modèle et a conservé la précision et la latence de FP32 dans les benchmarks ; utilise-le donc lorsque la taille du modèle compte. INT8 (quantize=8) a donné la latence CPU la plus faible pour la plupart des modèles : sur le CPU serveur, il a réduit la latence de YOLO26s de 5.18 ms à 4.51 ms par image, avec 47.6 mAPval 50-95 contre 48.5 en FP32 ; sur les CPU Intel Core Ultra, il a été 1,2 à 3,8 fois plus rapide que FP32. Sur les GPU Intel intégrés, le gain d'INT8 était plus faible, jusqu'à 2,3 fois, et sur les NPU, les modèles INT8 de ces tests, exportés sansdevice=npu, étaient à peu près aussi rapides que FP32. INT8 nécessite des données d'étalonnage représentatives ; valide donc le modèle INT8 sur tes propres données avant de faire ton choix.Exporte avec
dynamic=Trueet indique le lot etimgszdont tu as besoin au moment de la prédiction. La taille de l'image doit être un multiple du stride du modèle, soit 32 pour les checkpoints YOLO26 officiels autres que ceux de classification ; consulte Déploiement pour connaître les exceptions.Exportation dynamiquefrom ultralytics import YOLO model = YOLO("yolo26n.pt") model.export(format="openvino", dynamic=True) model = YOLO("yolo26n_openvino_model/") results = model(["https://ultralytics.com/images/bus.jpg"] * 4, imgsz=320) # un lot de 4 images de 320 pixelsUtilise OpenVINO lorsque le matériel de déploiement est Intel :
device=xpuetdevice=npusélectionnent le GPU et le NPU Intel, et les modèles OpenVINO INT8 ont été 1,2 à 3,8 fois plus rapides que FP32 sur les CPU Intel Core Ultra dans les benchmarks. Utilise ONNX lorsqu'un même fichier doit aussi fonctionner sur des GPU NVIDIA ou AMD, ou dans des environnements d'exécution autres qu'OpenVINO ; sous Windows, Windows ML peut sélectionner du matériel Intel pour un modèle ONNX.
Commentaires23
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
Heyujie96
how can i export a trained cls or obb kind model to openvino kind
EduardoNew
I encountered some difficulties while trying to run the official video demo. Here is my code:
from ultralytics import YOLO
def main(): # Load a YOLOv8n PyTorch model model = YOLO("yolov8n.pt")
# Export the model model.export(format="openvino") # creates 'yolov8n_openvino_model/' # Load the exported OpenVINO model with explicit task definition ov_model = YOLO("yolov8n_openvino_model\\", task='detect') # Explicitly define task as 'detect' # Run inference results_original = model("D:\\python_YOLO_test\\bus.jpg") # Run ov inference results_ov = ov_model("D:\\python_YOLO_test\\bus.jpg")if name == "main": main() Additional notes: My environment is openvino==2024.0.0, and I executed pip install --upgrade torch ultralytics.
The issue I encountered is as follows:
Results saved to D:\python_YOLO_test Ultralytics YOLOv8.2.57 🚀 Python-3.11.9 torch-2.1.1+cu118 CPU (11th Gen Intel Core(TM) i7-11800H 2.30GHz) YOLOv8n summary (fused): 168 layers, 3,151,904 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)
OpenVINO: starting export with openvino 2024.0.0-14509-34caeefd078-releases/2024/0... OpenVINO: export success ✅ 2.8s, saved as 'yolov8n_openvino_model' (12.3 MB)
Export complete (5.2s) Results saved to D:\python_YOLO_test Predict: yolo predict task=detect model=yolov8n_openvino_model imgsz=640
Validate: yolo val task=detect model=yolov8n_openvino_model imgsz=640 data=coco.yaml
Visualize: https://netron.appimage 1/1 D:\python_YOLO_test\bus.jpg: 640x480 4 persons, 1 bus, 1 stop sign, 324.0ms Speed: 24.0ms preprocess, 324.0ms inference, 21.0ms postprocess per image at shape (1, 3, 640, 480) Loading yolov8n_openvino_model for OpenVINO inference... Using OpenVINO LATENCY mode for batch=1 inference...
Process finished with exit code -1073741819 (0xC0000005)
Process finished with exit code -1073740791 (0xC0000409) The model was successfully exported but did not perform inference, instead, it terminated directly. How should I resolve this issue?
Glenn JocherUltralytics(modifié)@EduardoNew the exit code 0xC0000005 often indicates a memory access violation. Let's address this step-by-step:
-
Path Format: Try using forward slashes in your OpenVINO model path:
"yolov8n_openvino_model/"instead of backslashes. -
OpenVINO Version: Ultralytics requires
openvino>=2024.0.0. Try upgrading to a recent release:
pip install -U openvino- Hardware Compatibility: Ensure you have the latest Intel drivers installed from Intel's official site.
If issues persist, please create a Minimum Reproducible Example and open a GitHub Issue following our bug report guidelines. We'll be happy to investigate further!
-
Ranjith3436
You mentioned that the core CPU inference model takes 23.53 ms. I would like to know if the processing time decreases when we increase the number of CPU cores ? currently i am using 12 thread CPU.
Glenn JocherUltralytics@Ranjith3436 increasing the number of CPU cores can potentially reduce processing time, as it allows for parallel processing, but the actual speedup will depend on the model's ability to leverage multi-threading effectively.
Ranjith3436
how do i can know about model's ability?
Glenn JocherUltralyticsTo assess a model's ability to utilize multiple CPU cores, you can check its support for multi-threading or parallel processing in the documentation or by running benchmarks on your hardware configuration.
kimchi2020
hey i am working on object detection in videos and came across openvino that helps in increasing speed. how can i use openvino and yolov8 together to find objects in a video
Glenn JocherUltralytics@kimchi2020 hi there! It's great to hear that you're exploring OpenVINO to enhance the speed of your object detection tasks in videos. OpenVINO can indeed provide significant performance improvements, especially on Intel hardware.
To get started with using YOLOv8 and OpenVINO together, follow these steps:
Exporting YOLOv8 to OpenVINO Format
-
Export the Model: You can export your YOLOv8 model to the OpenVINO format using the following Python code:
from ultralytics import YOLO # Load a YOLOv8n PyTorch model model = YOLO("yolov8n.pt") # Export the model to OpenVINO format model.export(format="openvino") # creates 'yolov8n_openvino_model/'Alternatively, you can use the CLI:
yolo export model=yolov8n.pt format=openvino # creates 'yolov8n_openvino_model/' -
Run Inference with the Exported Model: After exporting, you can run inference using the exported OpenVINO model. Here’s how you can do it in Python:
from ultralytics import YOLO # Load the exported OpenVINO model ov_model = YOLO("yolov8n_openvino_model/") # Run inference results = ov_model("https://ultralytics.com/images/bus.jpg")Or using the CLI:
yolo predict model=yolov8n_openvino_model source='https://ultralytics.com/images/bus.jpg'
Running Inference on Videos
To process videos, you can modify the inference code to read frames from a video file and run the model on each frame. Here’s an example in Python:
import cv2 from ultralytics import YOLO # Load the exported OpenVINO model model = YOLO("yolov8n_openvino_model/") # Open the video file video_path = "path/to/your/video.mp4" cap = cv2.VideoCapture(video_path) # Loop through the video frames while cap.isOpened(): ret, frame = cap.read() if not ret: break # Run inference on the frame results = model(frame) # Visualize the results on the frame annotated_frame = results[0].plot() # Display the annotated frame cv2.imshow("YOLOv8 OpenVINO Inference", annotated_frame) # Break the loop if 'q' is pressed if cv2.waitKey(1) & 0xFF == ord('q'): break # Release the video capture object and close the display window cap.release() cv2.destroyAllWindows()Additional Resources
For more detailed information and advanced usage, you can refer to the OpenVINO documentation. This guide covers everything from exporting models to running inference and optimizing performance.
Feel free to reach out if you have any more questions. Happy coding! 🚀
-
kimchi2020
Traceback (most recent call last): File "/home/kimchi/Desktop/yolov8/onnx.py", line 18, in results = model(frame) ^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 174, in call return self.predict(source, stream, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 442, in predict return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 168, in call return list(self.stream_inference(source, model, *args, **kwargs)) # merge list of Result into one ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/utils/_contextlib.py", line 35, in generator_context response = gen.send(None) ^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 234, in stream_inference self.model.warmup(imgsz=(1 if self.model.pt or self.model.triton else self.dataset.bs, 3, *self.imgsz)) File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/nn/autobackend.py", line 626, in warmup import torchvision # noqa (import here so torchvision import time not recorded in postprocess time) ^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/init.py", line 6, in from torchvision import _meta_registrations, datasets, io, models, ops, transforms, utils File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/models/init.py", line 2, in from .convnext import * File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/models/convnext.py", line 8, in from ..ops.misc import Conv2dNormActivation, Permute File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/ops/init.py", line 1, in from ._register_onnx_ops import _register_custom_op File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/ops/_register_onnx_ops.py", line 5, in from torch.onnx import symbolic_opset11 as opset11 File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/onnx/init.py", line 59, in from ._internal.onnxruntime import ( File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/onnx/_internal/onnxruntime.py", line 36, in import onnx File "/home/kimchi/Desktop/yolov8/onnx.py", line 18, in results = model(frame) ^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 174, in call return self.predict(source, stream, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 442, in predict return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 168, in call return list(self.stream_inference(source, model, *args, **kwargs)) # merge list of Result into one ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/utils/_contextlib.py", line 35, in generator_context response = gen.send(None) ^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 261, in stream_inference self.results = self.postprocess(preds, im, im0s) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/models/yolo/detect/predict.py", line 25, in postprocess preds = ops.non_max_suppression( ^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/utils/ops.py", line 291, in non_max_suppression i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS ^^^^^^^^^^^^^^^ AttributeError: partially initialized module 'torchvision' has no attribute 'ops' (most likely due to a circular import). Did you mean: 'os'?
I am getting this error, how to get rid of it and what does it mean
Glenn JocherUltralyticsHi @kimchi2020,
Thank you for reaching out! The error you're encountering seems to be related to a circular import issue with the
torchvisionlibrary. This can happen if there's a naming conflict or an import loop in your code.Steps to Resolve the Issue:
-
Check for Naming Conflicts: Ensure that your script name (
onnx.py) is not conflicting with any library names. Rename your script to something unique, likerun_inference.py. -
Verify Installation: Make sure you have the latest versions of
torch,torchvision, andultralyticsinstalled. You can update them using:pip install --upgrade torch torchvision ultralytics -
Reproduce the Issue: If the issue persists, please provide a minimum reproducible example. This helps us diagnose the problem more effectively. You can refer to our guide on creating a reproducible example here: Minimum Reproducible Example.
Example Code for Inference with OpenVINO:
Here's a quick example of how to export your YOLOv8 model to OpenVINO and run inference on a video:
import cv2 from ultralytics import YOLO # Load a YOLOv8n PyTorch model model = YOLO("yolov8n.pt") # Export the model to OpenVINO format model.export(format="openvino") # creates 'yolov8n_openvino_model/' # Load the exported OpenVINO model ov_model = YOLO("yolov8n_openvino_model/") # Open the video file video_path = "path/to/your/video.mp4" cap = cv2.VideoCapture(video_path) # Loop through the video frames while cap.isOpened(): ret, frame = cap.read() if not ret: break # Run inference on the frame results = ov_model(frame) # Visualize the results on the frame annotated_frame = results[0].plot() # Display the annotated frame cv2.imshow("YOLOv8 OpenVINO Inference", annotated_frame) # Break the loop if 'q' is pressed if cv2.waitKey(1) & 0xFF == ord('q'): break # Release the video capture object and close the display window cap.release() cv2.destroyAllWindows()For more detailed information on exporting and using OpenVINO, please refer to our OpenVINO Integration Guide.
Feel free to reach out if you have any more questions or need further assistance. Happy coding! 🚀
-
YA12SHYAM
Hi @glenn-jocher , what if i want to use intel GPU's for the inference, using device=GPU doesn't seems to works , it looks for cuda i.e nvidia gpu
Glenn JocherUltralytics(modifié)To use Intel GPUs for inference, export your YOLOv8 model to OpenVINO format with
model.export(format="openvino"), then run inference with the exported model and select the GPU withdevice="intel:gpu", for exampleov_model("bus.jpg", device="intel:gpu"). For more details, please refer to the OpenVINO integration guide.YA12SHYAM
ok, just to confirm i can't use ultralytics python api for inference with intel gpu like i usually do within the ultralytics ecosystem for example ?
from ultralytics import YOLO model = YOLO(path/to/model)here the path/to/model works with onnx, engine, opnevino;s xml , but it use cpu in case of openvino , i want to use my intel GPU
Glenn JocherUltralytics(modifié)@YA12SHYAM to use Intel GPUs with YOLOv8, export your model to OpenVINO format and select the GPU at inference with
device="intel:gpu", e.g.model("bus.jpg", device="intel:gpu"). For detailed steps, refer to the OpenVINO integration guide.
kanishkasw
Hi Im getting the following error when attempting to convert the model to openVino. Tried with both 2024.1.0 and 2024.0.0. Im on ubuntu 20.04 with python 3.8 $ yolo export model=runs/classify/train/weights/best.pt format=openvino Ultralytics YOLOv8.2.31 🚀 Python-3.8.10 torch-2.3.1+cu121 CPU (Intel Core(TM) i9-7900X 3.30GHz) YOLOv8n-cls summary (fused): 73 layers, 1438723 parameters, 0 gradients, 3.3 GFLOPs
PyTorch: starting from 'runs/classify/train/weights/best.pt' with input shape (1, 3, 320, 320) BCHW and output shape(s) (1, 3) (2.8 MB) OpenVINO: export failure ❌ 0.0s: module 'openvino' has no attribute 'version' Traceback (most recent call last): File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/bin/yolo", line 8, in sys.exit(entrypoint()) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/cfg/init.py", line 591, in entrypoint getattr(model, mode)(**overrides) # default args from model File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/model.py", line 602, in export return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/torch/utils/_contextlib.py", line 115, in decorate_context return func(*args, **kwargs) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 308, in call f[3], _ = self.export_openvino() File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 142, in outer_func raise e File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 137, in outer_func f, model = inner_func(*args, **kwargs) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 454, in export_openvino LOGGER.info(f"\n{prefix} starting export with openvino {ov.version}...") AttributeError: module 'openvino' has no attribute 'version'
Paula DerrengerUltralytics(modifié)@kanishkasw hi there,
Thank you for reaching out and providing detailed information about the issue you're encountering. It looks like you're experiencing an error when attempting to export your model to OpenVINO format. Let's work through this together.
First, let's ensure that you are using the latest versions of
torchandultralytics. Please run the following commands to update your packages:pip install --upgrade torch ultralyticsNext, it seems the error is related to the OpenVINO package. The error message
module 'openvino' has no attribute '__version__'suggests there might be an issue with the OpenVINO installation. Please make sure you have a recent version of OpenVINO installed (Ultralytics requiresopenvino>=2024.0.0). You can install it using the following command:pip install -U openvinoOnce you've updated the packages, try exporting the model again:
yolo export model=runs/classify/train/weights/best.pt format=openvinoIf the issue persists, could you please provide a minimum reproducible example? This will help us investigate the problem more effectively. You can find guidance on creating a minimum reproducible example here: Minimum Reproducible Example.
Additionally, here's a Python example to ensure everything is set up correctly:
from ultralytics import YOLO # Load a YOLOv8n PyTorch model model = YOLO("runs/classify/train/weights/best.pt") # Export the model to OpenVINO format model.export(format="openvino") # creates 'best_openvino_model/' # Load the exported OpenVINO model ov_model = YOLO("best_openvino_model/") # Run inference results = ov_model("https://ultralytics.com/images/bus.jpg")For more detailed instructions on using OpenVINO, please refer to our OpenVINO Integration Guide.
Feel free to reach out if you have any further questions or run into any other issues. We're here to help! 😊
renato-rodrig
hello everything is fine? I have a question about the results exposed in the article above. Is the time shown in the graphs in relation to the inference time that the model takes to return the detections or is it the time for image reading, image pre-processing and model inference? I ask this because on my computer (intel core i7 12 generation CPU) the yolov8n model ran with an inference time of 40ms and the gain from using OpenVINO was not that great.
Paula DerrengerUltralytics@renato-rodrig hello! 👋 Regarding your question about the times shown in the graphs, they typically refer to the total inference time, which includes the actual model inference as well as the time taken for pre-processing the input data (like image reading and resizing).
The difference you observed with OpenVINO on your Intel Core i7 may vary due to several factors such as the specific configuration of your system, the type of tasks being run, and the optimizations that the YOLOv8n model can leverage on that platform. Generally, OpenVINO tends to show more significant performance gains on integrated Intel GPUs and some specific CPU configurations.
If you haven't seen a major performance improvement, you might want to look into further tuning your OpenVINO deployment or explore using other optimization techniques provided by OpenVINO. Additionally, ensure all drivers and software components are up to date for optimal performance.
Here’s a quick example of ensuring you're using the model in the most optimized manner:
from ultralytics import YOLO # Load YOLOv8n PyTorch model model = YOLO('yolov8n.pt') # Export the model to OpenVINO model.export(format='openvino') # Creates 'yolov8n_openvino_model/' # Load the exported OpenVINO model ov_model = YOLO('yolov8n_openvino_model/') # Run inference to see if performance improves results = ov_model('https://ultralytics.com/images/bus.jpg')Feel free to experiment with different configurations and settings! 😊
1
YouROS12
I wanna do inferences with my exported pre-trained yolov8 model using Raspberry PI with a Neural Network Computing 2 (NCS2) plugged in.. but its doesn't support opset 11 or above.. only opset10.. I specified onnx opset to 10 and convert it to Openvino but it didn't work.
Anyway please to export openvino model directly in opset10 ? Does even yolov8 support this specified opset format ?
Thank you.
Glenn JocherUltralytics(modifié)@YouROS12 the current OpenVINO export no longer goes through ONNX: Ultralytics converts the PyTorch model directly to OpenVINO IR with
openvino.convert_model, so the ONNXopsetargument does not apply and the oldmoModel Optimizer step isn't needed. Export with:from ultralytics import YOLO # Load a pretrained YOLOv8 model model = YOLO('yolov8n.pt') # Export the model to OpenVINO model.export(format='openvino') # creates 'yolov8n_openvino_model/'The export requires
openvino>=2024.0.0. If your target requires an older OpenVINO that cannot load these models, you can still trymodel.export(format='onnx', opset=10)and convert the ONNX file with that toolkit's own tools, but some YOLOv8 operations may not be supported in older opsets, which could lead to errors during export or inference.YouROS12
Where can I find documentation about YOLOv8's operations with opset 10 ? Updating OpenVINO toolkit is not an option because NCS2 works only at opset 10 and lower.
Paula DerrengerUltralytics@YouROS12 the documentation for ONNX opset versions and the operations they support can be found on the ONNX GitHub repository or the official ONNX documentation. However, there isn't specific documentation for YOLOv8's operations with opset 10, as this would be a combination of YOLOv8's implementation details and ONNX's opset specifications.
To check which operations are supported in opset 10, you can refer to the ONNX Operators documentation for that specific version. This documentation lists all the operators available in opset 10 and their details.
For YOLOv8, you would need to look at the model's architecture and identify which operations are used. Then, cross-reference these operations with the ONNX opset 10 documentation to see if they are supported. If certain operations are not supported in opset 10, you might need to modify the model or the export script to use alternative operations that are compatible with opset 10.
Since updating OpenVINO is not an option for you, if you find that YOLOv8 uses operations not supported in opset 10, you might need to consider using a different model architecture that is compatible with opset 10, or reach out to the community or Ultralytics for further assistance on how to proceed with your specific use case and hardware constraints.
