Mit Coral Edge-TPUs TFlite-Modelle in Node mit TensorFlow.js ausführen

1. Einführung

Zuletzt aktualisiert:11.04.2022

In diesem Codelab erfahren Sie, wie Sie ein Bildklassifizierungsmodell mit Teachable Machine trainieren und es mit Coral-Hardwarebeschleunigung mithilfe von TensorFlow.js ausführen, einer leistungsfähigen und flexiblen ML-Bibliothek für JavaScript. Sie entwickeln eine Electron-App, die Bilder von einer Webcam anzeigt und mit einer Coral Edge TPU klassifiziert. Eine vollständig funktionsfähige Version dieses Codelabs ist im GitHub-Repository „sig-tfjs“ verfügbar.

Brauche ich ein Coral-Gerät?

Nein. Sie können dieses Codelab auch ohne Coral-Gerät ausprobieren und trotzdem auf einem Computer eine gute Leistung erzielen, wenn Sie stattdessen den WebNN-Beschleuniger verwenden.

Inhalt

In diesem Codelab erstellen Sie eine Electron-App, die Bilder klassifiziert. Ihre App:

• Klassifiziert Bilder von der Webcam in die Kategorien, die in dem von Ihnen trainierten Modell definiert wurden.
• Verwendet einen Coral-Beschleuniger zur Steigerung der Leistung, falls verfügbar.
• Zur Steigerung der Leistung wird WebNN verwendet, sofern es auf Ihrer Plattform unterstützt wird.

Aufgaben in diesem Lab

• Das NPM-Paket tfjs-tflite-node installieren und einrichten, um TFLite-Modelle in Node.js auszuführen.
• So installieren Sie die Edge TPU-Laufzeitbibliothek zum Ausführen von Modellen auf einem Coral-Gerät.
• Modellinferenz mit einer Coral Edge TPU beschleunigen
• Modellinferenz mit WebNN beschleunigen

In diesem Codelab geht es um TFLite in Node.js. Nicht relevante Konzepte und Codeblöcke werden ignoriert und können einfach kopiert und eingefügt werden.

Voraussetzungen

Für dieses Codelab benötigen Sie Folgendes:

• Einen Computer mit einer Webcam
• Für Coral empfehlen wir einen Raspberry Pi mit Raspberry Pi OS (64-Bit) mit Desktop.
• Für WebNN empfehlen wir einen Intel x86-64-Computer mit Ubuntu 20.04 oder Windows 10.
• Node.js-Version >= 12
• Kenntnisse in JavaScript.
• (Empfohlen) Einen Coral USB Accelerator, um das Modell zu beschleunigen.

2. Einrichten

Code abrufen

Wir haben den gesamten Code, den Sie für dieses Projekt benötigen, in einem Git-Repository abgelegt. Rufen Sie den Code ab und öffnen Sie ihn in Ihrer bevorzugten Entwicklungsumgebung. Für dieses Codelab empfehlen wir die Verwendung eines Raspberry Pi mit Raspberry Pi OS (64-Bit) mit Computer. So lässt sich ein Beschleuniger von Coral ganz einfach verbinden.

Dringend empfohlen: Mit Git das Repository auf einem Raspberry Pi klonen

Öffnen Sie zum Abrufen des Codes ein neues Terminalfenster und klonen Sie das Repository:

git clone https://github.com/tensorflow/sig-tfjs.git

Alle Dateien, die du für das Codelab bearbeiten musst, befinden sich im Verzeichnis tfjs-tflite-node-codelab (in sig-tfjs). In diesem Verzeichnis befinden sich Unterverzeichnisse mit den Namen starter_code, cpu_inference_working, coral_inference_working und webnn_inference_working. Dies sind Checkpoints für die Schritte in diesem Codelab.

Zu den anderen Dateien im Repository gehören die NPM-Pakete, von denen tfjs-tflite-node-codelab abhängt. Sie müssen diese Dateien nicht bearbeiten, aber Sie müssen einige Tests ausführen, um sicherzustellen, dass Ihre Umgebung korrekt eingerichtet ist.

Edge TPU-Laufzeitbibliothek installieren

Bei Coral-Geräten müssen Sie vor der Verwendung die Edge TPU-Laufzeitbibliothek installieren. Folgen Sie der Anleitung für Ihre Plattform, um sie zu installieren.

Unter Linux / Raspberry Pi

Unter Linux ist die Bibliothek im PPA von Google als Debian-Paket, libedgetpu1-std, für x86-64- und Armv8-Architekturen (64-Bit) verfügbar. Wenn Ihr Prozessor eine andere Architektur verwendet, müssen Sie sie aus der Quelle kompilieren.

Führen Sie diesen Befehl aus, um das Coral-PPA von Google hinzuzufügen und die Edge TPU-Laufzeitbibliothek zu installieren.

# None of this is needed on Coral boards
# This repo is needed for almost all packages below
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
# This repo is needed for only python3-coral-cloudiot and python3-coral-enviro
echo "deb https://packages.cloud.google.com/apt coral-cloud-stable main" | sudo tee /etc/apt/sources.list.d/coral-cloud.list

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

sudo apt-get update
sudo apt-get install libedgetpu1-std

Unter Windows und anderen Betriebssystemen

Vorkompilierte Binärdateien sind für die x86-64-Versionen von MacOS und Windows verfügbar und können nach dem Download durch Ausführung des Skripts install.sh oder install.bat im Archiv installiert werden.

Gerät neu starten

Nachdem die Edge TPU-Laufzeit installiert wurde, starten Sie das Gerät neu, um die neue Coral-Udev-Regel zu aktivieren, die das Installationsprogramm hinzugefügt hat.

Prüfen, ob das Coral-Gerät erkannt wird

Führe die Integrationstests für das coral-tflite-delegate-Paket aus, um zu prüfen, ob dein Coral-Gerät erkannt wird und funktioniert. Dieses Paket befindet sich im Stammverzeichnis des Repositorys. Um die Integrationstests auszuführen, stecken Sie Ihren Coral-Beschleuniger ein und führen Sie die folgenden Befehle im Verzeichnis des Pakets aus:

npx yarn
npx yarn build-deps
npx yarn test-integration

Hinweis:Wenn npx nicht verfügbar ist, prüfen Sie, ob Node.js installiert ist. Sie können Node gemäß der Anleitung auf nodejs.org installieren. Installieren Sie eine Version größer oder gleich 12. Wenn Sie apt install nodejs ausführen, wird möglicherweise Node 10 installiert, der für dieses Codelab nicht verwendet werden sollte.

Die Ausgabe sollte in etwa so aussehen:

yarn run v1.22.17
$ yarn build && yarn test-integration-dev
$ tsc
$ jasmine --config=jasmine-integration.json
Platform node has already been set. Overwriting the platform with node.
Randomized with seed 78904
Started

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
WARNING: converting 'int32' to 'uint8'
.


1 spec, 0 failures
Finished in 2.777 seconds
Randomized with seed 78904 (jasmine --random=true --seed=78904)
Done in 6.36s.

Sie müssen @tensorflow/tfjs-node, nicht wie in den Logs erwähnt installieren, da Sie das Modell in TFLite ausführen.

Wenn die Ausgabe stattdessen Encountered unresolved custom op: edgetpu-custom-op enthält, wurde Ihr Coral-Gerät nicht erkannt. Prüfen Sie, ob Sie die Edge TPU-Laufzeitbibliothek installiert und das Coral-Gerät an Ihren Computer angeschlossen haben. Sie können auch dem Startleitfaden von Coral folgen, um die Python-Version von Coral-Bindungen zu testen. Wenn die Python-Version funktioniert, diese Tests aber immer noch fehlschlagen, teilen Sie uns dies bitte mit, indem Sie einen Fehlerbericht einreichen.

Startcode ausführen

Jetzt können Sie den Startcode ausführen. Führen Sie zunächst die folgenden Schritte aus.

1. Wechseln Sie zum Verzeichnis starter_code im Verzeichnis tfjs-tflite-node-codelab.
2. Führen Sie npm install aus, um Abhängigkeiten zu installieren.
3. Führen Sie npm start aus, um das Projekt zu starten. Nun sollte eine App geöffnet werden, in der ein Videofeed von der Webcam Ihres Computers angezeigt wird.

Hinweis:Wenn Sie ein Coral-Entwicklerboard verwenden und npm install einen ENOMEM-Fehler ausgibt, führen Sie npm rebuild && npm install aus, um die fehlerhaften Pakete neu zu erstellen.

Was ist unser Ausgangspunkt?

Als Ausgangspunkt dient die einfache Kamera-App Electron, die für dieses Codelab entwickelt wurde. Der Code wurde vereinfacht, um die Konzepte im Codelab zu zeigen, und hat wenig Fehlerbehandlung. Wenn Sie Code in einer Produktions-App wiederverwenden, achten Sie darauf, dass Sie alle Fehler beheben und den gesamten Code vollständig testen.

Startcode ausprobieren

Dieser Startcode enthält viele Dateien, aber die einzige, die du bearbeiten musst, ist renderer.js. Damit wird gesteuert, was auf der Seite zu sehen ist, einschließlich Videofeed und HTML-Elemente. Außerdem fügen Sie dort Ihr Modell für maschinelles Lernen in die App ein. Unter den anderen Dateien befindet sich eine index.html-Datei, die lediglich die renderer.js-Datei lädt. Außerdem gibt es eine main.js-Datei, die als Einstiegspunkt für Electron dient. Sie steuert den Lebenszyklus der App, d. h., was angezeigt wird, wenn sie geöffnet wird, und was zu tun ist, wenn sie geschlossen wird. Sie müssen jedoch keine Änderungen daran vornehmen.

Debugger öffnen

Wenn Sie diesem Codelab folgen, müssen Sie möglicherweise Fehler in Ihrer App beheben. Da diese App auf Electron basiert, ist der Chrome-Debugger integriert. Auf den meisten Plattformen können Sie es mit Strg + Umschalttaste + i öffnen. Klicken Sie auf den Tab Console, um sich Protokolle und Fehlermeldungen der App anzusehen.

Es gibt hier sonst nicht viel zu entdecken. Lassen Sie uns also gleich mit dem Trainieren des Bildklassifikators beginnen.

3. Bildklassifikator trainieren

In diesem Abschnitt trainieren Sie die TFLite- und Coral-Versionen eines benutzerdefinierten Bildklassifizierungsmodells.

Klassifikator trainieren

Ein Bildklassifikator nimmt Eingabebilder und weist ihnen Labels zu. Für dieses Codelab verwenden Sie Teachable Machine, um ein Modell in Ihrem Browser zu trainieren. Um das Training für diesen Abschnitt zu beschleunigen, können Sie anstelle eines Raspberry Pi einen Desktop- oder Laptop-Computer verwenden, müssen dann aber die resultierenden Dateien auf die Pi-Datei kopieren.

Jetzt können Sie ein Modell trainieren. Wenn Sie nicht sicher sind, welche Art von Modell Sie trainieren möchten, ist ein Personendetektor ein einfach zu trainierendes Modell, das nur erkennt, ob eine Person im Bild ist.

1. Öffnen Sie die Trainingsseite für Teachable Machine in einem neuen Tab.
2. Wählen Sie Image Project (Image-Projekt) und dann Standard image model (Standard-Bildmodell) aus.
3. Fügen Sie für jede Klasse Bildbeispiele hinzu. Am einfachsten geht das über die Webcam-Eingabe. Sie können die Kurse auch umbenennen.
4. Wenn Sie für jede Klasse genügend Daten erfasst haben (50 Stichproben sind in der Regel ausreichend), drücken Sie Modell trainieren.

Wenn das Training des Modells abgeschlossen ist, sollten Sie eine Vorschau der Modellausgabe sehen.

Versuchen Sie, dem Modell andere Eingaben zu geben. Wenn Sie eine Eingabe finden, die falsch klassifiziert ist, fügen Sie sie den Trainingsdaten hinzu und trainieren Sie das Modell noch einmal.

5. Wenn Sie mit der Genauigkeit des Modells zufrieden sind, klicken Sie auf Modell exportieren. Sie müssen zwei separate Versionen des Modells herunterladen.
6. Exportieren Sie Ihr Modell als Tensorflow Lite-Gleitkommamodell. Dadurch wird eine Datei mit dem Namen converted_tflite.zip heruntergeladen. der auf der CPU ausgeführt wird.
7. Exportieren Sie Ihr Modell als Tensorflow Lite EdgeTPU-Modell. Dadurch wird eine Datei mit dem Namen converted_edgetpu.zip heruntergeladen, die auf der Coral Edge TPU ausgeführt wird.

Tipp:Verwenden Sie für eine höhere Genauigkeit in Ihren Bildbeispielen verschiedene Rotationen, Positionen und Hintergründe. Verwenden Sie einen Laptop, um diese Muster leichter zu erfassen.

4. CPU-Modell in der Anwendung ausführen

Nachdem Sie nun ein Modell trainiert haben, können Sie es Ihrer App hinzufügen. Am Ende dieses Abschnitts kann die App Ihr Modell über die CPU des Geräts ausführen.

Modelldatei zur App hinzufügen

Entpacken Sie die Modelldatei converted_tflite.zip, die Sie beim Trainieren des Klassifikators heruntergeladen haben. Das Archiv enthält zwei Dateien. model_uquant.tflite ist das gespeicherte TFLite-Modell, einschließlich Modellgrafik und -gewichtungen. labels.txt enthält die menschenlesbaren Labels für die Klassen, die das Modell vorhersagt. Legen Sie beide Dateien im modeldirectory ab.

Abhängigkeiten installieren

Für das Laden eines Modells und die Vorverarbeitung von Eingaben sind einige Abhängigkeiten von TensorFlow.js erforderlich:

• tfjs-tflite-node: TensorFlow.js-Paket zum Ausführen von TFLite-Modellen in Node.js.
• @tensorflow/tfjs: Hauptpaket von TensorFlow.js

@tensorflow/tfjs ist bereits installiert, aber Sie müssen tfjs-tflite-node mit diesem Befehl installieren:

npm install --save tfjs-tflite-node

Nach der Installation fügen Sie es der App oben in renderer.js hinzu:

CODELAB, Teil 1: tfjs-tflite-node importieren.

const {loadTFLiteModel} = require('tfjs-tflite-node');

Modell laden

Jetzt können Sie das Modell laden. Dazu stellt tfjs-tflite-node die Funktion loadTFLiteModel bereit. Sie kann Modelle aus einem Dateipfad, einem ArrayBuffer oder einer TFHub-URL laden. Fügen Sie zum Laden des Modells und seiner Gewichtungen der Funktion main Folgendes hinzu:

CODELAB, Teil 1: Modell hier laden

const modelPath = './model/model_unquant.tflite';
const model = await loadTFLiteModel(modelPath);
const labels = fs.readFileSync('./model/labels.txt', 'utf8')
      .split('\n');

Modell ausführen

Für die Ausführung Ihres Modells sind drei Schritte erforderlich. Zuerst rufen Sie einen Eingabe-Frame aus der Webcam ab und verarbeiten ihn vorab. Dann führen Sie das Modell auf diesem Frame aus und erhalten eine Vorhersage. Danach wird die Vervollständigung auf der Seite angezeigt.

Webcam-Eingabe vorverarbeiten

Derzeit ist die Webcam nur ein HTML-Element und die angezeigten Frames sind nicht für die JavaScript-renderer.js-Datei verfügbar. Zum Abrufen von Frames aus der Webcam bietet TensorFlow.js tf.data.webcam, eine benutzerfreundliche capture()-Methode, um Frames mit der Kamera zu erfassen.

Fügen Sie main() diesen Einrichtungscode hinzu, um sie zu verwenden:

CODELAB Teil 1: tf.data.webcam hier einrichten

const tensorCam = await tf.data.webcam(webcam);

Fügen Sie dann run() Folgendes hinzu, um in jedem Frame ein Bild aufzunehmen:

CODELAB, Teil 1: Webcam-Frames hier aufnehmen

const image = await tensorCam.capture();

Außerdem müssen Sie jeden Frame vorverarbeiten, damit er mit dem Modell kompatibel ist. Das in diesem Codelab verwendete Modell hat die Eingabeform [1, 224, 224, 3], es wird also ein RGB-Bild mit 224 × 224 Pixeln erwartet. tensorCam.capture() gibt die Form [224, 224, 3] an. Sie müssen also mit tf.expandDims eine zusätzliche Dimension am Anfang des Tensors hinzufügen. Darüber hinaus erwartet das CPU-Modell eine Float32-Eingabe zwischen -1 und 1, die Webcam erfasst jedoch Werte von 0 bis 255. Sie können den Eingabetensor durch 127 dividieren, um seinen Bereich von [0, 255] in [0, ~2] zu ändern, und dann 1 subtrahieren, um den gewünschten Bereich [-1, ~1] zu erhalten. Fügen Sie dazu in der Funktion run() diese Zeilen zu tf.tidy() hinzu:

CODELAB, Teil 1: Webcam-Frames vorverarbeiten

const expanded = tf.expandDims(image, 0);
const divided = tf.div(expanded, tf.scalar(127));
const normalized = tf.sub(divided, tf.scalar(1));

Tensoren müssen nach ihrer Verwendung entfernt werden. tf.tidy() führt dies automatisch für den Code durch, der im Callback enthalten ist. Asynchrone Funktionen werden jedoch nicht unterstützt. Sie müssen den Bildtensor, den Sie zuvor erstellt haben, manuell entsorgen, indem Sie seine dispose()-Methode aufrufen.

CODELAB, Teil 1: Webcam-Frames hier entsorgen

image.dispose();

Modell ausführen und Ergebnisse anzeigen

Rufen Sie model.predict() für den normalisierten Tensor auf, um das Modell für die vorverarbeitete Eingabe auszuführen. Dies gibt einen eindimensionalen Tensor zurück, der die vorhergesagte Wahrscheinlichkeit für jedes Label enthält. Multiplizieren Sie diese Wahrscheinlichkeit mit 100, um die prozentuale Wahrscheinlichkeit für jedes Label zu erhalten, und verwenden Sie die im Startcode enthaltene Funktion showPrediction, um die Vorhersage des Modells auf dem Bildschirm anzuzeigen.

In diesem Code wird außerdem stats.js verwendet, um die Dauer der Vorhersage durch Aufrufe von stats.begin und stats.end um model.predict zu bestimmen.

CODELAB Teil 1: Modell ausführen und Ergebnisse hier anzeigen

stats.begin();
const prediction = model.predict(normalized);
stats.end();
const percentage = tf.mul(prediction, tf.scalar(100));
showPrediction(percentage.dataSync(), labels);

Führen Sie die App noch einmal mit yarn start aus. Nun sollten Sie Klassifizierungen aus Ihrem Modell sehen.

Leistung

Da das Modell derzeit eingerichtet ist, wird es auf der CPU ausgeführt. Dies ist für Desktop-Computer und die meisten Laptops in Ordnung, aber möglicherweise nicht wünschenswert, wenn Sie es auf einem Raspberry Pi oder einem anderen Gerät mit geringem Energieverbrauch ausführen. Auf einem Raspberry Pi 4 sind wahrscheinlich etwa 10 fps verfügbar, was für einige Anwendungen möglicherweise nicht schnell genug ist. Wenn Sie eine bessere Leistung ohne einen schnelleren Computer erzielen möchten, können Sie anwendungsspezifisches Silizium in Form einer Coral Edge TPU verwenden.

5. Coral-Modell in Ihrer App ausführen

Wenn du kein Coral-Gerät hast, kannst du diesen Abschnitt überspringen.

Dieser Schritt des Codelabs basiert auf dem Code, den Sie im letzten Abschnitt geschrieben haben. Sie können aber stattdessen den Prüfpunkt cpu_inference_working verwenden, wenn Sie mit einem sauberen Slate beginnen möchten.

Die Schritte zum Ausführen des Coral-Modells sind nahezu identisch mit den Schritten zum Ausführen des CPU-Modells. Der Hauptunterschied ist das Modellformat. Da Coral nur uint8-Tensoren unterstützt, ist das Modell quantisiert. Dies wirkt sich auf die an das Modell übergebenen Eingabetensoren und die zurückgegebenen Ausgabetensoren aus. Ein weiterer Unterschied besteht darin, dass Modelle mit dem Edge TPU-Compiler kompiliert werden müssen, um auf einer Coral TPU ausgeführt werden zu können. TeachableMachine hat diesen Schritt bereits durchgeführt, aber Sie können in der Coral-Dokumentation erfahren, wie Sie ihn für andere Modelle verwenden können.

Coral-Modelldatei zur App hinzufügen

Entpacken Sie die Modelldatei converted_edgetpu.zip, die Sie beim Trainieren des Klassifikators heruntergeladen haben. Das Archiv enthält zwei Dateien. model_edgetpu.tflite ist das gespeicherte TFLite-Modell, einschließlich Modellgrafik und -gewichtungen. labels.txt enthält die menschenlesbaren Labels für die Klassen, die das Modell vorhersagt. Platzieren Sie die Modelldatei im Verzeichnis coral_model.

Abhängigkeiten installieren

Zum Ausführen von Coral-Modellen ist die Edge TPU-Laufzeitbibliothek erforderlich. Vergewissern Sie sich, dass Sie die Erweiterung installiert haben, bevor Sie fortfahren. Folgen Sie dazu der Anleitung zur Einrichtung.

Auf Coral-Geräte erfolgt der Zugriff als TFLite-Bevollmächtigte. Installieren Sie das Paket coral-tflite-delegate, um über JavaScript darauf zuzugreifen:

npm install --save coral-tflite-delegate

Importieren Sie dann den Bevollmächtigten, indem Sie diese Zeile oben in die Datei renderer.js einfügen:

CODELAB, Teil 2: Bevollmächtigten hier importieren

const {CoralDelegate} = require('coral-tflite-delegate');

Modell laden

Jetzt können Sie das Coral-Modell laden. Der Vorgang entspricht dem für das CPU-Modell, mit dem Unterschied, dass Sie jetzt Optionen an die Funktion loadTFLiteModel übergeben, um den Coral-Delegaten zu laden.

CODELAB, Teil 2: Hier laden Sie das Delegatmodell.

const coralModelPath = './coral_model/model_edgetpu.tflite';
const options = {delegates: [new CoralDelegate()]};
const coralModel = await loadTFLiteModel(coralModelPath, options);

Sie müssen die Labels nicht laden, da sie mit denen für das CPU-Modell identisch sind.

Schaltfläche zum Wechseln zwischen CPU und Coral hinzufügen

Sie fügen das Coral-Modell zusammen mit dem CPU-Modell hinzu, das Sie im letzten Abschnitt hinzugefügt haben. Wenn Sie beide gleichzeitig ausführen, sind Leistungsunterschiede nur schwer zu erkennen, sodass eine Ein/Aus-Schaltfläche zwischen Coral und der CPU-Ausführung wechseln kann.

Fügen Sie die Schaltfläche mit diesem Code hinzu:

CODELAB, Teil 2: Hier die Schaltfläche zum Delegieren erstellen

let useCoralDelegate = false;
const toggleCoralButton = document.createElement('button');
function toggleCoral() {
  useCoralDelegate = !useCoralDelegate;
  toggleCoralButton.innerText = useCoralDelegate
      ? 'Using Coral. Press to switch to CPU.'
      : 'Using CPU. Press to switch to Coral.';
}
toggleCoralButton.addEventListener('click', toggleCoral);
toggleCoral();
document.body.appendChild(toggleCoralButton);

Wir verknüpfen diese Bedingung mit der Funktion run(). Wenn useCoralDelegate „false“ ist, sollte die CPU-Version ausgeführt werden. Andernfalls wird die Coral-Version ausgeführt (aber für den Moment ist es einfach nichts). Umschließen Sie den Code für die Ausführung des CPU-Modells mit einer if-Anweisung. Beachten Sie, dass der expanded-Tensor in der if-Anweisung ausgelassen wird, da er vom Coral-Modell verwendet wird.

CODELAB Teil 2: Hier wird geprüft, ob der Bevollmächtigte verwendet werden soll.

// NOTE: Don't just copy-paste this code into the app.
// You'll need to edit the code from the CPU section.
const expanded = tf.expandDims(image, 0);
if (useCoralDelegate) {
  // CODELAB part 2: Run Coral prediction here.
} else {
  const divided = tf.div(expanded, tf.scalar(127));
  const normalized = tf.sub(divided, tf.scalar(1));
  stats.begin();
  const prediction = model.predict(normalized);
  stats.end();
  const percentage = tf.mul(prediction, tf.scalar(100));
  showPrediction(percentage.dataSync(), labels);
}

Modell ausführen

Die Coral-Version des Modells erwartet uint8-Tensoren von 0 bis 255, sodass die Eingabe nicht normalisiert werden muss. Die Ausgabe ist jedoch auch ein uint8-Tensor im Bereich von 0 bis 255. Es muss in einen Gleitkommawert zwischen 0 und 100 konvertiert werden, bevor er angezeigt wird.

CODELAB Teil 2: Hier können Sie die Korallenvorhersage ausführen. (Dies ist Teil des obigen Code-Snippets.)

stats.begin();
const prediction = coralModel.predict(expanded);
stats.end();
const percentage = tf.div(tf.mul(prediction, tf.scalar(100)), tf.scalar(255));
showPrediction(percentage.dataSync(), labels);

Führen Sie die App noch einmal mit yarn start aus. Daraufhin sollten Klassifizierungen aus dem Coral-Beschleuniger angezeigt werden.

Sie können zwischen Coral und CPU-Inferenz wechseln, indem Sie die Taste drücken. Sie werden möglicherweise feststellen, dass die Konfidenzbewertungen des Coral-Modells weniger genau sind als die des CPU-Modells und enden in der Regel mit einer geraden Dezimalstelle. Dieser Genauigkeitsverlust ist ein Kompromiss bei der Ausführung eines quantisierten Modells auf Coral. In der Praxis spielt das normalerweise keine Rolle, aber es ist etwas, das Sie im Hinterkopf behalten sollten.

Hinweis zur Leistung

Die Framerate, die Sie sehen, umfasst die Vor- und Nachbearbeitung und ist daher nicht repräsentativ für die Möglichkeiten der Coral-Hardware. Sie können sich eine bessere Vorstellung von der Leistung machen, indem Sie auf das FPS-Messtool klicken, bis die Latenz (in Millisekunden) angezeigt wird, mit der nur der Aufruf von model.predict gemessen wird. Dazu gehört jedoch immer noch die Zeit, die benötigt wird, um Tensoren zu den nativen TFLite-nativen C-Bindungen und dann zum Coral-Gerät zu verschieben, sodass dies keine perfekte Messung ist. Genauere Leistungs-Benchmarks in C++ finden Sie auf der EdgeTPU-Benchmark-Seite.

Beachten Sie außerdem, dass das Video auf einem Laptop statt auf einem Raspberry Pi aufgenommen wurde. Daher sehen Sie möglicherweise eine andere fps.

Beschleunigung der Coral-Vorverarbeitung

In einigen Fällen können Sie die Vorverarbeitung beschleunigen, indem Sie TFJS-Back-Ends wechseln. Das Standard-Back-End ist WebGL, das sich gut für große, parallelisierbare Vorgänge eignet, aber diese App führt in der Vorverarbeitungsphase nur wenig davon aus (der einzige Vorgang, der verwendet wird, ist expandDims, der nicht parallel ist). Sie können zum CPU-Back-End wechseln, um die zusätzliche Latenz beim Verschieben von Tensoren zur und von der GPU zu vermeiden, indem Sie diese Zeile nach den Importen oben in der Datei einfügen.

tf.setBackend(‘cpu');

Dies wirkt sich auch auf die Vorverarbeitung des TFLite-CPU-Modells aus, das parallelisiert ist, sodass das Modell nach dieser Änderung viel langsamer läuft.

6. CPU-Modell mit WebNN beschleunigen

Wenn Sie keinen Coral-Beschleuniger haben oder einfach nur eine andere Methode zur Beschleunigung des Modells ausprobieren möchten, können Sie den WebNN TFLite-Delegaten verwenden. Dieser Bevollmächtigte nutzt die Hardware für maschinelles Lernen, die in Intel-Prozessoren integriert ist, um die Modellinferenz mit dem OpenVINO-Toolkit zu beschleunigen. Dementsprechend hat es zusätzliche Anforderungen, die im Abschnitt „Einrichtung“ dieses Codelab nicht behandelt werden, und Sie müssen das OpenVINO-Toolkit installieren. Überprüfen Sie Ihre Einrichtung auf die unterstützten Zielsystemplattformen, bevor Sie fortfahren. Beachten Sie jedoch, dass der WebNN-Delegaten macOS noch nicht unterstützt.

OpenVINO-Toolkit installieren

Das OpenVINO-Toolkit nutzt Hardware für maschinelles Lernen, die in Intel-Prozessoren integriert ist, um Modelle zu beschleunigen. Sie können eine vorkompilierte Version von Intel herunterladen oder aus der Quelle erstellen. Es gibt verschiedene Möglichkeiten, OpenVINO zu installieren. Für dieses Codelab empfehlen wir jedoch die Verwendung des Installationsskripts für Windows oder Linux. Achten Sie darauf, die LTS-Laufzeitversion 2021.4.2 zu installieren, da andere Versionen möglicherweise nicht kompatibel sind. Nachdem Sie das Installationsprogramm ausgeführt haben, müssen Sie die Umgebungsvariablen Ihrer Shell entsprechend der Installationsanleitung für Linux oder Windows ( dauerhafte Lösung) konfigurieren oder den Befehl setupvars.sh (Linux) bzw. setupvars.bat (Windows) im Verzeichnis webnn-tflite-delegate ausführen.

Hinweis für Windows-Nutzer:Der Befehl setupvars.bat unterstützt Git bash nicht. Führen Sie ihn und andere Befehle aus diesem Codelab daher unbedingt über die Windows-Eingabeaufforderung aus.

Prüfen, ob WebNN Delegate funktioniert

Führen Sie die Integrationstests für das Paket webnn-tflite-delegate im Stammverzeichnis des Repositorys aus, um zu prüfen, ob der WebNN-Delegaten korrekt funktioniert. Führen Sie die folgenden Befehle im Verzeichnis des Pakets aus, um die Integrationstests auszuführen:

# In webnn-tflite-delegate/
npx yarn
npx yarn test-integration

Die Ausgabe sollte in etwa so aussehen:

WebNN delegate: WebNN device set to 0.
INFO: Created TensorFlow Lite WebNN delegate for device Default and power Default.

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
label: wine bottle
score:  0.934505045413971
.


1 spec, 0 failures
Finished in 0.446 seconds
Randomized with seed 58441 (jasmine --random=true --seed=58441)
Done in 8.07s.

Wenn Sie eine solche Ausgabe sehen, weist dies auf einen Konfigurationsfehler hin:

Platform node has already been set. Overwriting the platform with node.
Randomized with seed 05938
Started
error Command failed with exit code 3221225477.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

Diese Ausgabe bedeutet höchstwahrscheinlich, dass Sie die Umgebungsvariablen von OpenVINO nicht festgelegt haben. Derzeit können Sie sie mit den Befehlen setupvars.sh (Linux) oder setupvars.bat (Windows) festlegen. Wenn Sie sie dauerhaft festlegen möchten, folgen Sie der Anleitung für Linux oder Windows ( dauerhafte Lösung). Wenn Sie Windows verwenden, ist das

setupvars.bat

Der Befehl unterstützt Git bash nicht. Deshalb sollten Sie ihn und andere Befehle aus diesem Codelab über die Windows-Eingabeaufforderung ausführen.

WebNN Delegate installieren

Nachdem Sie OpenVINO installiert haben, können Sie das CPU-Modell mit WebNN beschleunigen. Dieser Abschnitt des Codelab baut auf dem Code auf, den Sie im Abschnitt „CPU-Modell in Ihrer App ausführen“ geschrieben haben. . Sie können den Code verwenden, den Sie in diesem Schritt geschrieben haben. Wenn Sie den Coral-Abschnitt jedoch bereits abgeschlossen haben, nutzen Sie stattdessen den Prüfpunkt cpu_inference_working, um mit einem leeren Slate zu beginnen.

Der Node.js-Teil des WebNN-Delegaten wird auf npmjs verteilt. Führen Sie den folgenden Befehl aus, um es zu installieren:

npm install --save webnn-tflite-delegate

Importieren Sie dann den Bevollmächtigten, indem Sie diese Zeile oben in die Datei renderer.js einfügen:

CODELAB, Teil 2: Bevollmächtigten hier importieren

const {WebNNDelegate, WebNNDevice} = require('webnn-tflite-delegate');

Der WebNN-Delegate unterstützt die Ausführung auf der CPU oder der GPU. Mit WebNNDevice können Sie auswählen, welches Gerät verwendet werden soll.

Modell laden

Jetzt können Sie das Modell mit aktiviertem WebNN-Delegaten laden. Für Coral mussten Sie eine andere Modelldatei laden, aber WebNN unterstützt dasselbe Modellformat wie TFLite. Fügen Sie WebNNDelegate zur Liste der an das Modell übergebenen Delegierten hinzu, um es zu aktivieren:

CODELAB, Teil 2: Hier laden Sie das Delegatmodell.

let webnnModel = await loadTFLiteModel(modelPath, {
  delegates: [new WebNNDelegate({webnnDevice: WebNNDevice.DEFAULT})],
});

Sie müssen die Labels nicht noch einmal laden, da es sich um dasselbe Modell handelt.

Schaltfläche zum Wechseln zwischen TfLite-CPU und WebNN hinzufügen

Die WebNN-Version des Modells ist nun bereit. Fügen Sie eine Schaltfläche hinzu, um zwischen der WebNN- und TfLite-CPU-Inferenz zu wechseln. Wenn Sie beide Funktionen gleichzeitig ausführen, lassen sich Leistungsunterschiede nur schwer erkennen.

Fügen Sie die Schaltfläche mit diesem Code hinzu (beachten Sie, dass dadurch noch nicht das Modell gewechselt wird):

CODELAB, Teil 2: Hier die Schaltfläche zum Delegieren erstellen

let useWebNNDelegate = false;
const divElem = document.createElement('div');
const toggleWebNNButton = document.createElement('button');
function toggleWebNN() {
  useWebNNDelegate = !useWebNNDelegate;
  toggleWebNNButton.innerHTML = useWebNNDelegate
      ? 'Using WebNN. Press to switch to TFLite CPU.'
      : 'Using TFLite CPU. Press to switch to WebNN.';
  divElem.hidden = useWebNNDelegate ? false : true;
}

toggleWebNNButton.addEventListener('click', toggleWebNN);
toggleWebNN();
document.body.appendChild(toggleWebNNButton);
document.body.appendChild(divElem);

Mit diesem Code wird außerdem ein div-Element hinzugefügt, mit dem Sie im nächsten Abschnitt die WebNN-Einstellungen konfigurieren.

Drop-down-Menü zum Wechseln zwischen WebNN-Geräten hinzufügen

WebNN unterstützt die Ausführung auf CPU und GPU. Fügen Sie daher ein Drop-down-Menü hinzu, um zwischen ihnen zu wechseln. Fügen Sie diesen Code nach dem Code ein, mit dem die Schaltfläche erstellt wird:

// Create elements for WebNN device selection
divElem.innerHTML = '<br/>WebNN Device: ';
const selectElem = document.createElement('select');
divElem.appendChild(selectElem);

const webnnDevices = ['Default', 'GPU', 'CPU'];
// append the options
for (let i = 0; i < webnnDevices.length; i++) {
  var optionElem = document.createElement('option');
  optionElem.value = i;
  optionElem.text = webnnDevices[i];
  selectElem.appendChild(optionElem);
}

Wenn Sie die Anwendung jetzt ausführen, sehen Sie ein Drop-down-Menü mit den Optionen „Standard“, „GPU“ und „CPU“. Die Auswahl eines dieser Elemente führt im Moment nichts, da das Drop-down-Menü noch nicht eingebunden wurde.

Das Gerät über das Drop-down-Menü ändern

Wenn Sie das Drop-down-Menü verknüpfen möchten, damit sich das zu verwendende WebNN-Gerät ändert, fügen Sie dem change-Ereignis des Drop-down-Auswahlelements einen Listener hinzu. Wenn sich der ausgewählte Wert ändert, erstellen Sie das WebNN-Modell noch einmal mit dem entsprechenden WebNN-Gerät, das in den Delegationsoptionen ausgewählt wurde.

Fügen Sie dem Code, mit dem das Drop-down-Menü hinzugefügt wurde, den folgenden Code ein:

selectElem.addEventListener('change', async () => {
  let webnnDevice;
  switch(selectElem.value) {
    case '1':
      webnnDevice = WebNNDevice.GPU;
      break;
    case '2':
      webnnDevice = WebNNDevice.CPU;
      break;
    default:
      webnnDevice = WebNNDevice.DEFAULT;
      break;
  }
  webnnModel = await loadTFLiteModel(modelPath, {
    delegates: [new WebNNDelegate({webnnDevice})],
  });
});

Mit dieser Änderung wird bei jeder Änderung im Drop-down-Menü ein neues Modell mit den richtigen Einstellungen erstellt. Jetzt verknüpfen Sie das WebNN-Modell und verwenden es für die Inferenz.

WebNN-Modell ausführen

Das WebNN-Modell ist einsatzbereit, aber mit der Schaltfläche zum Wechseln zwischen der WebNN- und der TfLite-CPU wird das Modell noch nicht gewechselt. Wenn Sie das Modell wechseln möchten, müssen Sie zuerst die Variable model umbenennen, die Sie beim Laden des TfLite-CPU-Modells im ersten Abschnitt des Codelabs verwendet haben.

Die folgende Zeile ändern...

const model = await loadTFLiteModel(modelPath);

...sodass er mit dieser Zeile übereinstimmt.

const cpuModel = await loadTFLiteModel(modelPath);

Nachdem die Variable model in cpuModel umbenannt wurde, fügen Sie der Funktion run Folgendes hinzu, um das richtige Modell basierend auf dem Status der Schaltfläche auszuwählen:

CODELAB Teil 2: Hier wird geprüft, ob der Bevollmächtigte verwendet werden soll.

let model;
if (useWebNNDelegate) {
  model = webnnModel;
} else {
  model = cpuModel;
}

Wenn Sie jetzt die Anwendung ausführen, wechselt die Schaltfläche zwischen TfLite-CPU und WebNN.

Wenn Sie eine integrierte Intel-GPU haben, können Sie auch zwischen der WebNN-CPU und der GPU-Inferenz wechseln.

Hinweis zur Leistung

Die Framerate, die Sie sehen, umfasst die Vorverarbeitung und Nachverarbeitung und ist daher nicht repräsentativ für die Möglichkeiten von WebNN. Sie können sich eine bessere Vorstellung von der Leistung machen, indem Sie auf das FPS-Messtool klicken, bis die Latenz (in Millisekunden) angezeigt wird, mit der nur der Aufruf von model.predict gemessen wird. Dazu gehört aber immer noch die Zeit, die zum Verschieben von Tensoren in die nativen TFLite-nativen C-Bindungen benötigt wird, sodass dies keine perfekte Messung ist.

7. Glückwunsch

Glückwunsch! Sie haben gerade Ihr allererstes Coral-/WebNN-Projekt mit tfjs-tflite-node in Electron abgeschlossen.

Probieren Sie es aus und testen Sie es mit verschiedenen Bildern. Sie können auch ein neues Modell auf TeachableMachine trainieren, um etwas völlig anderes zu klassifizieren.

Zusammenfassung

In diesem Codelab haben Sie Folgendes gelernt:

• Installation und Einrichtung des npm-Pakets tfjs-tflite-node zum Ausführen von TFLite-Modellen in Node.js
• So installieren Sie die Edge TPU-Laufzeitbibliothek zum Ausführen von Modellen auf einem Coral-Gerät.
• Modellinferenz mit einer Coral Edge TPU beschleunigen
• So beschleunigen Sie die Modellinferenz mit WebNN.

Was liegt als Nächstes an?

Sie haben nun eine Arbeitsgrundlage. Welche kreativen Ideen können Sie entwickeln, um dieses Modell für maschinelles Lernen auf einen realen Anwendungsfall zu erweitern, an dem Sie möglicherweise gerade arbeiten? Vielleicht könnten Sie die Branche, in der Sie arbeiten, mit schneller und erschwinglicher Inferenz revolutionieren oder vielleicht einen Toaster so umbauen, dass er aufhört zu rösten, wenn das Brot schön aussieht. Die Möglichkeiten sind praktisch endlos.

Wenn Sie mehr darüber erfahren möchten, wie TeachableMachine das von Ihnen verwendete Modell trainiert hat, sehen Sie sich unser Codelab zu Lerntransfer an. Wenn Sie nach anderen Modellen suchen, die mit Coral funktionieren, z. B. Spracherkennung und Posenschätzung, sehen Sie sich coral.ai/models an. Auf TensorFlow Hub finden Sie außerdem die CPU-Versionen dieser und vieler anderer Modelle.

Deine Arbeit mit uns teilen

Ihr könnt das, was ihr heute gemacht habt, ganz einfach für andere kreative Anwendungsfälle erweitern. Wir ermutigen euch, unkonventionell zu denken und weiter Hacking zu betreiben.

Vergessen Sie nicht, uns in den sozialen Medien mit dem Hashtag #MadeWithTFJS zu taggen, damit Ihr Projekt in unserem TensorFlow-Blog oder sogar auf zukünftigen Veranstaltungen vorgestellt wird. Wir freuen uns auf Ihr Feedback.

Interessante Websites

• Offizielle TensorFlow.js-Website
• Vordefinierte TensorFlow.js-Modelle
• TensorFlow.js-API
• TensorFlow.js-Anzeige und Erzählen