Link to this sectionGuide sur l'exportation de modèles YOLO26 vers TFLite pour le déploiement#

Le déploiement de modèles de computer vision sur des appareils de bord ou des appareils embarqués nécessite un format capable d'assurer des performances fluides.

Le format d'exportation TensorFlow Lite ou TFLite te permet d'optimiser tes modèles Ultralytics YOLO26 pour des tâches comme la object detection et l'image classification dans des applications basées sur des appareils de bord. Dans ce guide, nous suivrons les étapes de conversion de tes modèles vers le format TFLite, facilitant ainsi leurs performances sur divers appareils de bord.

Link to this sectionPourquoi devrais-tu exporter vers TFLite ?#

Introduit par Google en mai 2017 au sein de leur framework TensorFlow, TensorFlow Lite, ou TFLite en abrégé, est un framework d'apprentissage profond open-source conçu pour l'inférence sur appareil, également appelé 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, dont 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.

Link to this sectionFonctionnalités clés des modèles TFLite#

Les modèles TFLite offrent une vaste gamme de fonctionnalités clés qui permettent l'apprentissage automatique sur appareil en aidant les développeurs à exécuter leurs modèles sur des appareils mobiles, embarqués et de bord :

• On-device Optimization : TFLite optimise l'apprentissage automatique sur appareil, réduisant la latence en traitant les données localement, renforçant la confidentialité en ne transmettant pas de données personnelles, et minimisant la taille du modèle pour économiser de l'espace.

• Multiple Platform Support : TFLite offre une compatibilité étendue, prenant en charge Android, iOS, Linux embarqué et les microcontrôleurs.

• Diverse Language Support : TFLite est compatible avec divers langages de programmation, notamment Java, Swift, Objective-C, C++ et Python.

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

Link to this sectionOptions de déploiement dans TFLite#

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

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

• Déploiement sur Android et iOS : Les applications Android et iOS utilisant TFLite peuvent analyser les flux de caméras et les capteurs en bordure de réseau 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 montre le processus de déploiement d'un modèle entraîné sur des plateformes Android et iOS à l'aide de TensorFlow Lite.

• Implémentation sur Linux embarqué : Si l'exécution d'inférences sur un Raspberry Pi en utilisant le Ultralytics Guide ne répond pas aux exigences de vitesse pour 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 Coral Edge TPU device.

• Déploiement sur microcontrôleurs : Les modèles TFLite peuvent également être déployés sur des microcontrôleurs et d'autres appareils ne disposant que de 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, de bibliothèques C ou C++ standard, ni d'allocation dynamique de mémoire.

Link to this sectionExport vers TFLite : Conversion de ton modèle YOLO26#

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

Link to this sectionInstallation#

Pour installer les paquets requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées et les bonnes pratiques liées au processus d'installation, consulte notre guide d'installation Ultralytics. Lors de l'installation des packages requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et conseils.

Link to this sectionUtilisation#

Tous les modèles Ultralytics YOLO26 sont conçus pour prendre en charge l'exportation dès leur installation, ce qui facilite leur intégration dans ton workflow 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.

Le format TFLite prend en charge les modes Export, Predict et Validate. Exporte ton modèle, puis charge le modèle exporté pour exécuter l'inférence ou valider sa précision.

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionArguments d'exportation#

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

Link to this sectionDéploiement de modèles TFLite YOLO26 exportés#

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 au format TFLite, tu peux maintenant les déployer. La première étape, recommandée et principale, 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, jette un œil aux 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 de machine learning.

• 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.

• End-To-End Examples : Cette page donne un aperçu de divers exemples 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 de bord.

Link to this sectionRé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 efficaces et adaptés aux environnements d'edge computing.

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

De plus, si tu es curieux à propos d'autres intégrations Ultralytics YOLO26, consulte notre integration guide page. Tu y trouveras beaucoup d'informations et d'aperçus utiles.

Link to this sectionFAQ#

Link to this sectionComment exporter un modèle YOLO26 au format TFLite ?#

Pour exporter un modèle YOLO26 au format TFLite, tu peux utiliser la bibliothèque Ultralytics. Commence par installer le package requis avec :

pip install ultralytics

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

from ultralytics import YOLO

# Load a 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 CLI, tu peux y parvenir avec :

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

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

Link to this sectionQuels 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 appareil, ce qui le rend idéal pour déployer des modèles YOLO26 sur des appareils mobiles, embarqués et IoT. Les avantages clés incluent :

• On-device optimization : Minimise la latence et renforce la confidentialité en traitant les données localement.
• Platform compatibility : 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, consulte le TFLite guide.

Link to this sectionEst-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 au 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, réfère-toi à notre Raspberry Pi deployment guide et au Edge TPU integration guide.

Link to this sectionPuis-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 aux 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 une puissance de calcul et une mémoire minimales.

Pour commencer, visite le TFLite Micro for Microcontrollers guide.

Link to this sectionQuelles plateformes sont compatibles avec les modèles YOLO26 exportés vers TFLite ?#

TensorFlow Lite offre une compatibilité étendue avec les plateformes, te permettant de déployer des modèles YOLO26 sur une large gamme d'appareils, notamment :

• Android et iOS : Support natif via les bibliothèques TFLite Android et iOS.
• Embedded Linux : Idéal pour les ordinateurs monocartes tels que Raspberry Pi.
• Microcontrôleurs : Adapté aux MCU ayant des ressources limitées.

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

Link to this sectionComment puis-je résoudre les problèmes courants lors de l'exportation de modèles 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. Réfère-toi à notre installation guide.
• Support du modèle : Vérifie que le modèle YOLO26 spécifique prend en charge l'exportation TFLite en consultant la export documentation page 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 Common Issues guide.