Un guide sur l'exportation de modèles YOLO11 vers TFLite pour le déploiement

Le déploiement de modèles de vision par ordinateur sur des appareils périphériques ou des appareils embarqués nécessite un format qui peut garantir des performances homogènes.

Le format d'exportation TensorFlow Lite ou TFLite vous permet d'optimiser vos modèles Ultralytics YOLO11 pour des tâches telles que la détection d'objets et la classification d'images dans les applications basées sur des appareils périphériques. Dans ce guide, nous allons passer en revue les étapes de conversion de vos modèles au format TFLite, ce qui facilitera les performances de vos modèles sur divers appareils périphériques.

Pourquoi devriez-vous exporter vers TFLite ?

Présenté par Google en mai 2017 dans le cadre de son framework TensorFlow, TensorFlow Lite, ou TFLite en abrégé, est un framework open source d'apprentissage profond conçu pour l'inférence sur l'appareil, également appelée 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 un large éventail de plateformes, notamment Linux embarqué, Android, iOS et MCU. L'exportation de votre modèle vers TFLite rend vos applications plus rapides, plus fiables et capables de fonctionner hors ligne.

Principales caractéristiques des modèles TFLite

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

• Optimisation sur l'appareil: TFLite optimise pour 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 de plusieurs plateformes : TFLite offre une compatibilité étendue avec les plateformes, prenant en charge Android, iOS, Linux embarqué et les microcontrôleurs.

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

• Haute Performance : Atteint une performance supérieure grâce à l'accélération matérielle et à l'optimisation du modèle.

Options de déploiement dans TFLite

Avant d'examiner le code d'exportation des modèles YOLO11 au 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 avec 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 schéma d’architecture ci-dessous illustre le processus de déploiement d’un modèle entraîné sur les plateformes Android et iOS à l’aide de TensorFlow Lite.

• Implémentation avec Linux embarqué : Si l'exécution d'inférences sur un Raspberry Pi à l'aide du Guide Ultralytics ne répond pas aux exigences de vitesse de votre cas d'utilisation, vous pouvez 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 seulement 16 Ko sur un Arm Cortex M3 et peut exécuter de nombreux modèles de base. Il ne nécessite pas de prise en charge du système d’exploitation, de bibliothèques C ou C++ standard, ni d’allocation dynamique de mémoire.

Exporter vers TFLite : Conversion de votre modèle YOLO11

Vous pouvez améliorer l'efficacité de l'exécution du modèle sur l'appareil et optimiser les performances en convertissant vos modèles au format TFLite.

Installation

Pour installer les packages requis, exécutez :

# Install the required package for YOLO11
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques relatives au processus d'installation, consultez notre guide d'installation Ultralytics. Si vous rencontrez des difficultés lors de l'installation des packages requis pour YOLO11, consultez notre guide des problèmes courants pour obtenir des solutions et des conseils.

Utilisation

Tous les modèles Ultralytics YOLO11 sont conçus pour prendre en charge l’exportation prête à l’emploi, ce qui facilite leur intégration à votre flux de travail de déploiement préféré. Vous pouvez consulter la liste complète des formats d’exportation et des options de configuration pris en charge pour choisir la meilleure configuration pour votre application.

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

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

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

# Export a YOLO11n PyTorch model to TFLite format
yolo export model=yolo11n.pt format=tflite # creates 'yolo11n_float32.tflite'

# Run inference with the exported model
yolo predict model='yolo11n_float32.tflite' source='https://ultralytics.com/images/bus.jpg'

Arguments d'exportation

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

Déploiement de modèles YOLO11 TFLite exportés

Après avoir exporté avec succès vos modèles Ultralytics YOLO11 au format TFLite, vous pouvez maintenant les déployer. La première étape principale et recommandée pour exécuter un modèle TFLite est d'utiliser le YOLO("model.tflite") méthode, comme indiqué dans l'extrait de code d'utilisation précédent. Cependant, pour des instructions détaillées sur le déploiement de vos modèles TFLite dans divers autres contextes, consultez les ressources suivantes :

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

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

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

Résumé

Dans ce guide, nous nous sommes concentrés sur la façon d'exporter au format TFLite. En convertissant vos modèles Ultralytics YOLO11 au format de modèle TFLite, vous pouvez améliorer l'efficacité et la vitesse des modèles YOLO11, les rendant plus efficaces et adaptés aux environnements de edge computing.

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

De plus, si vous êtes curieux de connaître d'autres intégrations Ultralytics YOLO11, n'oubliez pas de consulter notre page de guide d'intégration. Vous y trouverez des tonnes d'informations et d'idées utiles.

FAQ

Comment exporter un modèle YOLO11 au format TFLite ?

Pour exporter un modèle YOLO11 au format TFLite, vous pouvez utiliser la bibliothèque Ultralytics. Tout d’abord, installez le package requis à l’aide de :

pip install ultralytics

Ensuite, utilisez l'extrait de code suivant pour exporter votre modèle:

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

Pour les utilisateurs de CLI, vous pouvez y parvenir avec :

yolo export model=yolo11n.pt format=tflite # creates 'yolo11n_float32.tflite'

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

Quels sont les avantages de l'utilisation de TensorFlow Lite pour le déploiement de modèles YOLO11 ?

TensorFlow Lite (TFLite) est un framework open source d'apprentissage profond conçu pour l'inférence sur l'appareil, ce qui le rend idéal pour le déploiement de modèles YOLO11 sur des appareils mobiles, embarqués et IoT. Les principaux avantages sont les suivants :

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

Pour en savoir plus, consultez le guide TFLite.

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

Oui, vous pouvez exécuter des modèles YOLO11 TFLite sur Raspberry Pi pour améliorer les vitesses d'inférence. Tout d'abord, exportez votre modèle au format TFLite comme expliqué ci-dessus. Ensuite, utilisez un outil comme TensorFlow Lite Interpreter pour exécuter le modèle sur votre Raspberry Pi.

Pour des optimisations supplémentaires, vous pourriez envisager d'utiliser Coral Edge TPU. Pour des étapes détaillées, consultez notre guide de déploiement Raspberry Pi et le guide d'intégration Edge TPU.

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

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 YOLO11 de base. Cela le rend approprié pour le déploiement sur des appareils avec une puissance de calcul et une mémoire minimales.

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

Quelles plateformes sont compatibles avec les modèles YOLO11 exportés en TFLite ?

TensorFlow Lite offre une compatibilité étendue avec les plateformes, ce qui vous permet de déployer des modèles YOLO11 sur un large éventail d'appareils, notamment :

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

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

Comment puis-je résoudre les problèmes courants lors de l'exportation du modèle YOLO11 vers TFLite ?

Si vous rencontrez des erreurs lors de l'exportation de modèles YOLO11 vers TFLite, les solutions courantes incluent :

• Vérifier la compatibilité des packages: Assurez-vous d'utiliser des versions compatibles d'Ultralytics et TensorFlow. Consultez notre guide d'installation.
• Prise en charge du modèle : Vérifiez que le modèle YOLO11 spécifique prend en charge l'exportation TFLite en consultant la page de documentation sur l'exportation d'Ultralytics.
• Problèmes de quantification: Lorsque vous utilisez la quantification INT8, assurez-vous que le chemin d'accès à votre ensemble de données est correctement spécifié dans le data paramètre.

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

📅 Créé il y a 1 an ✏️ Mis à jour il y a 5 mois

Commentaires