Erste Schritte

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#

EigenschaftDetails
Argument formatlitert. Die älteren Werte tflite und tfjs funktionieren weiterhin: Sie protokollieren eine Deprecation-Warnung und exportieren dieselbe LiteRT-Datei.
Ausgabeyolo26n.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 aufAndroid- und iOS-Geräte, eingebettete Linux-Boards, Desktop-CPUs, Webbrowser über LiteRT.js sowie Intel-GPUs und NPUs.
LaufzeitumgebungLiteRT: das Python-Paket ai-edge-litert (Version 2.1.4 oder neuer), die LiteRT-Bibliotheken für Android und iOS oder LiteRT.js.
PrecisionFP32, 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.
ExportrechnerLinux 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.
In der Cloud exportieren

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:

PaketErforderliche Version
Python3.10 oder neuer
litert-torch0.10.0 oder neuer
torchDer 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-litert2.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-quantizer0.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.

Exportieren
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“
Vorhersagen
from ultralytics import YOLO

# Exportiertes LiteRT-Modell laden
model = YOLO("yolo26n.tflite")

# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")
Validieren
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#

ArgumentTypStandardBeschreibung
formatstr'litert'Zielformat des exportierten Modells, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt.
imgszint oder tuple640Bildgröß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.
quantizeint oder strNoneQuantisierungsschema: '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.
datastrNoneDatensatz-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.
fractionfloat, int oder list1.0Kalibrierungs-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.
nmsbool, optionalNoneWä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.
batchint1Batchgröße des exportierten Modells, die in der Eingabeform festgelegt ist. Dies ist auch die für die Kalibrierung verwendete Batchgröße.
devicestrNoneDer 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.

Bildgröße der offiziellen Mobil- und Webmodelle

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:

quantizeGewichteAktivierungenKalibrierungsdatenYOLO26n-DateiGröße
nicht angegeben oder 32FP32FP32Neinyolo26n.tflite10.0 MB
'w8a32'INT8FP32Neinyolo26n_w8a32.tflite2.9 MB
8INT8INT8Jayolo26n_int8.tflite3.1 MB
'w8a16'INT8INT16Jayolo26n_w8a16.tflite3.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 Layout nms exportiert wurde.
  • 'w8a32': Quantisierung des dynamischen Wertebereichs. Sie benötigt keine Kalibrierungsdaten, unterstützt den NMS-freien Kopf mit nms=False und entspricht der Genauigkeit der offiziellen Mobilmodelle, die in der Tabelle Gemessene Leistung in den CPU- und GPU-Spalten aufgeführt sind.
  • 8 und 'w8a16': statische Quantisierung. Beim Export wird mit jedem vollständigen Batch der Aufteilung val von data oder der mit split festgelegten Aufteilung kalibriert. Bei weniger als 300 Bildern wird eine Warnung ausgegeben. Mit fraction kannst 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=8 und 'w8a16' eines YOLO26- oder YOLOv10-Modells verwenden den One-to-many-Kopf und geben Rohausgaben zurück, auf die NMS angewendet werden muss – auch mit nms=False.
  • FP16: Es gibt keinen FP16-Export. LiteRT-GPU-Delegates führen ein FP32-Modell standardmäßig mit halber Genauigkeit aus. quantize=16 ist daher nicht erforderlich und führt zu einem Fehler.
Beispiel
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:

AufgabeStandardmäßiges imgszAusgabe mit nms=NoneAusgabe mit nms=False
Detect640(1, 84, 8400)(1, 300, 6)
Segment640(1, 116, 8400) und (1, 32, 160, 160)(1, 300, 38) und (1, 32, 160, 160)
Semantisch1024(1, 19, 1024, 1024), ein Wert für jede Klasse und jedes PixelWie nms=None
Tiefe768(1, 1, 768, 768), TiefenkarteWie nms=None
Klassifizieren224(1, 1000), KlassenwahrscheinlichkeitenWie nms=None
Pose640(1, 56, 8400)(1, 300, 57): 6 Boxwerte, dann 17 Keypoints mit je 3 Werten
OBB1024(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_det Zeilen (standardmäßig 300) mit x1, y1, x2, y2, score, class in Pixeln des Eingabebildes, ohne NMS-Schritt. OBB-Zeilen haben das Format center 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.

Vorhersagen
from ultralytics import YOLO

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

Leitfäden zur Bereitstellung#

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 macOS fehl. Führe den Export auf einem unterstützten Rechner aus und kopiere die Datei .tflite auf das Gerät.
  • Erster Export nach einer einfachen Installation: Wenn beim ersten Export ein litert-torch installiert 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 protokolliert Restart runtime or rerun command for updates to take effect und der Export kann fehlschlagen – bei PyTorch 2.15.0 mit RuntimeError: duplicate registrations for aten.miopen_batch_norm.default. Führe den Export erneut aus.
  • FP16: quantize=16 schlägt mit quantize=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=8 trainierte Checkpoints: Ein mit quantisierungsbewusstem Training feinabgestimmter Checkpoint lässt sich nicht mit format='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends exportieren. Exportiere stattdessen den Checkpoint, von dem aus du die Feinabstimmung begonnen hast, mit quantize=8, oder exportiere den feinabgestimmten Checkpoint nach ONNX oder TensorRT.
  • NMS-freier Kopf mit quantize=8 oder 'w8a16': Mit nms=False protokolliert der Export LiteRT 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=True protokolliert format=litert does not support embedded NMS; exporting native outputs for external NMS. und schreibt die Rohausgabe.
  • NMS-freier Kopf bei anderen Modellen: nms=False erfordert ein Modell mit NMS-freiem Kopf, etwa YOLO26 oder YOLOv10. Bei anderen Modellen, zum Beispiel YOLO11, gibt der Export die Warnung This model has no one-to-one head; using one-to-many outputs. aus und schreibt die Rohausgabe (1, 84, 8400).
  • Feste Eingabeform: dynamic=True schlägt mit argument '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 mit quantize=8 oder 'w8a16' protokolliert der Export INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. und verwendet zur Kalibrierung den kleinen Standarddatensatz für die Aufgabe. Übergib data mit 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.yaml enthä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 quantize schreibt dieselbe Datei, zum Beispiel yolo26n.tflite für FP32, unabhängig von imgsz, batch oder nms. 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.

ModellAufgabeGröße
(Pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetect64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-segSegment64050.5
1.9 / 42.9 / 5.8
18.0
1.9 / 9.5 / 6.6
19.2
3.6 / 5.9 / 9.7
YOLO26n-semSemantisch64045.7
1.9 / 35.7 / 8.2
30.6
1.9 / 20.5 / 8.3
25.8
3.6 / 11.0 / 11.3
YOLO26n-depthTiefe64066.8
2.2 / 55.0 / 9.7
21.9
2.1 / 10.1 / 9.8
24.8
4.3 / 6.0 / 14.5
YOLO26n-clsKlassifizieren2243.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
  • 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-Plugin 0.7.1 und den offiziellen v0.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-.tflite mit einem Float-Eingabewert — der GPU-Delegate kompiliert den gesamten Graphen (hier laufen alle sieben Aufgaben auf der Adreno-GPU), und w8a32 benötigt keine Kalibrierungsdaten. Nutzer sollten Tensorformen und Signaturnamen auslesen, statt das ältere onnx2tf-NHWC-Layout oder Identity-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 Release v0.7.0 der 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, ohne quantize), der auf dem Gerät von den Laufzeitumgebungen litert-npu-runtime-qualcomm und -mediatek 2.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ür n, bis zu 6 s für x). Die w8a32-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.

ModellAufgabeGröße
(Pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
YOLO26nDetect64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-segSegment64053.1
1.5 / 45.8 / 5.7
51.5
1.6 / 40.1 / 9.9
YOLO26n-semSemantisch64057.2
1.5 / 47.7 / 8.0
75.9
1.8 / 63.4 / 10.8
YOLO26n-depthTiefe64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-clsKlassifizieren2246.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: 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.

ModellAufgabeGröße
(Pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT w8a32 AOT
(ms)
YOLO26nDetect64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-segSegment64045.6
1.3 / 39.1 / 5.2
30.5
1.3 / 23.6 / 5.6
17.0
1.4 / 9.7 / 5.8
YOLO26n-semSemantisch64038.1
1.3 / 28.6 / 8.2
26.1
1.3 / 16.8 / 7.9
28.3
1.7 / 15.1 / 11.5
YOLO26n-depthTiefe64063.5
1.4 / 53.6 / 8.4
37.3
1.4 / 24.6 / 11.3
28.4
2.1 / 12.9 / 13.4
YOLO26n-clsKlassifizieren2243.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: 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.

ModellAufgabeGröße
(Pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetect64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-segSegment64077.8
2.6 / 65.3 / 9.9
47.4
2.6 / 33.6 / 11.3
36.5
2.6 / 23.4 / 10.4
YOLO26n-semSemantisch64081.3
2.6 / 62.2 / 16.5
79.3
2.6 / 59.5 / 17.1
87.6
2.6 / 68.3 / 16.7
YOLO26n-depthTiefe640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-clsKlassifizieren2246.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: 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.

ModellAufgabeGröße
(Pixel)
CPU
w8a32 LiteRT
(ms)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26nDetect64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-segSegment64024.2
0.9 / 22.1 / 1.3
32.6
1.0 / 30.1 / 1.5
6.2
0.8 / 4.2 / 1.2
YOLO26n-semSemantisch64025.2
1.0 / 14.2 / 10.0
33.1
1.1 / 21.9 / 10.2
16.5
1.0 / 5.5 / 10.0
YOLO26n-depthTiefe64031.7
0.9 / 30.2 / 0.5
76.6
0.9 / 75.2 / 0.5
9.1
1.0 / 7.5 / 0.5
YOLO26n-clsKlassifizieren2244.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: 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.

LiteRT edge deployment framework



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 ersetzt format="litert" zwei frühere Exportformate: tflite für Mobilgeräte, eingebettete Systeme und Edge-Geräte sowie tfjs für Browser und Node.js, in denen LiteRT.js jetzt dieselbe Datei .tflite ausfü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 mit nms=False unterstützt und die offiziellen Ultralytics-Mobilmodelle für CPU und GPU verwenden diese Genauigkeit. Verwende quantize=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 als 8. 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 .tflite auf 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 .tflite mit 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 .tflite unter Android und unterstützt alle sieben YOLO26-Aufgaben. Exportiere mit imgsz=640 oder bei der Klassifizierung mit imgsz=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.