Ultralytics YOLO27:

TFLite-Modellexport für die Bereitstellung (veraltet)#

Veraltet – ersetzt durch LiteRT

Ab Ultralytics 8.4.83 wurde das eigenständige Exportformat tflite entfernt und durch das einheitliche Format Google LiteRT ersetzt. LiteRT (leichte Laufzeitumgebung) ist die nächste Generation und der neue Name von TensorFlow Lite und exportiert dasselbe .tflite-Modell – jetzt für die Bereitstellung auf Mobilgeräten, eingebetteten Systemen, Edge-Geräten und in Browsern in einem einzigen Format.

format="tflite" funktioniert weiterhin, gibt jedoch eine Warnung zur bevorstehenden Entfernung aus und exportiert stattdessen ein LiteRT-Modell. Verwende künftig format="litert". Aktuelle Anweisungen und Optionen zum Export findest du im LiteRT-Exportleitfaden.

TensorFlow Lite edge deployment framework

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

Das frühere TensorFlow-Lite- oder TFLite-Exportformat optimierte Ultralytics YOLO26-Modelle für Aufgaben wie Objekterkennung und Bildklassifizierung in Edge-Anwendungen. Dieser Leitfaden bewahrt den historischen Kontext der TFLite-Bereitstellung. Verwende für neue Exporte LiteRT.

Warum wurde TFLite für den Export verwendet?#

TensorFlow Lite, kurz TFLite, wurde im Mai 2017 von Google als Teil des TensorFlow-Frameworks eingeführt. Es war ein quelloffenes Deep-Learning-Framework für die Inferenz auf dem Gerät, auch bekannt als Edge Computing. Es stellte Entwicklern Werkzeuge zur Verfügung, um trainierte Modelle auf Mobilgeräten, eingebetteten Geräten und IoT-Geräten sowie auf herkömmlichen Computern auszuführen.

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

Wichtige Merkmale von TFLite-Modellen#

TFLite-Modelle bieten zahlreiche wichtige Funktionen für maschinelles Lernen auf dem Gerät und helfen Entwicklern dabei, ihre Modelle auf Mobilgeräten, eingebetteten Geräten und Edge-Geräten auszuführen:

  • Optimierung auf dem Gerät: TFLite ist für maschinelles Lernen auf dem Gerät optimiert. Dadurch wird die Latenz durch lokale Datenverarbeitung reduziert, der Datenschutz durch die Vermeidung der Übertragung personenbezogener Daten verbessert und die Modellgröße zur Einsparung von Speicherplatz minimiert.

  • Unterstützung mehrerer Plattformen: TFLite ist mit zahlreichen Plattformen kompatibel, darunter Android, iOS, eingebettetes Linux und Mikrocontroller.

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

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

Gemessene Leistung (historisch)#

Festgehaltener Stand vor und nach der Migration

Diese Ergebnisse wurden mit dem Ultralytics-Flutter-Plug-in 0.6.8 und LiteRT 2.1.5 unter Android 16/API 36 auf einem Xiaomi 17 mit 12 GB LPDDR5X-Speicher aufgezeichnet. Sein 3-nm-Snapdragon 8 Elite Gen 5 (SM8850) verfügt über eine 8-Kern-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. Diese Tabellen vergleichen die historischen onnx2tf-INT8-TFLite-Modelldateien mit den während der Migration bewerteten litert-torch-Exporten. Die veröffentlichten Modelldateien wurden anschließend durch die standardisierten Exporte überschrieben. Diese Zahlen beschreiben daher nicht die aktuellen Bytes der v0.6.6-Modelldatei. Aktuelle Messwerte findest du in den LiteRT-Leistungstabellen.

Beide Formate wurden im selben unmittelbar aufeinanderfolgenden GPU-Durchlauf mit den angegebenen Eingabegrößen ausgeführt. Jede Zelle zeigt die Gesamtzeit (Vorverarbeitung + Inferenz + Nachverarbeitung) sowie darunter die Aufteilung nach Phasen. Native Protokolle bestätigten, dass beide Formate den vollständigen Berechnungsgraphen an LiteRT OpenCL (LITERT_CL) auf der Adreno-GPU delegierten.

ModellAufgabeGröße
(Pixel)
Historisch
onnx2tf INT8 TFLite
(ms)
Kandidat
w8a32 LiteRT
(ms)
YOLO26nDetect64014.0
1.8 / 8.1 / 4.2
13.5
1.9 / 8.1 / 3.5
YOLO26n-segSegment64030.1
1.9 / 20.3 / 8.0
28.6
1.8 / 20.1 / 6.7
YOLO26n-semSemantisch64026.4
1.9 / 16.4 / 8.1
32.9
1.8 / 23.0 / 8.2
YOLO26n-clsKlassifizierung2243.5
0.9 / 2.2 / 0.4
3.2
1.0 / 2.2 / 0.1
YOLO26n-posePose64017.4
2.4 / 9.9 / 5.1
14.0
1.9 / 9.3 / 2.8
YOLO26n-obbOBB64013.9
3.0 / 8.3 / 2.7
13.0
2.9 / 7.9 / 2.3

Im selben Migrationslauf wurden außerdem die Quantisierungsformate für die YOLO26n-Erkennung verglichen. Die Inferenz ist die vergleichbare, formatabhängige Kennzahl:

Android-FormatGPU-Inferenz (ms)GPU-Kompilierung
onnx2tf INT8 (historisches TFLite)8.6ja
LiteRT w8a32 (Kandidat)8.4ja
LiteRT INT8 (quantize=8)11.0ja
LiteRT FP328.8ja
LiteRT w8a16 (quantize="w8a16")CPU-Ausweichlösungnein

In diesem Lauf wich w8a16 auf die CPU aus und benötigte insgesamt etwa 660 ms, verglichen mit etwa 17 ms bei den GPU-Formaten. Diese Ergebnisse waren ausschlaggebend für die Auslieferung von w8a32. Die Kompatibilität mit Delegaten und die Leistung hängen jedoch vom Gerät und der Laufzeitversion ab. Miss die Leistung auf dem Zielgerät und überprüfe in den Laufzeitprotokollen, wo der Beschleuniger eingesetzt wird.

Bereitstellungsoptionen in TFLite#

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

TFLite bietet verschiedene Optionen für die Bereitstellung von Machine-Learning-Modellen auf dem Gerät, darunter:

  • Bereitstellung mit Android und iOS: Android- und iOS-Anwendungen mit TFLite können kamerabasierte Datenströme und Sensoren an Edge-Geräten analysieren, um Objekte zu erkennen und zu identifizieren. TFLite bietet außerdem native iOS-Bibliotheken in Swift und Objective-C. Das folgende Architekt diagramm zeigt den Prozess zur Bereitstellung eines trainierten Modells auf Android- und iOS-Plattformen mit TensorFlow Lite.

TensorFlow Lite deployment architecture for mobile

  • Implementierung mit eingebettetem Linux: Wenn die Ausführung von Inferenzen auf einem Raspberry Pi mithilfe des Ultralytics-Leitfadens die Geschwindigkeitsanforderungen deines Anwendungsfalls nicht erfüllt, kannst du ein exportiertes TFLite-Modell verwenden, um die Inferenzzeiten zu verkürzen. Zusätzlich lässt sich die Leistung durch den Einsatz eines Coral-Edge-TPU-Geräts weiter verbessern.

  • Bereitstellung auf Mikrocontrollern: TFLite-Modelle können auch auf Mikrocontrollern und anderen Geräten mit nur wenigen Kilobyte Speicher bereitgestellt werden. Die Kernlaufzeit passt mit 16 KB gerade auf einen Arm Cortex M3 und kann viele einfache Modelle ausführen. Sie benötigt keine Unterstützung durch ein Betriebssystem, keine Standardbibliotheken für C oder C++ und keine dynamische Speicherzuweisung.

TFLite-Export durch LiteRT ersetzen#

Verwende für neue Exporte LiteRT, um dein Modell zu konvertieren. Das resultierende Modell behält die Dateierweiterung .tflite bei.

Installation#

Führe zur Installation der erforderlichen Pakete Folgendes aus:

Installation
# Install the required package for YOLO26
pip install ultralytics

Ausführliche Anweisungen und bewährte Vorgehensweisen zur Installation findest du in unserem Installationsleitfaden von Ultralytics. Sollten bei der Installation der für YOLO26 erforderlichen Pakete Schwierigkeiten auftreten, findest du in unserem Leitfaden zu häufigen Problemen Lösungen und Tipps.

Verwendung#

Alle Ultralytics YOLO26-Modelle sind so konzipiert, dass sie standardmäßig den Export unterstützen, sodass du sie problemlos in deinen bevorzugten Bereitstellungsablauf integrieren kannst. Du kannst die vollständige Liste der unterstützten Exportformate und Konfigurationsoptionen anzeigen, um die beste Konfiguration für deine Anwendung auszuwählen.

Das ersetzende LiteRT-Format unterstützt die Modi Export, Predict und Validate. Exportiere dein Modell und lade anschließend das exportierte .tflite-Modell, um Inferenzen auszuführen oder seine Genauigkeit zu überprüfen.

Export
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
Vorhersage
from ultralytics import YOLO

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

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")
Validieren
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")

Exportargumente#

ArgumentTypStandardwertBeschreibung
formatstr'litert'Zielformat für das exportierte Modell, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt.
imgszint oder tuple640Gewünschte Bildgröße für die Modelleingabe. Kann für quadratische Bilder eine Ganzzahl oder für bestimmte Abmessungen ein Tupel (height, width) sein.
quantizeint oder strNoneQuantisierungsgenauigkeit: 8 (statisches INT8, int8-Gewichte + int8-Aktivierungen; benötigt die Kalibrierung data/fraction), 'w8a16' (statisch, int8-Gewichte + int16-Aktivierungen; benötigt die Kalibrierung data/fraction), 'w8a32' (dynamisches INT8, int8-Gewichte + FP32-Aktivierungen; keine Kalibrierung erforderlich) oder 32/nicht gesetzt (FP32). FP16 wird nicht separat exportiert – ein FP32-Modell läuft auf GPU-Delegaten automatisch in FP16. Ersetzt die veralteten Flags half/int8.
batchint1Legt die Batchgröße für die Inferenz des exportierten Modells oder die maximale Anzahl der Bilder fest, die das exportierte Modell im Modus predict gleichzeitig verarbeitet.
datastrNonePfad zur Datensatz-YAML-Datei, die für die Quantisierung erforderlich ist; bei der Klassifizierung wird stattdessen ein Datensatzverzeichnis oder der Name eines integrierten Datensatzes verwendet. Wird der Pfad zusammen mit quantize=8 oder 'w8a16' weggelassen, wählt Ultralytics den standardmäßigen Kalibrierungsdatensatz für die Modellaufgabe aus.
fractionfloat, int oder list1.0Kalibrierungs-Teilmenge als Verhältnis, Bildanzahl oder [train, val, test]-Verhältnisse bzw. -Anzahlen. Bei Listen mit zwei Elementen bleibt test vollständig, während 0 übersprungen wird.
devicestrNoneGibt das Gerät für den Export an: CPU (device=cpu), MPS für Apple-Chips (device=mps).

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

Bereitstellung exportierter YOLO26-TFLite-Modelle#

Nachdem du dein Ultralytics YOLO26-Modell in das LiteRT-Format exportiert hast, kannst du das resultierende .tflite-Modell bereitstellen. Der wichtigste und empfohlene erste Schritt zum Ausführen eines TFLite-Modells ist die Verwendung der Methode YOLO("model.tflite"), wie im vorherigen Codebeispiel zur Verwendung beschrieben. Ausführliche Anweisungen zur Bereitstellung deiner TFLite-Modelle in verschiedenen anderen Umgebungen findest du in den folgenden Ressourcen:

  • Android: Ein Schnellstartleitfaden zur Integration von TensorFlow Lite in Android-Anwendungen mit leicht nachvollziehbaren Schritten zum Einrichten und Ausführen von Machine-Learning-Modellen.

  • iOS: Dieser ausführliche Leitfaden für Entwickler beschreibt die Integration und Bereitstellung von TensorFlow-Lite-Modellen in iOS-Anwendungen und bietet schrittweise Anweisungen und Ressourcen.

  • End-to-End-Beispiele: Diese Seite bietet einen Überblick über verschiedene TensorFlow-Lite-Beispiele und zeigt praktische Anwendungen und Tutorials, die Entwickler bei der Implementierung von TensorFlow Lite in ihren Machine-Learning-Projekten auf Mobil- und Edge-Geräten unterstützen.

Zusammenfassung#

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

Weitere Informationen zur Verwendung findest du in der offiziellen TFLite-Dokumentation.

Wenn du dich außerdem für andere Ultralytics-YOLO26-Integrationen interessierst, sieh dir unsere Integrationsleitfäden an. Dort findest du zahlreiche hilfreiche Informationen und Einblicke.

FAQ#

  • Verwende für einen neuen Export das LiteRT-Format. Installiere zunächst das erforderliche Paket mit:

    pip install ultralytics

    Verwende anschließend das folgende Codebeispiel, 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", imgsz=640)  # use imgsz=224 for classification

    Als CLI-Nutzer kannst du dies mit folgendem Befehl erreichen:

    yolo export model=yolo26n.pt format=litert imgsz=640 # use imgsz=224 for classification

    Weitere Informationen findest du in der Ultralytics-Exportanleitung.

  • TensorFlow Lite (TFLite) ist ein quelloffenes Deep-Learning-Framework für die Inferenz auf dem Gerät und eignet sich daher ideal für die Bereitstellung von YOLO26-Modellen auf Mobilgeräten, eingebetteten Geräten und IoT-Geräten. Zu den wichtigsten Vorteilen gehören:

    • Optimierung auf dem Gerät: Latenz minimieren und Datenschutz verbessern, indem Daten lokal verarbeitet werden.
    • Plattformkompatibilität: Unterstützt Android, iOS, eingebettetes Linux und MCU.
    • Leistung: Nutzt Hardwarebeschleunigung, um Geschwindigkeit und Effizienz des Modells zu optimieren.

    Weitere Informationen findest du im TFLite-Leitfaden.

  • Ja, du kannst YOLO26-TFLite-Modelle auf einem Raspberry Pi ausführen, um die Inferenzgeschwindigkeit zu verbessern. Exportiere dein Modell zunächst wie oben beschrieben in das LiteRT-Format. Verwende anschließend ein Werkzeug wie den TensorFlow-Lite-Interpreter, um das Modell auf deinem Raspberry Pi auszuführen.

    Für weitere Optimierungen kannst du Coral Edge TPU verwenden. Ausführliche Schritte findest du in unserem Bereitstellungsleitfaden für Raspberry Pi und im Integrationsleitfaden für Edge TPU.

  • Ja, TFLite unterstützt die Bereitstellung auf Mikrocontrollern mit begrenzten Ressourcen. Die TFLite-Kernlaufzeit benötigt auf einem Arm Cortex M3 nur 16 KB Speicher und kann einfache YOLO26-Modelle ausführen. Dadurch eignet sie sich für die Bereitstellung auf Geräten mit sehr begrenzter Rechenleistung und Speicherkapazität.

    Besuche zum Einstieg den TFLite-Micro-Leitfaden für Mikrocontroller.

  • TensorFlow Lite bietet umfassende Plattformkompatibilität und ermöglicht die Bereitstellung von YOLO26-Modellen auf einer großen Bandbreite von Geräten, darunter:

    • Android und iOS: Native Unterstützung durch TFLite-Bibliotheken für Android und iOS.
    • Eingebettetes Linux: Ideal für Einplatinencomputer wie Raspberry Pi.
    • Mikrocontroller: Geeignet für MCUs mit begrenzten Ressourcen.

    Weitere Informationen zu den Bereitstellungsoptionen findest du in unserem ausführlichen Bereitstellungsleitfaden.

  • Wenn beim Export von YOLO26-Modellen nach LiteRT Fehler auftreten, gehören zu den häufigen Lösungen:

    • Paketkompatibilität prüfen: Stelle sicher, dass du kompatible Versionen von Ultralytics, litert-torch und ai-edge-litert verwendest. Sieh in unserem Installationsleitfaden nach.
    • Modellunterstützung: Überprüfe, ob das jeweilige YOLO26-Modell den LiteRT-Export unterstützt, indem du die Export-Dokumentationsseite von Ultralytics aufrufst.
    • Probleme bei der Quantisierung: Achte bei der INT8-Quantisierung darauf, dass der Pfad zu deinem Dataset im Parameter data korrekt angegeben ist.

    Weitere Tipps zur Fehlerbehebung findest du in unserem Leitfaden Häufige Probleme.

Kommentare