Exporter des modèles YOLO vers LiteRT pour un déploiement sur les périphériques Edge et Web#

LiteRT (diminutif de Lite Runtime) est le moteur haute performance de Google pour l'IA sur appareil. C'est la nouvelle génération et le 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 le mobile, l'embarqué, l'edge et le navigateur — couvrant tout ce que les anciens formats d'exportation tflite et tfjs géraient séparément, désormais sous un même toit.

Le format d'exportation 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 devrais-tu exporter vers LiteRT ?#

LiteRT est un framework open-source conçu pour l'inférence sur appareil, également connu sous le nom d'edge computing. Il donne aux développeurs les outils pour exécuter des modèles entraînés sur des appareils mobiles, embarqués et IoT, des ordinateurs traditionnels, et — via LiteRT.js — directement dans les navigateurs web et Node.js.

Un seul 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 une accélération WebGPU/WASM — éliminant le besoin d'un export TensorFlow.js séparé.

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

• Optimisation sur appareil : Réduit la latence en traitant les données localement, améliore la confidentialité en ne transmettant pas de données personnelles et minimise la taille du modèle pour économiser de l'espace.
• Support multiplateforme : S'exécute sur Android, iOS, Linux embarqué, microcontrôleurs et les navigateurs web modernes.
• Accélération matérielle : Tire parti de XNNPACK sur CPU et de l'accélération GPU via OpenCL, Metal et WebGPU. Le délégué GPU s'exécute en FP16 par défaut pour plus de 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 plus grande précision) et INT8 dynamique (quantize="w8a32", poids int8 + activations FP32, sans données de calibration nécessaires) pour compresser les modèles et accélérer l'inférence avec une perte de précision minimale.
• Support linguistique diversifié : 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 3 nm (SM8850) possède un processeur 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 pour 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 actifs standardisés v0.6.6. L'ordre CPU/GPU a alterné entre les tâches lors d'un balayage séquentiel. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et chaque ligne GPU déléguait le graphe complet à LiteRT OpenCL (LITERT_CL).
• L'export LiteRT trace directement le modèle PyTorch, produisant un .tflite NCHW avec une entrée flottante — le délégué GPU compile l'ensemble du graphe (les sept tâches s'exécutent sur le GPU Adreno ici), et w8a32 ne nécessite aucune donnée de calibration. Les consommateurs doivent lire les formes de tenseurs et les noms de signature au lieu de supposer la disposition héritée onnx2tf NHWC ou les noms de sortie Identity ; emballez les données RGB directement sous forme de CHW planaire ou transposez-les avant l'inférence. Les exports sémantiques renvoient des logits NCHW et nécessitent un argmax de classe côté hôte. Les actifs Android officiels sont hébergés sur la version yolo-flutter-app v0.6.6, avec le rapport de référence détaillé dans la documentation de performance Flutter.
• Les chiffres correspondants pour le NPU Hexagon de Snapdragon et le CPU/GPU LiteRT se trouvent dans l'intégration Qualcomm QNN.
• Compare les résultats du CPU/accélérateur Apple dans l'intégration CoreML.

Les balayages d'appareils suivants utilisent les mêmes actifs standardisés 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 de 3 nm possède un processeur à 8 cœurs (1 cœur Prime jusqu'à 3,78 GHz, 5 cœurs Performance jusqu'à 3,05 GHz et 2 cœurs d'efficacité jusqu'à 2,25 GHz), un GPU PowerVR D-Series et un TPU Google. Les fréquences d'horloge et le nom du pilote GPU ont été lus à partir de l'appareil de référence 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, en utilisant ultralytics_yolo 0.6.10 et les actifs officiels v0.6.6. L'ordre CPU/GPU alterne entre les tâches lors d'un balayage séquentiel. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et 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 de 2 nm possède un processeur Armv9.3 à 10 cœurs (1 cœur C1-Ultra jusqu'à 3,8 GHz, 3 cœurs performance C1-Pro jusqu'à 3,26 GHz et 6 cœurs d'efficacité C1-Pro 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, en utilisant ultralytics_yolo 0.6.10 et les actifs officiels v0.6.6. L'ordre CPU/GPU alterne entre les tâches lors d'un balayage séquentiel. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et 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) de 3 nm possède un processeur 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, en utilisant ultralytics_yolo 0.6.10 et les actifs officiels v0.6.6. L'ordre CPU/GPU alterne entre les tâches lors d'un balayage séquentiel. Les journaux natifs ont confirmé que chaque ligne CPU utilisait LiteRT CPU/XNNPACK et 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 d'Ultralytics. La segmentation sémantique et l'estimation de la profondeur ne sont disponibles qu'avec YOLO26, la seule famille qui intègre 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 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'exportation par défaut. 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, visite la page de documentation d'Ultralytics sur l'exportation.

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

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

Mobile et embarqué#

• Android : Un guide de démarrage rapide pour intégrer LiteRT dans des applications Android.
• iOS : Un 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 monocarte, avec une accélération optionnelle via un Coral Edge TPU.
• Microcontrôleurs : Déploie sur des MCU dotés de seulement quelques kilo-octets de mémoire — le moteur d'exécution principal tient dans environ 16 Ko sur un Arm Cortex-M3.

Navigateur et Node.js (LiteRT.js)#

• Aperçu de LiteRT.js : Exécute le même modèle .tflite directement dans le navigateur avec l'accélération WebGPU/WASM, éliminant le calcul côté serveur et maintenant les données sur l'appareil de l'utilisateur.
• Exemples de bout en bout : Exemples pratiques et tutoriels pour implémenter LiteRT sur mobile, edge et web.

Résumé#

Dans ce guide, nous avons couvert la manière d'exporter des modèles Ultralytics YOLO au format LiteRT. En regroupant le déploiement mobile/edge (anciennement TFLite) et navigateur (anciennement TF.js) dans un seul modèle .tflite, LiteRT rend tes modèles YOLO plus rapides, plus petits et portables sur pratiquement toutes les cibles sur appareil.

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

De plus, si tu es curieux de découvrir d'autres intégrations Ultralytics YOLO, consulte notre page du guide d'intégration pour trouver de nombreuses ressources utiles.

FAQ#

Comment exporter un modèle YOLO au format LiteRT ?#

Utilise la bibliothèque Ultralytics pour exporter un modèle YOLO vers LiteRT (.tflite). Tout d'abord, installe le paquet :

pip install ultralytics

Ensuite, exporte 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", imgsz=640)  # use imgsz=224 for classification

Pour les utilisateurs CLI :

yolo export model=yolo26n.pt format=litert imgsz=640 # use imgsz=224 for classification

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

Quelle est la différence entre LiteRT, TFLite et TF.js ?#

LiteRT est le nouveau nom de TensorFlow Lite — même format de modèle .tflite, même lignée d'exécution, rebaptisé par Google. Dans Ultralytics, le format d'exportation unique litert couvre désormais les deux cas d'utilisation qui nécessitaient auparavant deux formats distincts :

• L'ancien format tflite → déploiement mobile, embarqué et edge.
• L'ancien format tfjs → déploiement sur navigateur et Node.js, désormais géré par LiteRT.js exécutant le même fichier .tflite.

Si tu possèdes un fichier .tflite existant, tu peux le charger directement avec YOLO("model.tflite") et il s'exécutera via le backend LiteRT.

Puis-je exécuter des modèles YOLO LiteRT sur un Raspberry Pi ?#

Oui. Exporte ton modèle au format LiteRT, puis exécute-le sur un Raspberry Pi pour améliorer les vitesses d'inférence. Pour une optimisation supplémentaire, envisage un Coral Edge TPU. Pour des étapes détaillées, réfère-toi à notre guide de déploiement Raspberry Pi.

Puis-je exécuter des modèles YOLO dans le navigateur avec LiteRT ?#

Oui. LiteRT.js exécute le même modèle exporté .tflite directement dans un navigateur web ou une application Node.js, avec l'accélération WebGPU/WASM. Cela remplace le flux de travail TensorFlow.js précédent — il n'y a pas d'exportation de navigateur séparée, il suffit de déployer ton modèle LiteRT avec le moteur d'exécution LiteRT.js.

LiteRT supporte-t-il l'inférence FP16 (demi-précision) ?#

Oui — à l'exécution. Un modèle LiteRT FP32 s'exécute automatiquement en FP16 lorsqu'il est exécuté sur un délégué GPU (WebGPU, OpenCL ou Metal), ce qui constitue l'approche officielle de LiteRT. Tu n'as donc pas besoin d'un export FP16 dédié ; pour une compression supplémentaire, utilise la quantification INT8 avec quantize=8.

Comment résoudre les problèmes courants lors de l'exportation LiteRT ?#

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

• Vérifier la plateforme : L'exportation LiteRT est supportée sur Linux x86_64 et macOS. Vérifie que ton environnement correspond.
• Vérifie la compatibilité des paquets : Assure-toi d'utiliser une version compatible d'Ultralytics. Consulte notre guide d'installation.
• Problèmes de quantification : Lors de l'utilisation de la quantification INT8, assure-toi que le chemin de ton dataset est correctement spécifié dans le paramètre data.

Pour des conseils de dépannage supplémentaires, visite notre guide des problèmes courants.