Déploie facilement Ultralytics YOLO11 avec OpenVINO™

L’adoption de l’IA dépend de l’accessibilité des solutions d’IA, et cela passe en grande partie par la facilité de les déployer sur le matériel dont les utilisateurs disposent déjà. L’exécution de modèles d’IA sur des GPU (processeurs graphiques) est une excellente option en matière de performances et de puissance de traitement parallèle.

Cependant, tout le monde n’a pas accès à des GPU haut de gamme, en particulier dans les environnements edge ou sur les ordinateurs portables courants. C’est pourquoi il est si important d’optimiser les modèles pour qu’ils fonctionnent efficacement sur du matériel plus répandu, comme les CPU (processeurs), les GPU intégrés et les NPU (processeurs neuronaux).

La vision par ordinateur, par exemple, est une branche de l’IA qui permet aux machines d’analyser et de comprendre les images et les flux vidéo en temps réel. Les modèles d’IA visuelle comme Ultralytics YOLO11 prennent en charge des tâches clés telles que la détection d’objets et la segmentation d’instances, qui sont au cœur d’applications allant de l’analyse du commerce de détail aux diagnostics médicaux.

Fig. 1. Utilisation d’Ultralytics YOLO11 pour détecter et segmenter des objets dans un magasin.

Pour rendre la vision par ordinateur plus accessible, Ultralytics a publié une intégration mise à jour avec la boîte à outils OpenVINO, un projet open source destiné à optimiser et exécuter l’inférence IA sur les CPU, les GPU et les NPU.

Grâce à cette intégration, il est plus facile d’exporter et de déployer des modèles YOLO11, avec une inférence jusqu’à 3× plus rapide sur les CPU et des performances accélérées sur les GPU et NPU Intel. Dans cet article, nous verrons comment utiliser le package Python Ultralytics pour exporter des modèles YOLO11 au format OpenVINO et les utiliser pour l’inférence.

Présentation d’Ultralytics YOLO11#

Avant d’entrer dans les détails de l’intégration OpenVINO prise en charge par Ultralytics, examinons de plus près ce qui fait de YOLO11 un modèle de vision par ordinateur fiable et performant. Au moment de la rédaction de cet article, YOLO11 était le modèle le plus récent de la série YOLO d’Ultralytics (depuis remplacé par Ultralytics YOLO26) et apportait des améliorations considérables en matière de vitesse et de précision.

L’un de ses principaux atouts est son efficacité. Par exemple, Ultralytics YOLO11m compte 22 % de paramètres en moins qu’Ultralytics YOLOv8m, tout en obtenant une précision moyenne moyenne (mAP) supérieure sur le jeu de données COCO. Il s’exécute donc plus rapidement et détecte les objets avec davantage de précision, ce qui le rend idéal pour les applications en temps réel où les performances et la réactivité sont essentielles.

Fig. 2. Benchmarks de performances d’Ultralytics YOLO11.

Au-delà de la détection d’objets, YOLO11 prend en charge diverses tâches avancées de vision par ordinateur, comme la segmentation d’instances, la classification d’images, l’estimation de pose, la détection de cadres de délimitation orientés et le suivi d’objets. YOLO11 est également facile à utiliser pour les développeurs : le package Python Ultralytics fournit une interface simple et cohérente pour entraîner, évaluer et déployer des modèles.

De plus, le package Python Ultralytics prend en charge diverses intégrations et plusieurs formats d’exportation, dont OpenVINO, ONNX et TorchScript, ce qui te permet d’intégrer facilement YOLO11 à différents pipelines de déploiement. Que tu vises une infrastructure cloud, des appareils en périphérie ou des systèmes embarqués, le processus d’exportation est simple et adaptable à tes besoins matériels.

Qu’est-ce qu’OpenVINO™ ?#

OpenVINO™ (inférence visuelle ouverte et optimisation des réseaux neuronaux) est une boîte à outils open source qui permet d’optimiser et de déployer l’inférence IA sur un large éventail de matériels. Elle permet aux développeurs d’exécuter efficacement des applications d’inférence hautes performances sur diverses plateformes Intel, notamment les CPU, les GPU intégrés et discrets, les NPU et les réseaux de portes programmables sur le terrain (FPGAs).

OpenVINO fournit une interface d’exécution unifiée qui masque les différences matérielles grâce à des plug-ins spécifiques aux appareils. Les développeurs peuvent ainsi écrire leur code une seule fois et le déployer sur plusieurs cibles matérielles Intel avec une API cohérente.

Voici quelques-unes des principales fonctionnalités qui font d’OpenVINO un excellent choix pour le déploiement :

• Convertisseur de modèles : cet outil convertit et prépare les modèles issus de frameworks populaires tels que PyTorch, ONNX, TensorFlow, PaddlePaddle et d’autres, afin de les optimiser pour une inférence efficace sur le matériel Intel.
• Exécution hétérogène : tu n’as pas besoin de réécrire ton code pour différents matériels Intel. OpenVINO permet facilement d’exécuter le même modèle sur tout matériel pris en charge, des CPU aux GPU.
• Prise en charge de la quantification : la boîte à outils prend en charge des formats à précision réduite comme FP16 (par défaut) et INT8, qui contribuent à réduire la taille des modèles et à accélérer l’inférence sans affecter significativement la précision.

Fig. 3. OpenVINO offre diverses options de déploiement.

Découvrir l’intégration Ultralytics x OpenVINO#

Maintenant que nous avons vu ce qu’est OpenVINO et pourquoi il est important, voyons comment exporter des modèles Ultralytics YOLO11 au format OpenVINO et exécuter efficacement l’inférence sur du matériel Intel.

Étape 1 : installer le package Python Ultralytics#

Pour exporter un modèle au format OpenVINO, tu dois d’abord installer le package Python Ultralytics. Ce package fournit tout ce dont tu as besoin pour entraîner, évaluer et exporter des modèles YOLO, notamment YOLO11.

Tu peux l’installer en exécutant la commande pip install ultralytics dans ton terminal ou ton invite de commandes. Si tu travailles dans un environnement interactif comme Jupyter Notebook ou Google Colab, ajoute simplement un point d’exclamation avant la commande.

De plus, si tu rencontres des problèmes pendant l’installation ou l’exportation, la documentation Ultralytics et les guides de dépannage sont d’excellentes ressources pour t’aider à reprendre le fil.

Étape 2 : exporter ton modèle Ultralytics YOLO11 au format OpenVINO#

Une fois le package Ultralytics installé, l’étape suivante consiste à charger ton modèle YOLO11 et à le convertir dans un format compatible avec OpenVINO.

Dans l’exemple ci-dessous, nous utilisons un modèle YOLO11 préentraîné (« yolo11n.pt »). La fonction d’exportation sert à le convertir au format OpenVINO. Une fois ce code exécuté, le modèle converti sera enregistré dans un nouveau répertoire nommé « yolo11n_openvino_model ».

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="openvino")

Étape 3 : exécuter l’inférence avec le modèle exporté#

Une fois ton modèle YOLO11 exporté au format OpenVINO, tu peux exécuter des inférences de deux façons : avec le package Python Ultralytics ou avec le runtime OpenVINO natif.

Avec le package Python Ultralytics#

Le modèle YOLO11 exporté se déploie facilement avec le package Python Ultralytics, comme le montre l’extrait de code ci-dessous. Cette méthode est idéale pour réaliser rapidement des expérimentations et simplifier le déploiement sur du matériel Intel.

Tu peux aussi préciser l’appareil à utiliser pour l’inférence, par exemple « intel:cpu », « intel:gpu » ou « intel:npu », selon le matériel Intel disponible sur ton système.

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

Pour enregistrer l’image de sortie annotée dans le répertoire "runs/detect/predict", ajoute save=True à l’appel d’inférence.

Fig. 4. Utilisation du modèle Ultralytics YOLO11 exporté pour détecter des objets dans une image.

Avec le runtime OpenVINO natif#

Si tu cherches une façon personnalisable d’exécuter l’inférence, en particulier dans des environnements de production, le runtime OpenVINO te donne davantage de contrôle sur l’exécution de ton modèle. Il prend en charge des fonctionnalités avancées telles que l’exécution asynchrone (exécution parallèle de plusieurs requêtes d’inférence) et l’équilibrage de charge (répartition efficace des charges d’inférence sur le matériel Intel).

Pour utiliser le runtime natif, tu auras besoin des fichiers du modèle exporté : un fichier .xml (qui définit l’architecture du réseau) et un fichier .bin (qui contient les poids appris du modèle). Tu peux également configurer des paramètres supplémentaires, comme les dimensions d’entrée ou les étapes de prétraitement, selon ton application.

Un flux de déploiement classique consiste à initialiser le cœur OpenVINO, à charger et compiler le modèle pour l’appareil cible, à préparer l’entrée et à exécuter l’inférence. Pour des exemples détaillés et des instructions étape par étape, consulte la documentation officielle OpenVINO d’Ultralytics ou la leçon Ultralytics Academy sur l’exécution d’OpenVINO sur CPU.

Pourquoi choisir l’intégration Ultralytics x OpenVINO ?#

En explorant les intégrations Ultralytics, tu remarqueras que le package Python Ultralytics permet d’exporter des modèles YOLO11 dans différents formats, comme TorchScript, CoreML, TensorRT et ONNX. Alors, pourquoi choisir l’intégration OpenVINO ?

Voici quelques raisons pour lesquelles le format d’exportation OpenVINO convient parfaitement au déploiement de modèles sur du matériel Intel :

• Gains de performances : tu peux obtenir une inférence jusqu’à 3× plus rapide sur les CPU Intel, avec une accélération supplémentaire sur les GPU intégrés et les NPU.
• Aucun réentraînement nécessaire : tu peux exporter directement tes modèles Ultralytics YOLO11 existants au format OpenVINO sans les modifier ni les réentraîner.
• Conçu pour évoluer : le même modèle exporté peut être déployé sur des appareils edge basse consommation et sur de grandes infrastructures cloud, ce qui simplifie le déploiement de l’IA à grande échelle.

Tu peux également consulter les benchmarks de performances du modèle Ultralytics YOLO11 sur un éventail de plateformes Intel® dans l’OpenVINO™ Model Hub. L’OpenVINO Model Hub est une ressource qui permet aux développeurs d’évaluer des modèles IA sur du matériel Intel et de découvrir les avantages d’OpenVINO en matière de performances sur les CPU Intel, les GPU intégrés, les NPU et les cartes graphiques discrètes.

Fig. 5. OpenVINO™ Model Hub : benchmarks de performances du modèle Ultralytics YOLO11 sur un éventail de plateformes Intel®.

Applications d’Ultralytics YOLO11 et du format d’exportation OpenVINO#

Grâce à l’intégration OpenVINO, le déploiement de modèles Ultralytics YOLO11 sur du matériel Intel dans des situations réelles devient beaucoup plus simple.

Le commerce de détail intelligent en est un excellent exemple : Ultralytics YOLO11 peut aider à détecter en temps réel les rayons vides, à suivre les produits bientôt en rupture de stock et à analyser les déplacements des clients dans le magasin. Les commerçants peuvent ainsi améliorer la gestion des stocks et optimiser l’agencement des magasins pour mieux répondre aux attentes des clients.

De même, dans les villes intelligentes, YOLO11 peut servir à surveiller la circulation en comptant les véhicules, en suivant les piétons et en détectant les infractions aux feux rouges en temps réel. Ces informations peuvent contribuer à optimiser la circulation, à améliorer la sécurité routière et à faciliter les systèmes de contrôle automatisés.

Fig. 6. Comptage de véhicules avec YOLO11.

Un autre cas d’usage intéressant est l’inspection industrielle, où Ultralytics YOLO11 peut être déployé sur des lignes de production pour détecter automatiquement des défauts visuels, comme des composants manquants, des problèmes d’alignement ou des dommages de surface. Cela améliore l’efficacité, réduit les coûts et contribue à une meilleure qualité des produits.

Facteurs clés à prendre en compte lors de l’utilisation de la boîte à outils OpenVINO#

Lorsque tu déploies des modèles Ultralytics YOLO11 avec OpenVINO, garde à l’esprit quelques points importants pour obtenir les meilleurs résultats :

• Vérifie la compatibilité matérielle : assure-toi que ton matériel Intel, qu’il s’agisse d’un CPU, d’un GPU intégré ou d’un NPU, est pris en charge par OpenVINO afin que le modèle puisse fonctionner efficacement.
• Installe les bons pilotes : si tu utilises des GPU ou des NPU Intel, vérifie que tous les pilotes nécessaires sont correctement installés et à jour.
• Comprendre les compromis de précision : OpenVINO prend en charge les précisions de modèle FP32, FP16 et INT8, que tu peux sélectionner lors de l’exportation à l’aide de l’argument quantize (par exemple, quantize="int8"). Chacune implique un compromis entre vitesse et précision ; il est donc important de choisir l’option adaptée à tes objectifs de performance et au matériel disponible.

Points clés à retenir#

Exporter Ultralytics YOLO11 au format OpenVINO facilite l’exécution de modèles d’IA visuelle rapides et efficaces sur du matériel Intel. Tu peux les déployer sur des CPU, des GPU et des NPU sans avoir à les réentraîner ni à modifier ton code. C’est un excellent moyen d’améliorer les performances tout en conservant simplicité et évolutivité.

La prise en charge intégrée au package Python Ultralytics simplifie l’exportation et l’exécution de l’inférence avec OpenVINO. En quelques étapes seulement, tu peux optimiser ton modèle et l’exécuter sur diverses plateformes Intel. Que tu travailles sur le commerce de détail intelligent, la surveillance de la circulation ou l’inspection industrielle, ce flux de travail t’aide à passer du développement au déploiement rapidement et en toute confiance.

Rejoins la communauté YOLO et consulte le dépôt GitHub d’Ultralytics pour en savoir plus sur les intégrations prises en charge par Ultralytics. Consulte également les options de licence d’Ultralytics pour te lancer dès aujourd’hui dans la vision par ordinateur !

Visite le site web d’OpenVINO pour découvrir des outils permettant d’optimiser et de déployer l’IA à grande échelle.