Déploie les modèles Ultralytics YOLO en utilisant l'intégration ExecuTorch

Certaines applications de computer vision, comme le contrôle qualité automatisé, les drones autonomes ou les systèmes de sécurité intelligents, fonctionnent mieux lorsque les modèles Ultralytics YOLO, tels que Ultralytics YOLO11, tournent à proximité du capteur capturant les images. En d'autres termes, ces modèles doivent traiter les données là où elles sont générées, directement sur des caméras, des drones ou des systèmes embarqués, plutôt que de les envoyer dans le cloud.

Cette approche, connue sous le nom de edge AI, 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 au lieu de dépendre de serveurs distants, les systèmes bénéficient d'une latence réduite, d'une meilleure confidentialité des données et d'une fiabilité accrue, même dans des environnements avec une connectivité Internet limitée, voire inexistante.

Par exemple, une caméra industrielle qui inspecte des milliers de produits chaque minute, ou un drone naviguant dans des environnements complexes, ne peut pas se permettre les délais liés au traitement cloud. Faire tourner YOLO11 directement sur l'appareil permet une inférence instantanée, embarquée.

Pour faciliter et rendre plus efficace l'exécution des modèles Ultralytics YOLO en périphérie (edge), la nouvelle ExecuTorch integration prise en charge par Ultralytics offre un moyen simplifié d'exporter et de déployer des 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 edge, y compris 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, tel que YOLO11, de l'entraînement au déploiement sur des appareils edge. En combinant les capacités de vision de YOLO11 avec l'environnement d'exécution 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 edge tout en préservant la précision et les performances de l'inférence basée sur PyTorch.

Dans cet article, nous examinerons de plus près le fonctionnement de l'intégration ExecuTorch, pourquoi elle est idéale pour les applications d'IA en périphérie (edge AI), et comment tu peux commencer à déployer des modèles Ultralytics YOLO avec ExecuTorch. Allons-y !

Link to this sectionQu'est-ce qu'ExecuTorch ?#

Typiquement, lorsque tu entraînes un modèle avec PyTorch, il s'exécute sur des serveurs puissants ou des GPU dans le cloud. Cependant, déployer ce même modèle sur un appareil mobile ou embarqué, tel qu'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 exactement ce qu'apporte ExecuTorch. 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 à travers des plateformes mobiles, embarquées et edge. Elle étend les capacités de PyTorch au-delà du cloud, permettant aux modèles d'IA de s'exécuter directement sur des appareils locaux.

Link to this sectionAmener l'inférence PyTorch à la périphérie (edge)#

À la base, ExecuTorch fournit un environnement d'exécution C++ léger 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 un chargement plus rapide, une empreinte mémoire réduite et une meilleure portabilité.

Il prend en charge XNNPACK comme backend par défaut pour une inférence efficace sur CPU et étend la compatibilité à une large gamme 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 edge spécialisés. ExecuTorch s'intègre également au pipeline d'exportation PyTorch, offrant un support pour des fonctionnalités avancées telles que la quantization et la gestion dynamique des formes (dynamic shape) pour améliorer les performances et l'adaptabilité à travers différents environnements de déploiement.

La quantification réduit la taille du modèle et augmente la vitesse d'inférence en convertissant les valeurs de haute précision (telles que les flottants 32 bits) en valeurs de moindre précision, 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 cruciales pour exécuter des modèles d'IA sur des appareils edge aux ressources limitées.

Fig 1. Un aperçu du fonctionnement d'ExecuTorch (Source)

Link to this sectionUne couche unifiée pour le matériel edge#

Au-delà de son environnement d'exécution, ExecuTorch agit également comme une couche d'abstraction unifiée pour de multiples backends matériels. En termes simples, il abstrait les détails spécifiques au matériel et gère la manière dont les modèles interagissent avec différentes unités de traitement, y compris les CPU, les GPU et les NPU.

Une fois qu'un modèle est exporté, ExecuTorch peut être configuré pour cibler le backend le plus adapté à un appareil donné. Tu peux déployer des modèles efficacement sur du matériel diversifié sans avoir à écrire de code spécifique à l'appareil ou à maintenir des flux de conversion séparés.

Grâce à sa conception modulaire et portable ainsi qu'à son intégration transparente 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 comble le fossé entre l'entraînement du modèle et le déploiement dans le monde réel, rendant l'IA en périphérie plus rapide, plus efficace et plus facile à mettre en œuvre.

Link to this sectionCaractéristiques clés d'ExecuTorch#

Avant de voir comment exporter des modèles Ultralytics YOLO au format ExecuTorch, explorons ce qui fait d'ExecuTorch une option fiable pour déployer l'IA en périphérie.

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

• Support 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 moindre précision pour réduire la taille du modèle et accélérer l'inférence. Cela aide les modèles à s'exécuter plus rapidement et à consommer moins de mémoire sur les appareils edge tout en conservant quasiment le même niveau de précision.
• Utilisation efficace de la mémoire : L'un des plus grands avantages d'ExecuTorch est sa gestion de la mémoire. Au lieu de compter sur l'allocation dynamique de mémoire, qui peut introduire de la latence et une surconsommation énergétique, ExecuTorch utilise la planification mémoire Ahead-of-Time (AOT). Lors de l'exportation, il analyse le graphe du modèle et précalcule la mémoire nécessaire pour chaque opération. Cela permet à l'environnement d'exécution de faire tourner les modèles en utilisant un plan mémoire statique, garantissant des performances prévisibles et évitant les ralentissements ou les crashs sur les appareils ayant une RAM ou une capacité de traitement limitée.
• Métadonnées de modèle intégrées : Lors de l'exportation via l'intégration prise en charge par Ultralytics, chaque modèle inclut un fichier YAML contenant des métadonnées importantes telles que la taille de l'image 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 assure un comportement cohérent sur différentes plateformes edge.

Link to this sectionComment exporter des modèles Ultralytics YOLO au format ExecuTorch#

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

Link to this sectionÉtape 1 : Installer le package Python Ultralytics#

Pour commencer, tu dois installer le Ultralytics Python package en utilisant pip, le gestionnaire de paquets. Tu peux le faire en exécutant “pip install ultralytics” dans ton terminal ou ton invite de commande.

Si tu travailles dans un Jupyter Notebook ou un environnement Google Colab, ajoute simplement un point d'exclamation avant la commande, comme "!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, y compris 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 Common Issues guide proposent des étapes de dépannage détaillées et des bonnes pratiques pour t'aider à démarrer sans encombre.

Link to this sectionÉtape 2 : Exporter Ultralytics YOLO11#

Après avoir installé le package Ultralytics, tu peux charger une variante du modèle YOLO11 et l'export 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 inclut le fichier de modèle optimisé (.pte) et un fichier YAML de métadonnées séparé contenant des détails importants tels que la taille de l'image 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")

Link to this sectionÉ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 edge et mobiles en utilisant l'environnement d'exécution 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 avoir besoin d'une connexion cloud.

Par exemple, l'extrait de code ci-dessous montre comment charger le modèle exporté et exécuter l'inférence. L'inférence signifie 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 de 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 avoir exécuté le code, tu trouveras l'image de sortie avec les objets détectés enregistrée dans le dossier “runs/detect/predict”.

Fig 2. Détection d'objets utilisant un modèle YOLO11 exporté au format ExecuTorch.

Link to this sectionAvantages de l'utilisation de l'intégration ExecuTorch#

Tout en explorant les différentes options d'exportation prises en charge par Ultralytics, tu te demandes peut-être ce qui rend l'intégration ExecuTorch unique. La différence clé réside dans la façon dont elle combine performance, simplicité et flexibilité, facilitant ainsi le déploiement de puissants modèles d'IA directement sur des appareils mobiles et edge.

Voici un aperçu de quelques-uns des avantages clés de l'utilisation de l'intégration ExecuTorch :

• Options de déploiement flexibles : Les modèles ExecuTorch peuvent être déployés sur des applications mobiles, des systèmes embarqués, des appareils IoT (Internet des Objets) et du matériel d'IA edge spécialisé. 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 environnements variés.
• Performances prouvées par des benchmarks : Des tests sur des appareils tels que le Raspberry Pi 5 montrent que les modèles YOLO11 exportés au format ExecuTorch s'exécutent environ 2 fois plus vite que leurs homologues PyTorch, avec une précision quasi 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 les modèles YOLO directement dans des applications natives.
• Support de l'accélération matérielle : ExecuTorch prend en charge plusieurs backends d'accélération matérielle, incluant Vulkan et Metal pour les GPU mobiles, avec une intégration optionnelle pour OpenCL et d'autres API spécifiques aux fournisseurs. Il peut également tirer parti d'accélérateurs dédiés tels que les NPU et DSP pour obtenir des gains de vitesse substantiels par rapport à une inférence sur CPU uniquement.

Link to this sectionApplications concrètes de YOLO11 et de l'exportation ExecuTorch#

Récemment, Ultralytics a été reconnu comme une PyTorch ExecuTorch success story, mettant en avant notre support précoce de l'inférence sur 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 edge.

Link to this sectionDu cloud à la périphérie (edge) : Comment ExecuTorch et YOLO11 donnent vie à l'IA de vision#

En pratique, cela se traduit par des solutions d'IA de vision réelles fonctionnant efficacement sur tout, des smartphones aux systèmes embarqués. Par exemple, dans le secteur manufacturier, les appareils edge jouent un rôle crucial dans le contrôle des lignes de production et la détection des défauts en temps réel.

Fig 3. Un exemple d'utilisation de YOLO11 pour analyser une chaîne d'assemblage manufacturière. (Source)

Au lieu d'envoyer des images ou des données de capteurs vers le cloud pour traitement, ce qui peut introduire des délais et dépendre de la connectivité Internet, l'intégration ExecuTorch permet aux modèles YOLO11 de s'exécuter directement sur le matériel local. Cela signifie que les usines peuvent détecter les problèmes de qualité instantanément, 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 de la manière dont l'intégration ExecuTorch et les modèles Ultralytics YOLO peuvent être appliqués :

• Smart cities (Villes intelligentes) : En exécutant des modèles YOLO11 localement avec ExecuTorch, les villes peuvent prendre des décisions plus rapides et basées sur des données, de la détection des embouteillages à l'identification des 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 détaillants peuvent automatiser la surveillance des rayons, suivre les stocks et inspecter les colis rapidement et en toute sécurité, sans dépendre de connexions cloud.
• Robotics and drones : Les modèles YOLO11 optimisés pour l'edge permettent aux robots et aux drones de reconnaître des objets, de naviguer dans des environnements 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 le trafic en utilisant YOLO11 (Source)

Link to this sectionPoints clés#

Exporter les 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 tels que le Raspberry Pi. Cela signifie qu'il est possible d'exécuter une inférence optimisée sur l'appareil sans dépendre d'une connectivité cloud, améliorant ainsi la vitesse, la confidentialité et la fiabilité.

En plus d'ExecuTorch, Ultralytics prend en charge un large éventail d'intégrations, incluant TensorRT, OpenVINO, CoreML, et plus encore, offrant aux développeurs la flexibilité de faire fonctionner leurs modèles sur diverses plateformes. À mesure que l'adoption de l'IA de vision croît, ces intégrations simplifient le déploiement de systèmes intelligents conçus pour fonctionner efficacement dans des conditions réelles.

Curieux à propos de l'IA ? Consulte notre GitHub repository, rejoins notre communauté, et explore nos licensing options pour lancer ton projet d'IA de vision. Apprends-en davantage sur des innovations comme AI in retail et computer vision in logistics en visitant nos pages de solutions.