Guide pour l'exportation de modèles YOLO26 vers TFLite pour le déploiement

Le déploiement de modèles de vision par ordinateur sur des appareils en périphérie (edge) ou des systèmes embarqués nécessite un format capable de garantir des performances optimales.

Le format d'exportation TensorFlow Lite, ou TFLite, te permet d'optimiser tes modèles Ultralytics YOLO26 pour des tâches telles que la détection d'objets et la classification d'images au sein d'applications pour appareils en périphérie. Dans ce guide, nous parcourrons les étapes de conversion de tes modèles au format TFLite, facilitant ainsi leur exécution performante sur divers appareils en périphérie.

Pourquoi exporter vers TFLite ?

Introduit par Google en mai 2017 dans le cadre de leur framework TensorFlow, TensorFlow Lite, ou TFLite pour faire court, est un framework de deep learning open-source conçu pour l'inférence sur l'appareil, également connu sous le nom d'edge computing. Il fournit aux développeurs les outils nécessaires pour exécuter leurs modèles entraînés sur des appareils mobiles, embarqués et IoT, ainsi que sur des ordinateurs traditionnels.

TensorFlow Lite est compatible avec une large gamme de plateformes, y compris Linux embarqué, Android, iOS et les microcontrôleurs (MCU). Exporter ton modèle vers TFLite rend tes applications plus rapides, plus fiables et capables de fonctionner hors ligne.

Fonctionnalités clés des modèles TFLite

Les modèles TFLite offrent un large éventail de fonctionnalités clés permettant l'apprentissage automatique sur l'appareil en aidant les développeurs à exécuter leurs modèles sur des appareils mobiles, embarqués et en périphérie :

• Optimisation sur l'appareil : TFLite optimise le ML sur l'appareil, réduisant la latence en traitant les données localement, améliorant la confidentialité en ne transmettant pas de données personnelles et minimisant la taille du modèle pour économiser de l'espace.

• Prise en charge multiplateforme : TFLite offre une vaste compatibilité de plateforme, prenant en charge Android, iOS, Linux embarqué et les microcontrôleurs.

• Prise en charge de divers langages : TFLite est compatible avec divers langages de programmation, notamment Java, Swift, Objective-C, C++ et Python.

• Haute performance : Atteint des performances supérieures grâce à l'accélération matérielle et à l'optimisation des modèles.

Options de déploiement dans TFLite

Avant d'examiner le code pour l'exportation des modèles YOLO26 vers le format TFLite, comprenons comment les modèles TFLite sont normalement utilisés.

TFLite offre diverses options de déploiement sur l'appareil pour les modèles d'apprentissage automatique, notamment :

• Déploiement avec Android et iOS : Les applications Android et iOS utilisant TFLite peuvent analyser les flux de caméras et les capteurs en périphérie pour détecter et identifier des objets. TFLite propose également des bibliothèques iOS natives écrites en Swift et Objective-C. Le diagramme d'architecture ci-dessous illustre le processus de déploiement d'un modèle entraîné sur des plateformes Android et iOS à l'aide de TensorFlow Lite.

• Mise en œuvre avec Linux embarqué : Si l'exécution d'inférences sur un Raspberry Pi en utilisant le Guide Ultralytics ne répond pas aux exigences de vitesse de ton cas d'utilisation, tu peux utiliser un modèle TFLite exporté pour accélérer les temps d'inférence. De plus, il est possible d'améliorer encore les performances en utilisant un appareil Coral Edge TPU.

• Déploiement avec des microcontrôleurs : Les modèles TFLite peuvent également être déployés sur des microcontrôleurs et d'autres appareils avec seulement quelques kilo-octets de mémoire. Le runtime principal tient dans 16 Ko sur un Arm Cortex M3 et peut exécuter de nombreux modèles de base. Il ne nécessite pas de support de système d'exploitation, ni de bibliothèques C ou C++ standard, ni d'allocation dynamique de mémoire.

Exporter vers TFLite : Conversion de ton modèle YOLO26

Tu peux améliorer l'efficacité de l'exécution des modèles sur l'appareil et optimiser les performances en convertissant tes modèles au format TFLite.

Installation

Pour installer les packages requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation d'Ultralytics. Pendant l'installation des paquets requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et astuces.

Utilisation

Tous les modèles Ultralytics YOLO26 sont conçus pour prendre en charge l'exportation dès la sortie de la boîte, ce qui facilite leur intégration dans ton flux de déploiement préféré. Tu peux consulter la liste complète des formats d'exportation pris en charge et des options de configuration pour choisir la meilleure configuration pour ton application.

  from ultralytics import YOLO

  # Load the YOLO26 model
  model = YOLO("yolo26n.pt")

  # Export the model to TFLite format
  model.export(format="tflite")  # creates 'yolo26n_float32.tflite'

  # Load the exported TFLite model
  tflite_model = YOLO("yolo26n_float32.tflite")

  # Run inference
  results = tflite_model("https://ultralytics.com/images/bus.jpg")

Arguments d'exportation

Pour plus de détails sur le processus d'exportation, visite la page de documentation Ultralytics sur l'exportation.

Déploiement des modèles YOLO26 TFLite exportés

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 vers le format TFLite, tu peux maintenant les déployer. La première étape, principale et recommandée, pour exécuter un modèle TFLite consiste à utiliser la méthode YOLO("model.tflite"), comme indiqué dans l'extrait de code d'utilisation précédent. Cependant, pour des instructions approfondies sur le déploiement de tes modèles TFLite dans divers autres contextes, consulte les ressources suivantes :

• Android : Un guide de démarrage rapide pour intégrer TensorFlow Lite dans des applications Android, fournissant des étapes faciles à suivre pour configurer et exécuter des modèles d'apprentissage automatique.

• iOS : Consulte ce guide détaillé pour les développeurs sur l'intégration et le déploiement de modèles TensorFlow Lite dans des applications iOS, offrant des instructions étape par étape et des ressources.

• Exemples complets : Cette page fournit un aperçu de divers exemples de TensorFlow Lite, présentant des applications pratiques et des tutoriels conçus pour aider les développeurs à implémenter TensorFlow Lite dans leurs projets d'apprentissage automatique sur des appareils mobiles et en périphérie.

Résumé

Dans ce guide, nous nous sommes concentrés sur la manière d'exporter vers le format TFLite. En convertissant tes modèles Ultralytics YOLO26 au format de modèle TFLite, tu peux améliorer l'efficacité et la vitesse des modèles YOLO26, les rendant plus performants et adaptés aux environnements d'edge computing.

Pour plus de détails sur l'utilisation, visite la documentation officielle de TFLite.

De plus, si tu es curieux concernant d'autres intégrations Ultralytics YOLO26, consulte notre page de guide d'intégration. Tu y trouveras de nombreuses informations et perspectives utiles.

FAQ

Comment exporter un modèle YOLO26 vers le format TFLite ?

Pour exporter un modèle YOLO26 vers le format TFLite, tu peux utiliser la bibliothèque Ultralytics. D'abord, installe le package requis en utilisant :

pip install ultralytics

Ensuite, utilise l'extrait de code suivant pour exporter ton modèle :

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to TFLite format
model.export(format="tflite")  # creates 'yolo26n_float32.tflite'

Pour les utilisateurs de l'interface en ligne de commande (CLI), tu peux y parvenir avec :

yolo export model=yolo26n.pt format=tflite # creates 'yolo26n_float32.tflite'

Pour plus de détails, visite le guide d'exportation Ultralytics.

Quels sont les avantages d'utiliser TensorFlow Lite pour le déploiement de modèles YOLO26 ?

TensorFlow Lite (TFLite) est un framework de deep learning open-source conçu pour l'inférence sur l'appareil, le rendant idéal pour déployer des modèles YOLO26 sur des appareils mobiles, embarqués et IoT. Les avantages clés incluent :

• Optimisation sur l'appareil : Minimise la latence et améliore la confidentialité en traitant les données localement.
• Compatibilité de plateforme : Prend en charge Android, iOS, Linux embarqué et les MCU.
• Performance : Utilise l'accélération matérielle pour optimiser la vitesse et l'efficacité du modèle.

Pour en savoir plus, consulte le guide TFLite.

Est-il possible d'exécuter des modèles YOLO26 TFLite sur Raspberry Pi ?

Oui, tu peux exécuter des modèles YOLO26 TFLite sur Raspberry Pi pour améliorer les vitesses d'inférence. D'abord, exporte ton modèle vers le format TFLite comme expliqué ci-dessus. Ensuite, utilise un outil comme TensorFlow Lite Interpreter pour exécuter le modèle sur ton Raspberry Pi.

Pour des optimisations supplémentaires, tu pourrais envisager d'utiliser Coral Edge TPU. Pour des étapes détaillées, reporte-toi à notre guide de déploiement Raspberry Pi et au guide d'intégration Edge TPU.

Puis-je utiliser des modèles TFLite sur des microcontrôleurs pour des prédictions YOLO26 ?

Oui, TFLite prend en charge le déploiement sur des microcontrôleurs avec des ressources limitées. Le runtime principal de TFLite ne nécessite que 16 Ko de mémoire sur un Arm Cortex M3 et peut exécuter des modèles YOLO26 de base. Cela le rend adapté au déploiement sur des appareils avec un minimum de puissance de calcul et de mémoire.

Pour commencer, visite le guide TFLite Micro pour microcontrôleurs.

Quelles plateformes sont compatibles avec les modèles YOLO26 exportés vers TFLite ?

TensorFlow Lite offre une vaste compatibilité de plateforme, te permettant de déployer des modèles YOLO26 sur une large gamme d'appareils, y compris :

• Android et iOS : Prise en charge native via les bibliothèques Android et iOS de TFLite.
• Linux embarqué : Idéal pour les ordinateurs monocarte tels que Raspberry Pi.
• Microcontrôleurs : Adapté aux MCU avec des ressources limitées.

Pour plus d'informations sur les options de déploiement, consulte notre guide de déploiement détaillé.

Comment dépanner les problèmes courants lors de l'exportation d'un modèle YOLO26 vers TFLite ?

Si tu rencontres des erreurs lors de l'exportation de modèles YOLO26 vers TFLite, les solutions courantes incluent :

• Vérifier la compatibilité des packages : Assure-toi d'utiliser des versions compatibles d'Ultralytics et de TensorFlow. Reporte-toi à notre guide d'installation.
• Prise en charge du modèle : Vérifie que le modèle YOLO26 spécifique prend en charge l'exportation TFLite en consultant la page de documentation d'exportation d'Ultralytics.
• Problèmes de quantification : Lors de l'utilisation de la quantification INT8, assure-toi que le chemin de ton jeu de données est correctement spécifié dans le paramètre data.

Pour des conseils de dépannage supplémentaires, visite notre guide des problèmes courants.