Link to this sectionTFLite-Modell-Export für die Bereitstellung (veraltet)#

Die Bereitstellung von Computer Vision-Modellen auf Edge-Geräten oder eingebetteten Systemen erfordert ein Format, das eine reibungslose Leistung gewährleistet.

Das ehemalige TensorFlow Lite- oder TFLite-Exportformat optimierte Ultralytics YOLO26 Modelle für Aufgaben wie Objekterkennung und Bildklassifizierung in Edge-Anwendungen. Dieser Leitfaden bewahrt den Legacy-TFLite-Bereitstellungskontext; verwende LiteRT für neue Exporte.

Link to this sectionWarum wurde TFLite für den Export verwendet?#

Das im Mai 2017 von Google als Teil ihres TensorFlow-Frameworks eingeführte TensorFlow Lite, kurz TFLite, war ein Open-Source-Framework für Deep Learning, das für die Inferenz auf Geräten entwickelt wurde, auch bekannt als Edge Computing. Es gab Entwicklern Werkzeuge an die Hand, um trainierte Modelle auf Mobilgeräten, eingebetteten Systemen, IoT-Geräten sowie herkömmlichen Computern auszuführen.

TensorFlow Lite unterstützte eine breite Palette an Plattformen, darunter eingebettetes Linux, Android, iOS und Mikrocontroller (MCUs). TFLite-Exporte ermöglichten es Anwendungen, Modelle lokal und offline auszuführen.

Link to this sectionHauptfunktionen von TFLite-Modellen#

TFLite-Modelle bieten eine breite Palette an Funktionen, die maschinelles Lernen auf Geräten ermöglichen, indem sie Entwicklern helfen, ihre Modelle auf Mobil-, Embedded- und Edge-Geräten auszuführen:

• On-Device-Optimierung: TFLite optimiert für ML auf dem Gerät, reduziert die Latenz durch lokale Datenverarbeitung, verbessert die Privatsphäre, da keine persönlichen Daten übertragen werden, und minimiert die Modellgröße, um Speicherplatz zu sparen.

• Unterstützung mehrerer Plattformen: TFLite bietet umfangreiche Plattformkompatibilität und unterstützt Android, iOS, Embedded Linux und Mikrocontroller.

• Unterstützung verschiedener Sprachen: TFLite ist mit verschiedenen Programmiersprachen kompatibel, darunter Java, Swift, Objective-C, C++ und Python.

• Hohe Leistung: Erzielt überlegene Leistung durch Hardwarebeschleunigung und Modelloptimierung.

Link to this sectionGemessene Leistung (historisch)#

Aufgabenbasierter Vorher-/Nachher-Vergleich auf der Adreno GPU eines Xiaomi 17 (Qualcomm Snapdragon 8 Elite Gen 5, SM8850), gemessen mit dem Ultralytics Flutter plugin 0.6.8: Die alten onnx2tf INT8 TFLite-Assets (NHWC, Input images) im Vergleich zu den neuen w8a32 LiteRT-Assets (NCHW, Input args_0), beide ausgeführt auf LiteRT 2.x im selben aufeinanderfolgenden Durchlauf bei der ausgelieferten Android imgsz. Jede Zelle zeigt die Gesamtzeit (Preprocessing + Inference + Postprocessing) mit der Aufschlüsselung nach Phasen darunter; beide Formate wurden vollständig auf der GPU kompiliert.

w8a32 LiteRT erreicht oder übertrifft das alte onnx2tf INT8-Format bei fünf von sechs Aufgaben in der Gesamtlatenz. Semantic bleibt die Format-Regression, da die w8a32 NCHW-Logits selbst nach der Bereinigung des Preprocessings mehr Inference-Zeit beanspruchen als die alten NHWC-Logits. Die alten onnx2tf-Modelle laufen unverändert auf LiteRT 2.x neben den neuen NCHW-Exporten. Die offiziellen Android LiteRT-Assets werden im yolo-flutter-app v0.6.6 Release bereitgestellt, mit dem detaillierten Benchmark-Protokoll in der Flutter Performance-Doku.

Link to this sectionFormat-Regressionen vs LiteRT#

YOLO26n-Erkennung auf demselben Gerät auf der Adreno GPU eines Xiaomi 17 — altes onnx2tf INT8 TFLite im Vergleich zu den vier LiteRT-Quantisierungsformaten, alles gemessen in einem dauerhaften Durchlauf (daher ist die Inference die vergleichbare, formatabhängige Metrik):

Probleme für das Google LiteRT / litert-torch-Team, die bei der Migration von Produktions-Android-Assets von onnx2tf TFLite zu LiteRT aufgetreten sind:

1. Das NCHW-Layout macht Consumer Layout-aware. litert-torch verfolgt das PyTorch-Modell und gibt NCHW [1,3,H,W] mit einem Float-Input aus, während der onnx2tf TFLite-Export NHWC [1,H,W,3] war – was dem Layout von Kamera/Bitmap entspricht. Das aktuelle Flutter-Plugin schreibt während des RGB-Packings direkt planare CHW-Daten, wodurch eine separate HWC→CHW-Transponierung vermieden wird, aber einfachere Consumer benötigen dennoch entweder ein direktes planares Packing oder eine zusätzliche Transponierung.
2. quantize="w8a16" wird nicht auf dem GPU (OpenCL)-Delegaten kompiliert und fällt stillschweigend auf einen CPU-Pfad zurück, der ca. 40× langsamer ist (ca. 660 ms vs ca. 17 ms), was das Format mit int16-Aktivierung für den GPU-Einsatz unbrauchbar macht.
3. Statisch INT8 (quantize=8) ist das langsamste GPU-Format – ca. 11 ms vs ca. 8.6 ms für das äquivalente alte onnx2tf INT8-Modell, d. h. der eigene INT8-Pfad von LiteRT schneidet schlechter ab als das Format, das er ersetzt hat. Das dynamische w8a32 ist das einzige LiteRT-Format, das die Geschwindigkeit des alten INT8-Formats erreicht, weshalb es jetzt ausgeliefert wird.
4. Semantische Modelle exportieren als rohe NCHW-Logits ohne in-graph ArgMax-Option, was ein cache-ungünstiges hostseitiges Argmax über [1, C, H, W] erzwingt (jede Klassen-Ebene ist einen vollen H×W-Abstand entfernt). Die Pfade von onnx2tf, CoreML und QNN können stattdessen eine kompakte Klassen-Map ausgeben.
5. Die Output-Tensoren wurden in output_0, output_1, … umbenannt (vs onnx2tf Identity, Identity_1, …), was das Nachschlagen der Output-Shape zur Laufzeit unterbrach, bis die neuen Namen hinzugefügt wurden.

Die entsprechenden LiteRT w8a32-Zahlen (das Format, das jetzt ausgeliefert wird) finden sich auf der LiteRT-Seite.

Link to this sectionBereitstellungsoptionen in TFLite#

Bevor wir uns das Beispiel für den LiteRT-Ersatzexport ansehen, lass uns verstehen, wie TFLite-Modelle normalerweise verwendet werden.

TFLite bietet verschiedene On-Device-Bereitstellungsoptionen für Modelle des maschinellen Lernens, darunter:

• Bereitstellung mit Android und iOS: Android- und iOS-Anwendungen mit TFLite können Edge-basierte Kameradaten und Sensoren analysieren, um Objekte zu erkennen und zu identifizieren. TFLite bietet auch native iOS-Bibliotheken, die in Swift und Objective-C geschrieben sind. Das Architekturdiagramm unten zeigt den Prozess der Bereitstellung eines trainierten Modells auf Android- und iOS-Plattformen mit TensorFlow Lite.

• Implementierung mit Embedded Linux: Wenn die Ausführung von Inferenzen auf einem Raspberry Pi unter Verwendung des Ultralytics-Leitfadens nicht die Geschwindigkeitsanforderungen für deinen Anwendungsfall erfüllt, kannst du ein exportiertes TFLite-Modell verwenden, um die Inferenzzeiten zu beschleunigen. Zusätzlich ist es möglich, die Leistung durch die Nutzung eines Coral Edge TPU-Geräts weiter zu verbessern.

• Bereitstellung mit Mikrocontrollern: TFLite-Modelle können auch auf Mikrocontrollern und anderen Geräten mit nur wenigen Kilobyte Speicher bereitgestellt werden. Die Kern-Runtime passt in nur 16 KB auf einem Arm Cortex M3 und kann viele grundlegende Modelle ausführen. Sie erfordert keine Betriebssystemunterstützung, keine Standard-C- oder C++-Bibliotheken und keine dynamische Speicherzuweisung.

Link to this sectionErsetze den TFLite-Export durch LiteRT#

Für neue Exporte wandle dein Modell in LiteRT um. Das resultierende Modell behält die Dateiendung .tflite bei.

Link to this sectionInstallation#

Um die erforderlichen Pakete zu installieren, führe aus:

# Install the required package for YOLO26
pip install ultralytics

Detaillierte Anweisungen und Best Practices für den Installationsprozess findest du in unserem Ultralytics-Installationsleitfaden. Wenn du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stößt, schau in unserem Leitfaden zu häufigen Problemen nach Lösungen und Tipps.

Link to this sectionVerwendung#

Alle Ultralytics YOLO26 models sind so konzipiert, dass sie den Export sofort unterstützen, was die Integration in deinen bevorzugten Bereitstellungs-Workflow vereinfacht. Du kannst die vollständige Liste der unterstützten Exportformate und Konfigurationsoptionen einsehen, um das beste Setup für deine Anwendung zu wählen.

Das Ersatzformat LiteRT unterstützt die Modi Export, Predict und Validate. Exportiere dein Modell und lade dann das exportierte .tflite-Modell, 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

# Load the exported TFLite model
model = YOLO("yolo26n.tflite")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported TFLite 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 YOLO26 TFLite-Modelle#

Nachdem du dein Ultralytics YOLO26-Modell in das LiteRT-Format exportiert hast, kannst du das resultierende .tflite-Modell bereitstellen. Der primäre und empfohlene erste Schritt zur Ausführung eines TFLite-Modells ist die Verwendung der Methode YOLO("model.tflite"), wie im vorherigen Code-Snippet zur Verwendung skizziert. Für detaillierte Anweisungen zur Bereitstellung deiner TFLite-Modelle in verschiedenen anderen Umgebungen wirf jedoch einen Blick auf die folgenden Ressourcen:

• Android: Ein Schnellstartleitfaden für die Integration von TensorFlow Lite in Android-Anwendungen, der leicht verständliche Schritte für das Einrichten und Ausführen von Modellen des maschinellen Lernens bietet.

• iOS: Sieh dir diesen detaillierten Leitfaden für Entwickler zur Integration und Bereitstellung von TensorFlow Lite-Modellen in iOS-Anwendungen an, der Schritt-für-Schritt-Anweisungen und Ressourcen bietet.

• End-to-End-Beispiele: Diese Seite bietet einen Überblick über verschiedene TensorFlow Lite-Beispiele und zeigt praktische Anwendungen und Tutorials, die Entwicklern dabei helfen sollen, TensorFlow Lite in ihre Machine-Learning-Projekte auf Mobil- und Edge-Geräten zu implementieren.

Link to this sectionZusammenfassung#

Dieser Leitfaden bewahrt den Legacy-TFLite-Bereitstellungs-Workflow. Verwende für neue Exporte LiteRT, um .tflite-Modelle für Edge-Computing-Umgebungen zu erstellen.

Weitere Details zur Nutzung findest du in der offiziellen TFLite-Dokumentation.

Wenn du neugierig auf weitere Ultralytics YOLO26-Integrationen bist, schau dir unsere Seite mit Integrationsleitfäden an. Dort findest du viele hilfreiche Informationen und Einblicke.

Link to this sectionFAQ#

Link to this sectionWie ersetze ich einen TFLite-Export durch LiteRT?#

Verwende für einen neuen Export das LiteRT-Format. Installiere zuerst das erforderliche Paket mit:

pip install ultralytics

Verwende dann das folgende Code-Snippet, um dein Modell zu exportieren:

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 kannst du dies erreichen mit:

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

Für weitere Details besuche den Ultralytics-Exportleitfaden.

Link to this sectionWas sind die Vorteile der Verwendung von TensorFlow Lite für die YOLO26-Modellbereitstellung?#

TensorFlow Lite (TFLite) ist ein Open-Source-Deep Learning-Framework, das für die Inferenz auf dem Gerät entwickelt wurde und sich ideal für die Bereitstellung von YOLO26-Modellen auf Mobil-, Embedded- und IoT-Geräten eignet. Zu den wichtigsten Vorteilen gehören:

• On-Device-Optimierung: Minimiere Latenz und verbessere die Privatsphäre durch lokale Datenverarbeitung.
• Plattformkompatibilität: Unterstützt Android, iOS, Embedded Linux und MCU.
• Leistung: Nutzt Hardwarebeschleunigung, um Modellgeschwindigkeit und -effizienz zu optimieren.

Um mehr zu erfahren, lies den TFLite-Leitfaden.

Link to this sectionIst es möglich, YOLO26 TFLite-Modelle auf dem Raspberry Pi auszuführen?#

Ja, du kannst YOLO26 TFLite-Modelle auf dem Raspberry Pi ausführen, um die Inferenzgeschwindigkeiten zu verbessern. Exportiere zuerst dein Modell in das LiteRT-Format, wie oben erläutert. Verwende dann ein Werkzeug wie den TensorFlow Lite Interpreter, um das Modell auf deinem Raspberry Pi auszuführen.

Für weitere Optimierungen könntest du die Verwendung von Coral Edge TPU in Betracht ziehen. Detaillierte Schritte findest du in unserem Raspberry Pi-Bereitstellungsleitfaden und dem Edge TPU-Integrationsleitfaden.

Link to this sectionKann ich TFLite-Modelle auf Mikrocontrollern für YOLO26-Vorhersagen verwenden?#

Ja, TFLite unterstützt die Bereitstellung auf Mikrocontrollern mit begrenzten Ressourcen. Die Kern-Runtime von TFLite benötigt nur 16 KB Speicher auf einem Arm Cortex M3 und kann grundlegende YOLO26-Modelle ausführen. Dies macht es für den Einsatz auf Geräten mit minimaler Rechenleistung und minimalem Speicher geeignet.

Um loszulegen, besuche den TFLite Micro für Mikrocontroller-Leitfaden.

Link to this sectionWelche Plattformen sind mit TFLite-exportierten YOLO26-Modellen kompatibel?#

TensorFlow Lite bietet eine umfassende Plattformkompatibilität, die es dir ermöglicht, YOLO26-Modelle auf einer Vielzahl von Geräten bereitzustellen, darunter:

• Android und iOS: Native Unterstützung durch TFLite Android- und iOS-Bibliotheken.
• Embedded Linux: Ideal für Einplatinencomputer wie den Raspberry Pi.
• Mikrocontroller: Geeignet für MCUs mit eingeschränkten Ressourcen.

Weitere Informationen zu Bereitstellungsoptionen findest du in unserem detaillierten Bereitstellungsleitfaden.

Link to this sectionWie behebe ich häufige Probleme während des YOLO26-Modelexports zu LiteRT?#

Wenn bei der Exportierung von YOLO26-Modellen nach LiteRT Fehler auftreten, gehören zu den üblichen Lösungen:

• Überprüfe die Paketkompatibilität: Stelle sicher, dass du kompatible Versionen von Ultralytics, litert-torch und ai-edge-litert verwendest. Siehe unseren Installationsleitfaden.
• Modellunterstützung: Überprüfe, ob das spezifische YOLO26-Modell den LiteRT-Export unterstützt, indem du die Ultralytics Export-Dokumentationsseite konsultierst.
• 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.