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 sur appareil. Il s'agit de la prochaine génération et du nouveau nom de TensorFlow Lite (TFLite), et il exécute le même format de modèle .tflite. Avec LiteRT, un seul modèle Ultralytics YOLO exporté se déploie sur les appareils mobiles, embarqués, edge et les navigateurs — couvrant tout ce que les anciens formats d'export tflite et tfjs géraient séparément, désormais réunis sous une même bannière.

Le format d'export LiteRT optimise tes modèles pour des tâches telles que 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 un large éventail 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é informatique edge. 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 format de modèle, toutes les cibles :

• Mobile et embarqué : Android, iOS, Linux embarqué et microcontrôleurs (MCU).
• Accélérateurs edge : compatible avec le Coral Edge TPU pour une accélération supplémentaire.
• 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 besoin d'un export TensorFlow.js distinct.

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

• Optimisation sur appareil : réduit la latence en traitant les données localement, renforce la confidentialité en évitant de transmettre les 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 utilise FP16 par défaut pour offrir une vitesse supplémentaire.
• Quantification : prend en charge FP32, INT8 statique (quantize=8, poids int8 + activations int8), INT16-activation statique (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 nécessaires) afin de compresser les modèles et d'accélérer l'inférence avec une perte minimale 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) possède 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 sont des latences en rafale sur une seule image — la moyenne de 15 exécutions après 3 exécutions d'échauffement sur bus.jpg, mesurées avec le plugin Flutter Ultralytics 0.6.10 et les ressources standardisées v0.6.6. L'ordre CPU/GPU alternait entre les tâches au cours 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 le graphe complet à LiteRT OpenCL (LITERT_CL).
• L'export LiteRT retrace directement le modèle PyTorch et produit un .tflite NCHW avec une entrée flottante — le délégué GPU compile le graphe complet (les sept tâches s'exécutent ici sur le GPU Adreno), et w8a32 ne nécessite aucune donnée d'étalonnage. Les utilisateurs doivent lire les formes des tenseurs et les noms des signatures plutôt que de supposer l'ancienne disposition NHWC d'onnx2tf ou les noms de sortie Identity ; emballe les données RGB directement au format planaire CHW ou transpose-les avant l'inférence. Les exports sémantiques renvoient des logits NCHW et nécessitent un argmax des classes côté hôte. Les ressources Android officielles sont hébergées dans la release v0.6.6 de yolo-flutter-app, avec le relevé détaillé des benchmarks dans le document sur les performances Flutter.
• Les résultats du NPU Hexagon Snapdragon correspondant et les valeurs LiteRT CPU/GPU se trouvent dans l'intégration Qualcomm QNN.
• Compare les résultats CPU/accélérateur Apple dans l'intégration CoreML.

Les balayages des appareils ci-dessous utilisent les mêmes ressources standardisé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 possède 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é lus sur l'appareil de benchmark, car Google ne les publie pas dans les spécifications liées.

Benchmark : moyenne de 15 appels predict() après 3 échauffements 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 au cours 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 le graphe complet à 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 possède un CPU Armv9.3 à 10 cœurs (1 cœur C1-Ultra jusqu'à 3,8 GHz, 3 cœurs C1-Pro Performance jusqu'à 3,26 GHz et 6 cœurs C1-Pro Efficiency jusqu'à 2,76 GHz), un GPU Xclipse 960 et un NPU Samsung.

Benchmark : moyenne de 15 appels predict() après 3 échauffements 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 au cours 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 le graphe complet à 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 (MT6993) possède 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 échauffements 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 au cours 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 le graphe complet à LiteRT OpenCL (LITERT_CL).

Tâches prises en charge#

L'export 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 à proposer ces têtes.

Exporter vers LiteRT : convertir ton modèle YOLO#

Tu peux améliorer l'efficacité de l'exécution sur 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 les meilleures pratiques, consulte notre guide d'installation 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'export immédiatement. Le format LiteRT prend en charge les modes Export, Predict et Validate, ce qui te permet d'exporter un modèle, puis de le charger pour exécuter une inférence ou valider sa précision localement.

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 classification

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32", imgsz=640)  # use imgsz=224 for classification

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # use 224 for classification

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # use 224 for classification

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

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

Arguments d'exportation#

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 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 la méthode YOLO("yolo26n.tflite") présentée ci-dessus. Pour le déploiement dans d'autres environnements, consulte les ressources suivantes :

Mobile et systèmes embarqués#

• Android : guide de démarrage rapide pour intégrer LiteRT aux applications Android.
• iOS : guide pour intégrer et déployer des modèles LiteRT dans les 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 tient dans 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, ce qui élimine les calculs côté serveur et conserve 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 expliqué comment exporter des modèles Ultralytics YOLO au format LiteRT. En regroupant le déploiement mobile/en périphérie (anciennement TFLite) et dans le navigateur (anciennement TF.js) au sein d'un seul modèle .tflite, LiteRT rend tes modèles YOLO plus rapides, plus compacts et portables sur pratiquement toutes les cibles exécutant l'inférence sur l'appareil.

Pour plus de détails, consulte la documentation officielle de LiteRT.

Si tu veux également découvrir d'autres intégrations Ultralytics YOLO, consulte notre page du guide des intégrations, qui propose de nombreuses ressources utiles.

FAQ#