TensorFlow.js: Python-Gerät in das TensorFlow.js-Format konvertieren

1. Einführung

Sie haben also erste Schritte mit TensorFlow.js gemacht, unsere vorgefertigten Modelle getestet oder vielleicht sogar Ihre eigenen erstellt. Python hat Ihnen jedoch bahnbrechende Forschungen aufgezeigt und Sie sind neugierig, ob die Idee im Webbrowser ausgeführt wird, um diese coole Idee für Millionen von Menschen skalierbar umzusetzen. Kommt dir das bekannt vor? Wenn ja, ist dies das Codelab für Sie!

Das TensorFlow.js-Team hat ein praktisches Tool entwickelt, mit dem sich Modelle im SavedModel-Format über einen Befehlszeilenkonverter in TensorFlow.js umwandeln lassen. So können Sie diese Modelle mit der Reichweite und Skalierung des Webs verwenden.

Aufgaben in diesem Lab

In diesem Code-Lab erfahren Sie, wie Sie mit dem TensorFlow.js-Befehlszeilenkonverter ein mit Python generiertes SavedModel in das Modell.json-Format portieren, das für die clientseitige Ausführung in einem Webbrowser erforderlich ist.

Im Detail:

  • Hier erfahren Sie, wie Sie ein einfaches Python ML-Modell erstellen und in dem Format speichern, das für den TensorFlow.js-Konverter erforderlich ist.
  • TensorFlow.js-Konverter auf dem aus Python exportierten SavedModel installieren und verwenden
  • Nehmen Sie die aus der Konvertierung resultierenden Dateien und verwenden Sie sie in Ihrer JS-Webanwendung.
  • Informieren Sie sich, was zu tun ist, wenn etwas schiefgeht (nicht alle Modelle werden konvertiert) und welche Optionen Ihnen zur Verfügung stehen.

Stellen Sie sich vor, Sie könnten kürzlich veröffentlichte Forschungen durchführen und dieses Modell Millionen von JS-Entwicklern weltweit zur Verfügung stellen. Oder vielleicht verwenden Sie diese Funktion selbst bei Ihrer eigenen Kreation, die jeder auf der Welt erleben kann, wenn der Browser im Webbrowser ausgeführt wird, da keine komplexen Abhängigkeiten oder Umgebungseinrichtung erforderlich sind. Bereit zum Hacken? Los gehts!

Sagen Sie uns, was Sie konvertieren.

Sie können das, was wir heute gelernt haben, verwenden, um einige Ihrer bevorzugten Modelle aus Python zu konvertieren. Wenn es Ihnen gelingt und Sie eine funktionierende Demo-Website des Modells in Aktion haben, taggen Sie uns in den sozialen Medien mit dem Hashtag #MadeWithTFJS. So haben Sie die Chance, dass Ihr Projekt in unserem TensorFlow-Blog oder sogar zukünftigen Show-and-Tell-Veranstaltungen vorgestellt wird. Wir würden uns freuen, wenn noch mehr Forschungsergebnisse ins Web gebracht würden und mehr Menschen die Möglichkeit haben, solche Modelle auf innovative und kreative Weise zu nutzen, wie in diesem Beispiel gezeigt.

2. Was ist TensorFlow.js?

1aee0ede85885520.png

TensorFlow.js ist eine Open-Source-Bibliothek für maschinelles Lernen, die überall JavaScript ausgeführt werden kann. Es basiert auf der ursprünglichen TensorFlow-Bibliothek, die in Python geschrieben wurde, und zielt darauf ab, diese Entwicklerumgebung und eine Reihe von APIs für die JavaScript-Umgebung nachzubilden.

Wo kann sie verwendet werden?

Aufgrund der Übertragbarkeit von JavaScript können Sie jetzt problemlos in nur einer Sprache schreiben und maschinelles Lernen ganz einfach auf allen folgenden Plattformen ausführen:

  • Clientseite im Webbrowser mit einfachem JavaScript
  • Serverseitige und sogar IoT-Geräte wie Raspberry Pi mit Node.js
  • Desktop-Apps mit Electron
  • Native mobile Apps, in denen React Native verwendet wird

TensorFlow.js unterstützt außerdem mehrere Back-Ends in jeder dieser Umgebungen (die tatsächlichen hardwarebasierten Umgebungen, in denen es ausgeführt werden kann, z. B. die CPU oder WebGL). Ein „Back-End“ bedeutet in diesem Zusammenhang keine serverseitige Umgebung. Das Back-End für die Ausführung könnte beispielsweise clientseitig in WebGL ausgeführt werden, um die Kompatibilität sicherzustellen und gleichzeitig eine schnelle Ausführung zu gewährleisten. Derzeit unterstützt TensorFlow.js:

  • WebGL-Ausführung auf der Grafikkarte (GPU) des Geräts: Dies ist die schnellste Möglichkeit, größere Modelle (über 3 MB) mit GPU-Beschleunigung auszuführen.
  • Web Assembly-Ausführung (WASM) auf der CPU – zur Verbesserung der CPU-Leistung auf verschiedenen Geräten, z. B. auf Smartphones älterer Generationen. Diese Methode eignet sich besser für kleinere Modelle (kleiner als 3 MB), die auf der CPU mit WASM schneller ausgeführt werden können als mit WebGL, da Inhalte auf einen Grafikprozessor hochgeladen werden müssen.
  • CPU-Ausführung: Das Fallback sollte keine der anderen Umgebungen verfügbar sein. Das ist zwar die langsamste Methode, ist aber immer für dich da.

Hinweis:Sie können eines dieser Back-Ends erzwingen, wenn Sie wissen, auf welchem Gerät die Ausführung erfolgen soll, oder einfach TensorFlow.js die Entscheidung überlassen, wenn Sie dies nicht angeben.

Clientseitige Funktionen

Die Ausführung von TensorFlow.js im Webbrowser auf dem Clientcomputer kann mehrere Vorteile bieten, die in Betracht gezogen werden sollten.

Datenschutz

Sie können Daten auf dem Clientcomputer trainieren und klassifizieren, ohne Daten an einen Drittanbieter-Webserver senden zu müssen. In bestimmten Fällen kann dies erforderlich sein, um lokale Gesetze wie die DSGVO einzuhalten oder wenn Daten verarbeitet werden, die der Nutzer auf seinem Computer behalten und nicht an Dritte senden möchte.

Geschwindigkeit

Da keine Daten an einen Remote-Server gesendet werden müssen, kann die Inferenz (die Klassifizierung der Daten) schneller erfolgen. Noch besser: Sie haben direkten Zugriff auf die Sensoren des Geräts, wie Kamera, Mikrofon, GPS, Beschleunigungsmesser und mehr, wenn der Nutzer Ihnen Zugriff gewährt.

Reichweite und Skalierung

Mit nur einem Klick kann jeder auf der Welt auf einen Link klicken, den Sie ihm senden, die Webseite in einem Browser öffnen und Ihre Arbeit nutzen. Eine komplexe serverseitige Linux-Einrichtung mit CUDA-Treibern entfällt und vieles mehr, nur um das ML-System zu verwenden.

Kosten

Da es keine Server gibt, müssen Sie nur für ein CDN bezahlen, das Ihre HTML-, CSS-, JS- und Modelldateien hostet. Die Kosten für ein CDN sind wesentlich günstiger als den Betrieb eines Servers (ggf. mit angeschlossener Grafikkarte) rund um die Uhr.

Serverseitige Funktionen

Durch die Nutzung der Node.js-Implementierung von TensorFlow.js werden die folgenden Funktionen aktiviert.

Vollständiger CUDA-Support

Auf der Serverseite müssen Sie für die Grafikkartenbeschleunigung die NVIDIA CUDA-Treiber installieren, damit TensorFlow mit der Grafikkarte funktioniert. Im Gegensatz zum Browser, der WebGL verwendet, ist keine Installation erforderlich. Mit vollständiger CUDA-Unterstützung können Sie jedoch die niedrigeren Fähigkeiten der Grafikkarte voll nutzen, was zu kürzeren Trainings- und Inferenzzeiten führt. Die Leistung entspricht der Python-Implementierung von TensorFlow, da beide dasselbe C++-Backend nutzen.

Modellgröße

Bei hochmodernen Modellen aus der Forschung arbeiten Sie möglicherweise mit sehr großen Modellen, die vielleicht Gigabyte groß sind. Diese Modelle können derzeit aufgrund der Einschränkungen der Arbeitsspeichernutzung pro Browsertab nicht im Webbrowser ausgeführt werden. Wenn Sie diese größeren Modelle ausführen möchten, können Sie Node.js auf Ihrem eigenen Server mit den Hardwarespezifikationen verwenden, die für eine effiziente Ausführung eines solchen Modells erforderlich sind.

IOT

Node.js wird auf gängigen Einplatinencomputern wie Raspberry Pi unterstützt, was wiederum bedeutet, dass Sie TensorFlow.js-Modelle auch auf diesen Geräten ausführen können.

Geschwindigkeit

Node.js ist in JavaScript geschrieben und profitiert daher von einer Just-in-Time-Kompilierung. Das bedeutet, dass Sie bei der Verwendung von Node.js häufig eine Leistungssteigerung erzielen, da das Programm während der Laufzeit optimiert wird, insbesondere für die Vorverarbeitung. Ein gutes Beispiel hierfür ist diese Fallstudie, die zeigt, wie Hugging Face mit Node.js die Leistung seines Natural Language Processing-Modells verdoppeln konnte.

Sie kennen jetzt die Grundlagen von TensorFlow.js, wissen, wo es ausgeführt werden kann und welche Vorteile es bietet. Lassen Sie uns nun anfangen, nützliche Dinge damit zu beginnen.

3. System einrichten

In dieser Anleitung verwenden wir Ubuntu, eine beliebte Linux-Distribution, die von vielen Menschen verwendet wird und in der Compute Engine von Google Cloud als Basis-Image verfügbar ist, wenn Sie sich für eine cloudbasierte virtuelle Maschine entscheiden.

Zum Zeitpunkt der Erstellung dieses Artikels können wir das Image von Ubuntu 18.04.4 LTS auswählen, wenn wir eine neue einfache Compute Engine-Instanz erstellen, die wir verwenden werden. Sie können natürlich Ihren eigenen Computer verwenden oder auch ein anderes Betriebssystem verwenden. Die Installationsanleitung und die Abhängigkeiten können jedoch von System zu System unterschiedlich sein.

TensorFlow (Python-Version) installieren

Da Sie wahrscheinlich versuchen, ein vorhandenes auf Python basierendes Modell zu konvertieren, das Sie gefunden haben oder schreiben werden, bevor wir ein „SavedModel“ exportieren können aus Python hochladen, müssen Sie die Python-Version von TensorFlow auf Ihrer Instanz einrichten, wenn das steht noch nicht zum Download zur Verfügung.

Stellen Sie eine SSH-Verbindung zu Ihrem Cloud-Computer her, den Sie oben erstellt haben, und geben Sie dann Folgendes in das Terminalfenster ein:

Terminalfenster:

sudo apt update
sudo apt-get install python3

Dadurch wird sichergestellt, dass Python 3 auf dem Computer installiert ist. Zur Verwendung von TensorFlow muss Python 3.4 oder höher installiert sein.

Geben Sie Folgendes ein, um zu prüfen, ob die richtige Version installiert ist:

Terminalfenster:

python3 --version

Sie sollten eine Ausgabe mit der Versionsnummer sehen, z. B. Python 3.6.9. Wenn die Meldung korrekt angezeigt wird und der Wert höher als 3,4 ist, können wir fortfahren.

Als Nächstes installieren wir PIP für Python 3, den Paketmanager von Python, und aktualisieren es dann. Typ:

Terminalfenster:

sudo apt install python3-pip
pip3 install --upgrade pip

Auch hier können wir die Installation von pip3 überprüfen:

Terminalfenster:

pip3 --version

Beim Schreiben wird pip 20.2.3 angezeigt, nachdem dieser Befehl ausgeführt wurde.

Bevor wir TensorFlow installieren können, ist das Python-Paket „setuptools“ erforderlich. Version 41.0.0 oder höher sein. Führen Sie den folgenden Befehl aus, damit er auf die neueste Version aktualisiert wird:

Terminalfenster:

pip3 install -U setuptools

Abschließend können wir TensorFlow für Python installieren:

Terminalfenster:

pip3 install tensorflow

Dies kann einige Zeit dauern. Warten Sie daher bitte, bis die Ausführung abgeschlossen ist.

Überprüfen wir, ob TensorFlow korrekt installiert ist. Erstellen Sie in Ihrem aktuellen Verzeichnis eine Python-Datei mit dem Namen test.py:

Terminalfenster:

nano test.py

Sobald Nano geöffnet ist, können Sie Python-Code schreiben, um die installierte TensorFlow-Version auszugeben:

test.py:

import tensorflow as tf
print(tf.__version__)

Drücken Sie CTRL + O, um Änderungen auf das Laufwerk zu schreiben, und dann CTRL + X, um den Nano-Editor zu beenden.

Jetzt können wir diese Python-Datei ausführen, um zu sehen, wie die TensorFlow-Version auf dem Bildschirm ausgegeben wird:

Terminalfenster:

python3 test.py

Beim Schreiben dieses Dokuments wird 2.3.1 an die Konsole ausgegeben, damit unsere Version von TensorFlow Python installiert ist.

4. Python-Modell erstellen

Im nächsten Schritt dieses Codelabs wird beschrieben, wie Sie ein einfaches Python-Modell erstellen, um zu zeigen, wie Sie das resultierende trainierte Modell im „SavedModel“ speichern. Format, das dann mit unserem TensorFlow.js-Befehlszeilenkonverter verwendet wird. Das Prinzip wäre für jedes Python-Modell, das Sie konvertieren wollten, ähnlich, aber wir werden diesen Code einfach halten, damit alle ihn verstehen können.

Lassen Sie uns nun die im ersten Abschnitt erstellte Datei test.py bearbeiten und den Code wie folgt aktualisieren:

test.py:

import tensorflow as tf
print(tf.__version__)

# Import NumPy - package for working with arrays in Python.
import numpy as np

# Import useful keras functions - this is similar to the
# TensorFlow.js Layers API functionality.
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

# Create a new dense layer with 1 unit, and input shape of [1].
layer0 = Dense(units=1, input_shape=[1])
model = Sequential([layer0])

# Compile the model using stochastic gradient descent as optimiser
# and the mean squared error loss function.
model.compile(optimizer='sgd', loss='mean_absolute_error')

# Provide some training data! Here we are using some fictional data 
# for house square footage and house price (which is simply 1000x the 
# square footage) which our model must learn for itself.
xs = np.array([800.0, 850.0, 900.0, 950.0, 980.0, 1000.0, 1050.0, 1075.0, 1100.0, 1150.0, 1200.0, 1250.0, 1300.0, 1400.0, 1500.0, 1600.0, 1700.0, 1800.0, 1900.0, 2000.0], dtype=float)

ys = np.array([800000.0, 850000.0, 900000.0, 950000.0, 980000.0, 1000000.0, 1050000.0, 1075000.0, 1100000.0, 1150000.0, 1200000.0,  1250000.0, 1300000.0, 1400000.0, 1500000.0, 1600000.0, 1700000.0, 1800000.0, 1900000.0, 2000000.0], dtype=float)

# Train the model for 500 epochs.
model.fit(xs, ys, epochs=500, verbose=0)

# Test the trained model on a test input value
print(model.predict([1200.0]))

# Save the model we just trained to the "SavedModel" format to the
# same directory our test.py file is located.
tf.saved_model.save(model, './')

Mit diesem Code wird eine sehr einfache lineare Regression trainiert, um zu lernen, die Beziehung zwischen den x-Werten (Eingaben) und den y-Werten (Ausgaben) zu schätzen. Das resultierende trainierte Modell wird dann auf dem Laufwerk gespeichert. In den Inline-Kommentaren finden Sie weitere Informationen zur Funktion der einzelnen Zeilen.

Wenn wir das Verzeichnis überprüfen, nachdem wir dieses Programm ausgeführt haben (durch Aufrufen von python3 test.py), sollten wir jetzt einige neue Dateien und Ordner sehen, die in unserem aktuellen Verzeichnis erstellt wurden:

  • test.py
  • saved_model.pb
  • Assets
  • variables

Wir haben nun die Dateien generiert, die vom TensorFlow.js-Konverter verwendet werden müssen, um dieses Modell zu konvertieren und im Browser auszuführen.

5. SavedModel in TensorFlow.js-Format konvertieren

TensorFlow.js-Converter installieren

Führen Sie den folgenden Befehl aus, um den Converter zu installieren:

Terminalfenster:

pip3 install tensorflowjs

Das war einfach.

Wenn wir den Befehlszeilenkonverter (tensorflowjs_converter) und nicht die oben gezeigte Assistentenversion verwenden, können wir den folgenden Befehl aufrufen, um das soeben erstellte gespeicherte Modell zu konvertieren und die Parameter explizit an den Converter zu übergeben:

Terminalfenster:

tensorflowjs_converter \
    --input_format=keras_saved_model \
    ./ \
    ./predict_houses_tfjs

Was ist hier los? Zuerst rufen wir die Binärdatei "tensorflowjs_converter" auf, die wir gerade installiert haben, und geben an, dass wir versuchen, ein gespeichertes Keras-Modell zu konvertieren.

In unserem Beispielcode oben sehen Sie, dass wir Keras importiert und die APIs auf höheren Ebenen zum Erstellen unseres Modells verwendet haben. Wenn Sie in Ihrem Python-Code nicht keras verwendet haben, sollten Sie ein anderes Eingabeformat verwenden:

  • keras – zum Laden des Keras-Formats (HDF5-Dateityp)
  • tf_saved_model – zum Laden eines Modells, das Tensorflow Core APIs anstelle von Keras verwendet.
  • tf_frozen_model – zum Laden eines Modells, das eingefrorene Gewichte enthält.
  • tf_hub – zum Laden eines aus TensorFlow-Hub generierten Modells

Weitere Informationen zu diesen anderen Formaten

Die nächsten beiden Parameter geben an, in welchem Ordner sich das gespeicherte Modell befindet. In unserer Demo geben wir das aktuelle Verzeichnis an und zum Schluss geben wir an, in welches Verzeichnis die Konvertierung ausgegeben werden soll. Oben geben wir einen Ordner namens „predict_houses_tfjs“ an. im aktuellen Verzeichnis.

Durch Ausführen des obigen Befehls wird im aktuellen Verzeichnis mit dem Namen predict_houses_tfjs ein neuer Ordner erstellt, der : enthält

  • model.json
  • Gruppe1-shard1of1.bin

Dies sind die Dateien, die wir benötigen, um das Modell im Webbrowser auszuführen. Speichern Sie diese Dateien, da wir sie im nächsten Abschnitt verwenden werden.

6. Konvertiertes Modell im Browser verwenden

Konvertierte Dateien hosten

Zuerst müssen wir die Dateien model.json und *.bin, die generiert wurden, auf einem Webserver ablegen, damit wir über unsere Webseite darauf zugreifen können. Für diese Demo verwenden wir Glitch.com, damit Sie die Schritte einfach nachvollziehen können. Wenn Sie jedoch noch Erfahrung in der Webentwicklung haben, können Sie stattdessen einen einfachen HTTP-Server auf Ihrer aktuellen Ubuntu-Serverinstanz starten, um dies zu tun. Die Entscheidung liegt ganz bei dir.

Dateien in Glitch hochladen

  1. Melden Sie sich auf Glitch.com an.
  2. Verwenden Sie diesen Link, um das Boilerplate-Projekt mit TensorFlow.js zu klonen. Sie enthält die Grundstruktur der HTML-, CSS- und JS-Dateien, die die TensorFlow.js-Bibliothek zur Verwendung importieren.
  3. Klicken Sie auf „Assets“. im linken Bereich.
  4. Klicken Sie auf „Asset hochladen“. und wählen Sie group1-shard1of1.bin zum Hochladen in diesen Ordner aus. Nach dem Hochladen sollte sie so aussehen: 25a2251c7f165184.png
  5. Wenn Sie auf die Datei group1-shard1of1.bin klicken, die Sie gerade hochgeladen haben, können Sie die URL an den Speicherort kopieren. Kopieren Sie diesen Pfad jetzt wie gezeigt: 92ded8d46442c404.png
  6. Bearbeiten Sie jetzt model.json mit Ihrem bevorzugten Texteditor auf Ihrem lokalen Computer und suchen Sie mit STRG + F nach der Datei group1-shard1of1.bin, die an einer anderen Stelle darin erwähnt wird.

Ersetzen Sie diesen Dateinamen durch die URL, die Sie in Schritt 5 kopiert haben, aber löschen Sie das vorangestellte https://cdn.glitch.com/, das aus dem kopierten Pfad generiert wurde.

Nach der Bearbeitung sollte sie in etwa so aussehen (beachten Sie, dass der führende Serverpfad entfernt wurde, sodass nur der resultierende hochgeladene Dateiname beibehalten wird): d5a338f2dc1f31d4.png 7. Speichern Sie nun die bearbeitete model.json-Datei für eine Störung und laden Sie sie hoch. Klicken Sie dazu auf Assets und dann auf „Asset hochladen“. (wichtig). Wenn Sie die physische Schaltfläche nicht verwenden und per Drag-and-drop verschieben, wird die Datei als bearbeitbare Datei statt in das CDN hochgeladen. Diese Datei befindet sich nicht im selben Ordner und es wird der relative Pfad angenommen, wenn TensorFlow.js versucht, die Binärdateien für ein bestimmtes Modell herunterzuladen. Wenn Sie alles richtig gemacht haben, sollten Sie im Ordner assets zwei Dateien sehen: 51a6dbd5d3097ffc.png

Sehr gut! Jetzt können wir unsere gespeicherten Dateien mit einigem Code im Browser verwenden.

Modell laden

Nachdem wir die konvertierten Dateien gehostet haben, können wir eine einfache Webseite schreiben, um diese Dateien zu laden und sie für eine Vorhersage zu verwenden. Öffne script.js im Glitch-Projektordner und ersetze den Inhalt dieser Datei durch Folgendes, nachdem du const MODEL_URL so geändert hast, dass sie auf den generierten Glitch.com-Link für deine model.json-Datei verweist, die du über Glitch hochgeladen hast:

script.js:

// Grab a reference to our status text element on the web page.
// Initially we print out the loaded version of TFJS.
const status = document.getElementById('status');
status.innerText = 'Loaded TensorFlow.js - version: ' + tf.version.tfjs;

// Specify location of our Model.json file we uploaded to the Glitch.com CDN.
const MODEL_URL = ‘YOUR MODEL.JSON URL HERE! CHANGE THIS!';
// Specify a test value we wish to use in our prediction.
// Here we use 950, so we expect the result to be close to 950,000.
const TEST_VALUE = 950.0

// Create an asynchronous function.
async function run() {
    // Load the model from the CDN.
    const model = await tf.loadLayersModel(MODEL_URL);

    // Print out the architecture of the loaded model.
    // This is useful to see that it matches what we built in Python.
    console.log(model.summary());

    // Create a 1 dimensional tensor with our test value.
    const input = tf.tensor1d([TEST_VALUE]);

    // Actually make the prediction.
    const result = model.predict(input);

    // Grab the result of prediction using dataSync method
    // which ensures we do this synchronously.
    status.innerText = 'Input of ' + TEST_VALUE + 
        'sqft predicted as $' + result.dataSync()[0];
}

// Call our function to start the prediction!
run();

Wenn Sie den obigen Code ausführen, nachdem Sie die MODEL_URL-Konstante so geändert haben, dass sie auf Ihren model.json-Pfad verweist, erhalten Sie eine Ausgabe wie unten dargestellt.

c5e8457213058ec3.png

Wenn wir die Konsole des Webbrowsers überprüfen (Drücken Sie F12, um die Entwicklertools im Browser aufzurufen), können wir auch die Modellbeschreibung für das geladene Modell sehen, das Folgendes ausgibt:

35e79d70dbd66f27.png

Wenn wir dies mit unserem Python-Code zu Beginn dieses Codelabs vergleichen, können wir bestätigen, dass dies dasselbe Netzwerk ist, das wir mit einer dichten Eingabe und einer dichten Schicht mit einem Knoten erstellt haben.

Glückwunsch! Sie haben gerade ein konvertiertes, mit Python trainiertes Modell im Webbrowser ausgeführt.

7. Modelle, die nicht konvertiert werden

Komplexere Modelle, die für weniger gängige Operationen kompiliert werden, werden manchmal nicht für die Konvertierung unterstützt. Die browserbasierte Version von TensorFlow.js ist eine vollkommen neue Version von TensorFlow. Daher unterstützen wir derzeit nicht alle Low-Level-Operationen, die die TensorFlow C++ API hat (es gibt Hunderte). Im Laufe der Zeit werden jedoch weitere hinzukommen, während wir wachsen und die Kernoperationen stabiler werden.

Zum Zeitpunkt der Erstellung dieses Dokuments ist linalg.diag eine solche Funktion in TensorFlow Python, die beim Export als gespeichertes Modell einen nicht unterstützten Vorgang generiert. Wenn wir versuchen, ein gespeichertes Modell zu konvertieren, das dies in Python verwendet (das die resultierenden Operationen unterstützt, die es erzeugt), erhalten wir einen Fehler ähnlich dem folgenden:

5df94fc652393e00.png

Hier ist rot hervorgehoben, dass der linalg.diag-Aufruf so kompiliert wurde, dass ein Vorgang namens MatrixDiagV3 erzeugt wurde, der von TensorFlow.js zum Zeitpunkt der Erstellung dieses Codelabs nicht im Webbrowser unterstützt wurde.

Vorgehensweise

Sie haben zwei Optionen.

  1. Implementieren Sie diese fehlende Operation in TensorFlow.js – wir sind ein Open-Source-Projekt und freuen uns über Beiträge für Dinge wie neue Operationen. Lesen Sie diesen Leitfaden zum Schreiben neuer Operationen für TensorFlow.js. Wenn Sie dies tun, können Sie das Flag Skip_op_check in unserem Befehlszeilenkonverter verwenden, um diesen Fehler zu ignorieren und die Konvertierung trotzdem fortzusetzen. Es wird davon ausgegangen, dass dieser Vorgang in Ihrem neuen Build von TensorFlow.js verfügbar ist, den Sie erstellt haben, bei dem die fehlende Operation unterstützt wird.
  2. Ermitteln Sie in der exportierten Datei savedmodel, welcher Teil des Python-Codes den nicht unterstützten Vorgang verursacht hat. In einem kleinen Codesatz ist dies möglicherweise leicht zu finden. In komplexeren Modellen könnte dies jedoch einige Untersuchungen erfordern, da es derzeit keine Methode zum Identifizieren des übergeordneten Python-Funktionsaufrufs gibt, der eine bestimmte Operation einmal im Dateiformat savedmodel erzeugt hat. Sobald Sie ihn gefunden haben, können Sie gegebenenfalls eine andere unterstützte Methode verwenden.

8. Glückwunsch

Herzlichen Glückwunsch! Sie haben die ersten Schritte zur Verwendung eines Python-Modells über TensorFlow.js im Webbrowser getan.

Zusammenfassung

In diesem Code-Lab haben wir Folgendes gelernt:

  1. Richten Sie unsere Linux-Umgebung ein, um Python-basiertes TensorFlow zu installieren
  2. Python-„Modelle“ exportieren
  3. TensorFlow.js-Befehlszeilenkonverter installieren
  4. Mit dem Befehlszeilenkonverter TensorFlow.js die erforderlichen clientseitigen Dateien erstellen
  5. Erstellte Dateien in einer echten Webanwendung verwenden
  6. Identifizieren Sie die Modelle, die sich nicht konvertieren lassen, und welche Implementierungen erforderlich sind, damit sie in Zukunft konvertiert werden können.

Was liegt als Nächstes an?

Vergiss nicht, uns bei allen deinen Inhalten mit #MadeWithTFJS zu taggen, damit deine Chance in den sozialen Medien oder sogar bei zukünftigen TensorFlow-Veranstaltungen vorgestellt wird. Wir würden uns freuen, zu sehen, was Sie konvertieren und clientseitig im Browser verwenden!

Weitere TensorFlow.js-Codelabs, um tiefer in das Thema einzutauchen

Interessante Websites