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

LiteRT (abréviation de Lite Runtime) est le runtime 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é peut être déployé sur mobile, embarqué, edge et navigateur, couvrant tout ce que les anciens formats d'exportation tflite et tfjs géraient séparément, désormais sous une seule bannière.

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 une large gamme d'appareils.

Link to this sectionPourquoi devrais-tu exporter vers LiteRT ?#

LiteRT est un framework open source conçu pour l'inférence sur appareil, également appelé edge computing. Il donne 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 — 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 accrue.
• Navigateur et Node.js : LiteRT.js exécute le même modèle .tflite sur le web avec l'accélération WebGPU/WASM — remplaçant ainsi le besoin d'une exportation TensorFlow.js séparée.

Link to this sectionFonctionnalité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 : Supporte FP32, INT8 statique (quantize=8, poids int8 + activations int8), activation INT16 statique (quantize="w8a16", poids int8 + activations int16 pour une meilleure précision) et INT8 dynamique (quantize="w8a32", poids int8 + activations FP32, aucune donnée de calibration nécessaire) 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.

Link to this sectionExporter 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.

Link to this sectionInstallation#

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.

Link to this sectionUtilisation#

Tous les modèles Ultralytics YOLO supportent l'exportation nativement. Le format LiteRT supporte les modes Export, Predict et Validate, tu peux donc exporter un modèle, puis le charger pour exécuter l'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")  # creates 'yolo26n.tflite'

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32")  # creates 'yolo26n_w8a32.tflite'

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8.tflite'

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml")  # creates 'yolo26n_w8a16.tflite'

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")

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 YOLO LiteRT exportés#

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

Link to this sectionMobile et embarqué#

• Android : Un guide de démarrage rapide pour intégrer LiteRT dans les applications Android.
• iOS : Un 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 monocarte, éventuellement accélérés avec un Coral Edge TPU.
• Microcontrôleurs : Déploie sur des MCU avec seulement quelques kilo-octets de mémoire — le runtime de base tient en environ 16 Ko sur un Arm Cortex-M3.

Link to this sectionNavigateur 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, éliminant le calcul côté serveur et gardant 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.

Link to this sectionRésumé#

Dans ce guide, nous avons couvert comment exporter des modèles Ultralytics YOLO vers le format LiteRT. En consolidant 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 légers et portables sur pratiquement toutes les cibles sur appareil.

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

Aussi, si tu es curieux à propos d'autres intégrations Ultralytics YOLO, consulte notre page de guide d'intégration pour de nombreuses ressources utiles.

Link to this sectionFAQ#

Link to this sectionComment exporter un modèle YOLO au format LiteRT ?#

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

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")  # creates 'yolo26n.tflite'

Pour les utilisateurs CLI :

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

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

Link to this sectionQuelle 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 de runtime, renommée par Google. Chez Ultralytics, le format d'exportation unique litert couvre désormais les deux cas d'utilisation qui nécessitaient auparavant deux formats séparés :

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

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

Link to this sectionPuis-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.

Link to this sectionPuis-je exécuter des modèles YOLO dans le navigateur avec LiteRT ?#

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

Link to this sectionLiteRT supporte-t-il l'inférence FP16 (demi-précision) ?#

Oui — au moment de 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 est 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.

Link to this sectionComment 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érifier la compatibilité du package : Assure-toi d'utiliser une version compatible d'Ultralytics. Réfère-toi à notre guide d'installation.
• 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.