Link to this sectionExport de modèle TFLite pour le déploiement (obsolète)#

Le déploiement de modèles de vision par ordinateur sur des appareils de périphérie ou embarqués nécessite un format capable de garantir des performances fluides.

L'ancien format d'exportation TensorFlow Lite ou TFLite optimisait les modèles Ultralytics YOLO26 pour des tâches comme la détection d'objets et la classification d'images dans les applications de périphérie (edge). Ce guide conserve le contexte de déploiement TFLite hérité ; utilise LiteRT pour les nouvelles exportations.

Link to this sectionPourquoi TFLite était-il utilisé pour l'exportation ?#

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

TensorFlow Lite prenait en charge un large éventail de plateformes, notamment Linux embarqué, Android, iOS et les microcontrôleurs (MCU). Les exportations TFLite permettaient aux applications d'exécuter des modèles localement et hors ligne.

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

Les modèles TFLite offrent un large éventail 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 périphérie :

• Optimisation sur appareil : TFLite optimise pour le ML sur 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 compatibilité étendue avec les plateformes, 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, dont 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.

Link to this sectionPerformances mesurées (historique)#

Comparaison avant/après par tâche sur le GPU Adreno d'un Xiaomi 17 (Qualcomm Snapdragon 8 Elite Gen 5, SM8850), mesurée via le plugin Flutter Ultralytics 0.6.8 : les anciens assets INT8 TFLite onnx2tf (NHWC, entrée images) par rapport aux nouveaux assets w8a32 LiteRT (NCHW, entrée args_0), tous deux exécutés sur LiteRT 2.x lors du même balayage consécutif avec l' imgsz Android fourni. Chaque cellule représente le temps total (prétraitement + inférence + post-traitement) avec le détail par étape en dessous ; les deux formats ont été entièrement compilés sur le GPU.

Le format w8a32 LiteRT égale ou surpasse l'ancien format INT8 onnx2tf sur cinq des six tâches en termes de latence totale. La segmentation reste la régression de format car les logits NCHW w8a32 coûtent plus de temps d'inférence que les anciens logits NHWC, même après le nettoyage du prétraitement. Les anciens modèles onnx2tf s'exécutent sans changement sur LiteRT 2.x aux côtés des nouveaux exports NCHW. Les assets officiels Android LiteRT sont hébergés sur la version v0.6.6 de yolo-flutter-app, avec le rapport de benchmark détaillé dans la documentation sur les performances de Flutter.

Link to this sectionRégressions de format par rapport à LiteRT#

Détection YOLO26n sur le même appareil sur le GPU Adreno d'un Xiaomi 17 — TFLite INT8 onnx2tf hérité par rapport aux quatre formats de quantification LiteRT, tous mesurés en une seule exécution continue (donc l' inférence est la métrique comparable et dépendante du format) :

Problèmes pour l'équipe Google LiteRT / litert-torch, apparus lors de la migration de ressources Android de production de TFLite onnx2tf vers LiteRT :

1. La disposition NCHW rend les consommateurs conscients de la disposition. litert-torch trace le modèle PyTorch et émet du NCHW [1,3,H,W] avec une entrée flottante, alors que l'export TFLite onnx2tf était en NHWC [1,H,W,3] — correspondant à la disposition caméra/bitmap. Le plugin Flutter actuel écrit le CHW planaire directement lors de l'empaquetage RGB, évitant une transposition HWC→CHW séparée, mais les consommateurs plus simples ont encore besoin soit d'un empaquetage planaire direct, soit d'une transposition supplémentaire.
2. quantize="w8a16" ne compile pas sur le délégué GPU (OpenCL) et bascule silencieusement vers un chemin CPU environ 40 fois plus lent (environ 660 ms contre environ 17 ms), rendant le format avec activations int16 inutilisable pour un déploiement GPU.
3. L'INT8 statique (quantize=8) est le format GPU le plus lent — environ 11 ms contre environ 8,6 ms pour le modèle INT8 onnx2tf hérité équivalent, c'est-à-dire que le propre chemin INT8 de LiteRT régresse par rapport au format qu'il a remplacé. Le w8a32 à plage dynamique est le seul format LiteRT qui égale la vitesse de l'ancien INT8, c'est pourquoi il est maintenant utilisé.
4. Les modèles de segmentation s'exportent sous forme de logits NCHW bruts sans option ArgMax dans le graphe, forçant un argmax côté hôte peu optimisé pour le cache sur [1, C, H, W] (chaque plan de classe étant séparé par un H×W complet). Les chemins onnx2tf, CoreML et QNN peuvent émettre une carte de classe compacte à la place.
5. Les tenseurs de sortie ont été renommés output_0, output_1, … (par rapport aux Identity, Identity_1, … d'onnx2tf), ce qui a rompu silencieusement la recherche de forme de sortie lors de l'exécution jusqu'à ce que le consommateur ajoute les nouveaux noms.

Les chiffres correspondants pour LiteRT w8a32 (le format maintenant expédié) se trouvent sur la page LiteRT.

Link to this sectionOptions de déploiement dans TFLite#

Avant de regarder l'exemple d'exportation de remplacement LiteRT, 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 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 montre 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 des 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 de base tient dans 16 Ko sur un Arm Cortex M3 et peut exécuter de nombreux modèles basiques. 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 sectionRemplacer l'exportation TFLite par LiteRT#

Pour les nouvelles exportations, convertis ton modèle en LiteRT. Le modèle résultant conserve l'extension de fichier .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 meilleures 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 des 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 de remplacement LiteRT prend en charge les modes Export, Predict et Validate. Exporte ton modèle, puis charge le modèle .tflite 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 LiteRT format
model.export(format="litert")  # creates 'yolo26n.tflite'

from ultralytics import YOLO

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

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

from ultralytics import YOLO

# Load the exported TFLite model
model = YOLO("yolo26n.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, visite la page de documentation Ultralytics sur l'exportation.

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

Après avoir exporté ton modèle Ultralytics YOLO26 au format LiteRT, tu peux déployer le modèle .tflite résultant. La première étape principale et recommandée pour exécuter un modèle TFLite est d'utiliser la méthode YOLO("model.tflite"), comme indiqué dans l'extrait de code d'utilisation précédent. Cependant, pour des instructions détaillées 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 tes applications Android, te fournissant des étapes simples à 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.

• Exemples de bout en bout : 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 appareils mobiles et de périphérie.

Link to this sectionRésumé#

Ce guide conserve le flux de travail de déploiement TFLite hérité. Pour les nouvelles exportations, utilise LiteRT pour créer des modèles .tflite pour les environnements de edge computing.

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

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

Link to this sectionFAQ#

Link to this sectionComment remplacer une exportation TFLite par LiteRT ?#

Pour une nouvelle exportation, utilise le format LiteRT. Tout 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 a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to LiteRT format
model.export(format="litert")  # creates 'yolo26n.tflite'

Pour les utilisateurs de CLI, tu peux y parvenir avec :

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

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

Link to this sectionQuels sont les avantages d'utiliser TensorFlow Lite pour le déploiement du modèle YOLO26 ?#

TensorFlow Lite (TFLite) est un framework de deep learning open-source conçu pour l'inférence sur 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 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 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.

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. Tout d'abord, exporte ton modèle au format LiteRT comme expliqué ci-dessus. Ensuite, utilise un outil comme TensorFlow Lite Interpreter pour exécuter le modèle sur ton Raspberry Pi.

Pour d'autres optimisations, 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.

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 avec des ressources limitées. Le runtime de base de TFLite ne nécessite que 16 Ko de mémoire sur un Arm Cortex M3 et peut exécuter des modèles YOLO26 basiques. Cela le rend adapté au déploiement sur des appareils avec une puissance de calcul et une mémoire minimales.

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

Link to this sectionQuelles plateformes sont compatibles avec les modèles YOLO26 exportés en 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 Android et iOS 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é.

Link to this sectionComment résoudre les problèmes courants lors de l'exportation de modèles YOLO26 vers LiteRT ?#

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

• Vérifier la compatibilité des packages : Assure-toi d'utiliser des versions compatibles d'Ultralytics, litert-torch et ai-edge-litert. Reporte-toi à notre guide d'installation.
• Support des modèles : Vérifie que le modèle YOLO26 spécifique prend en charge l'exportation LiteRT en consultant la page de documentation sur l'exportation d'Ultralytics.
• Problèmes de quantification : Lorsque tu utilises 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.