Google LiteRT-Export
LiteRT ist die Laufzeitumgebung von Google für KI auf dem Gerät und der neue Name von TensorFlow Lite (TFLite). Beim Export eines Ultralytics YOLO26-Modells mit format="litert" wird eine einzelne .tflite-Datei für Android- und iOS-Smartphones, eingebettete Linux-Boards und Webbrowser erstellt, in FP32 oder mit einem von drei INT8-Quantisierung-Verfahren.
Auf einen Blick#
| Eigenschaft | Details |
|---|---|
Argument format | litert. Die älteren Werte tflite und tfjs funktionieren weiterhin: Sie protokollieren eine Deprecation-Warnung und exportieren dieselbe LiteRT-Datei. |
| Ausgabe | yolo26n.tflite, eine Datei, in der die Klassennamen, die Aufgabe und die Bildgröße als Metadaten gespeichert sind; quantisierte Exporte heißen yolo26n_w8a32.tflite, yolo26n_int8.tflite und yolo26n_w8a16.tflite. |
| Ausführbar auf | Android- und iOS-Geräte, eingebettete Linux-Boards, Desktop-CPUs, Webbrowser über LiteRT.js sowie Intel-GPUs und NPUs. |
| Laufzeitumgebung | LiteRT: das Python-Paket ai-edge-litert (Version 2.1.4 oder neuer), die LiteRT-Bibliotheken für Android und iOS oder LiteRT.js. |
| Precision | FP32, w8a32, INT8, w8a16. YOLO26n ist in FP32 10,0 MB groß, mit w8a32 2,9 MB, in INT8 3,1 MB und mit w8a16 3,0 MB. |
| Exportrechner | Linux x86-64 oder macOS auf Apple-Chips der M-Serie, mit Python 3.10 oder neuer. Der Export läuft auf der CPU und benötigt keine GPU. |
Die Ultralytics Platform kann ein trainiertes Modell für dich nach LiteRT exportieren, sodass du keine lokale Exportumgebung benötigst.
Schnellstart#
Installiere das Ultralytics-Paket mit den Abhängigkeiten für den LiteRT-Export:
pip install "ultralytics[export-litert]"Damit werden litert-torch, ai-edge-litert und ai-edge-quantizer installiert. Bei einer einfachen Installation mit pip install ultralytics werden die fehlenden Pakete beim ersten Export installiert, der mit einem Fehler abbrechen kann, wenn dadurch PyTorch ersetzt wird. Für den Export gelten folgende Versionsanforderungen:
| Paket | Erforderliche Version |
|---|---|
| Python | 3.10 oder neuer |
litert-torch | 0.10.0 oder neuer |
torch | Der Bereich, den das installierte litert-torch akzeptiert: 2.4.0 oder neuer und für 0.10.0 niedriger als 2.15.0. |
ai-edge-litert | 2.3.0 oder neuer für den Export; 2.1.4 oder neuer, ebenfalls mit Python 3.10 oder neuer, um ein exportiertes Modell auszuführen. |
ai-edge-quantizer | 0.10.0 oder neuer für quantize="w8a32", quantize=8 und "w8a16". |
Weitere Installationsmethoden findest du in der Installationsanleitung. Exportiere anschließend dein Modell und lade die exportierte Datei, um Inferenz auszuführen oder die Genauigkeit zu überprüfen.
from ultralytics import YOLO
# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")
# Modell ins LiteRT-Format exportieren
model.export(format="litert") # erstellt „yolo26n.tflite“
# Mit INT8-Gewichten und FP32-Aktivierungen exportieren; dafür sind keine Kalibrierungsdaten erforderlich.
model.export(format="litert", quantize="w8a32") # Erstellt „yolo26n_w8a32.tflite“from ultralytics import YOLO
# Exportiertes LiteRT-Modell laden
model = YOLO("yolo26n.tflite")
# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# Exportiertes LiteRT-Modell laden
model = YOLO("yolo26n.tflite")
# Die Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")Unterstützte Aufgaben#
Der LiteRT-Export unterstützt alle sieben Ultralytics-Aufgaben mit YOLOv8-, YOLO11- und YOLO26-Modellen: Objekterkennung, Instanzsegmentierung, semantische Segmentierung, Tiefenschätzung, Klassifizierung, Posenschätzung und OBB. Semantische Segmentierung und Tiefenschätzung gibt es nur mit YOLO26, der einzigen Modellfamilie mit diesen Köpfen.
Exportargumente#
| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
format | str | 'litert' | Zielformat des exportierten Modells, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt. |
imgsz | int oder tuple | 640 | Bildgröße der Modelleingabe: eine Ganzzahl für quadratische Bilder oder ein Tupel (height, width). Wenn dieser Wert nicht angegeben ist, verwendet der Export die Größe, mit der der Checkpoint trainiert wurde. Für die offiziellen YOLO26-Checkpoints gilt 640 für Erkennungs-, Segmentierungs- und Posemodelle sowie für semantische Modelle, die auf ADE20K vortrainiert wurden, 1024 für OBB-Modelle und semantische Modelle, die auf Cityscapes vortrainiert wurden, 768 für Tiefenmodelle und 224 für Klassifizierungsmodelle. |
quantize | int oder str | None | Quantisierungsschema: 'w8a32' (INT8-Gewichte, FP32-Aktivierungen, keine Kalibrierung), 8 (INT8-Gewichte und -Aktivierungen, kalibriert mit data) oder 'w8a16' (INT8-Gewichte, INT16-Aktivierungen, kalibriert mit data); 32/nicht gesetzt bedeutet FP32. 16 führt zu einem Fehler. Ein mit quantize=8 trainierter Checkpoint lässt sich nicht nach LiteRT exportieren. Weitere Informationen findest du unter Einschränkungen und Fehlerbehebung. Ersetzt die veralteten Flags half/int8. |
data | str | None | Datensatz-YAML-Datei für die Kalibrierung mit quantize=8 und 'w8a16'; bei der Klassifizierung wird stattdessen ein Datensatzverzeichnis oder der Name eines integrierten Datensatzes verwendet. Für die Kalibrierung wird die Aufteilung val genutzt, sofern split nicht gesetzt ist. Wenn du keinen Wert angibst, verwendet Ultralytics den kleinen Standarddatensatz für die jeweilige Modellaufgabe, etwa coco8.yaml für die Objekterkennung. |
fraction | float, int oder list | 1.0 | Kalibrierungs-Teilmenge: ein Verhältnis, eine Bildanzahl (Ganzzahlen über 1) oder eine [train, val, test]-Liste, aus der der Eintrag für die Kalibrierungsaufteilung verwendet wird. |
nms | bool, optional | None | Wähle die Rohausgabe (None, Standard) oder den NMS-freien Kopf (False, nur bei FP32- und 'w8a32'-Exporten). Eingebettetes NMS (True) ist für LiteRT nicht verfügbar. Siehe Ausgabeformat. |
batch | int | 1 | Batchgröße des exportierten Modells, die in der Eingabeform festgelegt ist. Dies ist auch die für die Kalibrierung verwendete Batchgröße. |
device | str | None | Der Export läuft unabhängig vom übergebenen Wert immer auf der CPU. |
Die für alle Formate geltenden Argumente findest du in der Dokumentation zum Exportmodus.
Die offiziellen Mobilmodelle für LiteRT, Core ML und QNN werden mit imgsz=640 exportiert, bei der Klassifizierung mit imgsz=224. Die Cityscapes-Checkpoints für semantische Segmentierung, Tiefenschätzung und OBB werden standardmäßig mit einer größeren Bildgröße exportiert. Übergib daher imgsz=640, um dieselbe Größe zu verwenden.
Quantisierung#
quantize wählt eines von drei INT8-Schemata aus. Bei allen werden die Gewichte als 8-Bit-Ganzzahlen gespeichert; sie unterscheiden sich darin, wie die Aktivierungen – die Werte, die zwischen den Schichten weitergegeben werden – gespeichert werden:
quantize | Gewichte | Aktivierungen | Kalibrierungsdaten | YOLO26n-Datei | Größe |
|---|---|---|---|---|---|
nicht angegeben oder 32 | FP32 | FP32 | Nein | yolo26n.tflite | 10.0 MB |
'w8a32' | INT8 | FP32 | Nein | yolo26n_w8a32.tflite | 2.9 MB |
8 | INT8 | INT8 | Ja | yolo26n_int8.tflite | 3.1 MB |
'w8a16' | INT8 | INT16 | Ja | yolo26n_w8a16.tflite | 3.0 MB |
- Eingaben und Ausgaben: Eingabe und Ausgaben bleiben bei allen vier Genauigkeitsstufen
float32. Inferenzcode für das FP32-Modell läuft daher unverändert mit einem quantisierten Modell, das mit demselben Layoutnmsexportiert wurde. 'w8a32': Quantisierung des dynamischen Wertebereichs. Sie benötigt keine Kalibrierungsdaten, unterstützt den NMS-freien Kopf mitnms=Falseund entspricht der Genauigkeit der offiziellen Mobilmodelle, die in der Tabelle Gemessene Leistung in den CPU- und GPU-Spalten aufgeführt sind.8und'w8a16': statische Quantisierung. Beim Export wird mit jedem vollständigen Batch der Aufteilungvalvondataoder der mitsplitfestgelegten Aufteilung kalibriert. Bei weniger als 300 Bildern wird eine Warnung ausgegeben. Mitfractionkannst du die Anzahl der Bilder begrenzen.- Kopfausgaben mit
quantize=8: Bei Erkennungs-, Segmentierungs-, Klassifizierungs-, Posenschätzungs- und OBB-Modellen bleiben die Ausgabeschichten des Modellkopfs und die Operationen, die sie dekodieren, im Gleitkommaformat, da INT8 Klassenbewertungen abschneidet und Boxkoordinaten gröber auflöst.'w8a16'quantisiert auch diese Schichten und verwendet dabei 16-Bit-Aktivierungen. - NMS-freier Kopf: Exporte
quantize=8und'w8a16'eines YOLO26- oder YOLOv10-Modells verwenden den One-to-many-Kopf und geben Rohausgaben zurück, auf die NMS angewendet werden muss – auch mitnms=False. - FP16: Es gibt keinen FP16-Export. LiteRT-GPU-Delegates führen ein FP32-Modell standardmäßig mit halber Genauigkeit aus.
quantize=16ist daher nicht erforderlich und führt zu einem Fehler.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Mit 10 % der COCO-Validierungsbilder kalibrieren (500 Bilder); coco.yaml durch deinen eigenen Datensatz ersetzen
model.export(format="litert", quantize=8, data="coco.yaml", fraction=0.1) # Erstellt „yolo26n_int8.tflite“
# Das exportierte INT8-Modell laden und Inferenz ausführen
model = YOLO("yolo26n_int8.tflite")
results = model("https://ultralytics.com/images/bus.jpg")Quantisierung verändert die Genauigkeit. Wie stark, hängt vom Modell, der Aufgabe und den Kalibrierungsbildern ab. Überprüfe ein quantisiertes Modell mit deinen eigenen Daten, bevor du es einsetzt.
Ausgabeformat#
Beim Export wird eine einzelne .tflite-Datei erstellt. Das Modell erwartet eine Eingabe mit der Form (batch, 3, height, width): RGB, Kanäle zuerst (NCHW), float32, skaliert auf 0 bis 1. Das unterscheidet sich von den TFLite-Dateien des früheren Exports format="tflite", die Bilder mit Kanälen zuletzt (NHWC) erwarteten. Das Argument nms und die Aufgabe legen die Ausgaben fest. Die unten aufgeführten Formen gelten für die offiziellen YOLO26n-Checkpoints mit ihrer standardmäßigen Exportgröße sowie für den Cityscapes-Checkpoint yolo26n-sem.pt für semantische Segmentierung:
| Aufgabe | Standardmäßiges imgsz | Ausgabe mit nms=None | Ausgabe mit nms=False |
|---|---|---|---|
| Detect | 640 | (1, 84, 8400) | (1, 300, 6) |
| Segment | 640 | (1, 116, 8400) und (1, 32, 160, 160) | (1, 300, 38) und (1, 32, 160, 160) |
| Semantisch | 1024 | (1, 19, 1024, 1024), ein Wert für jede Klasse und jedes Pixel | Wie nms=None |
| Tiefe | 768 | (1, 1, 768, 768), Tiefenkarte | Wie nms=None |
| Klassifizieren | 224 | (1, 1000), Klassenwahrscheinlichkeiten | Wie nms=None |
| Pose | 640 | (1, 56, 8400) | (1, 300, 57): 6 Boxwerte, dann 17 Keypoints mit je 3 Werten |
| OBB | 1024 | (1, 20, 21504) | (1, 300, 7): 4 Boxwerte, Score, Klasse, Winkel |
- Rohausgabe (
nms=None): Form(batch, values, anchors). Für jeden Anker: Mittelpunkt x der Box, Mittelpunkt y, Breite und Höhe, dann die Klassenscores und anschließend die aufgabenspezifischen Werte (32 Maskenkoeffizienten, 17 Keypoints mit je 3 Werten oder der OBB-Winkel im Bogenmaß). Die Boxwerte sowie die x- und y-Koordinaten der Keypoints sind auf 0 bis 1 normalisiert. Multipliziere sie daher mit der Eingabebreite und -höhe. Wende NMS selbst an. - NMS-freie Ausgabe (
nms=False):max_detZeilen (standardmäßig 300) mitx1, y1, x2, y2, score, classin Pixeln des Eingabebildes, ohne NMS-Schritt. OBB-Zeilen haben das Formatcenter x, center y, width, height, score, class, angle; der Winkel wird im Bogenmaß angegeben. Filtere die Zeilen nach dem Score. Verfügbar für FP32- und'w8a32'-Exporte von Modellen mit einem NMS-freien Detektionskopf. - Segmentierung: Die 32 Maskenkoeffizienten sind die letzten 32 Werte jedes Ankers oder jeder Zeile. Die zweite Ausgabe enthält die Maskenprototypen.
- Semantische Segmentierung: Die Ausgabe enthält Klassenscores und nicht die Klassenkarte des ONNX-Exports. Berechne daher in deinem eigenen Code das Argmax über die Klassenachse.
YOLO("yolo26n.tflite") liest das Layout aus den Dateimetadaten und skaliert die Koordinaten. Diese Details brauchst du also nur, wenn du das Modell in deinem eigenen Code ausführst. Die Metadaten sind ein Eintrag metadata.json, den der Export als ZIP-Archiv an die Datei anhängt. Er kann mit jeder ZIP-Bibliothek gelesen werden. Zu den Schlüsseln gehören names, task, imgsz, stride, batch, end2end, args und bei Poseschätzungsmodellen kpt_shape.
Ausführen mit dem LiteRT-Interpreter#
Um das Modell außerhalb des Ultralytics-Pakets auszuführen, lade es mit dem Interpreter des Pakets ai-edge-litert. Lies die Eingabe- und Ausgabeformen direkt aus dem Modell aus, statt dich auf Tensornamen zu verlassen. Ein Segmentierungsmodell hat zwei Ausgaben: Die 3D-Ausgabe enthält die Erkennungen, die 4D-Ausgabe die Maskenprototypen.
# Zuerst exportieren: 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) # dein vorverarbeitetes Bild: 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] # Zeilen oberhalb des Konfidenzschwellenwerts beibehalten
with zipfile.ZipFile("yolo26n.tflite") as z:
names = json.loads(z.read("metadata.json"))["names"] # {'0': 'person', '1': 'bicycle', ...}Bereitstellen#
YOLO("yolo26n.tflite") führt das Modell mit dem Interpreter ai-edge-litert auf der CPU und mit bis zu 8 Threads aus. Auch andere Werte für device, etwa 0 oder mps, führen das Modell auf der CPU aus; xpu und npu wählen Intel-Hardware aus. Die Tabelle der Inferenzgeräte vergleicht diese Bezeichnungen formatübergreifend.
Das Modell läuft immer mit imgsz und batch des Exports, die Ultralytics aus den Dateimetadaten ausliest. Ein an predict oder val übergebener Wert imgsz wird ignoriert. Größere Batches werden in Abschnitte der Batchgröße des Exports aufgeteilt, kleinere werden aufgefüllt. Daher funktioniert jede Bildanzahl.
Inferenz auf Intel-GPU und NPU#
Exportierte .tflite-Modelle laufen auf Intel-Hardware über das LiteRT-Intel-OpenVINO-Plugin. Übergib device=xpu für die GPU oder device=npu für die NPU. Bei der ersten Verwendung installiert Ultralytics ai-edge-litert>=2.3.0 und ai-edge-litert-sdk-intel. Das Plugin benötigt eine bestimmte Version von openvino. Verwende daher eine separate Umgebung, wenn du zusätzlich OpenVINO-Modelle mit einer anderen Version ausführst. Für die NPU ist ein Intel-Core-Ultra-Prozessor mit installiertem Intel-NPU-Treiber erforderlich. Siehe die auf einem Core Ultra X7 358H gemessene Latenz. Auf einem Rechner ohne das angeforderte Intel-Gerät kann das OpenVINO-Plugin das Modell nicht kompilieren. LiteRT führt es dann mit dem eigenen CPU-Backend (XNNPACK) aus, nicht über OpenVINO: Auf einer AMD-Server-CPU dauerte die Verarbeitung eines YOLO26n-Bildes mit device=xpu und device=npu 29 bis 30 ms, gegenüber 18 ms mit device=cpu. Ultralytics gibt in diesem Fall keine Warnung aus. Vergleiche daher die Latenz mit device=cpu, um sicherzugehen, dass das Gerät verwendet wird.
from ultralytics import YOLO
model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="npu") # oder "xpu"Leitfäden zur Bereitstellung#
- Ultralytics-YOLO-Flutter-Plugin: Führt LiteRT-Exporte
.tfliteunter Android mit Echtzeit-Inferenz über die Kamera, Einzelbildvorhersagen und GPU-Beschleunigung aus. - @ultralytics/yolo-npm-Paket: Führt LiteRT-Exporte
.tfliteim Browser über LiteRT.js mit WebGPU-Beschleunigung und einer CPU-Ausweichlösung (WASM) aus. Installiere es mitnpm i @ultralytics/yolo @litertjs/core. - MediaTek Dimensity: Bereitstellung auf Android-Geräten von MediaTek, einschließlich der NPU.
- Qualcomm QNN und Core ML: die Formate für Snapdragon-NPUs und Apple-Geräte.
- NXP i.MX95 und Coral Edge TPU: Formate für diese Beschleuniger.
- Raspberry Pi: Richte Ultralytics auf Raspberry-Pi-Boards ein.
- LiteRT-Dokumentation: Integriere die Laufzeitumgebung in Android- und iOS-Anwendungen oder im Browser.
Einschränkungen und Fehlerbehebung#
- Exportrechner: Unter Windows und Linux ARM64, zum Beispiel auf einem Raspberry Pi, schlägt der Export mit
LiteRT export only supported on Linux x86 and macOSfehl. Führe den Export auf einem unterstützten Rechner aus und kopiere die Datei.tfliteauf das Gerät. - Erster Export nach einer einfachen Installation: Wenn beim ersten Export ein
litert-torchinstalliert wird, das die installierte PyTorch-Version nicht unterstützt (0.10.0 unterstützt Versionen ab 2.4.0 und unter 2.15.0), ersetzt pip PyTorch, Ultralytics protokolliertRestart runtime or rerun command for updates to take effectund der Export kann fehlschlagen – bei PyTorch 2.15.0 mitRuntimeError: duplicate registrations for aten.miopen_batch_norm.default. Führe den Export erneut aus. - FP16:
quantize=16schlägt mitquantize=16 (FP16) is not supported; format='litert' supports quantize=8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 'w8a32' (dynamic INT8), 32 or None (FP32).fehl. Exportiere in FP32 und lass den GPU-Delegate das Modell mit halber Genauigkeit ausführen. - Mit
quantize=8trainierte Checkpoints: Ein mit quantisierungsbewusstem Training feinabgestimmter Checkpoint lässt sich nicht mitformat='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backendsexportieren. Exportiere stattdessen den Checkpoint, von dem aus du die Feinabstimmung begonnen hast, mitquantize=8, oder exportiere den feinabgestimmten Checkpoint nach ONNX oder TensorRT. - NMS-freier Kopf mit
quantize=8oder'w8a16': Mitnms=Falseprotokolliert der ExportLiteRT INT8 export does not support end2end models, disabling end2end branch.und schreibt Rohausgaben, auf die NMS angewendet werden muss. Verwende FP32 oder'w8a32', um den NMS-freien Kopf beizubehalten. - Eingebettetes NMS:
nms=Trueprotokolliertformat=litert does not support embedded NMS; exporting native outputs for external NMS.und schreibt die Rohausgabe. - NMS-freier Kopf bei anderen Modellen:
nms=Falseerfordert ein Modell mit NMS-freiem Kopf, etwa YOLO26 oder YOLOv10. Bei anderen Modellen, zum Beispiel YOLO11, gibt der Export die WarnungThis model has no one-to-one head; using one-to-many outputs.aus und schreibt die Rohausgabe(1, 84, 8400). - Feste Eingabeform:
dynamic=Trueschlägt mitargument 'dynamic' is not supported for format='litert'fehl. Exportiere das Modell erneut, um die Bildgröße oder Batchgröße zu ändern. - Kalibrierung ohne
data: Bei einem Export mitquantize=8oder'w8a16'protokolliert der ExportINT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'.und verwendet zur Kalibrierung den kleinen Standarddatensatz für die Aufgabe. Übergibdatamit Bildern, die deinen Einsatzdaten entsprechen. - Kalibrierungsumfang: Der Export protokolliert
>300 images recommended for INT8 calibration, found 4 images., wenn die Kalibrierungsaufteilung weniger als 300 Bilder enthält.coco8.yamlenthält nur 4 Validierungsbilder. Das reicht zum Testen des Exports, aber nicht zur Kalibrierung eines Modells für den Einsatz. 'w8a16'auf x86-CPUs: Der LiteRT-CPU-Interpreter führte ein YOLO26n-'w8a16'-Modell auf einer AMD-EPYC-9655-Server-CPU mit 8 Threads in etwa 1 s pro Bild aus. Beim FP32-Modell waren es etwa 17 ms. Miss'w8a16'auf dem Gerät und mit dem Delegate, die du einsetzen willst.- Dateiname: Jeder Export desselben Checkpoints mit demselben Wert für
quantizeschreibt dieselbe Datei, zum Beispielyolo26n.tflitefür FP32, unabhängig vonimgsz,batchodernms. Der spätere Export ersetzt daher den früheren.
Weitere Fehler findest du im Leitfaden zu häufigen Problemen.
Gemessene Leistung#
Die folgenden Tabellen zeigen die Latenz für ein Bild mit dem YOLO26n-Modell jeder Aufgabe auf vier Android-Smartphones und einem Intel-Core-Ultra-Prozessor. Jede Zelle zeigt die Gesamtzeit in Millisekunden. Darunter ist die Aufteilung in Vorverarbeitung, Inferenz und Nachverarbeitung angegeben. Die schnellste Spalte pro Modell ist fett gedruckt. Auf der YOLO26-Modellseite findest du die Genauigkeit der PyTorch-Checkpoints.
Xiaomi 17#
Hardware: Xiaomi 17 mit 12 GB LPDDR5X-Speicher und Android 17 / API 37. Der 3-nm-Snapdragon 8 Elite Gen 5 (SM8850) verfügt über eine 8-Core-Qualcomm-Oryon-CPU (2 Prime-Kerne mit bis zu 4,6 GHz und 6 Performance-Kerne mit bis zu 3,62 GHz), eine Adreno-GPU und eine Hexagon-NPU.
| Modell | Aufgabe | Größe (Pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT FP32 (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detect | 640 | 36.9 1.9 / 32.6 / 2.3 | 10.6 1.8 / 6.2 / 2.6 | 10.1 3.5 / 4.0 / 2.5 |
| YOLO26n-seg | Segment | 640 | 50.5 1.9 / 42.9 / 5.8 | 18.0 1.9 / 9.5 / 6.6 | 19.2 3.6 / 5.9 / 9.7 |
| YOLO26n-sem | Semantisch | 640 | 45.7 1.9 / 35.7 / 8.2 | 30.6 1.9 / 20.5 / 8.3 | 25.8 3.6 / 11.0 / 11.3 |
| YOLO26n-depth | Tiefe | 640 | 66.8 2.2 / 55.0 / 9.7 | 21.9 2.1 / 10.1 / 9.8 | 24.8 4.3 / 6.0 / 14.5 |
| YOLO26n-cls | Klassifizieren | 224 | 3.6 0.3 / 3.3 / 0.0 | 2.0 0.4 / 1.4 / 0.2 | 1.5 0.6 / 0.7 / 0.3 |
| YOLO26n-pose | Pose | 640 | 39.9 2.0 / 36.5 / 1.4 | 10.0 1.8 / 6.7 / 1.4 | 11.5 3.5 / 4.2 / 3.8 |
| YOLO26n-obb | OBB | 640 | 36.3 2.0 / 33.2 / 1.2 | 10.1 2.6 / 5.9 / 1.6 | 8.2 3.5 / 3.7 / 0.9 |
- Die Geschwindigkeitswerte sind Latenzen bei einem einzelnen Bild in einem Burst – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmdurchläufen auf
bus.jpg, gemessen mit dem Ultralytics-Flutter-Plugin0.7.1und den offiziellenv0.7.0-Assets (Exporte aus Ultralytics 8.4.188). Die Reihenfolge von CPU und GPU wechselte zwischen den Aufgaben innerhalb eines sequenziellen Durchlaufs. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete und jede GPU-Zeile den vollständigen Berechnungsgraphen an LiteRT OpenCL (LITERT_CL) übergab. - Der LiteRT-Export zeichnet das PyTorch-Modell direkt nach und erzeugt ein NCHW-
.tflitemit einem Float-Eingabewert — der GPU-Delegate kompiliert den gesamten Graphen (hier laufen alle sieben Aufgaben auf der Adreno-GPU), undw8a32benötigt keine Kalibrierungsdaten. Nutzer sollten Tensorformen und Signaturnamen auslesen, statt das ältere onnx2tf-NHWC-Layout oderIdentity-Ausgabenamen vorauszusetzen; RGB-Daten sollten direkt als planares CHW verpackt oder vor der Inferenz transponiert werden. Semantische Exporte geben NCHW-Logits zurück und erfordern ein klassenweises Argmax auf dem Host. Die offiziellen Android-Assets sind im Releasev0.7.0der yolo-flutter-app verfügbar; den ausführlichen Benchmarkbericht findest du in der Flutter-Performance-Dokumentation. - Die Spalte NPU zeigt den nativen NPU-Pfad von LiteRT: einen FP32-Export (
yolo export format=litert, ohnequantize), der auf dem Gerät von den Laufzeitumgebungenlitert-npu-runtime-qualcommund-mediatek2.3.0 kompiliert wurde. Gemessen wurde mit einem Prototyp-Build des Flutter-Plugins mit NPU-Unterstützung (noch nicht veröffentlicht). Beim ersten Laden ist diese Kompilierung enthalten (etwa 0.3 s fürn, bis zu 6 s fürx). Diew8a32-Assets lassen sich auf diesen NPUs nicht vollständig kompilieren. LiteRT meldet eine NPU-Kompilierung, auch wenn es den Berechnungsgraphen unbemerkt auf der GPU ausführt. Deshalb wurde jede NPU-Zeile mit der GPU-Zeit abgeglichen; Zeilen mit Rückfall auf die GPU sind mit — gekennzeichnet. - Die entsprechenden Werte für die Snapdragon-Hexagon-NPU mit den offiziellen QNN-Assets findest du unter Qualcomm-QNN-Integration.
- Vergleiche die Ergebnisse für die Apple-CPU und den Beschleuniger in der CoreML-Integration.
Die folgenden Gerätedurchläufe verwenden dieselben offiziellen v0.7.0-Assets.
Google Pixel 10#
Hardware: Google Pixel 10 mit 12 GB Speicher und Android 17 / API 37. Der 3-nm-Google Tensor G5 verfügt über eine 8-Core-CPU (1 Prime-Kern mit bis zu 3,78 GHz, 5 Performance-Kerne mit bis zu 3,05 GHz und 2 Effizienzkerne mit bis zu 2,25 GHz), eine PowerVR-D-Series-GPU und eine Google TPU. Die Kerntaktraten und der Name des GPU-Treibers wurden auf dem Benchmarkgerät ausgelesen, da Google diese Angaben nicht in den verlinkten technischen Daten veröffentlicht.
| Modell | Aufgabe | Größe (Pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) |
|---|---|---|---|---|
| YOLO26n | Detect | 640 | 36.6 1.5 / 33.5 / 1.6 | 36.5 3.5 / 28.4 / 4.6 |
| YOLO26n-seg | Segment | 640 | 53.1 1.5 / 45.8 / 5.7 | 51.5 1.6 / 40.1 / 9.9 |
| YOLO26n-sem | Semantisch | 640 | 57.2 1.5 / 47.7 / 8.0 | 75.9 1.8 / 63.4 / 10.8 |
| YOLO26n-depth | Tiefe | 640 | 75.0 1.6 / 65.1 / 8.3 | 50.1 1.7 / 33.5 / 14.9 |
| YOLO26n-cls | Klassifizieren | 224 | 6.1 0.3 / 5.5 / 0.3 | 12.1 0.9 / 11.0 / 0.1 |
| YOLO26n-pose | Pose | 640 | 35.2 1.5 / 31.9 / 1.8 | 38.2 3.5 / 29.3 / 5.4 |
| YOLO26n-obb | OBB | 640 | 32.7 1.5 / 29.3 / 1.9 | 38.8 3.8 / 29.6 / 5.4 |
Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmdurchläufen auf bus.jpg, unter Verwendung von ultralytics_yolo 0.7.1 und den offiziellen v0.7.0-Assets. Die Reihenfolge von CPU und GPU wechselt zwischen den Aufgaben innerhalb eines sequenziellen Durchlaufs. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete und jede GPU-Zeile den vollständigen Berechnungsgraphen an LiteRT OpenCL (LITERT_CL) übergab. Für die Tensor-NPU gibt es keine LiteRT-Zeile: Googles EdgeTPU-Dienst weist Apps zurück, die nicht auf der Zulassungsliste stehen, und LiteRT führt das Modell dann auf der GPU aus.
Samsung Galaxy S26#
Hardware: Samsung Galaxy S26 (SM-S942B) mit 12 GB Speicher und Android 17 / API 37. Der 2-nm-Exynos 2600 verfügt über eine 10-Core-Armv9.3-CPU (1 C1-Ultra-Kern mit bis zu 3,8 GHz, 3 C1-Pro-Performance-Kerne mit bis zu 3,26 GHz und 6 C1-Pro-Effizienzkerne mit bis zu 2,76 GHz), eine Xclipse-960-GPU und eine Samsung-NPU.
| Modell | Aufgabe | Größe (Pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT w8a32 AOT (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detect | 640 | 30.2 1.3 / 27.3 / 1.6 | 15.9 1.4 / 11.5 / 2.9 | 12.2 1.3 / 8.6 / 2.2 |
| YOLO26n-seg | Segment | 640 | 45.6 1.3 / 39.1 / 5.2 | 30.5 1.3 / 23.6 / 5.6 | 17.0 1.4 / 9.7 / 5.8 |
| YOLO26n-sem | Semantisch | 640 | 38.1 1.3 / 28.6 / 8.2 | 26.1 1.3 / 16.8 / 7.9 | 28.3 1.7 / 15.1 / 11.5 |
| YOLO26n-depth | Tiefe | 640 | 63.5 1.4 / 53.6 / 8.4 | 37.3 1.4 / 24.6 / 11.3 | 28.4 2.1 / 12.9 / 13.4 |
| YOLO26n-cls | Klassifizieren | 224 | 3.8 0.2 / 3.4 / 0.2 | 2.8 0.2 / 2.6 / 0.0 | 6.1 0.5 / 5.2 / 0.4 |
| YOLO26n-pose | Pose | 640 | 31.1 1.3 / 28.4 / 1.4 | 18.4 1.6 / 13.0 / 3.8 | 13.5 1.8 / 9.5 / 2.2 |
| YOLO26n-obb | OBB | 640 | 27.9 1.3 / 25.7 / 0.9 | 15.3 1.9 / 11.4 / 2.1 | 11.4 1.7 / 8.3 / 1.4 |
Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmdurchläufen auf bus.jpg, unter Verwendung von ultralytics_yolo 0.7.1 und den offiziellen v0.7.0-Assets. Die Reihenfolge von CPU und GPU wechselt zwischen den Aufgaben innerhalb eines sequenziellen Durchlaufs. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete und jede GPU-Zeile den vollständigen Berechnungsgraphen an LiteRT OpenCL (LITERT_CL) übergab. Die NPU-Spalte verwendet die w8a32-Assets, die vorab für den Exynos 2600 (E9965) mit Samsungs Compiler-Plugin für LiteRT kompiliert wurden. Samsung bietet in LiteRT 2.3 keinen Compiler auf dem Gerät, und Google veröffentlicht noch keine Laufzeitumgebung für Samsung-NPUs. Daher wurden diese Zeilen mit einer Dispatch-Bibliothek gemessen, die aus den LiteRT-2.3-Quellen erstellt wurde.
Xiaomi 17T Pro#
Hardware: Xiaomi 17T Pro (2602EPTC0G) mit 12 GB LPDDR5X-Speicher und Android 16 / API 36. Der 3-nm- MediaTek Dimensity 9500 (MT6993) verfügt über eine Armv9.3-CPU mit 8 Kernen (1 C1-Ultra-Kern mit bis zu 4,21 GHz, 3 C1-Premium-Kerne mit bis zu 3,5 GHz und 4 C1-Pro-Kerne mit bis zu 2,7 GHz), eine Mali-G1-Ultra-MC12-GPU und eine MediaTek-NPU 990.
| Modell | Aufgabe | Größe (Pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT FP32 (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detect | 640 | 31.4 1.5 / 28.0 / 1.9 | 25.6 1.4 / 22.2 / 2.0 | 11.0 1.3 / 7.8 / 1.8 |
| YOLO26n-seg | Segment | 640 | 77.8 2.6 / 65.3 / 9.9 | 47.4 2.6 / 33.6 / 11.3 | 36.5 2.6 / 23.4 / 10.4 |
| YOLO26n-sem | Semantisch | 640 | 81.3 2.6 / 62.2 / 16.5 | 79.3 2.6 / 59.5 / 17.1 | 87.6 2.6 / 68.3 / 16.7 |
| YOLO26n-depth | Tiefe | 640 | 111.3 3.4 / 91.1 / 16.8 | 55.3 2.8 / 36.3 / 16.1 | — |
| YOLO26n-cls | Klassifizieren | 224 | 6.3 0.5 / 5.4 / 0.4 | 8.1 0.5 / 7.5 / 0.1 | 3.2 0.5 / 2.2 / 0.5 |
| YOLO26n-pose | Pose | 640 | 53.9 2.6 / 49.5 / 1.8 | 32.8 2.7 / 26.7 / 3.4 | 16.2 2.9 / 11.1 / 2.3 |
| YOLO26n-obb | OBB | 640 | 49.5 2.7 / 44.4 / 2.4 | 29.4 2.8 / 22.7 / 3.9 | — |
Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmläufen auf bus.jpg, mit ultralytics_yolo 0.7.1 und den offiziellen v0.7.0-Assets. Die Reihenfolge von CPU und GPU wechselt zwischen den Aufgaben innerhalb eines einzelnen sequenziellen Durchlaufs. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK und jede GPU-Zeile den vollständigen Graphen an LiteRT OpenCL (LITERT_CL) übergab. Für Depth und OBB gibt es keine NPU-Ergebnisse: Der MediaTek-NPU-Compiler weist ihre Exponential- und trigonometrischen Operationen zurück, und LiteRT führt diese Graphen auf der GPU aus.
Informationen zum Bereitstellungsablauf unter Android und zu den Einschränkungen der NPU findest du im MediaTek-Dimensity-Leitfaden.
Intel Core Ultra X7 358H#
Hardware: Intel Core Ultra X7 358H (Panther Lake) und Intel AI Boost NPU 5010, Fedora Linux, NPU-Treiber 1.38.0, ai-edge-litert 2.3.0.
| Modell | Aufgabe | Größe (Pixel) | CPU w8a32 LiteRT (ms) | CPU w8a32 Intel (ms) | NPU w8a32 Intel (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detect | 640 | 17.5 0.8 / 16.1 / 0.6 | 22.6 1.2 / 20.6 / 0.8 | 4.8 1.0 / 3.3 / 0.4 |
| YOLO26n-seg | Segment | 640 | 24.2 0.9 / 22.1 / 1.3 | 32.6 1.0 / 30.1 / 1.5 | 6.2 0.8 / 4.2 / 1.2 |
| YOLO26n-sem | Semantisch | 640 | 25.2 1.0 / 14.2 / 10.0 | 33.1 1.1 / 21.9 / 10.2 | 16.5 1.0 / 5.5 / 10.0 |
| YOLO26n-depth | Tiefe | 640 | 31.7 0.9 / 30.2 / 0.5 | 76.6 0.9 / 75.2 / 0.5 | 9.1 1.0 / 7.5 / 0.5 |
| YOLO26n-cls | Klassifizieren | 224 | 4.6 2.8 / 1.7 / 0.0 | 7.3 3.3 / 3.9 / 0.0 | 4.1 3.2 / 0.9 / 0.0 |
| YOLO26n-pose | Pose | 640 | 20.3 0.8 / 19.0 / 0.5 | 28.6 1.1 / 26.8 / 0.8 | 6.3 0.8 / 4.9 / 0.5 |
| YOLO26n-obb | OBB | 640 | 17.2 0.8 / 16.1 / 0.3 | 22.1 1.2 / 20.5 / 0.4 | 4.6 0.9 / 3.4 / 0.3 |
Benchmark: Mittelwert aus 15 Aufrufen von predict() nach 3 Aufwärmläufen auf bus.jpg, mit ultralytics 8.4.174 und ai-edge-litert 2.3.0 sowie Exporten von w8a32. Jede Zelle zeigt die Gesamtzeit und darunter die Aufteilung in Vorverarbeitung, Inferenz und Nachverarbeitung.
Über LiteRT#
LiteRT, die Kurzform von Lite Runtime, ist der neue Name für TensorFlow Lite und verwendet dasselbe Modellformat .tflite. Die Laufzeitumgebung führt Modelle mit XNNPACK auf der CPU und über Hardware-Delegates auf GPUs und NPUs aus. LiteRT.js unterstützt dieselbe Datei in Browsern und Node.js. Die vollständige Referenz findest du in der LiteRT-Dokumentation.
Ansehen: So exportierst du Ultralytics YOLO26 nach Google LiteRT | Stelle Vision-KI auf Android und iOS bereit | Mobile KI 📱🚀
Häufig gestellte Fragen#
LiteRT ist der neue Name für TensorFlow Lite und verwendet dasselbe Modellformat
.tflite. In Ultralytics ersetztformat="litert"zwei frühere Exportformate:tflitefür Mobilgeräte, eingebettete Systeme und Edge-Geräte sowietfjsfür Browser und Node.js, in denen LiteRT.js jetzt dieselbe Datei.tfliteausführt. Beide früheren Werte exportieren weiterhin eine LiteRT-Datei und geben dabei eine Deprecation-Warnung aus. Auf den Seiten zu TFLite und TF.js werden die früheren Formate beschrieben.Beginne mit
quantize="w8a32". Dafür sind keine Kalibrierungsdaten nötig, die Datei ist weniger als ein Drittel so groß wie die FP32-Datei, der NMS-freie Kopf von YOLO26 wird mitnms=Falseunterstützt und die offiziellen Ultralytics-Mobilmodelle für CPU und GPU verwenden diese Genauigkeit. Verwendequantize=8, wenn das Zielgerät ganzzahlige Aktivierungen benötigt: Der Export für NXP i.MX95 kompiliert zum Beispiel ein kalibriertes INT8-LiteRT-Modell.'w8a16'erhält mehr Genauigkeit bei Aktivierungen als8. Beide benötigen repräsentative Kalibrierungsdaten und geben Rohausgaben zurück, auf die NMS angewendet werden muss. Miss Latenz und Genauigkeit auf deinem Zielgerät, bevor du dich entscheidest, denn die Unterstützung der einzelnen Verfahren unterscheidet sich je nach CPU-, GPU- und NPU-Delegate.Nein. Der Export läuft nur unter Linux x86-64 und unter macOS auf Apple-Chips der M-Serie. Exportiere das Modell auf einem dieser Rechner oder mit der Ultralytics Platform und kopiere die Datei
.tfliteauf das Gerät. Informationen zum Ausführen von Modellen auf dem Board findest du in der Raspberry-Pi-Anleitung. Ein Coral Edge TPU kann die Inferenz beschleunigen.Ja. LiteRT.js führt die exportierte Datei
.tflitemit WebGPU oder WASM in einem Browser oder in Node.js aus. Ein separater Browserexport ist nicht nötig. Das @ultralytics/yolo-npm-Paket ergänzt Unterstützung für Inferenz mit Webcam und Einzelbildern bei den Aufgaben Erkennung, Segmentierung, semantische Segmentierung, Klassifizierung, Pose und OBB.Verwende das Ultralytics-YOLO-Flutter-Plugin. Es lädt LiteRT-Exporte
.tfliteunter Android und unterstützt alle sieben YOLO26-Aufgaben. Exportiere mitimgsz=640oder bei der Klassifizierung mitimgsz=224, damit die Größe den offiziellen Modellen entspricht. Für eine native App folge der LiteRT-Anleitung für Android und übergib das Modell wie unter Ausgabeformat beschrieben. Auf dem iPhone ist Core ML das native Format.
Kommentare
Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.