Link to this sectionExportation Intel OpenVINO#

Dans ce guide, nous traitons l'exportation des modèles YOLO26 vers le format OpenVINO, qui peut offrir jusqu'à 3x d'accélération CPU, ainsi qu'une accélération de l'inférence YOLO sur le matériel GPU et NPU d'Intel.

OpenVINO, abréviation de Open Visual Inference & Neural Network Optimization toolkit, est une boîte à outils complète pour optimiser et déployer des modèles d'inférence IA. Bien que le nom contienne « Visual », OpenVINO prend également en charge diverses tâches supplémentaires, notamment le langage, l'audio, les séries temporelles, etc.

Link to this sectionExemples d'utilisation#

Le format OpenVINO prend en charge les modes Export, Predict et Validate. Exporte ton modèle, puis charge le modèle exporté pour exécuter l'inférence ou valider sa précision sur un CPU Intel, un GPU intégré/dédié ou un NPU.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to OpenVINO format
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

from ultralytics import YOLO

# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

# Run inference on a specific device, available devices: ["intel:gpu", "intel:npu", "intel:cpu"]
results = model("https://ultralytics.com/images/bus.jpg", device="intel:gpu")

from ultralytics import YOLO

# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionArguments d'exportation#

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

Link to this sectionAvantages d'OpenVINO#

1. Performance : OpenVINO offre une inférence haute performance en utilisant la puissance des CPU Intel, des GPU intégrés et dédiés, et des FPGA.
2. Prise en charge de l'exécution hétérogène : OpenVINO fournit une API pour écrire une fois et déployer sur n'importe quel matériel Intel pris en charge (CPU, GPU, FPGA, VPU, etc.).
3. Optimiseur de modèle : OpenVINO fournit un optimiseur de modèle qui importe, convertit et optimise les modèles à partir de frameworks de deep learning populaires tels que PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle et Caffe.
4. Facilité d'utilisation : La boîte à outils est livrée avec une grande collection de notebooks de tutoriels (incluant l'optimisation YOLO26) enseignant différents aspects de la boîte à outils.

Link to this sectionStructure d'exportation OpenVINO#

Lorsque tu exportes un modèle au format OpenVINO, cela génère un répertoire contenant ce qui suit :

1. Fichier XML : Décrit la topologie du réseau.
2. Fichier BIN : Contient les données binaires des poids et des biais.
3. Fichier de mappage : Détient le mappage des tenseurs de sortie du modèle original vers les noms de tenseurs OpenVINO.

Tu peux utiliser ces fichiers pour exécuter l'inférence avec le moteur d'inférence OpenVINO.

Link to this sectionUtilisation de l'exportation OpenVINO dans le déploiement#

Une fois ton modèle exporté avec succès au format OpenVINO, tu as deux options principales pour exécuter l'inférence :

1. Utilise le package ultralytics, qui fournit une API de haut niveau et encapsule le Runtime OpenVINO.

2. Utilise le package natif openvino pour un contrôle plus avancé ou personnalisé du comportement de l'inférence.

Link to this sectionInférence avec Ultralytics#

Le package ultralytics te permet d'exécuter facilement l'inférence en utilisant le modèle OpenVINO exporté via la méthode predict. Tu peux également spécifier le périphérique cible (par ex. intel:gpu, intel:npu, intel:cpu) en utilisant l'argument device.

from ultralytics import YOLO

# Load the exported OpenVINO model
ov_model = YOLO("yolo26n_openvino_model/")  # the path of your exported OpenVINO model
# Run inference with the exported model
ov_model.predict(device="intel:gpu")  # specify the device you want to run inference on

Cette approche est idéale pour le prototypage rapide ou le déploiement lorsque tu n'as pas besoin d'un contrôle total sur le pipeline d'inférence.

Link to this sectionInférence avec le Runtime OpenVINO#

Le Runtime OpenVINO fournit une API unifiée pour l'inférence sur tout le matériel Intel pris en charge. Il offre également des fonctionnalités avancées comme l'équilibrage de charge sur le matériel Intel et l'exécution asynchrone. Pour plus d'informations sur l'exécution de l'inférence, consulte les notebooks YOLO26.

N'oublie pas que tu auras besoin des fichiers XML et BIN ainsi que de tous les paramètres spécifiques à l'application tels que la taille d'entrée, le facteur d'échelle pour la normalisation, etc., pour configurer et utiliser correctement le modèle avec le Runtime.

Dans ton application de déploiement, tu effectuerais généralement les étapes suivantes :

1. Initialise OpenVINO en créant core = Core().
2. Charge le modèle en utilisant la méthode core.read_model().
3. Compile le modèle en utilisant la fonction core.compile_model().
4. Prépare l'entrée (image, texte, audio, etc.).
5. Exécute l'inférence en utilisant compiled_model(input_data).

Pour des étapes et des extraits de code plus détaillés, réfère-toi à la documentation OpenVINO ou au tutoriel API.

Link to this sectionBenchmarks YOLO26 OpenVINO#

L'équipe Ultralytics a évalué YOLO26 sur divers formats de modèles et précisions, en évaluant la vitesse et la précision sur différents appareils Intel compatibles avec OpenVINO.

Link to this sectionIntel® Core™ Ultra#

La série Intel® Core™ Ultra™ représente une nouvelle référence en matière de calcul haute performance, conçue pour répondre aux exigences évolutives des utilisateurs modernes, des joueurs et créateurs aux professionnels tirant parti de l'IA. Cette gamme de nouvelle génération est plus qu'une série de CPU traditionnelle ; elle combine des cœurs CPU puissants, des capacités GPU intégrées haute performance et une unité de traitement neuronal (NPU) dédiée sur une seule puce, offrant une solution unifiée pour des charges de travail informatiques diverses et intensives.

Au cœur de l'architecture Intel® Core Ultra™ se trouve une conception hybride qui permet des performances exceptionnelles sur les tâches de traitement traditionnelles, les charges de travail accélérées par GPU et les opérations pilotées par l'IA. L'inclusion du NPU améliore l'inférence IA sur l'appareil, permettant un apprentissage automatique et un traitement des données plus rapides et plus efficaces dans un large éventail d'applications.

La famille Core Ultra™ inclut divers modèles adaptés à différents besoins de performance, avec des options allant des conceptions écoénergétiques aux variantes haute puissance marquées par la désignation « H », idéales pour les ordinateurs portables et les facteurs de forme compacts qui exigent une puissance de calcul sérieuse. Sur toute la gamme, les utilisateurs bénéficient de la synergie de l'intégration CPU, GPU et NPU, offrant une efficacité, une réactivité et des capacités multitâches remarquables.

Dans le cadre de l'innovation continue d'Intel, la série Core Ultra™ établit une nouvelle norme pour l'informatique prête pour l'avenir. Avec plusieurs modèles disponibles et d'autres à venir, cette série souligne l'engagement d'Intel à fournir des solutions de pointe pour la prochaine génération d'appareils intelligents et améliorés par l'IA.

Les benchmarks ci-dessous sont exécutés sur Intel® Core™ Ultra™ X7 358H, Intel® Core™ Ultra™ 7 258V et Intel® Core™ Ultra™ 7 155H à des précisions FP32, FP16 et INT8.

Link to this sectionIntel® Core™ Ultra™ X7 358H#

Benchmarks

GPU Intel® Arc™ intégréCPU Intel® Panther LakeNPU Intel® AI Boost intégrée

Résultats détaillés des benchmarks

Modèle	Format	Précision	Statut	Taille (Mo)	métriques/mAP50-95(B)	Temps d'inférence (ms/im)
YOLO26n	PyTorch (CPU)	FP32	✅	5.3	0.4765	25.18
YOLO26n	OpenVINO	FP32	✅	9.6	0.4763	2.67
YOLO26n	OpenVINO	FP16	✅	5.1	0.4763	2.64
YOLO26n	OpenVINO	INT8	✅	3.2	0.4625	2.73
YOLO26s	PyTorch (CPU)	FP32	✅	19.5	0.5703	50.09
YOLO26s	OpenVINO	FP32	✅	36,7	0.5615	3.57
YOLO26s	OpenVINO	FP16	✅	18.6	0.5615	3.55
YOLO26s	OpenVINO	INT8	✅	10.0	0.547	3.09
YOLO26m	PyTorch (CPU)	FP32	✅	42.2	0.6196	135.1
YOLO26m	OpenVINO	FP32	✅	78.3	0.6168	5.64
YOLO26m	OpenVINO	FP16	✅	39.5	0.6168	5.85
YOLO26m	OpenVINO	INT8	✅	20.5	0.5994	4.14
YOLO26l	PyTorch (CPU)	FP32	✅	50.7	0.6215	169.75
YOLO26l	OpenVINO	FP32	✅	95,3	0.6206	8.14
YOLO26l	OpenVINO	FP16	✅	48.1	0.6206	8.18
YOLO26l	OpenVINO	INT8	✅	25.2	0.5999	4.67
YOLO26x	PyTorch (CPU)	FP32	✅	113.2	0.6512	407.56
YOLO26x	OpenVINO	FP32	✅	213,2	0.6569	13.11
YOLO26x	OpenVINO	FP16	✅	107.1	0.6569	13.15
YOLO26x	OpenVINO	INT8	✅	54.8	0.6374	9.24

Link to this sectionIntel® Core™ Ultra™ 7 258V#

Benchmarks

GPU Intel® Arc™ intégréCPU Intel® Lunar LakeNPU Intel® AI Boost intégrée

Résultats détaillés des benchmarks

Modèle	Format	Précision	Statut	Taille (Mo)	métriques/mAP50-95(B)	Temps d'inférence (ms/im)
YOLO26n	PyTorch (CPU)	FP32	✅	5.3	0.4765	31.43
YOLO26n	OpenVINO	FP32	✅	9.6	0.4762	3.57
YOLO26n	OpenVINO	FP16	✅	5.1	0.4762	3.53
YOLO26n	OpenVINO	INT8	✅	3.2	0.4625	3.65
YOLO26s	PyTorch (CPU)	FP32	✅	19.5	0.5703	60.4
YOLO26s	OpenVINO	FP32	✅	36,7	0.5616	5.02
YOLO26s	OpenVINO	FP16	✅	18.6	0.5616	5.01
YOLO26s	OpenVINO	INT8	✅	10.0	0.547	4.31
YOLO26m	PyTorch (CPU)	FP32	✅	42.2	0.6196	173.31
YOLO26m	OpenVINO	FP32	✅	78.3	0.6191	9.48
YOLO26m	OpenVINO	FP16	✅	39.5	0.6168	9.6
YOLO26m	OpenVINO	INT8	✅	20.5	0.5994	6.03
YOLO26l	PyTorch (CPU)	FP32	✅	50.7	0.6173	224.52
YOLO26l	OpenVINO	FP32	✅	95,3	0.3725	11.88
YOLO26l	OpenVINO	FP16	✅	48.1	0.6201	12.0
YOLO26l	OpenVINO	INT8	✅	25.2	0.5999	8.47
YOLO26x	PyTorch (CPU)	FP32	✅	113.2	0.6512	595.72
YOLO26x	OpenVINO	FP32	✅	213,2	0.6567	20.26
YOLO26x	OpenVINO	FP16	✅	107.1	0.6454	20.25
YOLO26x	OpenVINO	INT8	✅	54.8	0.6374	14.77

Link to this sectionIntel® Core™ Ultra™ 7 155H#

Benchmarks

GPU Intel® Arc™ intégréIntel® Meteor Lake CPU

Résultats détaillés des benchmarks

Modèle	Format	Précision	Statut	Taille (Mo)	métriques/mAP50-95(B)	Temps d'inférence (ms/im)
YOLO26n	PyTorch (CPU)	FP32	✅	5.3	0.4765	38.77
YOLO26n	OpenVINO	FP32	✅	9.6	0.4774	9.87
YOLO26n	OpenVINO	FP16	✅	5.1	0.4774	9.84
YOLO26n	OpenVINO	INT8	✅	3.2	0.4705	5.86
YOLO26s	PyTorch (CPU)	FP32	✅	19.5	0.5703	69.54
YOLO26s	OpenVINO	FP32	✅	36,7	0.5616	17.29
YOLO26s	OpenVINO	FP16	✅	18.6	0.5616	17.06
YOLO26s	OpenVINO	INT8	✅	10.0	0.5452	10.33
YOLO26m	PyTorch (CPU)	FP32	✅	42.2	0.6196	192.22
YOLO26m	OpenVINO	FP32	✅	78.3	0.6187	34.64
YOLO26m	OpenVINO	FP16	✅	39.5	0.6187	34.75
YOLO26m	OpenVINO	INT8	✅	20.5	0.6073	15.99
YOLO26l	PyTorch (CPU)	FP32	✅	50.7	0.6215	245.62
YOLO26l	OpenVINO	FP32	✅	95,3	0.6202	43.7
YOLO26l	OpenVINO	FP16	✅	48.1	0.6202	44.65
YOLO26l	OpenVINO	INT8	✅	25.2	0.6048	20.31
YOLO26x	PyTorch (CPU)	FP32	✅	113.2	0.6512	513.06
YOLO26x	OpenVINO	FP32	✅	213,2	0.6544	80.19
YOLO26x	OpenVINO	FP16	✅	107.1	0.6544	79.83
YOLO26x	OpenVINO	INT8	✅	54.8	0.6393	35.16

Link to this sectionReproduis nos résultats#

Pour reproduire les benchmarks Ultralytics ci-dessus sur tous les formats d'exportation, exécute ce code :

from ultralytics import YOLO

# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")

# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml")

Link to this sectionConclusion#

Les résultats des benchmarks démontrent clairement les avantages de l'exportation du modèle YOLO26 au format OpenVINO. Sur différents modèles et plates-formes matérielles, le format OpenVINO surpasse systématiquement les autres formats en termes de vitesse d'inférence tout en maintenant une précision comparable.

Les benchmarks soulignent l'efficacité d'OpenVINO en tant qu'outil pour déployer des modèles de deep learning. En convertissant les modèles au format OpenVINO, tu peux obtenir des améliorations de performances significatives, facilitant ainsi le déploiement de ces modèles dans des applications réelles.

Pour des informations plus détaillées et des instructions sur l'utilisation d'OpenVINO, réfère-toi à la documentation officielle d'OpenVINO.

Link to this sectionFAQ#

Link to this sectionComment exporter des modèles YOLO26 au format OpenVINO ?#

L'exportation des modèles YOLO26 au format OpenVINO peut considérablement augmenter la vitesse du CPU et permettre des accélérations par GPU et NPU sur le matériel Intel. Pour exporter, tu peux utiliser Python ou l'interface CLI comme indiqué ci-dessous :

from ultralytics import YOLO

# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")

# Export the model
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

Pour plus d'informations, consulte la documentation sur les formats d'exportation.

Link to this sectionQuels sont les avantages d'utiliser OpenVINO avec les modèles YOLO26 ?#

L'utilisation de la boîte à outils OpenVINO d'Intel avec les modèles YOLO26 offre plusieurs avantages :

1. Performances : Obtiens jusqu'à 3x d'accélération sur l'inférence CPU et tire parti des GPU et NPU Intel pour l'accélération.
2. Optimiseur de modèle : Convertis, optimise et exécute des modèles issus de frameworks populaires tels que PyTorch, TensorFlow et ONNX.
3. Facilité d'utilisation : Une vaste collection de notebooks de tutoriel est disponible pour aider les utilisateurs à démarrer, y compris ceux pour YOLO26.
4. Exécution hétérogène : Déploie des modèles sur divers matériels Intel avec une API unifiée.

Pour des comparaisons de performances détaillées, visite notre section benchmarks.

Link to this sectionComment puis-je effectuer une inférence en utilisant un modèle YOLO26 exporté vers OpenVINO ?#

Après avoir exporté un modèle YOLO26n au format OpenVINO, tu peux effectuer l'inférence en utilisant Python ou l'interface CLI :

from ultralytics import YOLO

# Load the exported OpenVINO model
ov_model = YOLO("yolo26n_openvino_model/")

# Run inference
results = ov_model("https://ultralytics.com/images/bus.jpg")

Consulte notre documentation sur le mode prédiction pour plus de détails.

Link to this sectionPourquoi devrais-je choisir Ultralytics YOLO26 plutôt que d'autres modèles pour l'exportation OpenVINO ?#

Ultralytics YOLO26 est optimisé pour la détection d'objets en temps réel avec une grande précision et vitesse. Plus précisément, lorsqu'il est combiné avec OpenVINO, YOLO26 offre :

• Jusqu'à 3x d'accélération sur les CPU Intel
• Déploiement fluide sur les GPU et NPU Intel
• Précision cohérente et comparable à travers divers formats d'exportation

Pour une analyse approfondie des performances, consulte nos benchmarks YOLO26 détaillés sur différents matériels.

Link to this sectionPuis-je évaluer (benchmark) les modèles YOLO26 sur différents formats tels que PyTorch, ONNX et OpenVINO ?#

Oui, tu peux évaluer les modèles YOLO26 dans divers formats, notamment PyTorch, TorchScript, ONNX et OpenVINO. Utilise l'extrait de code suivant pour exécuter les benchmarks sur le jeu de données de ton choix :

from ultralytics import YOLO

# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")

# Benchmark YOLO26n speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8 dataset for all export formats
results = model.benchmark(data="coco8.yaml")

Pour des résultats de benchmark détaillés, réfère-toi à notre section benchmarks et à la documentation sur les formats d'exportation.