Exportation Intel OpenVINO

Dans ce guide, nous traitons de l'exportation des modèles YOLO26 vers le format OpenVINO, qui peut offrir jusqu'à 3x plus de vitesse 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 son nom contienne "Visual", OpenVINO prend également en charge diverses tâches supplémentaires, notamment le langage, l'audio, les séries temporelles, etc.

Exemples d'utilisation

Exporte un modèle YOLO26n au format OpenVINO et exécute l'inférence avec le modèle exporté.

from ultralytics import YOLO

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

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

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

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

# Run inference with specified device, available devices: ["intel:gpu", "intel:npu", "intel:cpu"]
results = ov_model("https://ultralytics.com/images/bus.jpg", device="intel:gpu")

Arguments d'exportation

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

Avantages d'OpenVINO

1. Performance : OpenVINO offre une inférence haute performance en utilisant la puissance des CPU Intel, des GPU intégrés et discrets, 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 d'apprentissage profond populaires tels que PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle et Caffe.
4. Facilité d'utilisation : La boîte à outils est fournie avec plus de 80 carnets de tutoriels (y compris l'optimisation YOLO26) enseignant différents aspects de la boîte à outils.

Structure 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 d'origine vers les noms de tenseur OpenVINO.

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

Utilisation de l'exportation OpenVINO dans le déploiement

Une fois ton modèle exporté avec succès vers le 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 enveloppe le runtime OpenVINO.

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

Inférence avec Ultralytics

Le package ultralytics te permet d'exécuter facilement l'inférence à l'aide du modèle OpenVINO exporté via la méthode predict. Tu peux également spécifier le périphérique cible (par exemple, 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.

Inférence avec OpenVINO Runtime

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, réfère-toi aux carnets 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 effectueras généralement les étapes suivantes :

1. Initialise OpenVINO en créant core = Core().
2. Charge le modèle à l'aide de la méthode core.read_model().
3. Compile le modèle à l'aide de la fonction core.compile_model().
4. Prépare l'entrée (image, texte, audio, etc.).
5. Exécute l'inférence à l'aide de 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.

Benchmarks OpenVINO YOLO26

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.

Intel® Core™ Ultra

La série Intel® Core™ Ultra™ représente une nouvelle référence en informatique haute performance, conçue pour répondre aux exigences évolutives des utilisateurs modernes, des joueurs et des 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 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 l'IA. L'inclusion du NPU améliore l'inférence IA sur le périphérique, 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 à 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 à l'horizon, cette série souligne l'engagement d'Intel à fournir des solutions de pointe pour la prochaine génération de dispositifs intelligents améliorés par l'IA.

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

Intel® Core™ Ultra™ 7 258V

Benchmarks

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

Résultats d'évaluation détaillés

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

Intel® Core™ Ultra™ 7 155H

Benchmarks

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

Résultats d'évaluation détaillés

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

Reproduire 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")

Conclusion

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 de déploiement de 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, réfère-toi à la documentation officielle d'OpenVINO.

FAQ

Comment exporter des modèles YOLO26 au format OpenVINO ?

L'exportation des modèles YOLO26 au format OpenVINO peut améliorer considérablement la vitesse du CPU et permettre des accélérations par GPU et NPU sur le matériel Intel. Pour exporter, tu peux utiliser soit Python, soit 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, réfère-toi à la documentation des formats d'exportation.

Quels sont les avantages de l'utilisation d'OpenVINO avec les modèles YOLO26 ?

L'utilisation du toolkit OpenVINO d'Intel avec les modèles YOLO26 offre plusieurs avantages :

1. Performance : 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. Model Optimizer : Convertis, optimise et exécute des modèles à partir de frameworks populaires tels que PyTorch, TensorFlow et ONNX.
3. Facilité d'utilisation : Plus de 80 notebooks de tutoriels sont disponibles pour t'aider à 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 performance détaillées, visite notre section benchmarks.

Comment puis-je exécuter 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 exécuter l'inférence en utilisant Python ou 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")

Réfère-toi à notre documentation du mode de prédiction pour plus de détails.

Pourquoi devrais-je choisir Ultralytics YOLO26 plutôt que d'autres modèles pour l'exportation vers OpenVINO ?

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

• Jusqu'à 3x plus rapide sur les CPU Intel
• Déploiement fluide sur les GPU et NPU Intel
• Une précision constante et comparable sur différents formats d'exportation

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

Puis-je tester les performances des modèles YOLO26 sur différents formats tels que PyTorch, ONNX et OpenVINO ?

Oui, tu peux tester les performances des 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.