Déploie les modèles YOLO d’Ultralytics avec l’intégration ExecuTorch

Certaines applications de vision par ordinateur, comme l’inspection qualité automatisée, les drones autonomes ou les systèmes de sécurité intelligents, sont plus performantes lorsque les modèles Ultralytics YOLO, comme Ultralytics YOLO11, fonctionnent à proximité du capteur qui capture les images. En d’autres termes, ces modèles doivent traiter les données directement là où elles sont générées, sur des caméras, des drones ou des systèmes embarqués, plutôt que de les envoyer vers le cloud.

Cette approche, connue sous le nom d’IA en périphérie, permet aux modèles d’effectuer l’inférence directement sur l’appareil où les données sont capturées. En traitant les informations localement plutôt qu’en dépendant de serveurs distants, les systèmes peuvent réduire la latence, renforcer la confidentialité des données et améliorer la fiabilité, même dans des environnements disposant d’une connectivité Internet limitée ou inexistante.

Par exemple, une caméra industrielle qui inspecte des milliers de produits par minute ou un drone qui navigue dans des environnements complexes ne peuvent pas se permettre les délais liés au traitement dans le cloud. Exécuter Ultralytics YOLO11 directement sur l’appareil permet d’effectuer une inférence instantanée sur l’appareil.

Pour rendre l’exécution des modèles Ultralytics YOLO en périphérie plus simple et plus efficace, la nouvelle intégration ExecuTorch prise en charge par Ultralytics offre un moyen rationalisé d’exporter et de déployer les modèles directement sur des appareils mobiles et embarqués. ExecuTorch fait partie de l’écosystème PyTorch Edge et fournit une solution de bout en bout pour exécuter des modèles d’IA directement sur du matériel mobile et périphérique, notamment des téléphones, des appareils portables, des cartes embarquées et des microcontrôleurs.

Cette intégration facilite le passage d’un modèle Ultralytics YOLO, tel que YOLO11, de l’entraînement au déploiement sur des appareils périphériques. En combinant les capacités de vision de YOLO11 avec le runtime léger d’ExecuTorch et le pipeline d’exportation PyTorch, tu peux déployer des modèles qui s’exécutent efficacement sur du matériel périphérique tout en préservant la précision et les performances de l’inférence basée sur PyTorch.

Dans cet article, nous allons examiner de plus près le fonctionnement de l’intégration ExecuTorch, les raisons pour lesquelles elle convient parfaitement aux applications d’IA en périphérie et la façon dont tu peux commencer à déployer des modèles Ultralytics YOLO avec ExecuTorch. Commençons !

Qu’est-ce qu’ExecuTorch ?#

En général, lorsque tu entraînes un modèle avec PyTorch, celui-ci s’exécute sur des serveurs puissants ou des unités de traitement graphique (GPU) dans le cloud. Cependant, le déploiement de ce même modèle sur un appareil mobile ou embarqué, comme un smartphone, un drone ou un microcontrôleur, nécessite une solution spécialisée capable de gérer une puissance de calcul, une mémoire et une connectivité limitées.

C’est précisément ce qu’ExecuTorch apporte. ExecuTorch est une solution de bout en bout développée dans le cadre de l’écosystème PyTorch Edge, qui permet une inférence efficace sur l’appareil, quelle que soit la plateforme mobile, embarquée ou périphérique. Elle étend les capacités de PyTorch au-delà du cloud et permet aux modèles d’IA de s’exécuter directement sur les appareils locaux.

Amener l’inférence PyTorch en périphérie#

Au cœur d’ExecuTorch se trouve un runtime léger en C++ qui permet aux modèles PyTorch de s’exécuter directement sur l’appareil. ExecuTorch utilise le format de modèle PyTorch ExecuTorch (.pte), un format d’export optimisé conçu pour accélérer le chargement, réduire l’empreinte mémoire et améliorer la portabilité.

Il prend en charge XNNPACK comme backend par défaut pour une inférence efficace sur unité centrale (CPU) et étend la compatibilité à un large éventail de backends matériels, notamment CoreML, Metal, Vulkan, Qualcomm, MediaTek, Arm EthosU, OpenVINO et d’autres.

Ces backends permettent une accélération optimisée sur les appareils mobiles, embarqués et périphériques spécialisés. ExecuTorch s’intègre également au pipeline d’exportation PyTorch et prend en charge des fonctionnalités avancées telles que la quantification et la gestion des formes dynamiques afin d’améliorer les performances et l’adaptabilité dans différents environnements de déploiement.

La quantification réduit la taille du modèle et accélère l’inférence en convertissant des valeurs de haute précision (comme les nombres flottants sur 32 bits) en valeurs de précision inférieure, tandis que la gestion des formes dynamiques permet aux modèles de traiter efficacement des tailles d’entrée variables. Ces deux fonctionnalités sont essentielles pour exécuter des modèles d’IA sur des appareils périphériques aux ressources limitées.

Fig. 1. Aperçu du fonctionnement d’ExecuTorch (Source)

Une couche unifiée pour le matériel périphérique#

Au-delà de son runtime, ExecuTorch agit également comme une couche d’abstraction unifiée pour plusieurs backends matériels. En termes simples, il masque les détails propres au matériel et gère la façon dont les modèles interagissent avec différentes unités de traitement, notamment les CPU, les GPU et les unités de traitement neuronal (NPU).

Une fois le modèle exporté, ExecuTorch peut être configuré pour cibler le backend le plus adapté à un appareil donné. Les développeurs peuvent déployer efficacement des modèles sur divers matériels sans écrire de code personnalisé propre à chaque appareil ni gérer des workflows de conversion distincts.

Grâce à sa conception modulaire et portable ainsi qu’à son intégration transparente avec PyTorch, ExecuTorch constitue une excellente option pour déployer des modèles de vision par ordinateur comme Ultralytics YOLO11 sur des systèmes mobiles et embarqués. Il comble l’écart entre l’entraînement des modèles et leur déploiement dans le monde réel, rendant l’IA en périphérie plus rapide, plus efficace et plus facile à mettre en œuvre.

Fonctionnalités clés d’ExecuTorch#

Avant d’examiner comment exporter des modèles Ultralytics YOLO au format ExecuTorch, voyons ce qui fait d’ExecuTorch une solution fiable pour déployer l’IA en périphérie.

Voici un aperçu de certaines de ses fonctionnalités clés :

• Prise en charge de la quantification : ExecuTorch prend en charge la quantification des modèles, une technique qui convertit les valeurs de haute précision en valeurs de précision inférieure afin de réduire la taille du modèle et d’accélérer l’inférence. Les modèles s’exécutent ainsi plus rapidement et utilisent moins de mémoire sur les appareils périphériques, tout en conservant un niveau de précision presque identique.
• Utilisation efficace de la mémoire : L’un des principaux avantages d’ExecuTorch réside dans sa gestion de la mémoire. Au lieu de s’appuyer sur une allocation dynamique de la mémoire, qui peut ajouter de la latence et augmenter la consommation énergétique, ExecuTorch utilise une planification de la mémoire en amont (AOT). Lors de l’exportation, il analyse le graphe du modèle et précalcule la quantité de mémoire nécessaire à chaque opération. Le runtime peut ainsi exécuter les modèles avec un plan mémoire statique, ce qui garantit des performances prévisibles et évite les ralentissements ou les plantages sur les appareils disposant d’une RAM ou d’une capacité de traitement limitées.
• Métadonnées intégrées au modèle : Lors de l’exportation avec l’intégration prise en charge par Ultralytics, chaque modèle inclut un fichier YAML contenant des métadonnées importantes, comme la taille des images d’entrée, les noms des classes et les paramètres de configuration. Ce fichier supplémentaire simplifie l’intégration du modèle dans diverses applications et garantit un comportement cohérent sur différentes plateformes périphériques.

Comment exporter des modèles Ultralytics YOLO au format ExecuTorch#

Maintenant que nous comprenons mieux ce qu’offre ExecuTorch, voyons étape par étape comment exporter des modèles Ultralytics YOLO au format ExecuTorch.

Étape 1 : installer le package Python Ultralytics#

Pour commencer, tu dois installer le package Python Ultralytics avec pip, qui est un programme d’installation de packages. Pour cela, exécute “pip install ultralytics” dans ton terminal ou ton invite de commandes.

Si tu travailles dans un environnement Jupyter Notebook ou Google Colab, ajoute simplement un point d’exclamation avant la commande, comme dans "!pip install ultralytics". Une fois installé, le package Ultralytics fournit tous les outils nécessaires pour entraîner, tester et exporter des modèles de vision par ordinateur, notamment Ultralytics YOLO11.

Si tu rencontres des problèmes lors de l’installation ou de l’exportation de ton modèle, la documentation officielle d’Ultralytics et le guide des problèmes courants proposent des étapes de dépannage détaillées et des bonnes pratiques pour t’aider à démarrer sans difficulté.

Étape 2 : exporter Ultralytics YOLO11#

Après avoir installé le package Ultralytics, tu peux charger une variante du modèle YOLO11 et l’exporter au format ExecuTorch. Par exemple, tu peux utiliser un modèle préentraîné tel que “yolo11n.pt” et l’exporter en appelant la fonction d’exportation avec le format défini sur “executorch”.

Cela crée un répertoire nommé “yolo11n_executorch_model”, qui contient le fichier de modèle optimisé (.pte) ainsi qu’un fichier YAML de métadonnées distinct contenant des informations importantes, comme la taille des images et les noms des classes.

Voici le code permettant d’exporter ton modèle :

from ultralytics import YOLO

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

Étape 3 : Exécuter des inférences après l’exportation du modèle#

Une fois exporté, le modèle est prêt à être déployé sur des appareils périphériques et mobiles à l’aide du runtime ExecuTorch. Le fichier de modèle .pte exporté peut être chargé dans ton application pour exécuter une inférence en temps réel sur l’appareil, sans connexion au cloud.

Par exemple, l’extrait de code ci-dessous montre comment charger le modèle exporté et exécuter une inférence. L’inférence consiste simplement à utiliser un modèle entraîné pour effectuer des prédictions sur de nouvelles données. Ici, le modèle est testé sur une image d’un bus provenant d’une URL publique.

executorch_model = YOLO("yolo11n_executorch_model")
results = executorch_model.predict("https://ultralytics.com/images/bus.jpg", save=True)

Après l’exécution du code, tu trouveras l’image de sortie contenant les objets détectés dans le dossier “runs/detect/predict”.

Fig. 2. Détection d’objets avec un modèle Ultralytics YOLO11 exporté au format ExecuTorch.

Avantages de l’utilisation de l’intégration ExecuTorch#

En explorant les différentes options d’exportation prises en charge par Ultralytics, tu peux te demander ce qui rend l’intégration ExecuTorch unique. La principale différence réside dans sa capacité à combiner performances, simplicité et flexibilité, ce qui facilite le déploiement de modèles d’IA puissants directement sur des appareils mobiles et périphériques.

Voici quelques-uns des principaux avantages de l’utilisation de l’intégration ExecuTorch :

• Options de déploiement flexibles : Les modèles ExecuTorch peuvent être déployés dans des applications mobiles, des systèmes embarqués, des appareils IoT (Internet des objets) et du matériel d’IA en périphérie spécialisé. Cette flexibilité permet aux développeurs de créer des solutions d’IA évolutives qui offrent des performances constantes sur diverses plateformes et dans différents environnements.
• Performances validées par des benchmarks : Les tests réalisés sur des appareils comme le Raspberry Pi 5 montrent que les modèles Ultralytics YOLO11 exportés au format ExecuTorch s’exécutent environ 2 fois plus rapidement que leurs équivalents PyTorch, avec une précision presque identique.
• API d’intégration flexibles : ExecuTorch fournit des API C++, Kotlin et Objective-C pour iOS, Android et Linux embarqué, permettant aux développeurs d’intégrer directement les modèles YOLO dans des applications natives.
• Prise en charge de l’accélération matérielle : ExecuTorch prend en charge plusieurs backends d’accélération matérielle, notamment Vulkan et Metal pour les GPU mobiles, avec une intégration facultative d’OpenCL et d’autres API propres aux fournisseurs. Il peut également exploiter des accélérateurs dédiés tels que les NPU et les DSP afin d’obtenir des gains de vitesse substantiels par rapport à une inférence utilisant uniquement le CPU.

Applications concrètes d’Ultralytics YOLO11 et de l’exportation ExecuTorch#

Récemment, Ultralytics a été reconnu comme success story PyTorch ExecuTorch, mettant en avant notre prise en charge précoce de l’inférence sur l’appareil et nos contributions continues à l’écosystème PyTorch. Cette reconnaissance reflète un objectif commun : rendre l’IA haute performance plus accessible sur les plateformes mobiles et périphériques.

Du cloud à la périphérie : comment ExecuTorch et Ultralytics YOLO11 donnent vie à l’IA de vision#

Concrètement, cela se traduit par des solutions d’IA de vision utilisées efficacement dans le monde réel, sur des appareils allant des smartphones aux systèmes embarqués. Par exemple, dans le secteur manufacturier, les appareils périphériques jouent un rôle essentiel dans la surveillance des lignes de production et la détection des défauts en temps réel.

Fig. 3. Exemple d’utilisation d’Ultralytics YOLO11 pour analyser une ligne d’assemblage industrielle. (Source)

Au lieu d’envoyer les images ou les données des capteurs vers le cloud pour traitement, ce qui peut entraîner des délais et dépendre de la connectivité Internet, l’intégration ExecuTorch permet aux modèles Ultralytics YOLO11 de s’exécuter directement sur le matériel local. Les usines peuvent ainsi détecter instantanément les problèmes de qualité, réduire les temps d’arrêt et préserver la confidentialité des données, tout en fonctionnant avec des ressources de calcul limitées.

Voici quelques autres exemples d’utilisation de l’intégration ExecuTorch et des modèles Ultralytics YOLO :

• Villes intelligentes : En exécutant localement les modèles Ultralytics YOLO11 avec ExecuTorch, les villes peuvent prendre plus rapidement des décisions fondées sur les données, qu’il s’agisse de détecter les embouteillages ou d’identifier les dangers, améliorant ainsi la mobilité et la sécurité globales.
• Commerce de détail et entreposage : Grâce à l’inférence sur l’appareil, les commerçants peuvent automatiser la surveillance des rayons, suivre les stocks et inspecter rapidement et en toute sécurité les colis sans dépendre de connexions au cloud.
• Robotique et drones : Les modèles Ultralytics YOLO11 optimisés pour la périphérie permettent aux robots et aux drones de reconnaître des objets, de naviguer dans leur environnement et de prendre des décisions en temps réel, même sans accès à Internet.

Fig. 4. Détection et comptage de voitures dans la circulation avec YOLO11 (Source)

Points clés à retenir#

L’exportation des modèles Ultralytics YOLO au format ExecuTorch facilite le déploiement de modèles de vision par ordinateur sur de nombreux appareils, notamment les smartphones, les tablettes et les systèmes embarqués comme le Raspberry Pi. Il est ainsi possible d’exécuter une inférence optimisée sur l’appareil sans dépendre de la connectivité au cloud, ce qui améliore la vitesse, la confidentialité et la fiabilité.

Outre ExecuTorch, Ultralytics prend en charge un large éventail d’intégrations, notamment TensorRT, OpenVINO, CoreML et bien d’autres, offrant aux développeurs la flexibilité d’exécuter leurs modèles sur différentes plateformes. À mesure que l’adoption de l’IA de vision progresse, ces intégrations simplifient le déploiement de systèmes intelligents conçus pour fonctionner efficacement dans des conditions réelles.

Tu t’intéresses à l’IA ? Consulte notre dépôt GitHub, rejoins notre communauté et découvre nos options de licence pour lancer ton projet d’IA de vision. Pour en savoir plus sur des innovations comme l’IA dans le commerce de détail et la vision par ordinateur dans la logistique, consulte nos pages consacrées aux solutions.