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

Certaines applications de vision par ordinateur, comme l'inspection automatisée de la qualité, les drones autonomes ou les systèmes de sécurité intelligents, fonctionnent mieux lorsque les modèles Ultralytics YOLO, comme Ultralytics YOLO11, s'exécutent à proximité du capteur qui capture les images. Autrement dit, 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 dans le cloud.

Cette approche, appelée 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 s'appuyant sur des serveurs distants, les systèmes réduisent la latence, renforcent la confidentialité des données et gagnent en fiabilité, même dans les environnements où la connexion Internet est limitée ou inexistante.

Par exemple, une caméra industrielle qui inspecte des milliers de produits chaque 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. L'exécution directe d'Ultralytics YOLO11 sur l'appareil permet une inférence instantanée sur l'appareil.

Pour faciliter et optimiser l'exécution des modèles Ultralytics YOLO en périphérie, la nouvelle intégration ExecuTorch, prise en charge par Ultralytics, offre une méthode simplifiée pour exporter et 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 les téléphones, les objets connectés, les cartes embarquées et les microcontrôleurs.

Cette intégration facilite le passage d'un modèle Ultralytics YOLO, comme YOLO11, de l'entraînement au déploiement sur des appareils périphériques. En associant les capacités de vision de YOLO11 au moteur d'exécution léger d'ExecuTorch et au 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 conservant 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 d’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.

Qu'est-ce qu'ExecuTorch ?#

En général, lorsqu’on entraîne un modèle dans PyTorch, celui-ci s’exécute sur de puissants serveurs 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'apporte ExecuTorch. ExecuTorch est une solution de bout en bout développée au sein de l'écosystème PyTorch Edge, qui permet une inférence efficace sur l'appareil, sur des plateformes mobiles, embarquées et périphériques. Elle étend les capacités de PyTorch au-delà du cloud et permet aux modèles d'IA de s'exécuter directement sur des appareils locaux.

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

ExecuTorch repose sur un moteur d'exécution 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), une exportation optimisée conçue 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 est compatible avec 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 dynamique des dimensions, 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 les valeurs de haute précision, comme les nombres flottants sur 32 bits, en valeurs de précision inférieure. La gestion dynamique des dimensions 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. Présentation du fonctionnement d'ExecuTorch (Source)

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

En plus de son environnement d’exécution, ExecuTorch joue également le rôle de 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 les interactions des modèles 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é à l'appareil concerné. Les développeurs peuvent déployer efficacement des modèles sur du matériel varié sans écrire de code propre à chaque appareil ni gérer des processus de conversion distincts.

Grâce à sa conception modulaire et portable ainsi qu’à son intégration étroite avec PyTorch, ExecuTorch est 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 fait le lien 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 quelques-unes 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 des valeurs de haute précision en valeurs de précision inférieure afin de réduire la taille des modèles 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 en périphérie, tout en conservant un niveau de précision presque équivalent. L’exportation Ultralytics produit actuellement des modèles FP32 pour le backend XNNPACK.
• 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 recourir à l'allocation dynamique de mémoire, qui peut augmenter la latence et la consommation d'énergie, ExecuTorch utilise la planification de la mémoire à l'avance (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 moteur d'exécution peut ainsi exécuter les modèles selon un plan mémoire statique, garantissant des performances prévisibles et évitant les ralentissements ou les plantages sur les appareils dont la RAM ou la capacité de traitement est limitée.
• 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 comprend 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 à différentes applications et garantit un comportement cohérent sur les diverses plateformes périphériques.

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

Maintenant que nous avons une meilleure compréhension des possibilités offertes par ExecuTorch, voyons 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 à l'aide de pip, un installateur 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 ceci : « !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 procédures de dépannage détaillées et des bonnes pratiques pour t'aider à démarrer sans encombre.

É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é comme « yolo11n.pt » et l’exporter en appelant la fonction d’exportation et en définissant le format sur « executorch ».

Cette opération crée un répertoire nommé « yolo11n_executorch_model », qui contient le fichier de modèle optimisé (.pte) et un fichier YAML de métadonnées distinct comprenant des informations importantes comme la taille des images et les noms des classes.

Voici le code pour 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 moteur d'exécution ExecuTorch. Le fichier de modèle .pte exporté peut être chargé dans ton application pour effectuer des inférences en temps réel directement 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 l'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 avec 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'intégration ExecuTorch#

En découvrant les différentes options d'exportation prises en charge par Ultralytics, tu te demandes peut-être ce qui rend l'intégration ExecuTorch unique. Sa principale différence réside dans l'alliance des performances, de la simplicité et de la flexibilité, 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'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 spécialisé pour l'IA en périphérie. Cette flexibilité permet aux développeurs de créer des solutions d'IA évolutives qui fonctionnent de manière cohérente sur des plateformes et dans des environnements variés.
• Performances confirmées par des benchmarks : des tests mené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 vite 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 GPUs 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 NPUs et les DSPs pour obtenir des gains de vitesse importants par rapport à l'inférence exécutée uniquement sur CPU.

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

Récemment, Ultralytics a été reconnu comme une réussite de PyTorch ExecuTorch, ce qui souligne 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 visuelle#

Concrètement, cela se traduit par des solutions d'IA visuelle qui fonctionnent efficacement dans des situations réelles, sur tout type d'appareil, du smartphone au système embarqué. 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 chaîne de montage industrielle. (Source)

Au lieu d'envoyer les images ou les données des capteurs dans le cloud pour les traiter, ce qui peut entraîner des délais et dépendre d'une connexion 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 les modèles Ultralytics YOLO11 localement avec ExecuTorch, les villes peuvent prendre plus rapidement des décisions fondées sur les données, qu'il s'agisse de détecter des embouteillages ou de repérer des dangers, et ainsi améliorer la mobilité et la sécurité globales.
• Commerce de détail et entreposage : grâce à l'inférence sur l'appareil, les détaillants peuvent automatiser la surveillance des rayons, suivre les stocks et inspecter rapidement et en toute sécurité les colis, sans dépendre d'une connexion 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'effectuer une inférence optimisée directement sur l'appareil sans dépendre d'une connexion au cloud, ce qui améliore la vitesse, la confidentialité et la fiabilité.

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

L'IA t'intéresse ? Consulte notre dépôt GitHub, rejoins notre communauté et découvre nos options de licence pour lancer ton projet d'IA visuelle. Découvre des innovations comme l'IA dans le commerce de détail et la vision par ordinateur dans la logistique en visitant nos pages de solutions.