Link to this sectionExportation Intel OpenVINO#

Dans ce guide, nous couvrons l'exportation des modèles YOLO26 vers le format OpenVINO, qui peut offrir jusqu'à 3x d'accélération sur 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, consulte la page de documentation Ultralytics sur l'exportation.

Link to this sectionAvantages d'OpenVINO#

1. Performances : OpenVINO offre une inférence haute performance en utilisant la puissance des processeurs 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 provenant 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 large 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 : Contient 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 paquet ultralytics, qui fournit une API de haut niveau et enveloppe le runtime OpenVINO.

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

Link to this sectionInférence avec Ultralytics#

Le paquet 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 comme 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 plus détaillées et des extraits de code, réfère-toi à la documentation OpenVINO ou au tutoriel API.

Link to this sectionBenchmarks YOLO26 sous OpenVINO#

L'équipe Ultralytics a benchmarké YOLO26 sur divers formats de modèle et précisions, é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 dans l'informatique haute performance, conçue pour répondre aux demandes évolutives des utilisateurs modernes, des joueurs et des créateurs aux professionnels exploitant l'IA. Cette nouvelle génération est plus qu'une série de CPU traditionnelle ; elle combine des cœurs CPU puissants, des capacités GPU haute performance intégrées et une unité de traitement neuronal (NPU) dédiée au sein d'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 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 sur un large éventail d'applications.

La famille Core Ultra™ comprend divers modèles adaptés aux différents besoins de performance, avec des options allant des conceptions économes en énergie 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 importante. 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 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 aux précisions FP32, FP16 et INT8.

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

Benchmarks

Intel® Arc™ GPU intégréIntel® Panther Lake CPUIntegrated Intel® AI Boost NPU

Résultats détaillés des benchmarks

Modèle	Format	Précision	Statut	Taille (MB)	metrics/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

Intel® Arc™ GPU intégréIntel® Lunar Lake CPUIntegrated Intel® AI Boost NPU

Résultats détaillés des benchmarks

Modèle	Format	Précision	Statut	Taille (MB)	metrics/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

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

Résultats détaillés des benchmarks

Modèle	Format	Précision	Statut	Taille (MB)	metrics/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 vers le format OpenVINO. À travers différents modèles et plateformes 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 performance 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, consulte la documentation officielle d'OpenVINO.

Link to this sectionFAQ#

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

L'exportation des modèles YOLO26 vers le format OpenVINO peut considérablement améliorer la vitesse CPU et permettre des accélérations GPU et NPU sur le matériel Intel. Pour exporter, tu peux utiliser Python ou le 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 du toolkit OpenVINO d'Intel avec les modèles YOLO26 offre plusieurs avantages :

1. Performance : Obtenez jusqu'à 3x d'accélération sur l'inférence CPU et tirez parti des GPU et NPU Intel pour l'accélération.
2. Optimiseur de modèle : Convertissez, optimisez et exécutez des modèles issus de frameworks populaires comme PyTorch, TensorFlow et ONNX.
3. Facilité d'utilisation : Une vaste collection de notebooks tutoriels est disponible pour aider les utilisateurs à démarrer, y compris ceux pour YOLO26.
4. Exécution hétérogène : Déployez des modèles sur divers matériels Intel avec une API unifiée.

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

Link to this sectionComment puis-je exécuter l'inférence en utilisant un modèle YOLO26 exporté vers OpenVINO ?#

Après avoir exporté un modèle YOLO26n vers le format OpenVINO, tu peux exécuter l'inférence en utilisant Python ou le 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 constante 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 benchmark les modèles YOLO26 sur différents formats tels que PyTorch, ONNX et OpenVINO ?#

Oui, tu peux benchmark les modèles YOLO26 dans divers formats incluant 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, consulte notre section benchmarks et la documentation sur les formats d'exportation.