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

LiteRT (kurz für Lite Runtime) ist die Hochleistungs-Runtime von Google für On-Device-KI. Sie ist die nächste Generation und der neue Name für TensorFlow Lite (TFLite) und verwendet dasselbe .tflite-Modellformat. Mit LiteRT lässt sich ein einziges exportiertes Ultralytics YOLO-Modell auf Mobilgeräten, eingebetteten Systemen, Edge-Geräten und im Browser einsetzen – und deckt damit alles ab, was die älteren Exportformate tflite und tfjs früher separat behandelt haben, jetzt vereint unter einem Dach.

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

npm i @ultralytics/yolo @litertjs/core

Warum solltest du nach LiteRT exportieren?#

LiteRT ist ein Open-Source-Framework für On-Device-Inferenz, das auch als Edge-Computing bekannt ist. Es bietet Entwicklern die Werkzeuge, um trainierte Modelle auf Mobil-, Embedded- und IoT-Geräten, herkömmlichen Computern und – über 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 ein separater TensorFlow.js-Export überflüssig wird.

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 bei 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. Sein 3 nm Snapdragon 8 Elite Gen 5 (SM8850) verfügt über eine 8-Kern Qualcomm Oryon CPU (2 Prime-Kerne mit bis zu 4,6 GHz und 6 Performance-Kerne mit bis zu 3,62 GHz), Adreno GPU und Hexagon NPU.

• Geschwindigkeitswerte sind Einzelbild-Burst-Latenzen – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmlä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 vollständigen Graphen an LiteRT OpenCL delegierte (LITERT_CL).
• Der LiteRT-Export verfolgt das PyTorch-Modell direkt und erzeugt ein NCHW .tflite mit einem Float-Eingang – der GPU-Delegat kompiliert den gesamten Graphen (alle sieben Aufgaben laufen hier auf der Adreno GPU), und w8a32 benötigt keine Kalibrierungsdaten. Anwender sollten Tensor-Formen und Signaturnamen lesen, anstatt das veraltete onnx2tf-NHWC-Layout oder Identity-Ausgabenamen 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 Snapdragon Hexagon NPU- und LiteRT CPU/GPU-Werte findest du 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. Sein 3 nm Google Tensor G5 verfügt über eine 8-Kern-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), PowerVR D-Series GPU und Google TPU. Die Kerntaktraten und der GPU-Treibername wurden vom Benchmark-Gerät abgelesen, da Google sie in den verlinkten Spezifikationen nicht veröffentlicht.

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

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) mit 12 GB Speicher und Android 16 / API 36. Sein 2 nm Exynos 2600 verfügt über eine 10-Kern-Armv9.3-CPU (1 C1-Ultra-Kern mit bis zu 3,8 GHz, 3 Performance C1-Pro-Kerne mit bis zu 3,26 GHz und 6 Effizienz C1-Pro-Kerne mit bis zu 2,76 GHz), Xclipse 960 GPU und Samsung NPU.

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

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) mit 12 GB LPDDR5X-Speicher und Android 16 / API 36. Sein 3 nm MediaTek Dimensity 9500 (MT6993) verfügt über eine 8-Kern-Armv9.3-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), Mali-G1 Ultra MC12 GPU und MediaTek NPU 990.

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

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

Detaillierte Anweisungen und Best Practices findest du in unserem Ultralytics Installationshandbuch. Wenn du auf Schwierigkeiten stößt, schaue in unseren Leitfaden zu häufigen Problemen.

Verwendung#

Alle Ultralytics YOLO Modelle unterstützen den Export von Haus aus. Das LiteRT-Format unterstützt die Modi Export, Predict und Validate, sodass du ein Modell exportieren und dann laden kannst, um lokale Inferenz auszufü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 Methode YOLO("yolo26n.tflite"). Für die Bereitstellung in anderen Umgebungen siehe die folgenden Ressourcen:

Mobil & Embedded#

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

Browser & Node.js (LiteRT.js)#

• LiteRT.js-Übersicht: Führe dasselbe .tflite-Modell direkt im Browser mit WebGPU/WASM-Beschleunigung aus, wodurch serverseitige Berechnungen entfallen und die Daten auf dem Gerät des Benutzers bleiben.
• End-to-End-Beispiele: Praxisnahe Beispiele und Tutorials zur Implementierung von LiteRT auf Mobilgeräten, Edge und Web.

Zusammenfassung#

In diesem Leitfaden haben wir behandelt, wie man Ultralytics YOLO-Modelle in das LiteRT-Format exportiert. Durch die Zusammenlegung von Mobil- und Edge-Bereitstellung (früher TFLite) sowie Browser-Bereitstellung (früher TF.js) in ein einziges .tflite-Modell macht LiteRT deine YOLO-Modelle schneller, kleiner und portabel für praktisch jedes On-Device-Ziel.

Weitere Details findest du in der offiziellen LiteRT-Dokumentation.

Wenn du außerdem neugierig auf andere Ultralytics YOLO-Integrationen bist, schaue dir unsere Integrationsseite an, die viele nützliche Ressourcen bietet.

FAQ#