Ein Leitfaden zum Export 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 Exportformat TensorFlow Lite bzw. TFLite 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 ausgeführt werden können.

Warum 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-Framework für Deep Learning, das für die Inferenz auf dem Gerät (On-Device Inference), auch bekannt als Edge Computing, entwickelt wurde. Es gibt Entwicklern die notwendigen Werkzeuge an die Hand, um ihre trainierten Modelle auf mobilen Geräten, eingebetteten Systemen, 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.

Hauptmerkmale von TFLite-Modellen

TFLite-Modelle bieten eine breite Palette an Funktionen, die maschinelles Lernen auf dem Gerät ermöglichen, indem sie Entwicklern 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 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 eine umfassende Plattformkompatibilität und unterstützt Android, iOS, eingebettetes Linux und Mikrocontroller.

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

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

Bereitstellungsoptionen in TFLite

Bevor wir uns den Code für den Export von YOLO26-Modellen in das TFLite-Format ansehen, sollten wir 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: Sowohl Android- als auch iOS-Anwendungen mit TFLite können Kamerabilder und Sensordaten am Edge analysieren, um Objekte zu erkennen und zu identifizieren. TFLite bietet zudem 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 mit dem Ultralytics-Leitfaden 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 den Einsatz 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 mit gerade einmal 16 KB auf einen 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.

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

Installation

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

# Install the required package for YOLO26
pip install ultralytics

Für detaillierte Anleitungen und Best Practices zur Installation, schau in unserem Ultralytics-Installationsleitfaden nach. Wenn 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.

Verwendung

Alle Ultralytics YOLO26-Modelle sind so konzipiert, dass sie den Export direkt unterstützen, was eine einfache Integration in deinen bevorzugten Bereitstellungs-Workflow ermöglicht. Du kannst die vollständige Liste der unterstützten Exportformate und Konfigurationsoptionen ansehen, um die beste Einrichtung für deine Anwendung zu wählen.

  from ultralytics import YOLO

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

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

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

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

Export-Argumente

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

Bereitstellung exportierter YOLO26 TFLite-Modelle

Nachdem du deine Ultralytics YOLO26-Modelle erfolgreich in das TFLite-Format exportiert hast, kannst du sie 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 Codebeispiel beschrieben. Für detaillierte Anweisungen zur Bereitstellung deiner TFLite-Modelle in anderen Umgebungen wirf einen Blick auf die folgenden Ressourcen:

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

• iOS: Schau 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 zeigt praktische Anwendungen und Tutorials, die Entwicklern helfen sollen, TensorFlow Lite in ihren Machine-Learning-Projekten auf mobilen Geräten und Edge-Systemen zu implementieren.

Zusammenfassung

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

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

Falls du dich außerdem für andere Ultralytics YOLO26-Integrationen interessierst, schau dir unsere Integrationsleitfaden-Seite an. Dort findest du viele hilfreiche Informationen und Einblicke.

FAQ

Wie 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 den folgenden Code-Schnipsel, um dein Modell zu exportieren:

from ultralytics import YOLO

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

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

Für CLI-Nutzer kannst du dies wie folgt erreichen:

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

Weitere Details findest du im Ultralytics-Export-Leitfaden.

Was 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 die Inferenz auf dem Gerät entwickelt wurde und sich ideal für die Bereitstellung von YOLO26-Modellen auf mobilen Geräten, eingebetteten Systemen und IoT-Geräten eignet. Die wichtigsten Vorteile sind:

• On-Device-Optimierung: Minimiere Latenz und verbessere den Datenschutz 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, sieh dir den TFLite-Leitfaden an.

Ist 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 Inferenzgeschwindigkeit zu verbessern. Exportiere zuerst dein Modell wie oben erklärt in das TFLite-Format. 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. Für detaillierte Schritte siehe unseren Raspberry Pi-Bereitstellungsleitfaden und den Edge TPU-Integrationsleitfaden.

Kann 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 die Bereitstellung auf Geräten mit minimaler Rechenleistung und geringem Speicher geeignet.

Für den Einstieg besuche den TFLite Micro für Mikrocontroller-Leitfaden.

Welche 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 den Bereitstellungsoptionen findest du in unserem detaillierten Bereitstellungsleitfaden.

Wie behebe ich häufige Probleme beim Export von YOLO26-Modellen nach TFLite?

Wenn beim Export von YOLO26-Modellen nach TFLite Fehler auftreten, umfassen die gängigen Lösungen:

• Überprüfe die Paketkompatibilität: Stelle sicher, dass du kompatible Versionen von Ultralytics und TensorFlow verwendest. Siehe dazu 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 INT8-Quantisierung verwendest, stelle sicher, dass dein Datenpfad im data-Parameter korrekt angegeben ist.

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