YOLO-Modelle für die Bereitstellung auf Edge-Geräten und im Web nach LiteRT exportieren#

LiteRT (Kurzform für Lite Runtime) ist die leistungsstarke Laufzeitumgebung von Google für KI direkt auf Geräten. Sie ist die nächste Generation und der neue Name von TensorFlow Lite (TFLite) und verwendet dasselbe Modellformat .tflite. Mit LiteRT lässt sich ein einzelnes exportiertes Ultralytics YOLO-Modell auf Mobilgeräten, eingebetteten Systemen, Edge-Geräten und im Browser bereitstellen. Damit deckt es alles ab, wofür zuvor die getrennten Exportformate tflite und tfjs erforderlich waren.

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 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 direkt auf Geräten, auch bekannt als Edge Computing. Es stellt Entwicklern Werkzeuge bereit, um trainierte Modelle auf Mobilgeräten, eingebetteten Systemen und IoT-Geräten sowie herkömmlichen Computern auszuführen – und mit LiteRT.js auch direkt in Webbrowsern und Node.js.

Ein Modellformat für alle Zielplattformen:

• Mobilgeräte und eingebettete Systeme: Android, iOS, eingebettetes Linux und Mikrocontroller (MCUs).
• Edge-Beschleuniger: Kompatibel mit Coral Edge TPU für zusätzliche Beschleunigung.
• Browser und Node.js: LiteRT.js führt dasselbe Modell .tflite im Web mit WebGPU-/WASM-Beschleunigung aus – ein separater TensorFlow.js-Export ist nicht 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 läuft standardmäßig mit FP16 für zusätzliche Geschwindigkeit.
• Quantisierung: Unterstützt FP32, statisches INT8 (quantize=8, int8-Gewichte + int8-Aktivierungen), statisches INT16 mit Aktivierungen (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 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-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 bei einer einzelnen Bildverarbeitung — 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 bei den Aufgaben in einem einzigen sequenziellen Durchlauf. Native Protokolle bestätigten, dass alle CPU-Zeilen LiteRT CPU/XNNPACK verwendeten und alle GPU-Zeilen den vollständigen Graphen an LiteRT OpenCL delegierten (LITERT_CL).
• 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.6.6 der yolo-flutter-app verfügbar; den ausführlichen Benchmarkbericht findest du in der Flutter-Performance-Dokumentation.
• Die passenden Werte für die Hexagon-NPU des Snapdragon sowie für LiteRT CPU/GPU 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 standardisierten v0.6.6-Assets.

Google Pixel 10#

Hardware: Google Pixel 10 mit 12 GB Speicher und Android 16 / API 36. Der 3-nm-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 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.

Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmdurchläufen auf bus.jpg, mit ultralytics_yolo 0.6.10 und den offiziellen v0.6.6-Assets. Die Reihenfolge von CPU und GPU wechselt bei den Aufgaben in einem einzigen sequenziellen Durchlauf. Native Protokolle bestätigten, dass alle CPU-Zeilen LiteRT CPU/XNNPACK verwendeten und alle GPU-Zeilen den vollständigen Graphen an LiteRT OpenCL delegierten (LITERT_CL).

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) mit 12 GB Speicher und Android 16 / API 36. Der 2-nm-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, mit ultralytics_yolo 0.6.10 und den offiziellen v0.6.6-Assets. Die Reihenfolge von CPU und GPU wechselt bei den Aufgaben in einem einzigen sequenziellen Durchlauf. Native Protokolle bestätigten, dass alle CPU-Zeilen LiteRT CPU/XNNPACK verwendeten und alle GPU-Zeilen den vollständigen Graphen an LiteRT OpenCL delegierten (LITERT_CL).

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.

Benchmark: Mittelwert aus 15 predict()-Aufrufen nach 3 Aufwärmdurchläufen auf bus.jpg, mit ultralytics_yolo 0.6.10 und den offiziellen v0.6.6-Assets. Die Reihenfolge von CPU und GPU wechselt bei den Aufgaben in einem einzigen sequenziellen Durchlauf. Native Protokolle bestätigten, dass alle CPU-Zeilen LiteRT CPU/XNNPACK verwendeten und alle GPU-Zeilen den vollständigen Graphen an LiteRT OpenCL delegierten (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 Modellfamilie, die diese Köpfe enthält.

Export nach LiteRT: Dein YOLO-Modell konvertieren#

Du kannst die Effizienz der Ausführung auf dem Gerät verbessern und mehr Bereitstellungsoptionen nutzen, indem du deine Modelle ins LiteRT-Format konvertierst.

Installation#

Führe zum Installieren des erforderlichen Pakets Folgendes aus:

# Install the required package for YOLO
pip install ultralytics

Ausführliche Anleitungen und bewährte Vorgehensweisen findest du in unserem Ultralytics-Installationsleitfaden. Falls Probleme auftreten, sieh dir unseren Leitfaden zu häufigen Problemen an.

Verwendung#

Alle Ultralytics-YOLO-Modelle unterstützen den Export standardmäßig. Das LiteRT-Format unterstützt die Modi Export, Vorhersage und Validierung. Du kannst also ein Modell exportieren und anschließend laden, um lokal Inferenzen auszuführen oder die Genauigkeit zu validieren.

from ultralytics import YOLO

# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Modell ins LiteRT-Format exportieren
model.export(format="litert", imgsz=640)  # Erstellt „yolo26n.tflite“; für die Klassifizierung imgsz=224 verwenden

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamisches INT8: int8-Gewichte, FP32-Aktivierungen – keine Kalibrierungsdaten erforderlich
model.export(format="litert", quantize="w8a32", imgsz=640)  # Erstellt „yolo26n_w8a32.tflite“

# Statisches INT8: int8-Gewichte + int8-Aktivierungen – benötigt Kalibrierungsdaten
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # Erstellt „yolo26n_int8.tflite“

# Statisches w8a16: int8-Gewichte + int16-Aktivierungen (höhere Genauigkeit) – benötigt Kalibrierungsdaten
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # Erstellt „yolo26n_w8a16.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")

Exportargumente#

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

Exportierte YOLO-LiteRT-Modelle bereitstellen#

Nachdem du dein Ultralytics-YOLO-Modell nach LiteRT exportiert hast, kannst du es auf verschiedenen Plattformen bereitstellen. Am schnellsten überprüfst du es lokal mit der oben gezeigten Methode YOLO("yolo26n.tflite"). Weitere Ressourcen zur Bereitstellung in anderen Umgebungen findest du hier:

Mobilgeräte & eingebettete Systeme#

• Android: Eine Schnellstartanleitung zur Integration von LiteRT in Android-Anwendungen.
• iOS: Eine Anleitung zur Integration und Bereitstellung von LiteRT-Modellen in iOS-Anwendungen.
• Eingebettetes Linux & Raspberry Pi: Führe LiteRT-Modelle auf Einplatinencomputern aus, bei Bedarf beschleunigt durch einen Coral Edge TPU.
• Mikrocontroller: Stelle Modelle auf MCUs mit nur wenigen Kilobyte Speicher bereit – die Laufzeitumgebung benötigt etwa 16 KB auf einem Arm Cortex-M3.

Browser & Node.js (LiteRT.js)#

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

Zusammenfassung#

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

Weitere Informationen findest du in der offiziellen LiteRT-Dokumentation.

Wenn du dich auch für andere Ultralytics-YOLO-Integrationen interessierst, findest du viele hilfreiche Ressourcen auf unserer Seite mit Integrationsanleitungen.

Häufig gestellte Fragen#