YOLO-Modelle für Edge- und Web-Bereitstellung nach LiteRT exportieren#

LiteRT (kurz für Lite Runtime) ist Googles leistungsstarke Laufzeitumgebung für KI auf dem Gerät. Es 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 einzelnes exportiertes Ultralytics YOLO-Modell auf Mobilgeräten, eingebetteten Systemen, Edge-Geräten und im Browser bereitstellen – und deckt damit alles ab, was die älteren Exportformate tflite und tfjs getrennt voneinander ermöglichten, jetzt unter einer gemeinsamen Lösung.

Das LiteRT-Exportformat optimiert deine Modelle für Aufgaben wie Objekterkennung, Segmentierung, Posenschätzung und Klassifizierung, sodass sie auf einer Vielzahl von Geräten schnell und offline ausgeführt werden können.

npm i @ultralytics/yolo @litertjs/core

Warum solltest du nach LiteRT exportieren?#

LiteRT ist ein Open-Source-Framework für Inferenz auf dem Gerät, auch bekannt als Edge Computing. Es stellt Entwicklern Werkzeuge zur Verfügung, um trainierte Modelle auf Mobilgeräten, eingebetteten Systemen und IoT-Geräten, herkömmlichen Computern sowie – über LiteRT.js – direkt in Webbrowsern und Node.js auszuführen.

Ein Modellformat, jedes Ziel:

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

Wichtige Funktionen von LiteRT-Modellen#

• Optimierung auf dem Gerät: Verringert die Latenz durch lokale Datenverarbeitung, verbessert den Datenschutz, da keine personenbezogenen Daten übertragen werden, und reduziert die Modellgröße, um Speicherplatz zu sparen.
• Unterstützung mehrerer Plattformen: Läuft auf Android, iOS, eingebettetem Linux, Mikrocontrollern und modernen Webbrowsern.
• Hardwarebeschleunigung: Nutzt XNNPACK auf der CPU sowie GPU-Beschleunigung über OpenCL, Metal und WebGPU. Der GPU-Delegate verwendet standardmäßig FP16 für zusätzliche Geschwindigkeit.
• Quantisierung: Unterstützt FP32, statisches INT8 (quantize=8, int8-Gewichte + int8-Aktivierungen), statisches INT16-Aktivierungsformat (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 Verlust an Genauigkeit zu beschleunigen.
• Unterstützung verschiedener Programmiersprachen: 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. Der 3-nm-Chip Snapdragon 8 Elite Gen 5 (SM8850) verfügt über eine Qualcomm-Oryon-CPU mit 8 Kernen (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 Latenzen für Einzelbild-Bursts – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmdurchläufen auf bus.jpg, gemessen mit dem Ultralytics Flutter-Plugin 0.6.10 und den standardisierten v0.6.6-Assets. 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 Graphen an LiteRT OpenCL (LITERT_CL) delegierte.
• Der LiteRT-Export zeichnet das PyTorch-Modell direkt nach und erzeugt ein NCHW-.tflite mit einem Float-Eingang – 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 alte onnx2tf-NHWC-Layout oder Identity-Ausgabenamen vorauszusetzen; RGB-Daten sollten direkt als planares CHW gepackt oder vor der Inferenz transponiert werden. Semantische Exporte geben NCHW-Logits zurück und erfordern ein klassenweises Argmax auf der Host-Seite. Die offiziellen Android-Assets werden im Release v0.6.6 der yolo-flutter-app bereitgestellt; der ausführliche Benchmark ist in der Flutter-Dokumentation zur Leistung enthalten.
• Die Werte der passenden Hexagon-NPU von Snapdragon sowie von LiteRT auf CPU und GPU findest du in der Qualcomm-QNN-Integration.
• Vergleiche die Ergebnisse von Apple-CPU und -Beschleuniger in der CoreML-Integration.

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

Google Pixel 10#

Hardware: Google Pixel 10 mit 12 GB Speicher und Android 16 / API 36. Der 3-nm-Chip Google Tensor G5 verfügt über eine CPU mit 8 Kernen (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 Kern-Taktfrequenzen und der Name des GPU-Treibers wurden vom Benchmark-Gerät ausgelesen, da Google sie in den verlinkten Spezifikationen nicht veröffentlicht.

Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmdurchläufen auf bus.jpg, unter Verwendung von ultralytics_yolo, 0.6.10 und den offiziellen v0.6.6-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 Graphen an LiteRT OpenCL (LITERT_CL) delegierte.

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) mit 12 GB Speicher und Android 16 / API 36. Der 2-nm-Chip Exynos 2600 verfügt über eine Armv9.3-CPU mit 10 Kernen (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.

Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmdurchläufen auf bus.jpg, unter Verwendung von ultralytics_yolo, 0.6.10 und den offiziellen v0.6.6-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 Graphen an LiteRT OpenCL (LITERT_CL) delegierte.

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) mit 12 GB LPDDR5X-Speicher und Android 16 / API 36. Der 3-nm-Chip 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.

Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmdurchläufen auf bus.jpg, unter Verwendung von ultralytics_yolo, 0.6.10 und den offiziellen v0.6.6-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 Graphen 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 Modellfamilie, die diese Köpfe bereitstellt.

Nach LiteRT exportieren: Dein YOLO-Modell konvertieren#

Du kannst die Ausführungseffizienz auf dem Gerät verbessern und die Bereitstellungsoptionen erweitern, indem du deine Modelle in das LiteRT-Format konvertierst.

Installation#

Führe zur Installation des erforderlichen Pakets folgenden Befehl aus:

# Install the required package for YOLO
pip install ultralytics

Ausführliche Anleitungen und bewährte Vorgehensweisen findest du in unserem Ultralytics-Installationsleitfaden. Wenn du auf Schwierigkeiten stößt, sieh in unserem Leitfaden zu häufigen Problemen nach.

Verwendung#

Alle Ultralytics-YOLO-Modelle unterstützen den Export sofort. Das LiteRT-Format unterstützt die Modi Export, Predict und Validate, sodass du ein Modell exportieren und anschließend laden kannst, um lokal Inferenz auszuführen oder seine Genauigkeit zu überprüfen.

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")

Exportargumente#

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Bereitstellung exportierter YOLO-LiteRT-Modelle#

Nach dem Export deines Ultralytics-YOLO-Modells nach LiteRT kannst du es auf verschiedenen Plattformen bereitstellen. Am schnellsten lässt sich das Modell lokal mit der oben gezeigten Methode YOLO("yolo26n.tflite") überprüfen. Informationen zur Bereitstellung in anderen Umgebungen findest du in den folgenden Ressourcen:

Mobilgeräte und eingebettete Systeme#

• Android: Eine Kurzanleitung zur Integration von LiteRT in Android-Anwendungen.
• iOS: Eine Anleitung zur Integration und Bereitstellung von LiteRT-Modellen in iOS-Anwendungen.
• Embedded Linux und Raspberry Pi: Führe LiteRT-Modelle auf Einplatinencomputern aus, optional beschleunigt durch einen Coral Edge TPU.
• Mikrocontroller: Stelle Modelle auf MCUs mit nur wenigen Kilobyte Speicher bereit – die Kernlaufzeit passt mit etwa 16 KB in einen Arm Cortex-M3.

Browser und Node.js (LiteRT.js)#

• Überblick zu LiteRT.js: Führe dasselbe .tflite-Modell mit WebGPU/WASM-Beschleunigung direkt im Browser aus. Dadurch entfällt die serverseitige Berechnung und die Daten bleiben auf dem Gerät des Benutzers.
• End-to-End-Beispiele: Praktische Beispiele und Tutorials zur Implementierung von LiteRT auf Mobilgeräten, Edge-Geräten und im Web.

Zusammenfassung#

In dieser Anleitung haben wir gezeigt, wie du Ultralytics-YOLO-Modelle in das LiteRT-Format exportierst. Durch die Zusammenführung der Bereitstellung auf Mobilgeräten und Edge-Geräten (früher TFLite) sowie im Browser (früher TF.js) in einem einzigen .tflite-Modell macht LiteRT deine YOLO-Modelle schneller, kleiner und auf nahezu jedem Gerät einsetzbar.

Weitere Informationen findest du in der offiziellen LiteRT-Dokumentation.

Wenn du dich außerdem für andere Ultralytics-YOLO-Integrationen interessierst, findest du auf unserer Seite zur Integrationsübersicht zahlreiche hilfreiche Ressourcen.

FAQ#