Commencer

Exportation Google LiteRT

LiteRT est le runtime de Google pour l’IA embarquée et le nouveau nom de TensorFlow Lite (TFLite). L’exportation d’un modèle Ultralytics YOLO26 avec format="litert" crée un seul fichier .tflite pour les téléphones Android et iOS, les cartes Linux embarquées et les navigateurs Web, en FP32 ou selon l’un des trois schémas de quantification INT8.

En bref#

PropriétéDétails
Argument formatlitert. Les anciennes valeurs tflite et tfjs fonctionnent toujours : elles affichent un avertissement de dépréciation et exportent le même fichier LiteRT.
Sortieyolo26n.tflite, un fichier contenant les noms des classes, la tâche et la taille d’image sous forme de métadonnées ; les exportations quantifiées portent les noms yolo26n_w8a32.tflite, yolo26n_int8.tflite et yolo26n_w8a16.tflite
Fonctionne surAppareils Android et iOS, cartes Linux embarquées, processeurs de bureau, navigateurs Web via LiteRT.js et GPU et NPU Intel
Environnement d’exécutionLiteRT : le paquet Python ai-edge-litert (version 2.1.4 ou ultérieure), les bibliothèques LiteRT pour Android et iOS, ou LiteRT.js
PrécisionFP32, w8a32, INT8, w8a16. YOLO26n fait 10,0 Mo en FP32, 2,9 Mo avec w8a32, 3,1 Mo en INT8 et 3,0 Mo avec w8a16
Machine d’exportationLinux x86-64 ou macOS sur Apple silicon, avec Python 3.10 ou version ultérieure. L’exportation s’effectue sur le CPU et ne nécessite pas de GPU.
Exporter dans le cloud

Ultralytics Platform peut exporter pour toi un modèle entraîné au format LiteRT ; tu n’as donc pas besoin d’un environnement d’exportation local.

Démarrage rapide#

Installe le paquet Ultralytics avec les dépendances d’exportation LiteRT :

pip install "ultralytics[export-litert]"

Cela installe litert-torch, ai-edge-litert et ai-edge-quantizer. Avec une simple installation pip install ultralytics, la première exportation installe les paquets manquants et peut s’interrompre sur une erreur si cela remplace PyTorch. L’exportation requiert les versions suivantes :

PaquetVersion requise
Python3.10 ou version ultérieure
litert-torch0.10.0 ou version ultérieure
torchPlage acceptée par le paquet litert-torch installé : 2.4.0 ou version ultérieure et antérieure à 2.15.0 pour la version 0.10.0
ai-edge-litert2.3.0 ou version ultérieure pour l’exportation ; 2.1.4 ou version ultérieure, également avec Python 3.10 ou version ultérieure, pour exécuter un modèle exporté
ai-edge-quantizer0.10.0 ou version ultérieure, pour quantize="w8a32", quantize=8 et "w8a16"

Pour les autres méthodes d’installation, consulte le guide d’installation. Exporte ensuite ton modèle et charge le fichier exporté pour effectuer une inférence ou valider sa précision.

Export
from ultralytics import YOLO

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

# Exporter le modèle au format LiteRT
model.export(format="litert")  # crée 'yolo26n.tflite'

# Exporter avec des poids INT8 et des activations FP32, sans données d’étalonnage requises
model.export(format="litert", quantize="w8a32")  # crée 'yolo26n_w8a32.tflite'
Prédiction
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")
Valider
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")

Tâches prises en charge#

L’exportation LiteRT prend en charge les sept tâches Ultralytics avec les modèles YOLOv8, YOLO11 et YOLO26 : détection, segmentation, segmentation sémantique, estimation de profondeur, classification, estimation de pose et OBB. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui inclut ces têtes.

Arguments d’exportation#

ArgumentTypeValeur par défautDescription
formatstr'litert'Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement.
imgszint ou tuple640Taille d’image de l’entrée du modèle : un entier pour les images carrées ou un tuple (height, width). Si elle n’est pas précisée, l’exportation utilise la taille à laquelle le point de contrôle a été entraîné. Les points de contrôle YOLO26 officiels utilisent 640 pour les modèles de détection, de segmentation et de pose, ainsi que pour les modèles sémantiques préentraînés sur ADE20K ; 1024 pour les modèles OBB et les modèles sémantiques préentraînés sur Cityscapes ; 768 pour la profondeur ; et 224 pour la classification.
quantizeint ou strNoneSchéma de quantification : 'w8a32' (poids INT8, activations FP32, sans étalonnage), 8 (poids et activations INT8, étalonnés sur data) ou 'w8a16' (poids INT8, activations INT16, étalonnés sur data) ; 32/non défini correspond au FP32. 16 génère une erreur, et un checkpoint entraîné avec quantize=8 ne peut pas être exporté au format LiteRT ; consulte Limitations et dépannage. Remplace les indicateurs obsolètes half/int8.
datastrNoneFichier YAML du jeu de données utilisé pour l’étalonnage avec quantize=8 et 'w8a16' ; la classification utilise plutôt un répertoire de jeu de données ou le nom d’un jeu de données intégré. L’étalonnage utilise la partition val, sauf si split est défini. Si cette valeur est omise, Ultralytics utilise le petit jeu de données par défaut pour la tâche du modèle, par exemple coco8.yaml pour la détection.
fractionfloat, int ou list1.0Sous-ensemble d’étalonnage : un ratio, un nombre d’images (entiers supérieurs à 1) ou une liste [train, val, test], dont l’entrée correspondant à la partition d’étalonnage est utilisée.
nmsbool, facultatifNoneSélectionne la sortie brute (None, valeur par défaut) ou la tête sans NMS (False, uniquement pour les exportations FP32 et 'w8a32'). Le NMS intégré (True) n’est pas disponible pour LiteRT. Consulte le format de sortie.
batchint1Taille du lot du modèle exporté, fixe dans la forme d’entrée. C’est aussi la taille de lot utilisée pour l’étalonnage.
devicestrNoneL’exportation s’effectue toujours sur le CPU, quelle que soit la valeur transmise.

Pour les arguments communs à tous les formats, consulte la documentation du mode Export.

Taille d’image des modèles mobiles et Web officiels

Les modèles mobiles officiels LiteRT, Core ML et QNN sont exportés avec imgsz=640, et avec imgsz=224 pour la classification. Les checkpoints Cityscapes de segmentation sémantique, de profondeur et OBB sont exportés avec une taille par défaut supérieure ; transmets donc imgsz=640 pour les faire correspondre.

Quantification#

quantize sélectionne l’un des trois schémas INT8. Tous stockent les poids sous forme d’entiers sur 8 bits et diffèrent par la manière dont sont stockées les activations, c’est-à-dire les valeurs qui circulent entre les couches :

quantizePoidsActivationsDonnées d’étalonnageFichier YOLO26nTaille
non défini ou 32FP32FP32Nonyolo26n.tflite10.0 MB
'w8a32'INT8FP32Nonyolo26n_w8a32.tflite2.9 MB
8INT8INT8Ouiyolo26n_int8.tflite3.1 MB
'w8a16'INT8INT16Ouiyolo26n_w8a16.tflite3.0 MB
  • Entrées et sorties : l’entrée et les sorties restent en float32 pour les quatre précisions ; le code d’inférence écrit pour le modèle FP32 s’exécute donc sans modification sur un modèle quantifié exporté avec la même structure nms.
  • 'w8a32' : quantification de la plage dynamique. Aucune donnée d’étalonnage n’est requise ; cette option prend en charge la tête sans NMS avec nms=False et correspond à la précision des modèles mobiles officiels figurant dans les colonnes CPU et GPU des performances mesurées.
  • 8 et 'w8a16' : quantification statique. L’exportation effectue l’étalonnage sur chaque lot complet de la partition val de data, ou de la partition définie par split, et émet un avertissement si elle contient moins de 300 images. Utilise fraction pour limiter le nombre d’images.
  • Sorties de tête avec quantize=8 : pour les modèles de détection, de segmentation, de classification, de pose et OBB, les couches de sortie de la tête et les opérations qui les décodent restent en virgule flottante, car INT8 écrête les scores de classe et réduit la précision des coordonnées des boîtes. 'w8a16' quantifie également ces couches, avec des activations sur 16 bits.
  • Tête sans NMS : les exportations quantize=8 et 'w8a16' d’un modèle YOLO26 ou YOLOv10 utilisent la tête un-vers-plusieurs et renvoient des prédictions brutes qui nécessitent NMS, également avec nms=False.
  • FP16 : aucune exportation FP16 n’est disponible. Par défaut, les délégués GPU LiteRT exécutent un modèle FP32 en demi-précision ; quantize=16 est donc inutile et génère une erreur.
Exemple
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Étalonne sur 10 % des images de validation COCO (500 images) ; remplace coco.yaml par ton propre jeu de données
model.export(format="litert", quantize=8, data="coco.yaml", fraction=0.1)  # crée 'yolo26n_int8.tflite'

# Charger le modèle INT8 exporté et exécuter l’inférence
model = YOLO("yolo26n_int8.tflite")
results = model("https://ultralytics.com/images/bus.jpg")

La quantification modifie la précision, et son effet dépend du modèle, de la tâche et des images d’étalonnage. Valide un modèle quantifié sur tes propres données avant de le déployer.

Format de sortie#

L’exportation écrit un seul fichier .tflite. Le modèle reçoit une entrée de forme (batch, 3, height, width) : RGB, canaux en premier (NCHW), float32, normalisée entre 0 et 1. Cela diffère des fichiers TFLite de l’ancienne exportation format="tflite", qui recevaient des images avec les canaux en dernier (NHWC). L’argument nms et la tâche déterminent les sorties. Les formes ci-dessous correspondent aux checkpoints YOLO26n officiels avec leur taille d’exportation par défaut, et au checkpoint Cityscapes yolo26n-sem.pt pour la segmentation sémantique :

Tâcheimgsz par défautSortie avec nms=NoneSortie avec nms=False
Détection640(1, 84, 8400)(1, 300, 6)
Segmentation640(1, 116, 8400) et (1, 32, 160, 160)(1, 300, 38) et (1, 32, 160, 160)
Sémantique1024(1, 19, 1024, 1024), un score pour chaque classe et chaque pixelIdentique à nms=None
Profondeur768(1, 1, 768, 768), carte de profondeurIdentique à nms=None
Classification224(1, 1000), probabilités des classesIdentique à nms=None
Pose640(1, 56, 8400)(1, 300, 57) : 6 valeurs de boîte, puis 17 points clés × 3
OBB1024(1, 20, 21504)(1, 300, 7) : 4 valeurs de boîte, score, classe, angle
  • Sortie brute (nms=None) : forme (batch, values, anchors). Pour chaque ancre : le centre x et le centre y de la boîte, sa largeur et sa hauteur, puis les scores de classe, puis les valeurs de la tâche (32 coefficients de masque, 17 × 3 valeurs de points clés ou l’angle OBB en radians). Les valeurs de boîte ainsi que les coordonnées x et y des points clés sont normalisées entre 0 et 1 ; multiplie-les par la largeur et la hauteur de l’entrée. Applique toi-même NMS.
  • Sortie sans NMS (nms=False) : max_det (300 par défaut) lignes de x1, y1, x2, y2, score, class en pixels d’entrée, sans étape NMS. Les lignes OBB sont au format center x, center y, width, height, score, class, angle, avec l’angle en radians. Filtre les lignes selon leur score. Disponible pour les exportations FP32 et 'w8a32' de modèles dotés d’une tête sans NMS.
  • Segmentation : les 32 coefficients de masque sont les 32 dernières valeurs de chaque ancre ou ligne, et la deuxième sortie contient les prototypes de masque.
  • Segmentation sémantique : la sortie contient les scores de classe, et non la carte de classes de l’exportation ONNX ; calcule donc l’argmax sur l’axe des classes dans ton propre code.

YOLO("yolo26n.tflite") lit la structure à partir des métadonnées du fichier et met les coordonnées à l’échelle ; tu n’as donc besoin de ces détails que si tu exécutes le modèle dans ton propre code. Les métadonnées sont une entrée metadata.json que l’exportation ajoute au fichier sous forme d’archive ZIP, lisible avec n’importe quelle bibliothèque ZIP. Elles comprennent notamment les clés names, task, imgsz, stride, batch, end2end, args et, pour les modèles de pose, kpt_shape.

Exécuter avec l’interpréteur LiteRT#

Pour exécuter le modèle en dehors du paquet Ultralytics, charge-le avec l’interpréteur du paquet ai-edge-litert. Lis les formes d’entrée et de sortie à partir du modèle au lieu de te fier aux noms des tenseurs. Un modèle de segmentation a deux sorties : celle en 3D contient les détections et celle en 4D les prototypes de masque.

# Exporter d’abord : yolo export model=yolo26n.pt format=litert nms=False
import json
import zipfile

import numpy as np
from ai_edge_litert.interpreter import Interpreter

interpreter = Interpreter(model_path="yolo26n.tflite")
interpreter.allocate_tensors()

image = np.zeros((1, 3, 640, 640), dtype=np.float32)  # ton image prétraitée : RGB, NCHW, 0-1
interpreter.set_tensor(interpreter.get_input_details()[0]["index"], image)
interpreter.invoke()
detections = interpreter.get_tensor(interpreter.get_output_details()[0]["index"])[0]  # shape (300, 6)
assert detections.shape == (300, 6), "export the model with nms=False"
detections = detections[detections[:, 4] > 0.25]  # conserver les lignes au-dessus du seuil de confiance

with zipfile.ZipFile("yolo26n.tflite") as z:
    names = json.loads(z.read("metadata.json"))["names"]  # {'0': 'person', '1': 'bicycle', ...}

Déployer#

YOLO("yolo26n.tflite") exécute le modèle sur le CPU avec l’interpréteur ai-edge-litert, en utilisant jusqu’à 8 threads. Les autres valeurs device, comme 0 ou mps, s’exécutent également sur le CPU ; xpu et npu sélectionnent le matériel Intel. Le tableau des appareils d’inférence compare ces noms selon les formats.

Le modèle s’exécute toujours avec les valeurs d’exportation imgsz et batch, qu’Ultralytics lit dans les métadonnées du fichier. Une valeur imgsz transmise à predict ou val est ignorée. Les lots plus grands sont divisés en blocs correspondant à la taille du lot d’exportation et les lots plus petits sont complétés ; tu peux donc traiter n’importe quel nombre d’images.

Inférence sur GPU et NPU Intel#

Les modèles .tflite exportés s’exécutent sur du matériel Intel via le plug-in LiteRT Intel OpenVINO. Transmets device=xpu pour le GPU ou device=npu pour le NPU ; Ultralytics installe ai-edge-litert>=2.3.0 et ai-edge-litert-sdk-intel lors de la première utilisation. Le plug-in impose sa propre version de openvino ; garde-le donc dans un environnement distinct si tu exécutes aussi des modèles OpenVINO avec une autre version. Le NPU nécessite un processeur Intel Core Ultra sur lequel le pilote Intel NPU est installé ; consulte la latence mesurée sur un Core Ultra X7 358H. Sur une machine dépourvue de l’appareil Intel demandé, le plug-in OpenVINO ne parvient pas à compiler le modèle et LiteRT l’exécute sur son propre moteur CPU (XNNPACK), et non via OpenVINO : sur un processeur serveur AMD, YOLO26n a pris de 29 à 30 ms par image avec device=xpu et device=npu, contre 18 ms avec device=cpu. Ultralytics n’émet aucun avertissement dans ce cas ; compare donc la latence avec device=cpu pour confirmer que l’appareil est utilisé.

Prédiction
from ultralytics import YOLO

model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="npu")  # ou « xpu »

Guides de déploiement#

  • Plug-in Ultralytics YOLO Flutter : exécute les exportations LiteRT .tflite sur Android avec l’inférence en temps réel à partir de la caméra, la prédiction sur une image unique et l’accélération GPU.
  • Paquet npm @ultralytics/yolo : exécute dans le navigateur les exportations LiteRT .tflite via LiteRT.js, avec l’accélération WebGPU et un repli sur le CPU (WASM). Installe-le avec npm i @ultralytics/yolo @litertjs/core.
  • MediaTek Dimensity : déploiement Android sur les téléphones MediaTek, y compris le NPU.
  • Qualcomm QNN et Core ML : les formats destinés aux NPU Snapdragon et aux appareils Apple.
  • NXP i.MX95 et Coral Edge TPU : les formats destinés à ces accélérateurs.
  • Raspberry Pi : configure Ultralytics sur les cartes Raspberry Pi.
  • Documentation LiteRT : intègre le runtime dans des applications Android et iOS, ou dans le navigateur.

Limites et dépannage#

  • Machine hôte pour l’exportation : sous Windows et Linux ARM64, par exemple sur un Raspberry Pi, l’exportation échoue avec LiteRT export only supported on Linux x86 and macOS. Effectue l’exportation sur une machine hôte compatible et copie le fichier .tflite sur l’appareil.
  • Première exportation après une installation simple : si la première exportation installe un litert-torch incompatible avec la version de PyTorch installée (la version 0.10.0 accepte les versions 2.4.0 à 2.15.0 exclue), pip remplace PyTorch, Ultralytics affiche Restart runtime or rerun command for updates to take effect et l’exportation peut échouer, avec RuntimeError: duplicate registrations for aten.miopen_batch_norm.default sous PyTorch 2.15.0. Relance l’exportation.
  • FP16 : quantize=16 échoue avec quantize=16 (FP16) is not supported; format='litert' supports quantize=8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 'w8a32' (dynamic INT8), 32 or None (FP32).. Exporte en FP32 et laisse le délégué GPU l’exécuter en demi-précision.
  • Checkpoints entraînés avec quantize=8 : un checkpoint affiné par apprentissage conscient de la quantification échoue avec format='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Exporte plutôt le checkpoint utilisé au début de l’affinage avec quantize=8, ou exporte le checkpoint affiné vers ONNX ou TensorRT.
  • Tête sans NMS avec quantize=8 ou 'w8a16' : avec nms=False, l’exportation affiche LiteRT INT8 export does not support end2end models, disabling end2end branch. et écrit des prédictions brutes qui nécessitent NMS. Utilise FP32 ou 'w8a32' pour conserver la tête sans NMS.
  • NMS intégrée : nms=True affiche format=litert does not support embedded NMS; exporting native outputs for external NMS. et écrit la sortie brute.
  • Tête sans NMS sur d’autres modèles : nms=False nécessite un modèle doté d’une tête sans NMS, comme YOLO26 ou YOLOv10. Pour les autres modèles, par exemple YOLO11, l’exportation affiche l’avertissement This model has no one-to-one head; using one-to-many outputs. et écrit la sortie brute (1, 84, 8400).
  • Forme d’entrée fixe : dynamic=True échoue avec argument 'dynamic' is not supported for format='litert'. Effectue une nouvelle exportation pour modifier la taille de l’image ou la taille du lot.
  • Étalonnage sans data : une exportation quantize=8 ou 'w8a16' affiche INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. et effectue l’étalonnage sur le petit jeu de données par défaut de la tâche. Transmets data avec des images représentatives des données de déploiement.
  • Taille de l’étalonnage : l’exportation affiche >300 images recommended for INT8 calibration, found 4 images. si la partition d’étalonnage contient moins de 300 images. coco8.yaml ne contient que 4 images de validation, ce qui suffit pour tester l’exportation, mais pas pour étalonner un modèle destiné au déploiement.
  • 'w8a16' sur les processeurs x86 : l’interpréteur CPU LiteRT a exécuté un modèle YOLO26n 'w8a16' en environ 1 s par image sur un processeur serveur AMD EPYC 9655 avec 8 threads, contre environ 17 ms pour le modèle FP32. Mesure 'w8a16' sur l’appareil et avec le délégué que tu comptes déployer.
  • Nom du fichier : chaque exportation d’un checkpoint avec la même valeur quantize écrit le même fichier, par exemple yolo26n.tflite pour le FP32, quelle que soit sa valeur imgsz, batch ou nms ; l’exportation la plus récente remplace donc la précédente.

Pour les autres erreurs, consulte le guide des problèmes courants.

Performances mesurées#

Les tableaux ci-dessous indiquent la latence pour une image du modèle YOLO26n de chaque tâche, sur quatre téléphones Android et un processeur Intel Core Ultra. Chaque cellule affiche le temps total en millisecondes, avec le détail du prétraitement, de l’inférence et du post-traitement en dessous ; la colonne la plus rapide pour chaque modèle est en gras. La page du modèle YOLO26 indique la précision des checkpoints PyTorch.

Xiaomi 17#

Matériel : Xiaomi 17 avec 12 Go de mémoire LPDDR5X et Android 17 / API 37. Son Snapdragon 8 Elite Gen 5 gravé en 3 nm (SM8850) comprend 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.

ModèleTâchetaille
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDétection64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-segSegmentation64050.5
1.9 / 42.9 / 5.8
18.0
1.9 / 9.5 / 6.6
19.2
3.6 / 5.9 / 9.7
YOLO26n-semSémantique64045.7
1.9 / 35.7 / 8.2
30.6
1.9 / 20.5 / 8.3
25.8
3.6 / 11.0 / 11.3
YOLO26n-depthProfondeur64066.8
2.2 / 55.0 / 9.7
21.9
2.1 / 10.1 / 9.8
24.8
4.3 / 6.0 / 14.5
YOLO26n-clsClassification2243.6
0.3 / 3.3 / 0.0
2.0
0.4 / 1.4 / 0.2
1.5
0.6 / 0.7 / 0.3
YOLO26n-posePose64039.9
2.0 / 36.5 / 1.4
10.0
1.8 / 6.7 / 1.4
11.5
3.5 / 4.2 / 3.8
YOLO26n-obbOBB64036.3
2.0 / 33.2 / 1.2
10.1
2.6 / 5.9 / 1.6
8.2
3.5 / 3.7 / 0.9
  • Les valeurs de vitesse correspondent aux latences en rafale sur 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 Ultralytics 0.7.1 et les artefacts officiels v0.7.0 (exports Ultralytics 8.4.188). 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 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.7.0 de yolo-flutter-app, et le document sur les performances Flutter contient le rapport détaillé du benchmark.
  • La colonne NPU correspond au chemin NPU propre à LiteRT : un export FP32 (yolo export format=litert, sans quantize) compilé sur l’appareil par les environnements d’exécution litert-npu-runtime-qualcomm et -mediatek version 2.3.0, mesuré avec une version prototype du plugin Flutter pour NPU (pas encore publiée). Le premier chargement comprend cette compilation (environ 0,3 s pour n, jusqu’à 6 s pour x). Les artefacts w8a32 ne se compilent pas entièrement sur ces NPU. LiteRT signale une compilation NPU même lorsqu’il exécute silencieusement le graphe sur le GPU ; chaque ligne NPU a donc été comparée au temps GPU et les lignes ayant basculé vers le GPU sont indiquées par —.
  • Les chiffres correspondants du NPU Hexagon Snapdragon pour les artefacts QNN officiels 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 balayages des appareils suivants utilisent les mêmes artefacts officiels v0.7.0.

Google Pixel 10#

Matériel : Google Pixel 10 avec 12 Go de mémoire et Android 17 / API 37. Son Google Tensor G5, gravé en 3 nm, comprend 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 série D et un TPU Google. Les fréquences des cœurs et le nom du pilote GPU ont été relevés sur l’appareil de test, car Google ne les publie pas dans les spécifications liées.

ModèleTâchetaille
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
YOLO26nDétection64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-segSegmentation64053.1
1.5 / 45.8 / 5.7
51.5
1.6 / 40.1 / 9.9
YOLO26n-semSémantique64057.2
1.5 / 47.7 / 8.0
75.9
1.8 / 63.4 / 10.8
YOLO26n-depthProfondeur64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-clsClassification2246.1
0.3 / 5.5 / 0.3
12.1
0.9 / 11.0 / 0.1
YOLO26n-posePose64035.2
1.5 / 31.9 / 1.8
38.2
3.5 / 29.3 / 5.4
YOLO26n-obbOBB64032.7
1.5 / 29.3 / 1.9
38.8
3.8 / 29.6 / 5.4

Benchmark : moyenne de 15 appels predict() après 3 préchauffages sur bus.jpg, avec ultralytics_yolo 0.7.1 et les artefacts officiels v0.7.0. 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 l’intégralité du graphe à LiteRT OpenCL (LITERT_CL). Le TPU Tensor n’a pas de ligne LiteRT : le service EdgeTPU de Google rejette les applications qui ne figurent pas sur sa liste d’autorisation, et LiteRT exécute alors le modèle sur le GPU.

Samsung Galaxy S26#

Matériel : Samsung Galaxy S26 (SM-S942B) avec 12 Go de mémoire et Android 17 / API 37. Son Exynos 2600, gravé en 2 nm, comprend 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.

ModèleTâchetaille
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT w8a32 AOT
(ms)
YOLO26nDétection64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-segSegmentation64045.6
1.3 / 39.1 / 5.2
30.5
1.3 / 23.6 / 5.6
17.0
1.4 / 9.7 / 5.8
YOLO26n-semSémantique64038.1
1.3 / 28.6 / 8.2
26.1
1.3 / 16.8 / 7.9
28.3
1.7 / 15.1 / 11.5
YOLO26n-depthProfondeur64063.5
1.4 / 53.6 / 8.4
37.3
1.4 / 24.6 / 11.3
28.4
2.1 / 12.9 / 13.4
YOLO26n-clsClassification2243.8
0.2 / 3.4 / 0.2
2.8
0.2 / 2.6 / 0.0
6.1
0.5 / 5.2 / 0.4
YOLO26n-posePose64031.1
1.3 / 28.4 / 1.4
18.4
1.6 / 13.0 / 3.8
13.5
1.8 / 9.5 / 2.2
YOLO26n-obbOBB64027.9
1.3 / 25.7 / 0.9
15.3
1.9 / 11.4 / 2.1
11.4
1.7 / 8.3 / 1.4

Benchmark : moyenne de 15 appels predict() après 3 préchauffages sur bus.jpg, avec ultralytics_yolo 0.7.1 et les artefacts officiels v0.7.0. 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 l’intégralité du graphe à LiteRT OpenCL (LITERT_CL). La colonne NPU utilise les artefacts w8a32 compilés à l’avance pour l’Exynos 2600 (E9965) avec le plugin compilateur Samsung de LiteRT. Samsung ne propose pas de compilateur sur l’appareil dans LiteRT 2.3 et Google ne publie pas encore d’environnement d’exécution NPU Samsung ; ces lignes utilisent donc une bibliothèque de dispatch compilée à partir des sources de LiteRT 2.3.

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.

ModèleTâchetaille
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDétection64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-segSegmentation64077.8
2.6 / 65.3 / 9.9
47.4
2.6 / 33.6 / 11.3
36.5
2.6 / 23.4 / 10.4
YOLO26n-semSémantique64081.3
2.6 / 62.2 / 16.5
79.3
2.6 / 59.5 / 17.1
87.6
2.6 / 68.3 / 16.7
YOLO26n-depthProfondeur640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-clsClassification2246.3
0.5 / 5.4 / 0.4
8.1
0.5 / 7.5 / 0.1
3.2
0.5 / 2.2 / 0.5
YOLO26n-posePose64053.9
2.6 / 49.5 / 1.8
32.8
2.7 / 26.7 / 3.4
16.2
2.9 / 11.1 / 2.3
YOLO26n-obbOBB64049.5
2.7 / 44.4 / 2.4
29.4
2.8 / 22.7 / 3.9
—

Benchmark : moyenne de 15 appels predict() après 3 phases de préchauffage sur bus.jpg, avec ultralytics_yolo 0.7.1 et les ressources officielles v0.7.0. 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 que chaque ligne GPU déléguait l’intégralité du graphe à LiteRT OpenCL (LITERT_CL). Depth et OBB n’ont aucun résultat NPU : le compilateur NPU MediaTek rejette leurs opérations exponentielles et trigonométriques, et LiteRT exécute ces graphes sur le GPU.

Pour le workflow de déploiement Android et les limites des NPU, consulte le guide MediaTek Dimensity.

Intel Core Ultra X7 358H#

Matériel : Intel Core Ultra X7 358H (Panther Lake) et NPU Intel AI Boost 5010, Fedora Linux, pilote NPU 1.38.0, ai-edge-litert 2.3.0.

ModèleTâchetaille
(pixels)
CPU
w8a32 LiteRT
(ms)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26nDétection64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-segSegmentation64024.2
0.9 / 22.1 / 1.3
32.6
1.0 / 30.1 / 1.5
6.2
0.8 / 4.2 / 1.2
YOLO26n-semSémantique64025.2
1.0 / 14.2 / 10.0
33.1
1.1 / 21.9 / 10.2
16.5
1.0 / 5.5 / 10.0
YOLO26n-depthProfondeur64031.7
0.9 / 30.2 / 0.5
76.6
0.9 / 75.2 / 0.5
9.1
1.0 / 7.5 / 0.5
YOLO26n-clsClassification2244.6
2.8 / 1.7 / 0.0
7.3
3.3 / 3.9 / 0.0
4.1
3.2 / 0.9 / 0.0
YOLO26n-posePose64020.3
0.8 / 19.0 / 0.5
28.6
1.1 / 26.8 / 0.8
6.3
0.8 / 4.9 / 0.5
YOLO26n-obbOBB64017.2
0.8 / 16.1 / 0.3
22.1
1.2 / 20.5 / 0.4
4.6
0.9 / 3.4 / 0.3

Benchmark : moyenne de 15 appels à predict() après 3 phases de préchauffage sur bus.jpg, avec ultralytics 8.4.174 et ai-edge-litert 2.3.0, à partir d’exports w8a32. Chaque cellule indique le temps total, avec le détail du prétraitement / de l’inférence / du post-traitement en dessous.

À propos de LiteRT#

LiteRT, abréviation de Lite Runtime, poursuit TensorFlow Lite sous un nouveau nom et exécute le même format de modèle .tflite. Il exécute les modèles sur le CPU avec XNNPACK et sur les GPU et NPU via des délégués matériels ; LiteRT.js permet également d’utiliser le même fichier dans les navigateurs et Node.js. Pour consulter la documentation de référence complète, voir la documentation LiteRT.

LiteRT edge deployment framework



À regarder : Comment exporter Ultralytics YOLO26 vers Google LiteRT | Déployer l’IA de vision sur Android et iOS | IA mobile 📱🚀

FAQ#

  • LiteRT est le nouveau nom de TensorFlow Lite et conserve le même format de modèle .tflite. Dans Ultralytics, format="litert" remplace deux anciens formats d’exportation : tflite pour les appareils mobiles, embarqués et périphériques, et tfjs pour les navigateurs et Node.js, où LiteRT.js exécute désormais le même fichier .tflite. Les deux anciennes valeurs exportent toujours un fichier LiteRT avec un avertissement de dépréciation. Les pages TFLite et TF.js décrivent les anciens formats.

  • Commence avec quantize="w8a32". Aucune donnée d’étalonnage n’est requise, le fichier fait moins d’un tiers de la taille du fichier FP32, cette option prend en charge la tête sans NMS de YOLO26 avec nms=False et correspond à la précision des modèles mobiles Ultralytics officiels pour CPU et GPU. Utilise quantize=8 si la cible nécessite des activations entières : par exemple, l’exportation NXP i.MX95 compile un modèle LiteRT INT8 étalonné. 'w8a16' conserve une plus grande précision des activations que 8. Ces deux options nécessitent des données d’étalonnage représentatives et renvoient des prédictions brutes qui nécessitent NMS. Mesure la latence et la précision sur ton appareil cible avant de faire ton choix, car la prise en charge de chaque schéma varie selon les délégués CPU, GPU et NPU.

  • Non. L’exportation s’effectue uniquement sous Linux x86-64 et sous macOS sur Apple silicon. Exporte le modèle sur l’une de ces machines hôtes ou avec Ultralytics Platform, puis copie le fichier .tflite sur l’appareil. Consulte le guide Raspberry Pi pour exécuter des modèles sur la carte ; un Coral Edge TPU peut accélérer l’inférence.

  • Oui. LiteRT.js exécute le fichier .tflite exporté dans un navigateur ou dans Node.js avec WebGPU ou WASM ; aucune exportation distincte pour le navigateur n’est donc nécessaire. Le paquet npm @ultralytics/yolo l’enveloppe et fournit l’inférence par webcam ou sur une image unique pour les tâches de détection, de segmentation, de segmentation sémantique, de classification, de pose et OBB.

  • Utilise le plug-in Ultralytics YOLO Flutter, qui charge sur Android les exportations LiteRT .tflite et prend en charge les sept tâches YOLO26. Exporte avec imgsz=640, ou avec imgsz=224 pour la classification, afin de correspondre aux modèles officiels. Pour une application native, suis le guide LiteRT pour Android et transmets le modèle comme indiqué dans le format de sortie. Sur iPhone, Core ML est le format natif.

Commentaires

Pose une question, partage tes résultats ou aide quelqu’un d’autre.