Exportiere YOLO-Modelle nach LiteRT für Edge- und Web-Deployment#

LiteRT (kurz für Lite Runtime) ist Googles Hochleistungs-Runtime für On-Device-KI. Es ist die nächste Generation und der neue Name für TensorFlow Lite (TFLite) und verwendet das gleiche .tflite-Modellformat. Mit LiteRT lässt sich ein einzelnes exportiertes Ultralytics YOLO-Modell auf Mobilgeräten, Embedded-Systemen, Edge-Geräten und im Browser einsetzen – und deckt damit alles ab, was die älteren tflite- und tfjs-Exportformate separat abwickelten, jetzt unter einem Dach.

Das LiteRT-Exportformat optimiert deine Modelle für Aufgaben wie Objekterkennung, Segmentierung, Pose-Schätzung und Klassifizierung, sodass sie schnell und offline auf einer Vielzahl von Geräten laufen.

npm i @ultralytics/yolo @litertjs/core

Warum solltest du nach LiteRT exportieren?#

LiteRT ist ein Open-Source-Framework für On-Device-Inferenz, auch bekannt als Edge Computing. Es bietet Entwicklern Werkzeuge, um trainierte Modelle auf Mobilgeräten, eingebetteten Systemen und IoT-Geräten, herkömmlichen Computern und – durch LiteRT.js – direkt in Webbrowsern und Node.js auszuführen.

Ein Modellformat, jedes Ziel:

• Mobil & Embedded: Android, iOS, eingebettetes Linux und Mikrocontroller (MCUs).
• Edge-Beschleuniger: Kompatibel mit der Coral Edge TPU für zusätzliche Beschleunigung.
• Browser & Node.js: LiteRT.js führt dasselbe .tflite-Modell im Web mit WebGPU/WASM-Beschleunigung aus – wodurch kein separater TensorFlow.js-Export mehr erforderlich ist.

Hauptmerkmale von LiteRT-Modellen#

• On-Device-Optimierung: Reduziert die Latenz durch lokale Datenverarbeitung, erhöht den Datenschutz, da keine persönlichen Daten übertragen werden, und minimiert die Modellgröße, um Speicherplatz zu sparen.
• Plattformübergreifende Unterstützung: Läuft auf Android, iOS, eingebettetem Linux, Mikrocontrollern und modernen Webbrowsern.
• Hardwarebeschleunigung: Nutzt XNNPACK auf der CPU und GPU-Beschleunigung über OpenCL, Metal und WebGPU. Das GPU-Delegate läuft standardmäßig in FP16 für zusätzliche Geschwindigkeit.
• Quantisierung: Unterstützt FP32, statisches INT8 (quantize=8, int8-Gewichte + int8-Aktivierungen), statische INT16-Aktivierung (quantize="w8a16", int8-Gewichte + int16-Aktivierungen für höhere Genauigkeit) und dynamisches INT8 (quantize="w8a32", int8-Gewichte + FP32-Aktivierungen, keine Kalibrierungsdaten erforderlich), um Modelle zu komprimieren und die Inferenz mit minimalem Genauigkeitsverlust zu beschleunigen.
• Vielfältige Sprachunterstützung: Kompatibel mit Java/Kotlin, Swift, Objective-C, C++, Python und JavaScript.

Gemessene Leistung#

Hardware: Xiaomi 17 mit 12 GB LPDDR5X-Speicher und Android 16 / API 36. Dessen 3-nm-Snapdragon 8 Elite Gen 5 (SM8850) verfügt über eine Qualcomm Oryon 8-Core-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.

• Geschwindigkeitswerte sind Burst-Latenzen für einzelne Bilder – der Mittelwert aus 15 Durchläufen nach 3 Warmup-Durchläufen auf bus.jpg, gemessen mit dem Ultralytics Flutter-Plugin 0.6.10 und den standardisierten v0.6.6-Assets. Die CPU/GPU-Reihenfolge wechselte bei den Aufgaben in einem sequenziellen Durchlauf ab. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete und jede GPU-Zeile den gesamten Graph an LiteRT OpenCL (LITERT_CL) delegierte.
• Der LiteRT-Export verfolgt das PyTorch-Modell direkt und erzeugt ein NCHW .tflite mit einer Gleitkomma-Eingabe – das GPU-Delegat kompiliert den gesamten Graph (alle sieben Aufgaben laufen hier auf der Adreno GPU), und w8a32 benötigt keine Kalibrierungsdaten. Konsumenten sollten Tensor-Formen und Signaturnamen lesen, anstatt das veraltete onnx2tf NHWC-Layout oder Identity-Ausgabennamen anzunehmen; packe RGB-Daten direkt als planares CHW oder transponiere sie vor der Inferenz. Semantische Exporte geben NCHW-Logits zurück und erfordern ein hostseitiges Klassen-Argmax. Die offiziellen Android-Assets werden im yolo-flutter-app v0.6.6-Release gehostet, wobei der detaillierte Benchmark-Datensatz in der Flutter-Leistungsdokumentation zu finden ist.
• Die passenden Zahlen für den Snapdragon Hexagon NPU und LiteRT CPU/GPU befinden sich in der Qualcomm QNN-Integration.
• Vergleiche die Apple CPU/Beschleuniger-Ergebnisse in der CoreML-Integration.

Die folgenden Gerätedurchläufe verwenden dieselben standardisierten v0.6.6-Assets.

Google Pixel 10#

Hardware: Google Pixel 10 mit 12 GB Speicher und Android 16 / API 36. Dessen 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 Effizienz-Kerne mit bis zu 2,25 GHz), eine PowerVR D-Series GPU und eine Google TPU. Die Kerntaktraten und der Name des GPU-Treibers wurden vom Benchmark-Gerät ausgelesen, da Google diese in den verlinkten Spezifikationen nicht veröffentlicht.

Benchmark: Mittelwert von 15 predict()-Aufrufen nach 3 Warmups auf bus.jpg unter Verwendung von ultralytics_yolo 0.6.10 und den offiziellen v0.6.6-Assets. Die CPU/GPU-Reihenfolge wechselt bei den Aufgaben in einem sequenziellen Durchlauf ab. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete und jede GPU-Zeile den gesamten Graph an LiteRT OpenCL (LITERT_CL) delegierte.

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) mit 12 GB Speicher und Android 16 / API 36. Dessen 2-nm-Exynos 2600 verfügt über eine Armv9.3 10-Core-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-Effizienz-Kerne mit bis zu 2,76 GHz), eine Xclipse 960 GPU und eine Samsung NPU.

Benchmark: Mittelwert von 15 predict()-Aufrufen nach 3 Warmups auf bus.jpg unter Verwendung von ultralytics_yolo 0.6.10 und den offiziellen v0.6.6-Assets. Die CPU/GPU-Reihenfolge wechselt bei den Aufgaben in einem sequenziellen Durchlauf ab. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete und jede GPU-Zeile den gesamten Graph an LiteRT OpenCL (LITERT_CL) delegierte.

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) mit 12 GB LPDDR5X-Speicher und Android 16 / API 36. Dessen 3-nm-MediaTek Dimensity 9500 (MT6993) verfügt über eine Armv9.3 8-Core-CPU (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.

Benchmark: Mittelwert von 15 predict()-Aufrufen nach 3 Warmups auf bus.jpg unter Verwendung von ultralytics_yolo 0.6.10 und den offiziellen v0.6.6-Assets. Die CPU/GPU-Reihenfolge wechselt bei den Aufgaben in einem sequenziellen Durchlauf ab. Native Protokolle bestätigten, dass jede CPU-Zeile LiteRT CPU/XNNPACK verwendete und jede GPU-Zeile den gesamten Graph an LiteRT OpenCL (LITERT_CL) delegierte.

Unterstützte Aufgaben#

Der LiteRT-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Familie, die diese Köpfe bereitstellt.

Export nach LiteRT: Konvertierung deines YOLO-Modells#

Du kannst die Effizienz der On-Device-Ausführung verbessern und die Einsatzmöglichkeiten erweitern, indem du deine Modelle in das LiteRT-Format konvertierst.

Installation#

Um das erforderliche Paket zu installieren, führe Folgendes aus:

# Install the required package for YOLO
pip install ultralytics

Für detaillierte Anweisungen und Best Practices, schau dir unseren Ultralytics-Installationsleitfaden an. Solltest du auf Schwierigkeiten stoßen, konsultiere unseren Leitfaden für häufige Probleme.

Verwendung#

Alle Ultralytics YOLO-Modelle unterstützen den Export von Haus aus. Das LiteRT-Format unterstützt die Modi Exportieren, Vorhersagen und Validieren, sodass du ein Modell exportieren und dann lokal laden kannst, um eine Inferenz durchzuführen oder dessen Genauigkeit zu validieren.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to LiteRT format
model.export(format="litert", imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32", imgsz=640)  # use imgsz=224 for classification

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # use 224 for classification

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # use 224 for classification

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Export-Argumente#

Weitere Details zum Exportprozess findest du auf der Ultralytics-Dokumentationsseite zum Exportieren.

Bereitstellung exportierter YOLO LiteRT-Modelle#

Nachdem du dein Ultralytics YOLO-Modell nach LiteRT exportiert hast, kannst du es plattformübergreifend bereitstellen. Der schnellste Weg, es lokal zu überprüfen, ist die oben gezeigte YOLO("yolo26n.tflite")-Methode. Für die Bereitstellung in anderen Umgebungen findest du hier weitere Ressourcen:

Mobil & Embedded#

• Android: Ein Schnellstartleitfaden für die Integration von LiteRT in Android-Anwendungen.
• iOS: Ein Leitfaden für die Integration und Bereitstellung von LiteRT-Modellen in iOS-Anwendungen.
• Embedded Linux & Raspberry Pi: Führe LiteRT-Modelle auf Einplatinencomputern aus, optional beschleunigt mit einer Coral Edge TPU.
• Mikrocontroller: Bereitstellung auf MCUs mit nur wenigen Kilobyte Speicher – die Core-Runtime benötigt etwa 16 KB auf einem Arm Cortex-M3.

Browser & Node.js (LiteRT.js)#

• LiteRT.js Überblick: Führe dasselbe .tflite-Modell direkt im Browser mit WebGPU/WASM-Beschleunigung aus, was serverseitige Berechnungen überflüssig macht und die Daten auf dem Gerät des Benutzers belässt.
• End-to-End-Beispiele: Praktische Beispiele und Tutorials zur Implementierung von LiteRT für Mobilgeräte, Edge und Web.

Zusammenfassung#

In diesem Leitfaden haben wir behandelt, wie man Ultralytics YOLO-Modelle in das LiteRT-Format exportiert. Durch die Zusammenführung von Mobile/Edge (ehemals TFLite) und Browser (ehemals TF.js) in ein einziges .tflite-Modell macht LiteRT deine YOLO-Modelle schneller, kleiner und portabel für nahezu jedes On-Device-Ziel.

Weitere Details findest du in der offiziellen LiteRT-Dokumentation.

Wenn du neugierig auf andere Ultralytics YOLO-Integrationen bist, schau dir unsere Seite mit Integrationsleitfäden für viele hilfreiche Ressourcen an.

FAQ#

Wie exportiere ich ein YOLO-Modell in das LiteRT-Format?#

Verwende die Ultralytics-Bibliothek, um ein YOLO-Modell nach LiteRT (.tflite) zu exportieren. Installiere zuerst das Paket:

pip install ultralytics

Exportiere dann dein Modell:

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to LiteRT format
model.export(format="litert", imgsz=640)  # use imgsz=224 for classification

Für CLI-Benutzer:

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

Für weitere Details besuche den Ultralytics-Exportleitfaden.

Was ist der Unterschied zwischen LiteRT, TFLite und TF.js?#

LiteRT ist der neue Name für TensorFlow Lite – dasselbe .tflite-Modellformat, dieselbe Runtime-Linie, von Google umbenannt. Bei Ultralytics deckt das einzelne litert-Exportformat nun beide Anwendungsfälle ab, für die zuvor zwei separate Formate erforderlich waren:

• Das alte tflite-Format → Bereitstellung auf Mobilgeräten, Embedded-Systemen und Edge-Geräten.
• Das alte tfjs-Format → Bereitstellung im Browser und unter Node.js, jetzt abgewickelt durch LiteRT.js, das dieselbe .tflite-Datei ausführt.

Wenn du eine bestehende .tflite-Datei hast, kannst du sie direkt mit YOLO("model.tflite") laden, und sie läuft über das LiteRT-Backend.

Kann ich YOLO LiteRT-Modelle auf einem Raspberry Pi ausführen?#

Ja. Exportiere dein Modell in das LiteRT-Format und führe es dann auf einem Raspberry Pi aus, um die Inferenzgeschwindigkeiten zu verbessern. Für eine weitere Optimierung ziehe eine Coral Edge TPU in Betracht. Für detaillierte Schritte siehe unseren Raspberry Pi-Bereitstellungsleitfaden.

Kann ich YOLO-Modelle mit LiteRT im Browser ausführen?#

Ja. LiteRT.js führt das exportierte .tflite-Modell direkt in einem Webbrowser oder einer Node.js-Anwendung mit WebGPU/WASM-Beschleunigung aus. Dies ersetzt den früheren TensorFlow.js-Workflow – es gibt keinen separaten Browser-Export, setze dein LiteRT-Modell einfach mit der LiteRT.js-Runtime ein.

Unterstützt LiteRT FP16 (halbe Präzision) Inferenz?#

Ja – zur Laufzeit. Ein FP32 LiteRT-Modell läuft automatisch in FP16, wenn es auf einem GPU-Delegate (WebGPU, OpenCL oder Metal) ausgeführt wird, was der offizielle LiteRT-Ansatz ist. Du benötigst daher keinen dedizierten FP16-Export; für eine weitere Komprimierung verwende INT8-Quantisierung mit quantize=8.

Wie behebe ich häufige Probleme während des LiteRT-Exports?#

Wenn beim Exportieren von YOLO-Modellen nach LiteRT Fehler auftreten, gehören zu den üblichen Lösungen:

• Plattform prüfen: Der LiteRT-Export wird auf Linux x86_64 und macOS unterstützt. Überprüfe, ob deine Umgebung übereinstimmt.
• Paketkompatibilität prüfen: Stelle sicher, dass du eine kompatible Version von Ultralytics verwendest. Siehe unseren Installationsleitfaden.
• Quantisierungsprobleme: Wenn du INT8-Quantisierung verwendest, stelle sicher, dass dein Datensatzpfad im Parameter data korrekt angegeben ist.

Weitere Tipps zur Fehlerbehebung findest du in unserem Leitfaden zu häufigen Problemen.