YOLO Vision 2026:

Export in das TF.js-Modellformat aus einem YOLO26-Modellformat#

Veraltet – ersetzt durch LiteRT

Seit Ultralytics 8.4.83 wurde das tfjs-Exportformat (TensorFlow.js) entfernt und durch das einheitliche Google LiteRT-Format ersetzt. LiteRT läuft im Browser über LiteRT.js (mit WebGPU-Beschleunigung) und deckt damit die von TF.js abgedeckten Anwendungsfälle im Browser und in Node.js sowie Mobilgeräte, eingebettete Systeme und Edge-Geräte über ein einziges .tflite-Modell ab.

format="tfjs" funktioniert weiterhin, gibt jedoch eine Veraltungswarnung aus und exportiert stattdessen ein LiteRT-Modell. Verwende in Zukunft format="litert"; aktuelle Exportanweisungen und den Bereitstellungspfad für den Browser findest du im LiteRT-Exportleitfaden.

Die Bereitstellung von Modellen für maschinelles Lernen direkt im Browser oder unter Node.js kann knifflig sein. Du musst sicherstellen, dass dein Modellformat für eine höhere Leistung optimiert ist, damit das Modell verwendet werden kann, um interaktive Anwendungen lokal auf dem Gerät des Benutzers auszuführen. Das Modellformat TensorFlow.js, kurz TF.js, ist so konzipiert, dass es minimalen Stromverbrauch bei gleichzeitig schneller Leistung bietet.

Mit der Funktion zum Exportieren in das TF.js-Modellformat kannst du deine Ultralytics YOLO26-Modelle für die Hochgeschwindigkeits- und lokal ausgeführte Objekterkennungsinferenz optimieren. In diesem Leitfaden führen wir dich durch die Konvertierung deiner Modelle in das TF.js-Format, sodass deine Modelle in verschiedenen lokalen Browsern und Node.js-Anwendungen eine gute Leistung erbringen.

Warum solltest du in TF.js exportieren?#

Das Exportieren deiner Machine-Learning-Modelle nach TensorFlow.js, das vom TensorFlow-Team als Teil des breiteren TensorFlow-Ökosystems entwickelt wurde, bietet zahlreiche Vorteile für die Bereitstellung von Machine-Learning-Anwendungen. Es trägt dazu bei, den Datenschutz und die Sicherheit der Benutzer zu erhöhen, indem sensible Daten auf dem Gerät verbleiben. Das Bild unten zeigt die Architektur von TensorFlow.js und wie Machine-Learning-Modelle konvertiert und sowohl in Webbrowsern als auch auf Node.js bereitgestellt werden.

TensorFlow.js browser ML inference architecture

Das lokale Ausführen von Modellen reduziert zudem die Latenz und sorgt für eine reaktionsschnellere Benutzererfahrung. TensorFlow.js bietet zudem Offline-Funktionen, sodass Benutzer deine Anwendung auch ohne Internetverbindung nutzen können. TF.js ist für die effiziente Ausführung komplexer Modelle auf ressourcenbeschränkten Geräten konzipiert, da es auf Skalierbarkeit und Unterstützung für GPU-Beschleunigung ausgelegt ist.

Hauptfunktionen von TF.js#

Hier sind die Hauptfunktionen, die TF.js zu einem leistungsstarken Werkzeug für Entwickler machen:

  • Plattformübergreifende Unterstützung: TensorFlow.js kann sowohl in Browser- als auch in Node.js-Umgebungen verwendet werden, was Flexibilität bei der Bereitstellung über verschiedene Plattformen hinweg bietet. Es ermöglicht Entwicklern, Anwendungen einfacher zu erstellen und bereitzustellen.

  • Unterstützung für mehrere Backends: TensorFlow.js unterstützt verschiedene Backends für Berechnungen, darunter CPU, WebGL für GPU-Beschleunigung, WebAssembly (WASM) für eine nahezu native Ausführungsgeschwindigkeit und WebGPU für fortschrittliche browserbasierte Machine-Learning-Funktionen.

  • Offline-Funktionen: Mit TensorFlow.js können Modelle im Browser ohne Internetverbindung ausgeführt werden, was es ermöglicht, Anwendungen zu entwickeln, die offline funktionsfähig sind.

Bereitstellungsoptionen mit TensorFlow.js#

Bevor wir uns mit dem Prozess des Exportierens von YOLO26-Modellen in das TF.js-Format befassen, schauen wir uns einige typische Bereitstellungsszenarien an, in denen dieses Format verwendet wird.

TF.js bietet eine Reihe von Optionen zur Bereitstellung deiner Machine-Learning-Modelle:

  • Browserbasierte ML-Anwendungen: Du kannst Webanwendungen erstellen, die Machine-Learning-Modelle direkt im Browser ausführen. Der Bedarf an serverseitigen Berechnungen wird eliminiert und die Serverlast reduziert.

  • Node.js-Anwendungen: TensorFlow.js unterstützt auch die Bereitstellung in Node.js-Umgebungen, was die Entwicklung von serverseitigen Machine-Learning-Anwendungen ermöglicht. Dies ist besonders nützlich für Anwendungen, die die Rechenleistung eines Servers oder den Zugriff auf serverseitige Daten erfordern.

  • Chrome-Erweiterungen: Ein interessantes Bereitstellungsszenario ist die Erstellung von Chrome-Erweiterungen mit TensorFlow.js. Du kannst beispielsweise eine Erweiterung entwickeln, die es Benutzern ermöglicht, mit der rechten Maustaste auf ein Bild auf einer beliebigen Webseite zu klicken, um es mithilfe eines vortrainierten ML-Modells zu klassifizieren. TensorFlow.js kann in alltägliche Web-Browsing-Erlebnisse integriert werden, um sofortige Erkenntnisse oder Erweiterungen auf der Grundlage von Machine Learning bereitzustellen.

Exportieren von YOLO26-Modellen nach TensorFlow.js#

Du kannst die Modellkompatibilität und Bereitstellungsflexibilität erweitern, indem du YOLO26-Modelle in TF.js konvertierst.

Installation#

Um das erforderliche Paket zu installieren, führe Folgendes aus:

Installation
# Install the required package for YOLO26
pip install ultralytics

Detaillierte Anweisungen und bewährte Methoden zum Installationsprozess findest du in unserer Ultralytics-Installationsanleitung. Wenn während der Installation der erforderlichen Pakete für YOLO26 Schwierigkeiten auftreten, findest du in unserem Leitfaden zu häufigen Problemen Lösungen und Tipps.

Verwendung#

Alle Ultralytics YOLO26 models sind so konzipiert, dass sie den Export von Haus aus unterstützen, sodass du sie mühelos in deinen bevorzugten Bereitstellungsworkflow integrieren kannst. Du kannst the full list of supported export formats and configuration options einsehen, um das beste Setup für deine Anwendung auszuwählen.

Das Argument tfjs exportiert nun ein LiteRT .tflite-Modell, das die Modi Exportieren, Vorhersagen und Validieren lokal unterstützt und über LiteRT.js im Browser ausgeführt wird. Im LiteRT-Exportleitfaden findest du den aktuellen Bereitstellungspfad für Browser und Geräte.

Exportieren
from ultralytics import YOLO

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

# Export the model to TF.js format
model.export(format="litert", imgsz=640)  # use imgsz=224 for classification
Predict und Validate

Das exportierte LiteRT .tflite-Modell lädt direkt mit yolo predict und yolo val und wird über LiteRT.js im Browser ausgeführt. Siehe den LiteRT-Exportleitfaden.

Export-Argumente#

ArgumentTypStandardBeschreibung
formatstr'tfjs'Zielformat für das exportierte Modell, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen definiert.
imgszint oder tuple640Gewünschte Bildgröße für die Modelleingabe. Kann eine Ganzzahl für quadratische Bilder oder ein Tupel (height, width) für bestimmte Abmessungen sein.
quantizeint oder strNoneQuantisierungspräzision: 8 (statisch INT8, int8-Gewichte + int8-Aktivierungen; benötigt Kalibrierung data/fraction), 'w8a16' (statisch, int8-Gewichte + int16-Aktivierungen; benötigt Kalibrierung data/fraction), 'w8a32' (dynamisch 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 half/int8-Flags.
batchint1Legt die Batch-Inferenzgröße des exportierten Modells fest oder die maximale Anzahl an Bildern, die das exportierte Modell im Modus predict gleichzeitig verarbeitet.
datastrNonePfad zum Dataset-YAML, wichtig für die Quantisierung; die Klassifizierung erfordert stattdessen ein Dataset-Verzeichnis oder einen integrierten Dataset-Namen. Wenn dies bei quantize=8 oder 'w8a16' weggelassen wird, wählt Ultralytics das Standard-Kalibrierungs-Dataset für die Modellaufgabe aus.
fractionfloat, int oder list1.0Kalibrierungs-Teilmenge als Verhältnis, Bildanzahl oder [train, val]-Verhältnisse/-Anzahlen; eine Liste schränkt train oder val ein, während test vollständig bleibt.
devicestrNoneGibt das Gerät für den Export an: CPU (device=cpu), MPS für Apple Silicon (device=mps).

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

Bereitstellung exportierter YOLO26 TensorFlow.js-Modelle#

Jetzt, da du dein YOLO26-Modell exportiert hast, besteht der nächste Schritt in seiner Bereitstellung. Der Export erzeugt ein LiteRT .tflite-Modell, das auf dem Gerät und im Browser über LiteRT.js läuft – im LiteRT-Exportleitfaden findest du den aktuellen Pfad.

Als Referenz sind hier die Ressourcen für die ältere TensorFlow.js-Laufzeitumgebung:

Zusammenfassung#

In dieser Anleitung haben wir gelernt, wie man Ultralytics YOLO26-Modelle in das TensorFlow.js-Format exportiert. Durch den Export nach TF.js gewinnst du die Flexibilität, deine YOLO26-Modelle auf einer Vielzahl von Plattformen zu optimieren, bereitzustellen und zu skalieren.

Weitere Details zur Verwendung findest du in der offiziellen Dokumentation zu TensorFlow.js.

Weitere Informationen zur Integration von Ultralytics YOLO26 mit anderen Plattformen und Frameworks findest du in unserem integration guide page. Die Seite ist vollgepackt mit großartigen Ressourcen, die dir helfen, das Beste aus YOLO26 in deinen Projekten herauszuholen.

FAQ#

  • Das Exportieren von Ultralytics YOLO26-Modellen in das TensorFlow.js (TF.js)-Format ist unkompliziert. Du kannst diese Schritte befolgen:

    Verwendung
    from ultralytics import YOLO

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

# Export the model to TF.js format
model.export(format="litert", imgsz=640)  # use imgsz=224 for classification

# The exported '.tflite' model runs in the browser via LiteRT.js or locally with yolo predict/val.

    Weitere Details zu unterstützten Exportoptionen findest du auf der Ultralytics-Dokumentationsseite zu Bereitstellungsoptionen.

  • Das Exportieren von YOLO26-Modellen nach TensorFlow.js bietet mehrere Vorteile, darunter:

    1. Lokale Ausführung: Modelle können direkt im Browser oder in Node.js ausgeführt werden, was die Latenz reduziert und das Benutzererlebnis verbessert.
    2. Plattformübergreifende Unterstützung: TF.js unterstützt mehrere Umgebungen, was Flexibilität bei der Bereitstellung ermöglicht.
    3. Offline-Funktionen: Ermöglicht Anwendungen, ohne Internetverbindung zu funktionieren, was Zuverlässigkeit und Privatsphäre gewährleistet.
    4. GPU-Beschleunigung: Nutzt WebGL für die GPU-Beschleunigung und optimiert die Leistung auf Geräten mit begrenzten Ressourcen.

  • TensorFlow.js ist speziell für die effiziente Ausführung von ML-Modellen in Browsern und Node.js-Umgebungen konzipiert. So profitieren browserbasierte Anwendungen davon:

    • Reduziert die Latenz: Führt Machine-Learning-Modelle lokal aus und liefert sofortige Ergebnisse, ohne auf serverseitige Berechnungen angewiesen zu sein.
    • Verbessert die Privatsphäre: Bewahrt sensible Daten auf dem Gerät des Benutzers und minimiert Sicherheitsrisiken.
    • Ermöglicht Offline-Nutzung: Modelle können ohne Internetverbindung betrieben werden, was eine konsistente Funktionalität sicherstellt.
    • Unterstützt mehrere Backends: Bietet Flexibilität mit Backends wie CPU, WebGL, WebAssembly (WASM) und WebGPU für unterschiedliche Rechenanforderungen.

    Möchtest du mehr über TF.js erfahren? Sieh dir den offiziellen TF.js-Leitfaden an.

  • Zu den Hauptfunktionen von TensorFlow.js gehören:

    • Plattformübergreifende Unterstützung: TF.js kann sowohl in Webbrowsern als auch in Node.js verwendet werden, was eine umfassende Flexibilität bei der Bereitstellung bietet.
    • Mehrere Backends: Unterstützt CPU, WebGL für GPU-Beschleunigung, WebAssembly (WASM) und WebGPU für fortgeschrittene Operationen.
    • Offline-Funktionen: Modelle können direkt im Browser ohne Internetverbindung ausgeführt werden, was es ideal für die Entwicklung reaktionsschneller Webanwendungen macht.

    Informationen zu Bereitstellungsszenarien und detailliertere Einblicke findest du in unserem Abschnitt zu Bereitstellungsoptionen mit TensorFlow.js.

  • Ja, TensorFlow.js ermöglicht die Bereitstellung von YOLO26-Modellen in Node.js-Umgebungen. Dies ermöglicht serverseitige Machine-Learning-Anwendungen, die von der Rechenleistung eines Servers und dem Zugriff auf serverseitige Daten profitieren. Typische Anwendungsfälle sind Echtzeit-Datenverarbeitung und Machine-Learning-Pipelines auf Backend-Servern.

    Um mit der Node.js-Bereitstellung zu beginnen, beziehe dich auf den Leitfaden TensorFlow.js in Node.js ausführen von TensorFlow.

Mitwirkende
GLglenn-jocher20LAlakshanthad4RAraimbekovm3FCfcakyon1AMambitious-octopus1ONonuralpszr1PDpderrenger1MAMatthewNoyce1RIRizwanMunawar1ABabirami-vina1

Kommentare