Déploie de manière transparente Ultralytics YOLO11 avec OpenVINO™

L'adoption de l'IA dépend de l'accessibilité des solutions d'IA, et une grande partie de cela consiste à faciliter leur déploiement sur le matériel dont disposent déjà les utilisateurs. Exécuter des modèles d'IA sur des GPU (unités de traitement graphique) est une excellente option en termes de performance et de puissance de calcul parallèle.

Cependant, la réalité est que tout le monde n'a pas accès à des GPU haut de gamme, surtout dans les environnements périphériques (edge) ou sur des ordinateurs portables classiques. C'est pourquoi il est si important d'optimiser les modèles pour qu'ils s'exécutent efficacement sur du matériel plus largement disponible, comme les unités centrales (CPU), les GPU intégrés et les unités de traitement neuronal (NPU).

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

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

Pour rendre la vision par ordinateur plus largement accessible, Ultralytics a publié une intégration mise à jour avec le kit d'outils OpenVINO, qui est un projet open-source pour optimiser et exécuter l'inférence d'IA sur des CPU, des GPU et des 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 allons voir comment utiliser le package Python d'Ultralytics pour exporter des modèles YOLO11 vers le format OpenVINO et les utiliser pour l'inférence. C'est parti !

Un aperçu de Ultralytics YOLO11#

Avant de plonger 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 percutant. YOLO11 est le dernier modèle de la série Ultralytics YOLO, offrant des améliorations significatives en termes de vitesse et de précision.

L'un de ses points forts est l'efficacité. Par exemple, Ultralytics YOLO11m possède 22 % de paramètres en moins qu'Ultralytics YOLOv8m, tout en atteignant une précision moyenne (mAP) plus élevée sur le jeu de données COCO. Cela signifie qu'il s'exécute plus rapidement et qu'il détecte également les objets avec plus de précision, ce qui le rend idéal pour les applications en temps réel où la performance et la réactivité sont cruciales.

Fig 2. Benchmarks de performance d'Ultralytics YOLO11.

Au-delà de la détection d'objets, YOLO11 prend en charge diverses tâches de vision par ordinateur avancées telles que la segmentation d'instances, l'estimation de pose, la classification d'images, le suivi d'objets et la détection de boîtes englobantes orientées. YOLO11 est également adapté aux développeurs, le package Python d'Ultralytics offrant une interface simple et cohérente pour l'entraînement, l'évaluation et le déploiement des modèles.

En plus de cela, le package Python d'Ultralytics prend en charge diverses intégrations et de multiples formats d'exportation, notamment OpenVINO, ONNX, TorchScript, te permettant d'intégrer facilement YOLO11 dans divers pipelines de déploiement. Que tu cibles une infrastructure cloud, des appareils de périphérie ou des systèmes embarqués, le processus d'exportation est simple et adaptable à tes besoins matériels.

Qu'est-ce que OpenVINO™ ?#

OpenVINO™ (Open Visual Inference and Neural Network Optimization) est un toolkit open source permettant d'optimiser et de déployer l'inférence IA sur une large gamme de matériels. Il permet aux développeurs d'exécuter des applications d'inférence haute performance efficacement sur diverses plateformes Intel, notamment les CPU, les GPU intégrés et discrets, les NPU et les réseaux de portes programmables in situ (FPGA).

OpenVINO fournit une interface d'exécution unifiée qui abstrait les différences matérielles via des plugins spécifiques aux appareils. Cela signifie que les développeurs peuvent écrire du code une fois et le déployer sur plusieurs cibles matérielles Intel en utilisant une API cohérente.

Voici quelques-unes des caractéristiques clés qui font d'OpenVINO un excellent choix pour le déploiement :

• Convertisseur de modèle : Cet outil convertit et prépare des modèles provenant de frameworks populaires tels que PyTorch, ONNX, TensorFlow, PaddlePaddle et d'autres, afin qu'ils puissent être optimisés 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 facilite l'exécution du même modèle sur n'importe quel matériel pris en charge, des CPU aux GPU.
• Prise en charge de la quantification : Le toolkit prend en charge les formats à précision réduite comme FP16 (par défaut) et INT8, qui aident à réduire la taille du modèle et à accélérer l'inférence sans affecter significativement la précision.

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

Explorer l'intégration Ultralytics x OpenVINO#

Maintenant que nous avons exploré ce qu'est OpenVINO et son importance, voyons comment exporter tes modèles Ultralytics YOLO11 au format OpenVINO et exécuter une inférence efficace sur le 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 d'Ultralytics. Ce package fournit tout ce dont tu as besoin pour entraîner, évaluer et exporter des modèles YOLO, y compris YOLO11.

Tu peux l'installer en exécutant la commande "pip install ultralytics" dans ton terminal ou ton invite de commande. 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 lors de l'installation ou de l'exportation, la documentation d'Ultralytics et les guides de dépannage sont d'excellentes ressources pour t'aider à reprendre la bonne voie.

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

Une fois le package Ultralytics configuré, 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 fonctionnalité d'exportation est utilisée pour le convertir au format OpenVINO. Après avoir exécuté ce code, 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écute 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 manières : en utilisant le package Python Ultralytics ou le runtime natif OpenVINO.

Utiliser le package Python Ultralytics#

Le modèle YOLO11 exporté peut être facilement déployé en utilisant le package Python Ultralytics, comme indiqué dans l'extrait de code ci-dessous. Cette méthode est idéale pour une expérimentation rapide et un déploiement simplifié sur le matériel Intel.

Tu peux également spécifier quel appareil utiliser pour l'inférence, tel que "intel:cpu", "intel:gpu" ou "intel:npu", en fonction du 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")

Après avoir exécuté le code ci-dessus, l'image de sortie sera enregistrée dans le répertoire "runs/detect/predict".

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

Utiliser le runtime natif OpenVINO#

Si tu recherches un moyen personnalisable d'exécuter l'inférence, surtout dans des environnements de production, le runtime OpenVINO te donne plus de contrôle sur la façon dont ton modèle est exécuté. Il prend en charge des fonctionnalités avancées telles que l'exécution asynchrone (exécuter plusieurs requêtes d'inférence en parallèle) et l'équilibrage de charge (distribuer efficacement les charges de travail d'inférence sur le matériel Intel).

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

Un flux de déploiement typique comprend l'initialisation du cœur OpenVINO, le chargement et la compilation du modèle pour un appareil cible, la préparation de l'entrée et l'exécution de l'inférence. Pour des exemples détaillés et un guide étape par étape, consulte la documentation officielle Ultralytics OpenVINO.

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

En explorant les intégrations Ultralytics, tu remarqueras que le package Python Ultralytics prend en charge l'exportation des modèles YOLO11 vers une variété de formats tels que TorchScript, CoreML, TensorRT et ONNX. Alors, pourquoi choisir l'intégration OpenVINO ?

Voici quelques raisons pour lesquelles le format d'exportation OpenVINO est parfaitement adapté au déploiement de modèles sur le matériel Intel :

• Gains de performance : Tu peux bénéficier d'une inférence jusqu'à 3× plus rapide sur les CPU Intel, avec une accélération supplémentaire disponible sur les GPU intégrés et les NPU.
• Aucun réentraînement nécessaire : tu peux exporter tes modèles Ultralytics YOLO11 existants directement au format OpenVINO sans les modifier ni les réentraîner.
• Conçu pour l'échelle : Le même modèle exporté peut être déployé sur des appareils de périphérie à faible consommation et sur une infrastructure cloud à grande échelle, simplifiant le déploiement d'IA évolutif.

Tu peux également évaluer les benchmarks de performance pour le modèle Ultralytics YOLO11 sur différentes plateformes Intel® sur l'OpenVINO™ Model Hub. Le OpenVINO Model Hub est une ressource pour les développeurs pour évaluer des modèles d'IA sur le matériel Intel et découvrir l'avantage de performance d'OpenVINO sur les CPU, GPU intégrés, NPU et cartes graphiques dédiées Intel.

Fig. 5. OpenVINO™ Model Hub : benchmarks de performance pour le modèle Ultralytics YOLO11 sur une gamme de plateformes Intel®.

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

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

Un excellent exemple est le commerce intelligent, où Ultralytics YOLO11 peut aider à détecter les rayons vides en temps réel, suivre les produits qui s'épuisent et analyser la circulation des clients dans le magasin. Cela permet aux détaillants d'améliorer la gestion des stocks et d'optimiser l'agencement des magasins pour un meilleur engagement des acheteurs.

De même, dans les villes intelligentes, YOLO11 peut être utilisé pour surveiller le trafic 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 à l'optimisation du flux de circulation, améliorer la sécurité routière et aider les systèmes de verbalisation automatisée.

Fig 6. Comptage des véhicules à l'aide de YOLO11.

Un autre cas d'usage intéressant est l'inspection industrielle, où Ultralytics YOLO11 peut être déployé sur les lignes de production pour détecter automatiquement les défauts visuels tels que des composants manquants, un désalignement ou des dommages de surface. Cela améliore l'efficacité, réduit les coûts et favorise une meilleure qualité de produit.

Facteurs clés à prendre en compte lors de l'utilisation du toolkit OpenVINO#

Lors du déploiement de modèles Ultralytics YOLO11 avec OpenVINO, voici quelques éléments importants à garder à l'esprit pour obtenir les meilleurs résultats :

• Vérifier 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 s'exécuter efficacement.
• Installe les bons pilotes : Si tu utilises des GPU ou des NPU Intel, vérifie que tous les pilotes requis 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. Chacune comporte un compromis entre vitesse et précision, il est donc important de choisir la bonne option en fonction de tes objectifs de performance et du matériel disponible.

Points clés#

L'exportation d'Ultralytics YOLO11 vers le format OpenVINO permet d'exécuter facilement des modèles d'IA de vision rapides et efficaces sur le matériel Intel. Tu peux déployer sur des CPU, des GPU et des NPU sans avoir besoin de réentraîner ou de modifier ton code. C'est un excellent moyen d'augmenter les performances tout en restant simple et évolutif.

Grâce au support intégré dans le package Python Ultralytics, l'exportation et l'exécution de l'inférence avec OpenVINO sont simples. En quelques étapes, tu peux optimiser ton modèle et l'exécuter sur une variété de plateformes Intel. Que tu travailles sur le commerce intelligent, la surveillance du trafic ou l'inspection industrielle, ce flux de travail t'aide à passer du développement au déploiement avec rapidité et confiance.

Rejoins la communauté YOLO et consulte le dépôt GitHub d'Ultralytics pour en savoir plus sur les intégrations percutantes prises en charge par Ultralytics. Jette également un œil aux options de licence d'Ultralytics pour commencer avec la vision par ordinateur dès aujourd'hui !

Inscris-toi à notre prochain webinaire pour voir l'intégration Ultralytics × OpenVINO en action, et visite le site web d'OpenVINO pour explorer les outils d'optimisation et de déploiement de l'IA à grande échelle.