Exporter des modèles YOLO vers LiteRT pour un déploiement sur les appareils edge et le Web#

LiteRT (abréviation de Lite Runtime) est le runtime haute performance de Google pour l’IA embarquée. C’est la nouvelle génération de TensorFlow Lite (TFLite), dont il constitue le nouveau nom, et il utilise le même format de modèle .tflite. Avec LiteRT, un seul modèle Ultralytics YOLO exporté peut être déployé sur les appareils mobiles, embarqués et edge, ainsi que dans le navigateur : il couvre tous les cas d’utilisation pris en charge séparément par les anciens formats d’export tflite et tfjs, désormais réunis sous une même solution.

Le format d’export LiteRT optimise tes modèles pour des tâches comme la détection d’objets, la segmentation, l’estimation de pose et la classification, afin qu’ils s’exécutent rapidement et hors ligne sur une large gamme d’appareils.

npm i @ultralytics/yolo @litertjs/core

Pourquoi exporter vers LiteRT ?#

LiteRT est un framework open source conçu pour l’inférence sur appareil, également appelée informatique en périphérie. Il fournit aux développeurs les outils nécessaires pour exécuter des modèles entraînés sur des appareils mobiles, embarqués et IoT, des ordinateurs traditionnels et — grâce à LiteRT.js — directement dans les navigateurs Web et Node.js.

Un seul format de modèle, toutes les plateformes cibles :

• Mobile et embarqué : Android, iOS, Linux embarqué et microcontrôleurs (MCU).
• Accélérateurs edge : compatible avec le Coral Edge TPU pour accélérer davantage le traitement.
• Navigateur et Node.js : LiteRT.js exécute le même modèle .tflite sur le Web avec l’accélération WebGPU/WASM, ce qui évite d’avoir à effectuer un export TensorFlow.js distinct.

Fonctionnalités clés des modèles LiteRT#

• Optimisation sur l’appareil : réduit la latence en traitant les données localement, renforce la confidentialité en évitant de transmettre des données personnelles et réduit la taille du modèle pour économiser de l’espace.
• Prise en charge de plusieurs plateformes : fonctionne sur Android, iOS, Linux embarqué, les microcontrôleurs et les navigateurs web modernes.
• Accélération matérielle : exploite XNNPACK sur CPU et l’accélération GPU via OpenCL, Metal et WebGPU. Le délégué GPU s’exécute en FP16 par défaut pour gagner encore en vitesse.
• Quantification : prend en charge FP32, INT8 statique (quantize=8, poids int8 + activations int8), INT16 statique pour les activations (quantize="w8a16", poids int8 + activations int16 pour une meilleure précision) et INT8 dynamique (quantize="w8a32", poids int8 + activations FP32, sans données d’étalonnage requises) afin de compresser les modèles et d’accélérer l’inférence avec une perte minime de précision.
• Prise en charge de divers langages : compatible avec Java/Kotlin, Swift, Objective-C, C++, Python et JavaScript.

Performances mesurées#

Matériel : Xiaomi 17 avec 12 Go de mémoire LPDDR5X et Android 16 / API 36. Son Snapdragon 8 Elite Gen 5 gravé en 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.

• Les valeurs de vitesse correspondent aux latences en rafale pour une seule image — la moyenne de 15 exécutions après 3 exécutions de préchauffage sur bus.jpg, mesurée avec le plugin Flutter d’Ultralytics 0.6.10 et les ressources normalisées v0.6.6. L’ordre CPU/GPU alternait entre les tâches lors d’un balayage séquentiel unique. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et que chaque ligne GPU déléguait l’intégralité du graphe à LiteRT OpenCL (LITERT_CL).
• L’exportation LiteRT trace directement le modèle PyTorch et produit un .tflite NCHW avec une entrée flottante — le délégué GPU compile l’intégralité du graphe (ici, les sept tâches s’exécutent sur le GPU Adreno) et w8a32 ne nécessite aucune donnée d’étalonnage. Les utilisateurs doivent consulter les formes des tenseurs et les noms des signatures plutôt que de supposer la disposition NHWC historique d’onnx2tf ou les noms de sortie Identity ; ils doivent préparer les données RGB directement au format planaire CHW ou les transposer avant l’inférence. Les exportations sémantiques renvoient des logits NCHW et nécessitent un argmax de classe côté hôte. Les ressources Android officielles sont hébergées dans la version v0.6.6 de yolo-flutter-app, et le document sur les performances Flutter contient le rapport détaillé du benchmark.
• Les résultats correspondants du NPU Hexagon Snapdragon et du CPU/GPU LiteRT sont disponibles dans l’intégration Qualcomm QNN.
• Compare les résultats du CPU et de l’accélérateur Apple dans l’intégration CoreML.

Les tests sur les appareils suivants utilisent les mêmes ressources normalisées v0.6.6.

Google Pixel 10#

Matériel : Google Pixel 10 avec 12 Go de mémoire et Android 16 / API 36. Son Google Tensor G5 gravé en 3 nm intègre un CPU à 8 cœurs (1 cœur Prime jusqu’à 3,78 GHz, 5 cœurs Performance jusqu’à 3,05 GHz et 2 cœurs Efficiency jusqu’à 2,25 GHz), un GPU PowerVR D-Series et un TPU Google. Les fréquences des cœurs et le nom du pilote GPU ont été relevés sur l’appareil de benchmark, car Google ne les publie pas dans les spécifications indiquées.

Benchmark : moyenne de 15 appels predict() après 3 exécutions de préchauffage sur bus.jpg, avec ultralytics_yolo 0.6.10 et les ressources officielles v0.6.6. L’ordre CPU/GPU alterne entre les tâches lors d’un balayage séquentiel unique. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et que chaque ligne GPU déléguait l’intégralité du graphe à LiteRT OpenCL (LITERT_CL).

Samsung Galaxy S26#

Matériel : Samsung Galaxy S26 (SM-S942B) avec 12 Go de mémoire et Android 16 / API 36. Son Exynos 2600 gravé en 2 nm intègre un CPU Armv9.3 à 10 cœurs (1 cœur C1-Ultra jusqu’à 3,8 GHz, 3 cœurs C1-Pro performants jusqu’à 3,26 GHz et 6 cœurs C1-Pro économes jusqu’à 2,76 GHz), un GPU Xclipse 960 et un NPU Samsung.

Benchmark : moyenne de 15 appels predict() après 3 exécutions de préchauffage sur bus.jpg, avec ultralytics_yolo 0.6.10 et les ressources officielles v0.6.6. L’ordre CPU/GPU alterne entre les tâches lors d’un balayage séquentiel unique. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et que chaque ligne GPU déléguait l’intégralité du graphe à LiteRT OpenCL (LITERT_CL).

Xiaomi 17T Pro#

Matériel : Xiaomi 17T Pro (2602EPTC0G) avec 12 Go de mémoire LPDDR5X et Android 16 / API 36. Son MediaTek Dimensity 9500 gravé en 3 nm (MT6993) intègre un CPU Armv9.3 à 8 cœurs (1 cœur C1-Ultra jusqu’à 4,21 GHz, 3 cœurs C1-Premium jusqu’à 3,5 GHz et 4 cœurs C1-Pro jusqu’à 2,7 GHz), un GPU Mali-G1 Ultra MC12 et un NPU MediaTek 990.

Benchmark : moyenne de 15 appels predict() après 3 exécutions de préchauffage sur bus.jpg, avec ultralytics_yolo 0.6.10 et les ressources officielles v0.6.6. L’ordre CPU/GPU alterne entre les tâches lors d’un balayage séquentiel unique. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et que chaque ligne GPU déléguait l’intégralité du graphe à LiteRT OpenCL (LITERT_CL).

Tâches prises en charge#

L’exportation LiteRT prend en charge les sept tâches Ultralytics. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui propose ces têtes.

Exporter vers LiteRT : convertir ton modèle YOLO#

Tu peux améliorer l’efficacité de l’exécution sur l’appareil et élargir les options de déploiement en convertissant tes modèles au format LiteRT.

Installation#

Pour installer le package requis, exécute :

# Install the required package for YOLO
pip install ultralytics

Pour obtenir des instructions détaillées et connaître les bonnes pratiques, consulte notre guide d’installation d’Ultralytics. Si tu rencontres des difficultés, consulte notre guide des problèmes courants.

Utilisation#

Tous les modèles Ultralytics YOLO prennent en charge l’exportation dès le départ. Le format LiteRT prend en charge les modes Exporter, Prédire et Valider, ce qui te permet d’exporter un modèle, puis de le charger pour lancer l’inférence ou valider localement sa précision.

from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter le modèle au format LiteRT
model.export(format="litert", imgsz=640)  # crée 'yolo26n.tflite' ; utilise imgsz=224 pour la classification

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# INT8 dynamique : poids int8, activations FP32 - aucune donnée d’étalonnage requise
model.export(format="litert", quantize="w8a32", imgsz=640)  # crée 'yolo26n_w8a32.tflite'

# INT8 statique : poids int8 + activations int8 - nécessite des données d’étalonnage
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # crée 'yolo26n_int8.tflite'

# w8a16 statique : poids int8 + activations int16 (précision supérieure) - nécessite des données d’étalonnage
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # crée 'yolo26n_w8a16.tflite'

from ultralytics import YOLO

# Charger le modèle LiteRT exporté
model = YOLO("yolo26n.tflite")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Charger le modèle LiteRT exporté
model = YOLO("yolo26n.tflite")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Arguments d’exportation#

Pour en savoir plus sur le processus d’export, consulte la page de la documentation Ultralytics consacrée à l’export.

Déployer des modèles YOLO LiteRT exportés#

Après avoir exporté ton modèle Ultralytics YOLO vers LiteRT, tu peux le déployer sur différentes plateformes. La méthode la plus rapide pour le vérifier localement est celle de YOLO("yolo26n.tflite") présentée ci-dessus. Pour le déployer dans d’autres environnements, consulte les ressources suivantes :

Mobile et systèmes embarqués#

• Android : guide de démarrage rapide pour intégrer LiteRT dans des applications Android.
• iOS : guide pour intégrer et déployer des modèles LiteRT dans des applications iOS.
• Linux embarqué et Raspberry Pi : exécute des modèles LiteRT sur des ordinateurs monocartes, avec une accélération facultative par un Coral Edge TPU.
• Microcontrôleurs : déploie sur des MCU disposant de seulement quelques kilo-octets de mémoire — le runtime principal occupe environ 16 Ko sur un Arm Cortex-M3.

Navigateur et Node.js (LiteRT.js)#

• Présentation de LiteRT.js : exécute le même modèle .tflite directement dans le navigateur avec l'accélération WebGPU/WASM, sans calcul côté serveur et en conservant les données sur l'appareil de l'utilisateur.
• Exemples de bout en bout : exemples pratiques et tutoriels pour implémenter LiteRT sur mobile, en périphérie et sur le Web.

Résumé#

Dans ce guide, nous avons vu comment exporter des modèles Ultralytics YOLO au format LiteRT. En regroupant le déploiement mobile/en périphérie (anciennement TFLite) et le déploiement dans le navigateur (anciennement TF.js) dans un seul modèle .tflite, LiteRT rend tes modèles YOLO plus rapides, plus compacts et portables sur pratiquement toutes les cibles exécutant les modèles sur l'appareil.

Pour en savoir plus, consulte la documentation officielle de LiteRT.

Par ailleurs, si tu souhaites découvrir d'autres intégrations Ultralytics YOLO, consulte notre page des guides d'intégration, qui regorge de ressources utiles.

FAQ#