Link to this sectionExportiere 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.

Link to this sectionWarum 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.

Link to this sectionHauptmerkmale 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.

Link to this sectionExport 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.

Link to this sectionInstallation#

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.

Link to this sectionVerwendung#

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")  # creates 'yolo26n.tflite'

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32")  # creates 'yolo26n_w8a32.tflite'

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8.tflite'

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml")  # creates 'yolo26n_w8a16.tflite'

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

Link to this sectionExport-Argumente#

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

Link to this sectionBereitstellung 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:

Link to this sectionMobil & 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.

Link to this sectionBrowser & 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.

Link to this sectionZusammenfassung#

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.

Link to this sectionFAQ#

Link to this sectionWie 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")  # creates 'yolo26n.tflite'

Für CLI-Benutzer:

yolo export model=yolo26n.pt format=litert # creates 'yolo26n.tflite'

Für weitere Details besuche den Ultralytics-Exportleitfaden.

Link to this sectionWas 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.

Link to this sectionKann 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.

Link to this sectionKann 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.

Link to this sectionUnterstü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.

Link to this sectionWie 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.