Link to this sectionEin Leitfaden zum Exportieren von YOLO26-Modellen nach TFLite für die Bereitstellung#

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

Das TensorFlow Lite- oder TFLite-Exportformat ermöglicht es dir, deine Ultralytics YOLO26-Modelle für Aufgaben wie Objekterkennung und Bildklassifizierung in Anwendungen auf Edge-Geräten zu optimieren. In diesem Leitfaden führen wir dich durch die Schritte zur Konvertierung deiner Modelle in das TFLite-Format, damit sie auf verschiedenen Edge-Geräten effizienter funktionieren.

Link to this sectionWarum solltest du nach TFLite exportieren?#

Das im Mai 2017 von Google als Teil ihres TensorFlow-Frameworks eingeführte TensorFlow Lite, kurz TFLite, ist ein Open-Source-Deep-Learning-Framework für On-Device-Inferenz, auch bekannt als Edge Computing. Es bietet Entwicklern die notwendigen Werkzeuge, um ihre trainierten Modelle auf Mobil-, Embedded- und IoT-Geräten sowie auf herkömmlichen Computern auszuführen.

TensorFlow Lite ist mit einer Vielzahl von Plattformen kompatibel, darunter eingebettetes Linux, Android, iOS und Mikrocontroller (MCUs). Durch den Export deines Modells nach TFLite werden deine Anwendungen schneller, zuverlässiger und können offline ausgeführt werden.

Link to this sectionHauptmerkmale von TFLite-Modellen#

TFLite-Modelle bieten eine breite Palette an Funktionen, die On-Device-Maschinelles Lernen ermöglichen, indem sie Entwicklern dabei helfen, ihre Modelle auf mobilen, eingebetteten 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 den Datenschutz, da keine persönlichen Daten übertragen werden, und minimiert die Modellgröße, um Speicherplatz zu sparen.

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

• Vielfältige Sprachunterstützung: TFLite ist mit verschiedenen Programmiersprachen kompatibel, darunter Java, Swift, Objective-C, C++ und Python.

• Hohe Leistung: Erreicht eine überragende Leistung durch Hardwarebeschleunigung und Modelloptimierung.

Link to this sectionBereitstellungsoptionen in TFLite#

Bevor wir uns den Code für den Export von YOLO26-Modellen in das TFLite-Format ansehen, wollen wir verstehen, wie TFLite-Modelle normalerweise verwendet werden.

TFLite bietet verschiedene Optionen zur On-Device-Bereitstellung für Machine-Learning-Modelle, darunter:

• Bereitstellung mit Android und iOS: Sowohl Android- als auch iOS-Anwendungen mit TFLite können Edge-basierte Kamerafeeds und Sensoren analysieren, um Objekte zu erkennen und zu identifizieren. TFLite bietet außerdem 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 eingebettetem Linux: Wenn die Ausführung von Inferenzen auf einem Raspberry Pi unter Verwendung des Ultralytics-Leitfadens nicht den Geschwindigkeitsanforderungen deines Anwendungsfalls entspricht, 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 gerade einmal in 16 KB auf einem Arm Cortex M3 und kann viele grundlegende Modelle ausführen. Es ist keine Unterstützung durch ein Betriebssystem, keine Standard-C- oder C++-Bibliothek und keine dynamische Speicherzuweisung erforderlich.

Link to this sectionExport nach TFLite: Konvertierung deines YOLO26-Modells#

Du kannst die Effizienz der Modellausführung auf dem Gerät verbessern und die Leistung optimieren, indem du deine Modelle in das TFLite-Format konvertierst.

Link to this sectionInstallation#

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

# Install the required package for YOLO26
pip install ultralytics

Detaillierte Anweisungen und bewährte Verfahren bezüglich des Installationsprozesses findest du in unserem Ultralytics-Installationsleitfaden. Falls du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stößt, konsultiere unseren Leitfaden für allgemeine Probleme für Lösungen und Tipps.

Link to this sectionVerwendung#

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

Das TFLite-Format unterstützt die Modi Exportieren, Vorhersagen und Validieren. Exportiere dein Modell und lade dann das exportierte Modell, um Inferenzen auszuführen oder dessen Genauigkeit zu validieren.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to TFLite format
model.export(format="tflite")  # creates 'yolo26n_float32.tflite'

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionExport-Argumente#

Für weitere Details zum Exportprozess besuche die Dokumentationsseite von Ultralytics zum Thema Exportieren.

Link to this sectionBereitstellung exportierter YOLO26 TFLite-Modelle#

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

• Android: Ein Schnelleinstiegs-Leitfaden für die Integration von TensorFlow Lite in Android-Anwendungen, der einfach zu befolgende Schritte für die Einrichtung und Ausführung von Machine Learning-Modellen 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-Anleitungen und Ressourcen bietet.

• End-To-End-Beispiele: Diese Seite bietet einen Überblick über verschiedene TensorFlow Lite-Beispiele und präsentiert praktische Anwendungen und Tutorials, die Entwicklern helfen sollen, TensorFlow Lite in ihren Machine-Learning-Projekten auf Mobil- und Edge-Geräten zu implementieren.

Link to this sectionZusammenfassung#

In diesem Leitfaden haben wir uns darauf konzentriert, wie der Export in das TFLite-Format funktioniert. Durch die Konvertierung deiner Ultralytics YOLO26-Modelle in das TFLite-Modellformat kannst du die Effizienz und Geschwindigkeit von YOLO26-Modellen verbessern und sie effektiver und geeigneter für Edge-Computing-Umgebungen machen.

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

Wenn du außerdem neugierig auf andere Ultralytics YOLO26-Integrationen bist, sieh dir unsere Integrations-Leitfadenseite an. Dort findest du viele hilfreiche Informationen und Einblicke.

Link to this sectionFAQ#

Link to this sectionWie exportiere ich ein YOLO26-Modell in das TFLite-Format?#

Um ein YOLO26-Modell in das TFLite-Format zu exportieren, kannst du die Ultralytics-Bibliothek verwenden. 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 TFLite format
model.export(format="tflite")  # creates 'yolo26n_float32.tflite'

Für CLI-Benutzer erreichst du dies mit:

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

Weitere Details findest du im Ultralytics-Exportleitfaden.

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

TensorFlow Lite (TFLite) ist ein Open-Source-Deep Learning-Framework, das für On-Device-Inferenz konzipiert ist 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 die Latenz und verbessere die Privatsphäre durch lokale Datenverarbeitung.
• Plattformkompatibilität: Unterstützt Android, iOS, eingebettetes 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 einem Raspberry Pi auszuführen?#

Ja, du kannst YOLO26 TFLite-Modelle auf einem Raspberry Pi ausführen, um die Inferenzgeschwindigkeiten zu verbessern. Exportiere zuerst dein Modell wie oben erklärt in das TFLite-Format. Verwende dann ein Tool 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 Leitfaden zur Bereitstellung auf dem Raspberry Pi und im Leitfaden zur Edge TPU-Integration.

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 geeignet für die Bereitstellung auf Geräten mit minimaler Rechenleistung und minimalem Speicher.

Um zu beginnen, 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, einschließlich:

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

Weitere Informationen zu Bereitstellungsoptionen findest du in unserem detaillierten Bereitstellungsleitfaden.

Link to this sectionWie behebe ich häufige Probleme während des YOLO26-Modellexports nach TFLite?#

Wenn du beim Exportieren von YOLO26-Modellen nach TFLite auf Fehler stößt, umfassen häufige Lösungen:

• Überprüfe die Paketkompatibilität: Stelle sicher, dass du kompatible Versionen von Ultralytics und TensorFlow verwendest. Siehe unseren Installationsleitfaden.
• Modellunterstützung: Überprüfe, ob das spezifische YOLO26-Modell den TFLite-Export unterstützt, indem du die Ultralytics-Export-Dokumentationsseite konsultierst.
• Quantisierungsprobleme: Wenn du die INT8-Quantisierung verwendest, stelle sicher, dass dein Datenpfad im data-Parameter korrekt angegeben ist.

Für weitere Tipps zur Fehlerbehebung besuche unseren Leitfaden zu häufigen Problemen.