Ultralytics YOLO27:

In das TF.js-Modellformat aus einem YOLO26-Modellformat exportieren#

Veraltet – ersetzt durch LiteRT

Ab Ultralytics 8.4.83 wurde das Exportformat tfjs (TensorFlow.js) entfernt und durch das einheitliche Format Google LiteRT ersetzt. LiteRT läuft über LiteRT.js (mit WebGPU-Beschleunigung) im Browser und deckt damit die Anwendungsfälle im Browser und unter Node.js ab, die zuvor von TF.js unterstützt wurden, ebenso wie mobile, eingebettete und Edge-Szenarien – mit einem einzigen .tflite-Modell.

format="tfjs" funktioniert weiterhin, gibt jedoch eine Warnung zur Einstellung aus und exportiert stattdessen ein LiteRT-Modell. Verwende künftig format="litert"; aktuelle Anweisungen zum Export und zum Bereitstellungspfad im Browser findest du im LiteRT-Exportleitfaden.

Die direkte Bereitstellung von Machine-Learning-Modellen 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 interaktive Anwendungen lokal auf dem Gerät des Benutzers ausführen kann. Das TensorFlow.js- oder TF.js-Modellformat ist darauf ausgelegt, wenig Energie zu verbrauchen und gleichzeitig eine hohe Leistung zu liefern.

Mit der Funktion „In das TF.js-Modellformat exportieren“ kannst du deine Ultralytics YOLO26-Modelle für eine schnelle, lokal ausgeführte Objekterkennung-Inferenz optimieren. In diesem Leitfaden zeigen wir dir, wie du deine Modelle in das TF.js-Format konvertierst, damit sie in verschiedenen lokalen Browsern und Node.js-Anwendungen zuverlässig funktionieren.

Warum solltest du in TF.js exportieren?#

Der Export deiner Machine-Learning-Modelle nach TensorFlow.js, das vom TensorFlow-Team als Teil des umfassenderen TensorFlow-Ökosystems entwickelt wurde, bietet zahlreiche Vorteile für die Bereitstellung von Machine-Learning-Anwendungen. Er verbessert den Datenschutz und die Sicherheit der Benutzer, da vertrauliche Daten auf dem Gerät verbleiben. Die folgende Abbildung zeigt die TensorFlow.js-Architektur sowie die Konvertierung und Bereitstellung von Machine-Learning-Modellen in Webbrowsern und unter Node.js.

TensorFlow.js browser ML inference architecture

Die lokale Ausführung von Modellen reduziert außerdem die Latenz und sorgt für eine reaktionsschnellere Benutzererfahrung. TensorFlow.js bietet zudem Offline-Funktionen, sodass Benutzer deine Anwendung auch ohne Internetverbindung verwenden können. TF.js ist für die effiziente Ausführung komplexer Modelle auf Geräten mit begrenzten Ressourcen ausgelegt und unterstützt dank seiner skalierbaren Architektur die GPU-Beschleunigung.

Wichtige Funktionen von TF.js#

Die folgenden wichtigen Funktionen machen TF.js zu einem leistungsstarken Werkzeug für Entwickler:

  • Plattformübergreifende Unterstützung: TensorFlow.js kann sowohl in Browsern als auch in Node.js-Umgebungen verwendet werden und bietet dadurch Flexibilität bei der Bereitstellung auf verschiedenen Plattformen. Entwickler können damit Anwendungen einfacher erstellen und bereitstellen.

  • Unterstützung mehrerer Backends: TensorFlow.js unterstützt verschiedene Backends für Berechnungen, darunter CPU, WebGL für GPU-Beschleunigung, WebAssembly (WASM) für eine Ausführungsgeschwindigkeit nahe der nativen Geschwindigkeit sowie WebGPU für fortschrittliche browserbasierte Machine-Learning-Funktionen.

  • Offline-Funktionen: Mit TensorFlow.js können Modelle im Browser ohne Internetverbindung ausgeführt werden. Dadurch lassen sich Anwendungen entwickeln, die offline funktionieren.

Bereitstellungsoptionen mit TensorFlow.js#

Bevor wir uns mit dem Export von YOLO26-Modellen in das TF.js-Format beschäftigen, sehen wir uns einige typische Bereitstellungsszenarien an, in denen dieses Format verwendet wird.

TF.js bietet verschiedene Optionen für die Bereitstellung deiner Machine-Learning-Modelle:

  • Machine-Learning-Anwendungen im Browser: Du kannst Webanwendungen erstellen, die Machine-Learning-Modelle direkt im Browser ausführen. Dadurch entfällt die serverseitige Berechnung und die Serverlast wird reduziert.

  • Node.js-Anwendungen: TensorFlow.js unterstützt auch die Bereitstellung in Node.js-Umgebungen und ermöglicht so die Entwicklung serverseitiger Machine-Learning-Anwendungen. Das ist besonders nützlich für Anwendungen, die die Rechenleistung eines Servers oder Zugriff auf serverseitige Daten benötigen.

  • Chrome-Erweiterungen: Ein interessantes Bereitstellungsszenario ist die Erstellung von Chrome-Erweiterungen mit TensorFlow.js. Du kannst beispielsweise eine Erweiterung entwickeln, mit der Benutzer per Rechtsklick auf ein Bild auf einer beliebigen Webseite dieses mithilfe eines vortrainierten ML-Modells klassifizieren können. TensorFlow.js lässt sich in alltägliche Webbrowser-Erfahrungen integrieren, um auf Grundlage von Machine Learning sofortige Einblicke oder Erweiterungen bereitzustellen.

YOLO26-Modelle in TensorFlow.js exportieren#

Du kannst die Modellkompatibilität und die Flexibilität bei der Bereitstellung erweitern, indem du YOLO26-Modelle in TF.js konvertierst.

Installation#

Führe zur Installation des erforderlichen Pakets folgenden Befehl 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 Argument tfjs exportiert jetzt ein LiteRT-Modell .tflite, das lokal die Modi Export, Predict und Validate unterstützt und über LiteRT.js im Browser ausgeführt wird. Den aktuellen Bereitstellungspfad für Browser und Geräte findest du im LiteRT-Exportleitfaden.

Export
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-Modell .tflite wird direkt mit yolo predict und yolo val geladen und über LiteRT.js im Browser ausgeführt. Siehe den LiteRT-Exportleitfaden.

Exportargumente#

ArgumentTypStandardwertBeschreibung
formatstr'tfjs'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-TensorFlow.js-Modelle#

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

Zur Referenz findest du unten die Ressourcen der alten TensorFlow.js-Laufzeit:

Zusammenfassung#

In diesem Leitfaden haben wir gelernt, wie du Ultralytics YOLO26-Modelle in das TensorFlow.js-Format exportierst. Durch den Export nach TF.js erhältst du die Flexibilität, deine YOLO26-Modelle auf einer Vielzahl von Plattformen zu optimieren, bereitzustellen und zu skalieren.

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

Weitere Informationen zur Integration von Ultralytics YOLO26 in andere Plattformen und Frameworks findest du auf unserer Seite mit Integrationsleitfäden. Dort findest du zahlreiche hilfreiche Ressourcen, mit denen du YOLO26 optimal in deinen Projekten einsetzen kannst.

FAQ#

  • Der Export von Ultralytics YOLO26-Modellen in das TensorFlow.js- (TF.js-)Format ist unkompliziert. Du kannst die folgenden Schritte ausführen:

    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 Informationen zu den unterstützten Exportoptionen findest du auf der Ultralytics-Dokumentationsseite zu Bereitstellungsoptionen.

  • Der Export von YOLO26-Modellen nach TensorFlow.js bietet mehrere Vorteile, darunter:

    1. Lokale Ausführung: Modelle können direkt im Browser oder unter Node.js ausgeführt werden, wodurch die Latenz reduziert und die Benutzererfahrung verbessert wird.
    2. Plattformübergreifende Unterstützung: TF.js unterstützt mehrere Umgebungen und bietet dadurch Flexibilität bei der Bereitstellung.
    3. Offline-Funktionen: Anwendungen können ohne Internetverbindung funktionieren, was Zuverlässigkeit und Datenschutz gewährleistet.
    4. GPU-Beschleunigung: WebGL wird für die GPU-Beschleunigung genutzt, wodurch die Leistung auf Geräten mit begrenzten Ressourcen optimiert wird.

  • TensorFlow.js wurde speziell für die effiziente Ausführung von ML-Modellen in Browsern und Node.js-Umgebungen entwickelt. Browserbasierte Anwendungen profitieren davon wie folgt:

    • Reduziert die Latenz: Machine-Learning-Modelle werden lokal ausgeführt und liefern sofortige Ergebnisse, ohne auf serverseitige Berechnungen angewiesen zu sein.
    • Verbessert den Datenschutz: Vertrauliche Daten verbleiben auf dem Gerät des Benutzers, wodurch Sicherheitsrisiken minimiert werden.
    • Ermöglicht die Offline-Nutzung: Modelle können ohne Internetverbindung ausgeführt werden und gewährleisten so eine konsistente Funktionalität.
    • Unterstützt mehrere Backends: Bietet mit Backends wie CPU, WebGL, WebAssembly (WASM) und WebGPU Flexibilität für unterschiedliche Rechenanforderungen.

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

  • Zu den wichtigsten Funktionen von TensorFlow.js gehören:

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

    Szenarien für die Bereitstellung und ausführlichere Informationen findest du in unserem Abschnitt zu Bereitstellungsoptionen mit TensorFlow.js.

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

    Für den Einstieg in die Bereitstellung unter Node.js findest du im TensorFlow-Leitfaden TensorFlow.js in Node.js ausführen weitere Informationen.

Mitwirkende
GLglenn-jocher20LAlakshanthad4RAraimbekovm3FCfcakyon2AMambitious-octopus1ONonuralpszr1PDpderrenger1MAMatthewNoyce1RIRizwanMunawar1ABabirami-vina1

Kommentare