Utiliser les TPU Coral Edge pour exécuter des modèles TFlite dans Node.js avec TensorFlow.js

1. Introduction

Dernière mise à jour : 11/04/2022

Dans cet atelier de programmation, vous allez apprendre à entraîner un modèle de classification d'images à l'aide de Teachable Machine et à l'exécuter avec l'accélération matérielle Coral à l'aide de TensorFlow.js, une bibliothèque de machine learning puissante et flexible pour JavaScript. Vous allez créer une application Electron qui affiche les images d'une webcam et les classe à l'aide d'un TPU Coral Edge. Une version entièrement fonctionnelle de cet atelier de programmation est disponible dans le dépôt GitHub sig-tfjs.

Ai-je besoin d'un appareil Coral ?

Non. Vous pouvez essayer cet atelier de programmation sans appareil Coral et obtenir quand même de bonnes performances sur un ordinateur de bureau en utilisant l'accélérateur WebNN.

Objectifs de l'atelier

Dans cet atelier de programmation, vous allez créer une application Electron qui classe des images. Votre application:

• Elle classe les images de la webcam dans les catégories définies dans le modèle que vous avez entraîné.
• Utilise un accélérateur Coral pour améliorer les performances, le cas échéant.
• Il utilise WebNN pour améliorer les performances, si votre plate-forme le permet.

Points abordés

• Installer et configurer le package NPM tfjs-tflite-node pour exécuter des modèles TFLite en Node.js
• Installer la bibliothèque d'exécution Edge TPU pour exécuter des modèles sur un appareil Coral
• Comment accélérer l'inférence de modèle à l'aide d'un TPU Coral Edge.
• Comment accélérer l'inférence de modèle avec WebNN

Cet atelier de programmation est consacré à TFLite en Node.js. Les concepts et les blocs de code non pertinents ne sont pas abordés, mais vous sont fournis afin que vous puissiez simplement les copier et les coller.

Prérequis

Pour suivre cet atelier de programmation, vous devez remplir les conditions suivantes:

• Un ordinateur avec une webcam
• Pour le corail, nous vous recommandons d'utiliser un Raspberry Pi sous OS Raspberry Pi (64 bits) sur ordinateur.
• Pour WebNN, nous recommandons une machine Intel x86-64 exécutant Ubuntu 20.04 ou Windows 10.
• Node.js version 12 ou ultérieure.
• Connaissance de JavaScript
• (Recommandé) Un accélérateur USB Coral pour accélérer le modèle.

2. Configuration

Obtenir le code

Nous avons placé tout le code dont vous avez besoin pour ce projet dans un dépôt Git. Pour commencer, récupérez le code et ouvrez-le dans l'environnement de développement de votre choix. Pour cet atelier de programmation, nous vous recommandons d'utiliser un Raspberry Pi sous OS Raspberry Pi (64 bits) sur ordinateur. Cela facilite la connexion à un accélérateur Coral.

Fortement recommandé: utiliser Git pour cloner le dépôt sur un Raspberry Pi

Pour obtenir le code, ouvrez une nouvelle fenêtre de terminal et clonez le dépôt:

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

Tous les fichiers que vous devez modifier pour cet atelier de programmation se trouvent dans le répertoire tfjs-tflite-node-codelab (dans sig-tfjs). Il contient des sous-répertoires nommés starter_code, cpu_inference_working, coral_inference_working et webnn_inference_working. Il s'agit des points de contrôle pour les étapes de cet atelier de programmation.

Parmi les autres fichiers du dépôt, vous trouverez les packages NPM dont dépend tfjs-tflite-node-codelab. Vous n'aurez pas besoin de modifier ces fichiers, mais vous devrez exécuter certains de leurs tests pour vous assurer que votre environnement est correctement configuré.

Installer la bibliothèque d'exécution Edge TPU

Les appareils Coral nécessitent l'installation de la bibliothèque d'exécution Edge TPU avant utilisation. Installez-la en suivant les instructions correspondant à votre plate-forme.

Sous Linux / Raspberry Pi

Sous Linux, la bibliothèque est disponible dans le PPA de Google sous la forme d'un package Debian, libedgetpu1-std, pour les architectures x86-64 et Armv8 (64 bits). Si votre outil de traitement utilise une architecture différente, vous devrez le compiler à partir de la source.

Exécutez cette commande pour ajouter le PPA Coral de Google et installer la bibliothèque Edge TPU Runtime.

# 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

Sous Windows ou d'autres systèmes d'exploitation

Ces binaires précompilés sont disponibles pour les versions x86-64 de macOS et Windows. Vous pouvez les installer en exécutant le script install.sh ou install.bat dans l'archive une fois téléchargée.

Redémarrer l'appareil

Une fois l'environnement d'exécution Edge TPU installé, redémarrez l'appareil pour activer la nouvelle règle Coral Udev ajoutée par le programme d'installation.

Vérifier que votre appareil Coral est détecté

Pour vérifier que votre appareil Coral est détecté et fonctionne, exécutez les tests d'intégration pour le package coral-tflite-delegate. Ce package se trouve dans le répertoire racine du dépôt. Pour exécuter les tests d'intégration, connectez votre accélérateur Coral et exécutez les commandes suivantes dans le répertoire du package:

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

Remarque:Si npx n'est pas disponible, assurez-vous d'avoir installé Node.js. Vous pouvez installer Node.js en suivant les instructions disponibles sur nodejs.org. Assurez-vous d'installer une version supérieure ou égale à 12. L'exécution de apt install nodejs peut installer Node 10, qui ne doit pas être utilisé pour cet atelier de programmation.

Vous devriez obtenir un résultat semblable à celui-ci:

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.

Ne vous préoccupez pas d'installer @tensorflow/tfjs-node, comme indiqué dans les journaux, car vous exécuterez le modèle dans TFLite.

Si la sortie contient Encountered unresolved custom op: edgetpu-custom-op, cela signifie que votre appareil Coral n'a pas été détecté. Assurez-vous d'avoir installé la bibliothèque d'exécution Edge TPU et branché l'appareil Coral à votre ordinateur. Vous pouvez également suivre le guide de démarrage de Coral pour tester la version Python des liaisons Coral. Si la version Python fonctionne, mais que ces tests échouent toujours, veuillez nous envoyer un rapport de bug.

Exécuter le code de démarrage

Vous êtes maintenant prêt à exécuter le code de démarrage. Suivez ces étapes pour commencer.

1. Accédez au répertoire starter_code sous tfjs-tflite-node-codelab.
2. Exécutez npm install pour installer les dépendances.
3. Exécutez npm start pour lancer le projet. Une application affichant un flux vidéo provenant de la webcam de votre ordinateur doit s'ouvrir.

Remarque:Si vous utilisez une carte de développement Coral et que npm install génère une erreur ENOMEM, exécutez npm rebuild && npm install pour recréer les packages défectueux.

Quel est notre point de départ ?

Nous commençons par une application d'appareil photo Electron basique, conçue pour cet atelier de programmation. Le code a été simplifié pour illustrer les concepts abordés dans l'atelier de programmation, et la gestion des erreurs est minime. Si vous choisissez de réutiliser du code dans une application de production, assurez-vous de gérer les erreurs et de tester entièrement l'intégralité du code.

Explorer le code de démarrage

Ce code de démarrage contient de nombreux fichiers, mais le seul que vous devez modifier est renderer.js. Elle contrôle ce qui s'affiche sur la page, y compris le flux vidéo et les éléments HTML. C'est là que vous ajoutez votre modèle de machine learning à l'application. Parmi les autres fichiers se trouve un fichier index.html, qui se contente de charger le fichier renderer.js. Il existe également un fichier main.js, qui est le point d'entrée de Electron. Elle contrôle le cycle de vie de l'application, y compris ce qui doit s'afficher lorsqu'elle est ouverte et ce qu'il faut faire lorsqu'elle est fermée, mais vous n'avez pas besoin de la modifier.

Ouvrir le débogueur

Vous devrez peut-être déboguer votre application au cours de cet atelier de programmation. Cette application étant basée sur Electron, le débogueur Chrome est intégré. Sur la plupart des plates-formes, vous pouvez l'ouvrir avec les touches Ctrl+Maj+i. Cliquez sur l'onglet Console pour afficher les journaux et les messages d'erreur de l'application.

Il n'y a pas grand-chose d'autre à explorer ici. Passons donc directement à l'entraînement du classificateur d'images.

3. Entraîner un classificateur d'images

Dans cette section, vous allez entraîner les versions TFLite et Coral d'un modèle de classification d'images personnalisé.

Entraîner le classificateur

Un classificateur d'images prend des images d'entrée et leur attribue des étiquettes. Dans cet atelier de programmation, vous allez utiliser Teachable Machine pour entraîner un modèle dans votre navigateur. Pour accélérer l'entraînement de cette section, vous pouvez utiliser un ordinateur de bureau ou portable au lieu d'un Raspberry Pi, mais vous devrez copier les fichiers obtenus sur le Pi.

Vous êtes maintenant prêt à entraîner un modèle. Si vous ne savez pas quel type de modèle entraîner, un modèle facile à entraîner est un détecteur de personnes, qui détecte simplement si une personne est dans le cadre.

1. Ouvrez la page d'entraînement de Teachable Machine dans un nouvel onglet.
2. Sélectionnez Projet d'image, puis Modèle d'image standard.
3. Ajoutez des exemples d'images pour chaque classe. Le moyen le plus simple est d'utiliser l'entrée de la webcam. Vous pouvez également renommer les classes.
4. Une fois que vous avez collecté suffisamment de données pour chaque classe (50 échantillons suffisent généralement), appuyez sur Entraîner le modèle.

Une fois l'entraînement du modèle terminé, un aperçu de la sortie du modèle doit s'afficher.

Essayez de fournir différentes entrées au modèle. Si vous trouvez une entrée mal classée, ajoutez-la aux données d'entraînement et réentraînez le modèle.

5. Lorsque vous êtes satisfait de la précision du modèle, cliquez sur Exporter le modèle. Vous devez télécharger deux versions distinctes du modèle.
6. Exportez votre modèle en tant que modèle à virgule flottante TensorFlow Lite. Un fichier nommé converted_tflite.zip est alors téléchargé. qui s'exécute sur le CPU.
7. Exportez votre modèle en tant que modèle Tensorflow Lite EdgeTPU. Cette opération télécharge un fichier nommé converted_edgetpu.zip qui s'exécute sur le TPU Coral Edge.

Conseil:Pour une meilleure précision, utilisez plusieurs rotations, positions et arrière-plans dans vos échantillons d'images. Utilisez un ordinateur portable, si vous en avez un, pour collecter ces échantillons plus facilement.

4. Exécuter le modèle de processeur dans votre application

Maintenant que vous avez entraîné un modèle, vous pouvez l'ajouter à votre application. À la fin de cette section, l'application sera en mesure d'exécuter votre modèle en utilisant le processeur de l'appareil.

Ajouter le fichier de modèle à l'application

Décompressez le fichier de modèle converted_tflite.zip que vous avez téléchargé lors de l'entraînement du classificateur. L'archive contient deux fichiers. model_uquant.tflite est le modèle TFLite enregistré, y compris le graphe et les pondérations du modèle. labels.txt contient les étiquettes lisibles par l'humain des classes prédites par le modèle. Placez les deux fichiers dans modeldirectory.

Installer des dépendances

Le chargement d'un modèle et le prétraitement des entrées nécessitent quelques dépendances de TensorFlow.js:

• tfjs-tflite-node: package TensorFlow.js pour l'exécution de modèles TFLite dans Node.js.
• @tensorflow/tfjs: package principal de TensorFlow.js.

@tensorflow/tfjs est déjà installé, mais vous devez installer tfjs-tflite-node à l'aide de la commande suivante:

npm install --save tfjs-tflite-node

Une fois qu'il est installé, ajoutez-le à l'application en haut du fichier renderer.js:

Atelier de programmation partie 1: importer tfjs-tflite-node

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

Charger le modèle

Vous pouvez maintenant charger le modèle. Pour ce faire, tfjs-tflite-node fournit la fonction loadTFLiteModel. Elle peut charger des modèles à partir d'un chemin d'accès à un fichier, d'un objet ArrayBuffer ou d'une URL TFHub. Pour charger votre modèle et ses pondérations, ajoutez ce qui suit à la fonction main:

Atelier de programmation (partie 1) : charger le modèle ici.

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

Exécuter le modèle

L'exécution de votre modèle comporte trois étapes. Tout d'abord, vous extrayez et prétraitez une trame d'entrée de la webcam. Vous exécutez ensuite le modèle sur cette trame et obtenez une prédiction. La prédiction s'affiche ensuite sur la page.

Prétraiter l'entrée de la webcam

Pour le moment, la webcam n'est qu'un élément HTML et les cadres qu'elle affiche ne sont pas disponibles pour le fichier JavaScript Renderer.js. Pour extraire des images de la webcam, TensorFlow.js fournit tf.data.webcam, qui fournit une méthode capture() facile à utiliser pour enregistrer des images depuis l'appareil photo.

Pour l'utiliser, ajoutez ce code de configuration à main():

Atelier de programmation (partie 1) : configurer tf.data.webcam ici

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

Ensuite, pour capturer une image à chaque image, ajoutez le code suivant à run():

Atelier de programmation – 1re partie: Capturez les images de la webcam ici.

const image = await tensorCam.capture();

Vous devez également prétraiter chaque image pour qu'elle soit compatible avec le modèle. Le modèle utilisé dans cet atelier de programmation a une forme d'entrée [1, 224, 224, 3]. Il attend donc une image RVB de 224 x 224 pixels. tensorCam.capture()donne une forme de [224, 224, 3]. Vous devez donc ajouter une dimension supplémentaire à l'avant du Tensor avec tf.expandDims. De plus, le modèle de processeur attend une entrée de type Float32 comprise entre -1 et 1, mais la webcam capture des valeurs comprises entre 0 et 255. Vous pouvez diviser le Tensor d'entrée par 127 pour faire passer sa plage de [0, 255] à [0, ~2], puis soustraire 1 pour obtenir la plage souhaitée [-1, ~1]. Pour ce faire, ajoutez ces lignes à tf.tidy() dans la fonction run():

Atelier de programmation – 1re partie: Prétraitez les images de la webcam ici.

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

Il est important de supprimer les Tensors après les avoir utilisés. tf.tidy() effectue cette opération automatiquement pour le code contenu dans son rappel, mais n'est pas compatible avec les fonctions asynchrones. Vous devez supprimer manuellement le Tensor d'image que vous avez créé précédemment en appelant sa méthode dispose().

Atelier de programmation : partie 1 : supprimez les cadres de la webcam ici.

image.dispose();

Exécuter le modèle et afficher les résultats

Pour exécuter le modèle sur l'entrée prétraitée, appelez model.predict() sur le Tensor normalisé. Cette opération renvoie un Tensor unidimensionnel contenant la probabilité prédite de chaque étiquette. Multipliez cette probabilité par 100 pour obtenir le pourcentage de probabilité de chaque étiquette, puis utilisez la fonction showPrediction incluse dans le code de démarrage pour afficher la prédiction du modèle à l'écran.

Ce code utilise également stats.js pour chronométrer la durée de la prédiction en appelant stats.begin et stats.end autour de model.predict.

Atelier de programmation partie 1: Exécuter le modèle et afficher les résultats ici

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

Exécutez à nouveau l'application avec yarn start. Vous devriez voir les classifications de votre modèle.

Performances

Comme il est actuellement configuré, le modèle s'exécute sur le processeur. Cela convient aux ordinateurs de bureau et à la plupart des ordinateurs portables, mais n'est peut-être pas souhaitable si vous l'exécutez sur un Raspberry Pi ou un autre appareil basse consommation. Sur un Raspberry Pi 4, vous verrez probablement environ 10 FPS, ce qui n'est peut-être pas assez rapide pour certaines applications. Pour obtenir de meilleures performances sans utiliser de machine plus rapide, vous pouvez utiliser une puce spécifique à une application sous la forme d'un Coral Edge TPU.

5. Exécuter le modèle Coral dans votre application

Si vous n'avez pas d'appareil Coral, vous pouvez ignorer cette section.

Cette étape de l'atelier de programmation s'appuie sur le code que vous avez écrit dans la section précédente, mais vous pouvez utiliser le point de contrôle cpu_inference_working si vous souhaitez partir de zéro.

Les étapes d'exécution du modèle Coral sont presque identiques à celles du modèle de processeur. La principale différence réside dans le format du modèle. Comme Coral n'accepte que les Tensors uint8, le modèle est quantifié. Cela affecte les Tensors d'entrée transmis au modèle et les Tensors de sortie qu'il renvoie. Une autre différence est que les modèles doivent être compilés à l'aide du compilateur Edge TPU pour s'exécuter sur un Coral TPU. TeachableMachine a déjà effectué cette étape, mais vous pouvez découvrir comment procéder pour d'autres modèles en consultant la documentation sur Coral.

Ajouter le fichier de modèle Coral à l'application

Décompressez le fichier de modèle converted_edgetpu.zip que vous avez téléchargé lors de l'entraînement du classificateur. L'archive contient deux fichiers. model_edgetpu.tflite est le modèle TFLite enregistré, y compris le graphe et les pondérations du modèle. labels.txt contient les étiquettes lisibles par l'humain des classes prédites par le modèle. Placez le fichier de modèle dans le répertoire coral_model.

Installer des dépendances

L'exécution de modèles Coral nécessite la bibliothèque d'exécution Edge TPU. Assurez-vous de l'avoir installé en suivant les instructions de configuration avant de continuer.

Les appareils Coral sont accessibles en tant que délégués TFLite. Pour y accéder à partir de JavaScript, installez le package coral-tflite-delegate:

npm install --save coral-tflite-delegate

Importez ensuite le délégué en ajoutant la ligne suivante en haut du fichier renderer.js:

Atelier de programmation partie 2: Importez le délégué ici.

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

Charger le modèle

Vous êtes maintenant prêt à charger le modèle Coral. Cette opération s'effectue de la même manière que pour le modèle de processeur, sauf que vous transmettez maintenant des options à la fonction loadTFLiteModel pour charger le délégué Coral.

Atelier de programmation partie 2: charger le modèle délégué ici

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

Il n'est pas nécessaire de charger les étiquettes, car elles sont les mêmes que pour le modèle de processeur.

Ajouter un bouton pour basculer entre le processeur et le coloris Corail

Vous ajouterez le modèle Coral avec le modèle de processeur que vous avez ajouté dans la section précédente. En exécutant les deux en même temps, il est difficile de voir les différences de performances. C'est pourquoi un bouton d'activation permet de basculer entre l'exécution de Coral et celle du processeur.

Ajoutez le bouton avec le code suivant:

Atelier de programmation partie 2: Créer le bouton "Déléguer" ici.

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);

Relions cette condition dans la fonction run(). Lorsque useCoralDelegate est défini sur "false", il doit exécuter la version du processeur. Sinon, il exécutera la version de Coral (mais pour le moment, il ne fera rien). Encapsulez le code d'exécution du modèle de processeur dans une instruction "if". Notez que le Tensor expanded n'est pas inclus dans l'instruction "if", car le modèle Coral l'utilise.

Atelier de programmation partie 2: Vérifier ici si le délégué doit être utilisé

// 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);
}

Exécuter le modèle

La version Coral du modèle attend des Tensors uint8 compris entre 0 et 255. Il n'est donc pas nécessaire de normaliser ses entrées. Cependant, la sortie est également un Tensor uint8 compris entre 0 et 255. Elle doit être convertie en valeur flottante comprise entre 0 et 100 avant de s'afficher.

ATELIER DE CODES 2: Exécuter la prédiction Coral ici (Cela fait partie de l'extrait de code ci-dessus.)

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);

Exécutez à nouveau l'application avec yarn start. Elle devrait afficher les classifications de l'accélérateur Coral.

Vous pouvez basculer entre l'inférence Corail et l'inférence CPU en appuyant sur le bouton. Vous remarquerez peut-être que les classements de confiance du modèle Coral sont moins précis que ceux du modèle du processeur et qu'ils se terminent généralement par une décimale égale. Cette perte de précision est un compromis de l'exécution d'un modèle quantifié sur Coral. Dans la pratique, cela n'a généralement pas d'importance, mais c'est un point à garder à l'esprit.

Remarque sur les performances

La fréquence d'images que vous voyez comprend le prétraitement et le post-traitement, elle n'est donc pas représentative des capacités du matériel Coral. Vous pouvez vous faire une meilleure idée des performances en cliquant sur le compteur de FPS jusqu'à ce qu'il affiche la latence (en millisecondes), ce qui mesure uniquement l'appel à model.predict. Toutefois, cela inclut toujours le temps nécessaire pour déplacer les Tensors vers les liaisons C natives TFLite, puis vers l'appareil Coral. Ce n'est donc pas une mesure parfaite. Pour obtenir des analyses comparatives de performances plus précises écrites en C++, consultez la page d'analyse comparative EdgeTPU.

Notez également que la vidéo a été enregistrée sur un ordinateur portable et non sur un Raspberry Pi. Le FPS peut donc être différent.

Accélérer le prétraitement de Coral

Dans certains cas, vous pouvez accélérer le prétraitement en changeant de backend TFJS. Le backend par défaut est WebGL, qui convient aux opérations volumineuses et parallélisables. Toutefois, cette application n'effectue pas une grande partie de cette opération lors de la phase de prétraitement (seule l'opération qu'elle utilise est expandDims, qui n'est pas parallèle). Vous pouvez basculer vers le backend du processeur pour éviter la latence supplémentaire liée au déplacement des Tensors vers et depuis le GPU en ajoutant cette ligne après les importations en haut du fichier.

tf.setBackend(‘cpu');

Cela affecte également le prétraitement du modèle de processeur TFLite, qui est parallélisé, si bien que le modèle s'exécute beaucoup plus lentement avec ce changement.

6. Accélérer le modèle de processeur avec WebNN

Si vous ne disposez pas d'un accélérateur Coral, ou si vous souhaitez simplement essayer un autre moyen d'accélérer le modèle, vous pouvez utiliser le délégué WebNN TFLite. Ce délégué utilise du matériel de machine learning intégré aux processeurs Intel pour accélérer l'inférence de modèle avec le kit OpenVINO. Par conséquent, il présente des exigences supplémentaires qui n'ont pas été abordées dans la section de configuration de cet atelier de programmation, et vous devrez installer le kit OpenVINO. Avant de continuer, vérifiez votre configuration par rapport aux plates-formes système cibles compatibles. Notez toutefois que le délégué WebNN n'est pas encore compatible avec macOS.

Installer le kit OpenVINO

Le kit OpenVINO utilise du matériel de machine learning intégré aux processeurs Intel pour accélérer les modèles. Vous pouvez télécharger une version précompilée à partir d'Intel ou la compiler à partir de la source. Il existe plusieurs façons d'installer OpenVINO, mais dans le cadre de cet atelier de programmation, nous vous recommandons d'utiliser le script du programme d'installation pour Windows ou Linux. Veillez à installer la version d'exécution LTS 2021.4.2, car les autres versions peuvent ne pas être compatibles. Après avoir exécuté le programme d'installation, veillez à configurer les variables d'environnement de votre shell comme décrit dans les instructions d'installation pour Linux ou Windows ( solution permanente), ou en exécutant la commande setupvars.sh (Linux) ou setupvars.bat (Windows) située dans le répertoire webnn-tflite-delegate.

Remarque pour Windows:La commande setupvars.bat n'est pas compatible avec Git bash. Veillez donc à l'exécuter, ainsi qu'à d'autres commandes de cet atelier de programmation, à partir de l'invite de commande Windows.

Vérifier que le délégué WebNN fonctionne

Pour vérifier que le délégué WebNN fonctionne correctement, exécutez les tests d'intégration pour le package webnn-tflite-delegate qui se trouve dans le répertoire racine du dépôt. Pour exécuter les tests d'intégration, exécutez les commandes suivantes dans le répertoire du package:

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

Vous devriez obtenir un résultat semblable à celui-ci:

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.

Un résultat semblable à celui-ci indique une erreur de configuration:

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.

Ce résultat signifie probablement que vous n'avez pas défini les variables d'environnement d'OpenVINO. Pour le moment, vous pouvez les définir en exécutant la commande setupvars.sh (Linux) ou setupvars.bat (Windows), mais vous pouvez les définir définitivement en suivant les instructions concernant Linux ou Windows ( solution permanente). Si vous utilisez Windows, le

setupvars.bat

n'est pas compatible avec Git bash. Veillez donc à l'exécuter, ainsi que les autres commandes de cet atelier de programmation à partir de l'invite de commande Windows.

Installer le délégué WebNN

Une fois OpenVINO installé, vous pouvez accélérer le modèle de processeur avec WebNN. Cette section de l'atelier de programmation s'appuie sur le code que vous avez écrit dans l'atelier "Exécuter le modèle de processeur dans votre application". . Vous pouvez utiliser le code que vous avez écrit à cette étape, mais si vous avez déjà terminé la section Corail, utilisez plutôt le point de contrôle cpu_inference_working pour repartir de zéro.

La partie Node.js du délégué WebNN est distribuée sur npmjs. Pour l'installer, exécutez la commande suivante:

npm install --save webnn-tflite-delegate

Importez ensuite le délégué en ajoutant la ligne suivante en haut du fichier renderer.js:

Atelier de programmation partie 2: Importez le délégué ici.

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

Le délégué WebNN peut s'exécuter sur le processeur ou le GPU. WebNNDevice vous permet de choisir lequel utiliser.

Charger le modèle

Vous êtes maintenant prêt à charger le modèle avec le délégué WebNN activé. Pour Coral, vous avez dû charger un autre fichier de modèle, mais WebNN accepte le même format de modèle que TFLite. Ajoutez WebNNDelegate à la liste des délégués transmis au modèle pour l'activer:

Atelier de programmation partie 2: charger le modèle délégué ici

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

Il n'est pas nécessaire de charger à nouveau les étiquettes, car il s'agit du même modèle.

Ajouter un bouton pour basculer entre le processeur TfLite et le réseau de neurones WebNN

Maintenant que la version WebNN du modèle est prête, ajoutez un bouton permettant de basculer entre l'inférence de processeur WebNN et l'inférence de processeur TfLite. Si vous exécutez les deux en même temps, vous aurez du mal à voir les différences de performances.

Ajoutez le bouton avec le code suivant (notez qu'il ne changera pas encore de modèle):

Atelier de programmation partie 2: Créer le bouton "Déléguer" ici.

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);

Ce code ajoute également un élément div qui vous permettra de configurer les paramètres WebNN dans la section suivante.

Ajouter un menu déroulant pour passer d'un appareil WebNN à un autre

WebNN est compatible avec l'exécution sur processeur et GPU. Vous devez donc ajouter un menu déroulant pour passer de l'un à l'autre. Ajoutez le code suivant après le code qui crée le bouton:

// 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);
}

Si vous exécutez l'application, une liste déroulante affiche "Par défaut", "GPU" et "Processeur". Le choix de l'un d'entre eux ne changera rien pour le moment, car le menu déroulant n'est pas encore connecté.

Modifier l'appareil dans le menu déroulant

Pour associer la liste déroulante afin qu'elle modifie l'appareil WebNN utilisé, ajoutez un écouteur à l'événement change de l'élément de sélecteur de la liste déroulante. Lorsque la valeur sélectionnée change, recréez le modèle WebNN avec l'appareil WebNN correspondant sélectionné dans les options du délégué.

Ajoutez le code suivant après le code qui a ajouté la liste déroulante:

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})],
  });
});

Avec cette modification, le menu déroulant crée un modèle avec les paramètres corrects à chaque modification. Il est maintenant temps de connecter le modèle WebNN et de l'utiliser pour l'inférence.

Exécuter le modèle WebNN

Le modèle WebNN est prêt à être utilisé, mais le bouton permettant de basculer entre le processeur WebNN et le processeur TfLite ne permet pas encore de changer de modèle. Pour changer de modèle, vous devez d'abord renommer la variable model lors du chargement du modèle de processeur TfLite dans la première section de l'atelier de programmation.

Modifiez la ligne suivante...

const model = await loadTFLiteModel(modelPath);

...afin qu'il corresponde à cette ligne.

const cpuModel = await loadTFLiteModel(modelPath);

Maintenant que la variable model a été renommée cpuModel, ajoutez ce qui suit à la fonction run pour choisir le modèle approprié en fonction de l'état du bouton:

Atelier de programmation partie 2: Vérifier ici si le délégué doit être utilisé

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

À présent, lorsque vous exécutez l'application, le bouton bascule entre le processeur TfLite et le réseau WebNN.

Vous pouvez également basculer entre l'inférence GPU WebNN et l'inférence GPU si vous disposez d'un GPU Intel intégré.

Remarque sur les performances

La fréquence d'images que vous voyez comprend le prétraitement et le post-traitement. Elle n'est donc pas représentative des capacités de WebNN. Vous pouvez vous faire une meilleure idée des performances en cliquant sur le compteur de FPS jusqu'à ce qu'il affiche la latence (en millisecondes), ce qui mesure uniquement l'appel à model.predict. Toutefois, cela inclut toujours le temps nécessaire pour déplacer les Tensors vers les liaisons C natives TFLite. Cette mesure n'est donc pas parfaite.

7. Félicitations

Félicitations ! Vous venez de terminer votre tout premier projet Coral / WebNN en utilisant tfjs-tflite-node dans Electron.

Essayez-la et testez-la sur différentes images. Vous pouvez également entraîner un nouveau modèle sur TeachableMachine afin de classifier un élément complètement différent.

Résumé

Dans cet atelier de programmation, vous avez appris ce qui suit :

• Installer et configurer le package npm tfjs-tflite-node pour exécuter des modèles TFLite en Node.js
• Installer la bibliothèque d'exécution Edge TPU pour exécuter des modèles sur un appareil Coral
• Comment accélérer l'inférence de modèle à l'aide d'un TPU Coral Edge.
• Comment accélérer l'inférence de modèle avec WebNN.

Et ensuite ?

Maintenant que vous disposez d'une base de travail, quelles idées créatives pouvez-vous proposer pour étendre cet outil d'exécution de modèle de machine learning à un cas d'utilisation réel sur lequel vous êtes susceptible de travailler ? Vous pourriez peut-être révolutionner le secteur dans lequel vous travaillez grâce à des inférences rapides et abordables, ou modifier un grille-pain pour qu'il arrête de griller lorsque le pain vous semble parfait. Les possibilités sont innombrables.

Pour aller plus loin et en savoir plus sur la façon dont TeachableMachine a entraîné le modèle que vous avez utilisé, consultez notre atelier de programmation sur l'apprentissage par transfert. Si vous recherchez d'autres modèles compatibles avec Coral, comme la reconnaissance vocale et l'estimation des postures, accédez à coral.ai/models. Vous trouverez également les versions de processeur de ces modèles et bien d'autres sur TensorFlow Hub.

Partagez vos créations

Vous pouvez facilement étendre ce que vous avez créé aujourd'hui à d'autres cas d'utilisation créatifs. Nous vous encourageons à sortir des sentiers battus et à continuer à pirater.

N'oubliez pas de nous taguer sur les réseaux sociaux avec le hashtag #MadeWithTFJS. Votre projet sera peut-être présenté sur notre blog TensorFlow, voire dans des événements à venir. Nous serions ravis de découvrir vos créations.

Sites Web à consulter

• Site Web officiel de TensorFlow.js
• Modèles prédéfinis TensorFlow.js
• API TensorFlow.js
• TensorFlow.js Show & Raconter