Exportation de modèles TFLite pour le déploiement (obsolète)#
Depuis Ultralytics 8.4.83, le format d’export autonome tflite a été supprimé et remplacé par le format unifié Google LiteRT. LiteRT (Lite Runtime) est la nouvelle génération et le nouveau nom de TensorFlow Lite, et exporte le même modèle .tflite — couvrant désormais le déploiement sur mobile, les systèmes embarqués, les appareils edge et les navigateurs dans un seul format.
format="tflite" fonctionne toujours, mais émet un avertissement d’obsolescence et exporte à la place un modèle LiteRT. Utilise format="litert" désormais ; pour consulter les instructions et options d’export actuelles, reporte-toi au guide d’export LiteRT.
Le déploiement de modèles de vision par ordinateur sur des appareils edge ou des appareils embarqués nécessite un format capable de garantir des performances fluides.
L’ancien format d’export 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 edge. Ce guide conserve le contexte de déploiement TFLite historique ; utilise LiteRT pour les nouveaux exports.
Pourquoi TFLite était-il utilisé pour l’export ?#
Introduit par Google en mai 2017 dans le cadre de leur framework TensorFlow, TensorFlow Lite, ou TFLite en abrégé, était un framework open source de deep learning conçu pour l’inférence sur appareil, également appelée informatique edge. 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 exports TFLite permettaient aux applications d’exécuter les modèles localement et hors ligne.
Fonctionnalité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 edge :
-
Optimisation sur appareil : TFLite est optimisé pour le ML sur appareil, ce qui réduit la latence en traitant les données localement, renforce la confidentialité en évitant de transmettre les données personnelles et minimise la taille des modèles pour économiser de l’espace.
-
Prise en charge de plusieurs plateformes : TFLite offre une vaste compatibilité avec les plateformes, notamment Android, iOS, Linux embarqué et les microcontrôleurs.
-
Prise en charge de divers langages : TFLite est compatible avec plusieurs langages de programmation, notamment Java, Swift, Objective-C, C++ et Python.
-
Hautes performances : offre des performances supérieures grâce à l’accélération matérielle et à l’optimisation des modèles.
Performances mesurées (historiques)#
Ces résultats ont été enregistrés avec le plugin Flutter Ultralytics 0.6.8 et LiteRT 2.1.5 sur Android 16/API 36
à l’aide d’un Xiaomi 17 doté de 12 Go de mémoire LPDDR5X. Son Snapdragon 8 Elite Gen 5 de 3 nm
(SM8850) intègre un CPU Qualcomm Oryon à 8 cœurs (2 cœurs Prime jusqu’à 4,6 GHz et 6 cœurs Performance jusqu’à 3,62 GHz),
un GPU Adreno et un NPU Hexagon. Ces tableaux comparent les artefacts TFLite INT8 hérités d’onnx2tf aux exports litert-torch candidats évalués pendant la migration. Les artefacts de la version ont ensuite été remplacés par les exports standardisés ; ces chiffres ne décrivent donc pas les octets actuels de l’artefact v0.6.6. Consulte les
tableaux de performances LiteRT pour obtenir les mesures actuelles.
Les deux formats ont été exécutés dans le même balayage GPU consécutif, aux tailles d’entrée indiquées. Chaque cellule correspond au temps total
(prétraitement + inférence + post-traitement), avec le détail par étape en dessous ; les journaux natifs ont confirmé que les deux
formats déléguaient l’intégralité du graphe à LiteRT OpenCL (LITERT_CL) sur le GPU Adreno.
| Modèle | Tâche | taille (pixels) | Hérité onnx2tf INT8 TFLite (ms) | Candidat w8a32 LiteRT (ms) |
|---|---|---|---|---|
| YOLO26n | Détection | 640 | 14.0 1.8 / 8.1 / 4.2 | 13.5 1.9 / 8.1 / 3.5 |
| YOLO26n-seg | Segmentation | 640 | 30.1 1.9 / 20.3 / 8.0 | 28.6 1.8 / 20.1 / 6.7 |
| YOLO26n-sem | Sémantique | 640 | 26.4 1.9 / 16.4 / 8.1 | 32.9 1.8 / 23.0 / 8.2 |
| YOLO26n-cls | Classification | 224 | 3.5 0.9 / 2.2 / 0.4 | 3.2 1.0 / 2.2 / 0.1 |
| YOLO26n-pose | Pose | 640 | 17.4 2.4 / 9.9 / 5.1 | 14.0 1.9 / 9.3 / 2.8 |
| YOLO26n-obb | OBB | 640 | 13.9 3.0 / 8.3 / 2.7 | 13.0 2.9 / 7.9 / 2.3 |
La même exécution de migration a également comparé les formats de quantification de détection de YOLO26n. L’inférence est la métrique comparable et dépendante du format :
| Format Android | Inférence GPU (ms) | Compilation GPU |
|---|---|---|
| onnx2tf INT8 (TFLite hérité) | 8.6 | oui |
| LiteRT w8a32 (candidat) | 8.4 | oui |
LiteRT INT8 (quantize=8) | 11.0 | oui |
| LiteRT FP32 | 8.8 | oui |
LiteRT w8a16 (quantize="w8a16") | Repli sur le CPU | non |
Lors de cette exécution, w8a16 est repassé sur le CPU, avec environ 660 ms au total contre environ 17 ms pour les formats GPU. Ces résultats
ont motivé la livraison de w8a32, mais la compatibilité des délégués et les performances dépendent de l’appareil et de la version du runtime.
Évalue les performances sur l’appareil cible et confirme l’utilisation de l’accélérateur dans les journaux de son runtime.
Options de déploiement avec TFLite#
Avant d’examiner l’exemple d’export de remplacement LiteRT, voyons comment les modèles TFLite sont normalement utilisés.
TFLite propose différentes options de déploiement sur appareil pour les modèles de machine learning, notamment :
- Déploiement avec Android et iOS : les applications Android et iOS utilisant TFLite peuvent analyser les flux de caméras et les capteurs edge pour détecter et identifier des objets. TFLite propose également des bibliothèques iOS natives écrites en Swift et en 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 avec 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 ton cas d’utilisation, tu peux utiliser un modèle TFLite exporté pour accélérer les temps d’inférence. Tu peux également améliorer davantage 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 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 ni système d’exploitation, ni bibliothèques C ou C++ standard, ni allocation dynamique de mémoire.
Remplacer l’export TFLite par LiteRT#
Pour les nouveaux exports, convertis ton modèle au format LiteRT. Le modèle obtenu conserve l’extension de fichier .tflite.
Installation#
Pour installer les packages requis, exécute :
# Install the required package for YOLO26
pip install ultralyticsPour obtenir des instructions détaillées et les bonnes pratiques relatives au processus d'installation, consulte notre guide d'installation Ultralytics. Si tu rencontres des difficultés lors de l'installation des packages requis pour YOLO26, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.
Utilisation#
Tous les modèles Ultralytics YOLO26 sont conçus pour prendre en charge l’exportation directement, ce qui facilite leur intégration à ton workflow de déploiement préféré. Tu peux consulter la liste complète des formats d’exportation et des options de configuration pris en charge 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", imgsz=640) # use imgsz=224 for classificationfrom 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")Arguments d'exportation#
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
format | str | 'litert' | Format cible du modèle exporté, définissant sa compatibilité avec différents environnements de déploiement. |
imgsz | int ou tuple | 640 | Taille d’image souhaitée pour l’entrée du modèle. Peut être un entier pour les images carrées ou un tuple (height, width) pour des dimensions spécifiques. |
quantize | int ou str | None | Précision de la quantification : 8 (INT8 statique, poids int8 + activations int8 ; nécessite l’étalonnage data/fraction), 'w8a16' (statique, poids int8 + activations int16 ; nécessite l’étalonnage data/fraction), 'w8a32' (INT8 dynamique, poids int8 + activations FP32 ; aucun étalonnage requis) ou 32/non défini (FP32). FP16 n’est pas exporté séparément — un modèle FP32 s’exécute automatiquement en FP16 avec les délégués GPU. Remplace les indicateurs obsolètes half/int8. |
batch | int | 1 | Indique la taille du lot d'inférence du modèle exporté ou le nombre maximal d'images que le modèle exporté traitera simultanément en mode predict. |
data | str | None | Chemin vers le fichier YAML du jeu de données, indispensable pour la quantification ; la classification accepte à la place un répertoire de données ou le nom d'un jeu de données intégré. S'il est omis avec quantize=8 ou 'w8a16', Ultralytics sélectionne le jeu de données d'étalonnage par défaut pour la tâche du modèle. |
fraction | float, int ou list | 1.0 | Sous-ensemble de calibration sous forme de ratio, de nombre d’images ou de ratios/nombres [train, val, test]. Les listes de deux éléments laissent test complet, tandis que 0 l’ignore. |
device | str | None | Indique l'appareil utilisé pour l'exportation : CPU (device=cpu), MPS pour le silicium Apple (device=mps). |
Pour plus de détails sur le processus d’exportation, consulte la page de la documentation Ultralytics consacrée à l’exportation.
Déployer 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 obtenu. 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. Toutefois, pour obtenir des instructions détaillées sur le déploiement de tes modèles TFLite dans divers autres contextes, consulte les ressources suivantes :
-
Android : guide de démarrage rapide pour intégrer TensorFlow Lite dans les applications Android, avec des étapes faciles à suivre pour configurer et exécuter des modèles de machine learning.
-
iOS : consulte ce guide détaillé destiné aux développeurs sur l’intégration et le déploiement de modèles TensorFlow Lite dans les applications iOS, avec des instructions et des ressources étape par étape.
-
Exemples de bout en bout : cette page présente divers exemples TensorFlow Lite, avec des applications pratiques et des tutoriels conçus pour aider les développeurs à implémenter TensorFlow Lite dans leurs projets de machine learning sur appareils mobiles et edge.
Résumé#
Ce guide conserve le workflow de déploiement TFLite historique. Pour les nouveaux exports, utilise LiteRT afin de créer des modèles .tflite pour les environnements d’informatique edge.
Pour plus de détails sur l’utilisation, consulte la documentation officielle de TFLite.
Si tu souhaites également découvrir d’autres intégrations Ultralytics YOLO26, consulte notre page du guide des intégrations. Tu y trouveras de nombreuses informations et analyses utiles.
FAQ#
TensorFlow Lite (TFLite) est un framework open source de deep learning 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. Ses principaux avantages sont les suivants :
- Optimisation sur appareil : minimise la latence et renforce la confidentialité en traitant les données localement.
- Compatibilité avec les plateformes : prend en charge Android, iOS, Linux embarqué et les MCU.
- Performances : utilise l’accélération matérielle pour optimiser la vitesse et l’efficacité des modèles.
Pour en savoir plus, consulte le guide TFLite.
Oui, tu peux exécuter des modèles YOLO26 TFLite sur Raspberry Pi pour améliorer les vitesses d’inférence. Commence par exporter ton modèle au format LiteRT comme expliqué ci-dessus. Utilise ensuite un outil tel que TensorFlow Lite Interpreter pour exécuter le modèle sur ton Raspberry Pi.
Pour optimiser davantage les performances, tu peux envisager d’utiliser Coral Edge TPU. Pour obtenir des instructions détaillées, consulte notre guide de déploiement Raspberry Pi et le guide d’intégration Edge TPU.
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 disposant d’une puissance de calcul et d’une mémoire minimales.
Pour commencer, consulte le guide TFLite Micro pour microcontrôleurs.
TensorFlow Lite offre une vaste compatibilité avec les plateformes, ce qui te permet de déployer des modèles YOLO26 sur un large éventail d’appareils, notamment :
- Android et iOS : prise en charge native via les bibliothèques TFLite pour Android et iOS.
- Linux embarqué : idéal pour les ordinateurs monocartes tels que Raspberry Pi.
- Microcontrôleurs : adapté aux MCU disposant de ressources limitées.
Pour plus d’informations sur les options de déploiement, consulte notre guide de déploiement détaillé.
Si tu rencontres des erreurs lors de l’exportation de modèles YOLO26 vers LiteRT, les solutions courantes sont les suivantes :
- Vérifie la compatibilité des packages : assure-toi d’utiliser des versions compatibles d’Ultralytics, de
litert-torchet deai-edge-litert. Consulte notre guide d’installation. - Prise en charge du modèle : vérifie que le modèle YOLO26 concerné prend en charge l’export LiteRT en consultant la page de documentation sur l’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 indiqué dans le paramètre
data.
Pour obtenir d'autres conseils de dépannage, consulte notre guide des problèmes courants.
- Vérifie la compatibilité des packages : assure-toi d’utiliser des versions compatibles d’Ultralytics, de
Pour un nouvel export, utilise le format LiteRT. Commence par installer le package requis avec :
Utilise ensuite l’extrait de code suivant pour exporter ton modèle :
Si tu utilises la CLI, tu peux effectuer cette opération avec :
Pour plus de détails, consulte le guide d'exportation d'Ultralytics.