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.

Ansehen: So exportierst du Ultralytics YOLO26 nach Google LiteRT | Stelle Vision-KI auf Android und iOS bereit | Mobile KI 📱🚀

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 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.

• 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.

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.

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.

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.

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.

Inference auf Intel-CPU und NPU#

Exportierte .tflite-Modelle laufen auf Intel-Hardware über das Plugin LiteRT Intel OpenVINO. Gib device=intel:cpu oder device=intel:npu an; Ultralytics installiert ai-edge-litert>=2.3.0 und ai-edge-litert-sdk-intel bei der ersten Verwendung. Für die NPU wird ein Intel Core Ultra-Prozessor benötigt, auf dem der Intel-NPU-Treiber installiert ist.

from ultralytics import YOLO

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

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.

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.

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#