Accélérer Ultralytics YOLO26 avec OpenVINO sur Intel Core Ultra Series 3 (Panther Lake)

Au cours des dernières années, l'IA et la vision par ordinateur sont passées du stade expérimental à celui de pilier des opérations commerciales quotidiennes. En fait, des études montrent qu'environ 88% des organisations utilisent déjà l'IA dans au moins une partie de leur activité.

Cependant, transformer cette adoption en valeur réelle, que ce soit dans des systèmes de production ou des projets personnels, dépend souvent de la manière dont les modèles s'exécutent une fois déployés. Dans de nombreux scénarios réels, les modèles de vision par ordinateur tels que Ultralytics YOLO26 sont déployés sur des appareils en périphérie (edge) et sur une variété de matériels, souvent des CPU, des GPU intégrés ou des NPU, plutôt que sur des GPU haut de gamme.

C'est là que les performances peuvent commencer à varier, et que l'optimisation devient critique. Un modèle qui fonctionne bien dans un environnement peut être en difficulté dans un autre s'il n'est pas correctement optimisé pour le matériel sous-jacent.

Pour simplifier cela, le package Python Ultralytics prend en charge l'exportation des modèles YOLO26 vers des formats optimisés comme OpenVINO, afin qu'ils puissent s'exécuter de manière fluide sur le matériel Intel sans nécessiter de modifications de ton workflow.

Par exemple, lorsqu'un modèle YOLO26 est exporté au format OpenVINO, il peut s'exécuter plus efficacement sur les processeurs Intel Core Ultra Series 3, avec des vitesses d'inférence GPU multipliées par trois.

Dans cet article, nous allons explorer comment l'intégration mise à jour de Ultralytics et OpenVINO facilite le déploiement des modèles YOLO26 sur le matériel Intel Core Ultra Series 3. Commençons !

Link to this sectionUn aperçu de l'intégration Ultralytics x OpenVINO#

Le package Python Ultralytics fournit une interface unique pour l'entraînement, l'exécution de l'inférence et le déploiement des modèles Ultralytics YOLO tels que YOLO26. Il prend en charge une gamme d'intégrations qui t'aident dans différentes parties du workflow de vision par IA, de l'entraînement et l'expérimentation au déploiement et à l'optimisation.

L'une des intégrations axées sur le déploiement concerne la boîte à outils OpenVINO, qui te permet d'exporter tes modèles YOLO26 vers un format optimisé pour le matériel Intel. Ce processus convertit les modèles YOLO dans un format qui s'exécute plus efficacement sur les CPU, GPU et NPU Intel, y compris les systèmes équipés de processeurs Intel® Core™ Ultra™ series.

Cela rend l'exécution de modèles sur différents appareils Intel plus fluide, sans avoir besoin de les ajuster manuellement pour chaque configuration. Que tu travailles sur une machine locale, un appareil en périphérie ou un déploiement plus important, le même modèle exporté peut être réutilisé.

Ce qui rend cette intégration particulièrement pratique, c'est la façon dont elle s'insère naturellement dans ton workflow Ultralytics existant. Tu peux exporter un modèle en utilisant la même interface que celle utilisée pour l'entraînement et l'inférence, sans avoir besoin d'outils supplémentaires ou d'une configuration complexe.

Une fois exporté, le modèle peut être utilisé pour l'inférence soit via le package Python Ultralytics, soit via le runtime OpenVINO, selon le niveau de contrôle et de flexibilité dont tu as besoin.

Link to this sectionUn examen plus approfondi d'OpenVINO et du matériel Intel Panther Lake pour l'inférence IA#

Avant de voir avec quelle efficacité un modèle YOLO26 exporté peut s'exécuter sur le matériel Intel, prenons un peu de recul pour comprendre comment OpenVINO et le matériel Intel collaborent pour permettre une inférence efficace.

OpenVINO est une boîte à outils open-source conçue pour optimiser et exécuter l'inférence IA sur le matériel Intel, y compris les CPU, les GPU intégrés et les NPU. Elle fournit un runtime unifié, de sorte que le même modèle peut s'exécuter sur ces différentes unités de calcul sans avoir besoin d'être réécrit.

Fig 1. OpenVINO facilite le déploiement de modèles sur plusieurs cibles matérielles. (Source)

Sur les nouveaux processeurs Intel® Core™ Ultra™ Series 3 (nom de code Panther Lake), les charges de travail IA s'exécutent sur plusieurs unités de calcul au sein du même processeur. Chaque puce combine des cœurs CPU pour les tâches générales, un GPU intégré pour le traitement parallèle, et un NPU dédié conçu spécifiquement pour l'inférence IA.

OpenVINO fournit une API unifiée qui te permet de cibler n'importe laquelle de ces unités de calcul, qu'il s'agisse du CPU, du GPU ou du NPU, sans modifier ton code. Tu peux simplement spécifier sur quel appareil exécuter l'inférence au moment de l'exécution, ce qui facilite le basculement entre les trois en fonction de tes besoins en matière de performance et d'efficacité.

Link to this sectionBenchmark de YOLO26 sur la série Intel® Core™ Ultra™#

En explorant l'intégration entre Ultralytics et OpenVINO, tu te demandes peut-être : quel genre de gains de performance de modèle peux-tu attendre de l'exportation de YOLO26 vers le format OpenVINO ?

La différence de vitesse d'inférence devient évidente lorsque l'on compare les modèles YOLO26 à travers différents formats et niveaux de précision. Par exemple, lors de l'exécution de la variante nano de YOLO26 (YOLO26n) sur un Intel Core Ultra X7 358H, un processeur Panther Lake, le temps d'inférence passe de 25,18 ms par image dans PyTorch en précision FP32 à 2,64 ms avec OpenVINO à la même précision avec le NPU intégré.

C'est plus rapide que la référence PyTorch FP32 d'origine, ce qui peut faire une différence notable dans les applications en temps réel et en périphérie où la latence est critique. Ces gains deviennent encore plus apparents lors de l'exécution du même modèle sur le GPU intégré Intel Arc.

Fig 2. Benchmark de l'inférence YOLO26 sur le GPU Intel Panther Lake via OpenVINO (Source)

Fig 3. Benchmark de l'inférence YOLO26 sur le NPU Intel Panther Lake via OpenVINO (Source)

Link to this sectionExploration de deux méthodes pour exporter Ultralytics YOLO26 vers le format OpenVINO#

Il existe deux manières principales d'exporter des modèles YOLO26 vers le format OpenVINO. Tu peux soit utiliser le package Python Ultralytics, soit exporter directement via Ultralytics Platform, un espace de travail complet pour créer et gérer des workflows de vision par ordinateur au même endroit. Ensuite, nous passerons en revue ces deux approches.

Link to this sectionUtilisation du package Python Ultralytics pour exporter YOLO26#

Le package Python Ultralytics fournit un moyen simple d'exporter les modèles YOLO26 vers le format OpenVINO au sein d'un workflow basé sur le code. Comme la même interface est utilisée pour l'entraînement et l'inférence, l'exportation d'un modèle s'intègre naturellement dans les pipelines existants sans nécessiter d'outils supplémentaires.

Pour commencer, tu peux installer le package Ultralytics. Cela peut se faire en exécutant la commande "pip install ultralytics" dans un terminal ou une invite de commande. Si tu travailles dans un environnement interactif tel que Jupyter Notebook ou Google Colab, tu peux exécuter la même commande en la faisant précéder d'un point d'exclamation.

Une fois installé, tu peux charger un modèle YOLO26 entraîné et l'exporter directement vers le format OpenVINO. Comme indiqué ci-dessous, un modèle YOLO26n pré-entraîné (yolo26n.pt) est chargé puis converti au format OpenVINO en utilisant la méthode d'exportation.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

model.export(format="openvino")

Après l'exécution du code, le modèle converti est enregistré dans un nouveau répertoire, où il peut être utilisé pour le déploiement.

Link to this sectionExportation de YOLO26 sur Ultralytics Platform#

Si tu recherches une approche plus simple, sans code, tu peux exporter tes modèles YOLO26 directement via Ultralytics Platform. La plateforme réunit l'intégralité du workflow de vision par ordinateur dans un espace de travail unique, facilitant le passage de l'entraînement au déploiement sans configuration supplémentaire.

Une fois ton modèle prêt, tu peux l'ouvrir au sein de la plateforme et naviguer vers l'onglet Export. À partir de là, tu peux sélectionner OpenVINO comme format d'exportation et éventuellement ajuster des paramètres tels que la taille de l'image ou la précision.

Fig 4. Aperçu de l'exportation de YOLO26 au sein de Ultralytics Platform

La plateforme gère la conversion automatiquement, il n'est donc pas nécessaire de gérer des scripts, des dépendances ou la configuration de l'environnement. Une fois l'exportation terminée, le modèle optimisé peut être téléchargé et utilisé pour le déploiement sur des CPU, GPU et NPU Intel.

Link to this sectionOptions de déploiement activées par l'intégration Ultralytics x OpenVINO#

Une fois qu'un modèle YOLO26 a été exporté au format OpenVINO, il existe quelques moyens d'exécuter l'inférence en fonction de ton workflow et du niveau de contrôle requis. Tu peux soit utiliser le package Python Ultralytics pour une approche plus simple et intégrée, soit utiliser le runtime natif OpenVINO pour plus de flexibilité et de contrôle.

Link to this sectionExécution de l'inférence avec le package Python Ultralytics#

Une fois ton modèle exporté au format OpenVINO, tu peux exécuter l'inférence en utilisant le package Python Ultralytics. Cette approche est idéale pour les tests rapides et un déploiement simplifié, car elle utilise la même interface que pour l'entraînement et l'exportation.

Avec cette approche, tu peux charger le modèle OpenVINO exporté à partir de son répertoire et exécuter l'inférence sur une entrée telle qu'une image ou une vidéo. Tu peux également choisir sur quel appareil effectuer l'exécution en spécifiant des options telles que "intel:cpu", "intel:gpu" ou "intel:npu", selon le matériel disponible sur ton système.

L'extrait de code ci-dessous montre comment charger le modèle exporté et exécuter l'inférence sur une image tout en ciblant le GPU. Une fois l'inférence terminée, l'image de sortie est enregistrée dans le répertoire "runs/detect/predict".

ov_model = YOLO("yolo26n_openvino_model/")

results = ov_model("https://ultralytics.com/images/bus.jpg", device="intel:gpu")

Link to this sectionExploitation du package natif OpenVINO pour l'inférence#

Si tu as besoin d'un contrôle plus précis sur la façon dont ton modèle s'exécute en production, tu peux utiliser le runtime OpenVINO natif pour l'inférence. Cette méthode est utile lors de l'intégration de modèles dans des applications plus vastes ou lorsque tu souhaites affiner l'exécution de l'inférence sur un matériel spécifique.

OpenVINO fournit un moyen unifié d'exécuter des modèles sur des CPU, GPU et NPU Intel, avec des fonctionnalités telles que l'exécution asynchrone et une utilisation efficace des ressources de calcul disponibles. Pour configurer cela, tu peux travailler directement avec les fichiers de modèle exportés, y compris le fichier .xml qui définit la structure du modèle et le fichier .bin qui contient les poids entraînés.

Selon ton cas d'utilisation, tu peux également ajuster des paramètres comme la taille de l'entrée ou les étapes de prétraitement. La configuration de l'inférence implique l'initialisation du runtime OpenVINO, le chargement et la compilation du modèle pour un appareil cible, la préparation des données d'entrée, puis l'exécution de l'inférence.

Fig 5. Exemple d'un pipeline d'inférence typique avec OpenVINO (Source)

Cela te permet de contrôler la manière dont le modèle est exécuté et comment il s'insère dans ton déploiement global. Pour en savoir plus sur la configuration et l'exécution de l'inférence avec le runtime OpenVINO, tu peux consulter la documentation officielle de Ultralytics.

Link to this sectionApplications réelles de YOLO26 sur matériel Intel#

La véritable valeur de l'intégration Ultralytics et OpenVINO apparaît en production, où une inférence fiable et à faible latence peut faire une différence tangible. Voici un aperçu de quelques secteurs clés où cette intégration génère des résultats significatifs :

• Fabrication : En exportant YOLO26 vers OpenVINO, les systèmes de ligne de production peuvent détecter automatiquement des défauts visuels tels que des composants manquants, un mauvais alignement ou des dommages de surface sur le matériel Intel, aidant ainsi à améliorer la qualité du produit et à réduire les erreurs coûteuses.

• Santé : L'imagerie médicale et les systèmes de surveillance des patients peuvent exécuter des modèles YOLO26 exportés localement sur du matériel Intel, tout en respectant des exigences strictes de confidentialité des données et en maintenant des performances d'inférence fiables.

• Villes intelligentes : La surveillance du trafic et l'analyse de foule peuvent être déployées en utilisant des modèles YOLO26 exportés sur des caméras en périphérie alimentées par Intel, permettant des informations en temps réel telles que le comptage des véhicules, le suivi des piétons et la détection d'incidents.

• Automobile : La faible latence et l'efficacité énergétique sont critiques dans la surveillance du conducteur et la détection dans l'habitacle, ce qui fait du matériel Intel associé aux modèles YOLO26 exportés une solution robuste pour les systèmes automobiles embarqués.

Si tu souhaites en savoir plus sur cette intégration, rejoins-nous pour la série d'ateliers Intel OpenVINO DevCon, “From Annotation to Deployment: Building an Object Detection Pipeline with Geti, YOLO26, and OpenVINO™”, où notre responsable des partenariats et de l'écosystème, Francesco Mattioli, rejoindra l'évangéliste logiciel IA d'Intel, Adrian Boguszewski, pour une démonstration en direct et une présentation sur la façon de construire des pipelines de vision par ordinateur prêts pour la production pour des scénarios industriels réels. L'atelier présentera un workflow complet et de bout en bout de détection d'objets, depuis la création du jeu de données et l'entraînement du modèle jusqu'à l'optimisation et le déploiement en périphérie.

Link to this sectionAvantages de l'utilisation du format d'exportation OpenVINO#

Voici quelques-uns des avantages clés de l'utilisation du format d'exportation OpenVINO :

• Accessible et facile à intégrer : Avec une API unifiée et plus de 80 notebooks de tutoriels, OpenVINO facilite le passage de l'expérimentation au déploiement sans introduire une complexité significative.

• Exécuter le même modèle sur différents matériels : OpenVINO te permet d'utiliser un seul modèle exporté sur le matériel Intel pris en charge, en le déployant sur des CPU, GPU ou NPU sans avoir besoin de le réécrire ou de l'adapter pour chaque appareil.

• Optimisation intégrée lors de l'exportation : L'exportation vers OpenVINO convertit les modèles issus de frameworks populaires comme PyTorch et TensorFlow en un format optimisé prêt pour l'inférence, éliminant ainsi le besoin d'étapes de conversion distinctes.

• Meilleure utilisation des ressources matérielles : OpenVINO prend en charge l'inférence asynchrone et l'équilibrage de charge sur le matériel Intel, aidant à améliorer l'efficacité dans les applications réelles.

Link to this sectionExécution de YOLO26 avec ExecuTorch et le backend OpenVINO#

Si tu déploies YOLO26 dans des environnements de production plus exigeants, il existe une autre option disponible qui combine l'efficacité sur l'appareil avec une compression avancée du modèle.

ExecuTorch, le framework d'inférence sur appareil de PyTorch, prend en charge un backend OpenVINO qui te permet de déployer YOLO26 sur le matériel Intel via un chemin d'exportation et d'exécution différent.

Cela fonctionne ainsi : ExecuTorch gère l'exportation du modèle et l'exécution du runtime, tandis qu'OpenVINO agit comme la couche d'accélération matérielle sous-jacente, gérant le calcul réel sur les CPU, GPU ou NPU Intel. Les deux travaillent ensemble afin que tu bénéficies de la portabilité et de l'efficacité sur appareil d'ExecuTorch, combinées aux optimisations spécifiques au matériel fournies par OpenVINO.

Pour en savoir plus sur le fonctionnement et comment commencer avec YOLO26 sur ExecuTorch et le backend OpenVINO, consulte le blog Intel couvrant les dernières mises à jour ExecuTorch et OpenVINO.

Link to this sectionPoints clés#

L'exportation des modèles YOLO26 via l'intégration Ultralytics et OpenVINO améliore les performances sur le matériel Intel sans ajouter de complexité à ton workflow. Tu peux passer de l'entraînement au déploiement sans refaire ton pipeline. Globalement, cela offre un moyen simple d'exécuter des modèles efficacement sur des CPU, GPU et NPU Intel dans des applications réelles.

Rejoins notre communauté et explore notre dépôt GitHub pour en savoir plus sur l'IA de vision. Consulte nos options de licence pour lancer tes projets de vision par ordinateur. Intéressé par des innovations comme l'IA dans la fabrication ou la vision par ordinateur dans l'industrie automobile ? Visite nos pages de solutions pour en découvrir davantage.