Exportation 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.

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 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 des 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 accompagnée de plus de 80 carnets de tutoriels (incluant l'optimisation YOLO26) enseignant différents aspects de la boîte à outils.

Structure de l'exportation OpenVINO

Lorsque tu exportes un modèle au format OpenVINO, cela génère un répertoire contenant les éléments suivants :

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

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

Utiliser 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 natif openvino pour un contrôle plus avancé ou personnalisé sur le comportement de l'inférence.

Infé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.

Infé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 capacité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, reporte-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 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, consulte la documentation OpenVINO ou le tutoriel API.

Benchmarks YOLO26 sur OpenVINO

L'équipe Ultralytics a évalué 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.

Intel® 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 demandes changeantes 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 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 l'appareil, permettant un apprentissage automatique et un traitement des données plus rapides et plus efficaces sur une large gamme 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 formats compacts qui exigent une puissance de calcul sérieuse. Sur l'ensemble de 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 le calcul prêt 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 à des précisions FP32, FP16 et INT8.

Intel® Core™ Ultra™ X7 358H

Benchmarks

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

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

Intel® Core™ Ultra™ 7 258V

Benchmarks

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

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

Intel® Core™ Ultra™ 7 155H

Benchmarks

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

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

Reproduis 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 vers le 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 conservant 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.

FAQ

Comment exporter des modèles YOLO26 vers le format OpenVINO ?

L'exportation de modèles YOLO26 vers le format OpenVINO peut considérablement augmenter la vitesse du CPU et activer les accélérations GPU et NPU sur le matériel Intel. Pour exporter, tu peux utiliser soit Python, soit la 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 sur les 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. 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. Model Optimizer : Convertis, optimise et exécute des modèles provenant de frameworks populaires comme 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 performances détaillées, visite notre section benchmarks.

Comment puis-je exécuter l'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 la 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 sur le mode prédiction pour plus de détails.

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

YOLO26 d'Ultralytics est optimisé pour la détection d'objets en temps réel avec une précision et une vitesse élevées. Spécifiquement, lorsqu'il est combiné avec OpenVINO, YOLO26 offre :

• Jusqu'à 3x d'accélération sur les CPU Intel
• Un déploiement transparent sur les GPU et NPU Intel
• Une précision constante et comparable sur divers formats d'exportation

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

Puis-je évaluer 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, y compris PyTorch, TorchScript, ONNX et OpenVINO. Utilise l'extrait de code suivant pour exécuter des 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.