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, puis à 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'une 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 de bonnes performances sur un ordinateur de bureau en utilisant l'accélérateur WebNN à la place.

Objectifs de l'atelier

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

• 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, si disponible.
• Utilise WebNN pour améliorer les performances, si cette fonctionnalité est compatible avec votre plate-forme.

Points abordés

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

Cet atelier de programmation est consacré à TFLite dans 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 effectuer cet atelier de programmation, vous avez besoin des éléments suivants :

• Un ordinateur équipé d'une webcam.
• Pour Coral, nous recommandons un Raspberry Pi exécutant Raspberry Pi OS (64 bits) avec bureau.
• Pour WebNN, nous recommandons une machine Intel x86-64 exécutant Ubuntu 20.04 ou Windows 10.
• Version Node.js >= 12.
• Connaissances en JavaScript
• (Recommandé) Un accélérateur USB Coral pour accélérer le modèle.

2. Configuration

Obtenir le code

Pour ce projet, nous avons regroupé tout le code dont vous avez besoin 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 exécutant Raspberry Pi OS (64 bits) avec bureau. Cela permet de connecter facilement un accélérateur Coral.

Il est vivement recommandé d'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 l'atelier de programmation se trouvent dans le répertoire tfjs-tflite-node-codelab (dans sig-tfjs). Dans ce répertoire, vous trouverez des sous-répertoires nommés starter_code, cpu_inference_working, coral_inference_working et webnn_inference_working. Il s'agit de points de contrôle pour les étapes de cet atelier de programmation.

Parmi les autres fichiers du dépôt figurent 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-le en suivant les instructions pour votre plate-forme.

Sous Linux / Raspberry Pi

Sur Linux, la bibliothèque est disponible à partir du PPA de Google en tant que package Debian, libedgetpu1-std, pour les architectures x86-64 et Armv8 (64 bits). Si votre processeur 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

Sur Windows / Autres OS

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

Redémarrer votre appareil

Une fois le runtime Edge TPU installé, redémarrez l'appareil pour activer la nouvelle règle Udev Coral 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, branchez 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 en suivant les instructions 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.

Le résultat doit ressembler à ce qui suit :

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 inquiétez pas d'installer @tensorflow/tfjs-node, comme indiqué dans les journaux, car vous exécuterez le modèle dans TFLite.

Si le résultat 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 d'avoir 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 en informer en signalant un 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 le répertoire 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 le flux vidéo de la webcam de votre ordinateur devrait 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 reconstruire les packages endommagés.

Quel est notre point de départ ?

Notre point de départ est une application d'appareil photo Electron de base, conçue spécialement pour cet atelier de programmation. Nous avons simplifié le code pour montrer les concepts abordés dans cet atelier de programmation, c'est pourquoi il offre peu de gestion des erreurs. Si vous choisissez de réutiliser l'un de ces codes dans une application de production, assurez-vous de gérer les erreurs et de tester entièrement tous les codes.

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. Il contrôle ce qui s'affiche sur la page, y compris le flux vidéo et les éléments HTML, et c'est là que vous ajoutez votre modèle de machine learning à l'application. Parmi les autres fichiers se trouve un fichier index.html, mais il ne fait que charger le fichier renderer.js. Il existe également un fichier main.js, qui est le point d'entrée pour Electron. Il contrôle le cycle de vie de l'application, y compris ce qui doit être affiché lorsqu'elle est ouverte et ce qui doit se passer lorsqu'elle est fermée, mais vous n'aurez pas besoin de le modifier.

Ouvrir le débogueur

Vous devrez peut-être déboguer votre application en suivant cet atelier de programmation. Comme cette application est basée sur Electron, elle intègre le débogueur Chrome. Sur la plupart des plates-formes, vous pouvez l'ouvrir avec 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 en entrée et leur attribue des libellés. Pour cet atelier de programmation, vous utiliserez Teachable Machine pour entraîner un modèle dans votre navigateur. Pour accélérer l'entraînement pour 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 détecteur de personnes est un bon point de départ. Il détecte simplement si une personne se trouve dans le cadre.

1. Ouvrez la page d'entraînement 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 cours.
4. Lorsque vous avez collecté suffisamment de données pour chaque classe (50 échantillons suffisent généralement), appuyez sur Train Model (Entraîner le modèle).

Une fois l'entraînement du modèle terminé, vous devriez voir un aperçu de son résultat.

Essayez de fournir différentes entrées au modèle. Si vous trouvez une entrée qui a été classée de manière incorrecte, 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 devrez télécharger deux versions distinctes du modèle.
6. Exportez votre modèle en tant que modèle TensorFlow Lite à virgule flottante. 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. Un fichier nommé converted_edgetpu.zip, qui s'exécute sur Coral Edge TPU, est alors téléchargé.

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

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

Maintenant que vous avez entraîné un modèle, il est temps de l'ajouter à votre application. À la fin de cette section, l'application pourra exécuter votre modèle à l'aide du 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é lorsque vous avez entraîné le classificateur. L'archive contient deux fichiers. model_uquant.tflite est le modèle TFLite enregistré, y compris le graphique et les poids du modèle. labels.txt contient les libellés lisibles par l'utilisateur pour les classes que le modèle prédit. Placez les deux fichiers dans le 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 de TensorFlow.js pour exécuter des 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 avec cette commande :

npm install --save tfjs-tflite-node

Une fois installé, ajoutez-le à l'application en haut de renderer.js :

ATELIER DE PROGRAMMATION, PARTIE 1 : Importer tfjs-tflite-node.

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

Charger le modèle

Vous êtes maintenant prêt à charger le modèle. tfjs-tflite-node fournit la fonction loadTFLiteModel pour ce faire. Il peut charger des modèles à partir d'un chemin d'accès à un fichier, d'un ArrayBuffer ou d'une URL TFHub. Pour charger votre modèle et ses pondérations, ajoutez ce code à la fonction main :

PARTIE 1 DE L'ATELIER DE PROGRAMMATION : chargez 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 se fait en trois étapes. Tout d'abord, vous extrayez et prétraitez un frame d'entrée de la webcam. Vous exécutez ensuite le modèle sur ce frame et obtenez une prédiction. Ensuite, vous affichez la prédiction 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 frames qu'elle affiche ne sont pas disponibles pour le fichier JavaScript renderer.js. Pour extraire des frames de la webcam, TensorFlow.js fournit tf.data.webcam, qui fournit une méthode capture() facile à utiliser pour capturer des frames à partir de la caméra.

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

CODELAB, partie 1 : Configurez tf.data.webcam ici.

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

Ensuite, pour capturer une image à chaque frame, ajoutez ce qui suit à run() :

PARTIE 1 DE L'ATELIER DE PROGRAMMATION : Capturez les frames de la webcam ici.

const image = await tensorCam.capture();

Vous devez également prétraiter chaque frame pour qu'il 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 s'attend donc à une image RVB de 224 x 224 pixels. tensorCam.capture() donne une forme [224, 224, 3]. Vous devez donc ajouter une dimension supplémentaire au début du Tensor avec tf.expandDims. De plus, le modèle de processeur attend une entrée 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 modifier sa plage de [0, 255] à [0, ~2], puis soustraire 1 pour obtenir la plage souhaitée [-1, ~1]. Pour ce faire, ajoutez les lignes suivantes à tf.tidy() dans la fonction run() :

Atelier de programmation, partie 1 : 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() le fait automatiquement pour le code contenu dans son rappel, mais il ne prend pas en charge les fonctions asynchrones. Vous devrez supprimer manuellement le Tensor d'image que vous avez créé précédemment en appelant sa méthode dispose().

CODELAB part 1: Dispose webcam frames here.

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é. Cela renvoie un Tensor à une dimension contenant la probabilité prédite de chaque libellé. Multipliez cette probabilité par 100 pour obtenir le pourcentage de chance de chaque libellé, 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 plaçant des appels à stats.begin et stats.end autour de model.predict.

CODELAB 1 : Exécutez le modèle et affichez 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

Dans sa configuration actuelle, le modèle s'exécute sur le processeur. Cela ne pose pas de problème pour les ordinateurs de bureau et la plupart des ordinateurs portables, mais peut ne pas être 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 peut ne pas être assez rapide pour certaines applications. Pour améliorer les performances sans utiliser une machine plus rapide, vous pouvez utiliser du silicium spécifique à l'application sous la forme d'un Coral Edge TPU.

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

Si vous ne possédez 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. Toutefois, vous pouvez utiliser le point de contrôle cpu_inference_working si vous souhaitez repartir de zéro.

Les étapes d'exécution du modèle Coral sont presque identiques à celles du modèle CPU. La principale différence réside dans le format du modèle. Le modèle est quantifié, car Coral n'accepte que les tenseurs uint8. 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 TPU Coral. Teachable Machine a déjà effectué cette étape, mais vous pouvez apprendre à le faire pour d'autres modèles en consultant la documentation Coral.

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

Décompressez le fichier modèle converted_edgetpu.zip que vous avez téléchargé lorsque vous avez entraîné le classificateur. L'archive contient deux fichiers. model_edgetpu.tflite est le modèle TFLite enregistré, y compris le graphique et les poids du modèle. labels.txt contient les libellés lisibles par l'utilisateur pour les classes que le modèle prédit. Placez le fichier du 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 depuis JavaScript, installez le package coral-tflite-delegate :

npm install --save coral-tflite-delegate

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

CODELAB part 2: Import the delegate here.

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

Charger le modèle

Vous êtes maintenant prêt à charger le modèle Coral. Pour ce faire, procédez de la même manière que pour le modèle de CPU, sauf que vous transmettez maintenant des options à la fonction loadTFLiteModel pour charger le délégué Coral.

CODELAB, partie 2 : Chargez 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);

Vous n'avez pas besoin de charger les libellés, car ils sont identiques à ceux du modèle de processeur.

Ajouter un bouton pour basculer entre le CPU et Coral

Vous allez ajouter le modèle Coral à côté du modèle de processeur que vous avez ajouté dans la dernière section. Il est difficile de voir les différences de performances si vous les exécutez en même temps. Un bouton bascule donc entre l'exécution Coral et l'exécution CPU.

Ajoutez le bouton avec ce code :

CODELAB : créez le bouton de délégué 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);

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

CODELAB, partie 2 : Vérifiez s'il faut utiliser le délégué ici.

// 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 s'attend à des Tensors uint8 de 0 à 255. Son entrée n'a donc pas besoin d'être normalisée. Toutefois, la sortie est également un Tensor uint8 dans la plage de 0 à 255. Il doit être converti en float de 0 à 100 avant d'être affiché.

CODELAB part 2: Run Coral prediction here. (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 Coral 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 CPU et qu'ils se terminent généralement par un nombre décimal pair. Cette perte de précision est un compromis pour exécuter un modèle quantifié sur Coral. En pratique, cela n'a généralement pas d'importance, mais il est bon de le garder à l'esprit.

Remarque sur les performances

La fréquence d'images que vous voyez inclut le prétraitement et le post-traitement. Elle n'est donc pas représentative des capacités du matériel Coral. Pour mieux comprendre les performances, cliquez sur le compteur FPS jusqu'à ce qu'il affiche la latence (en millisecondes), 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 de TFLite, puis vers l'appareil Coral. Il ne s'agit donc pas d'une mesure parfaite. Pour obtenir des benchmarks de performances plus précis écrits en C++, consultez la page Benchmark Edge TPU.

Notez également que la vidéo a été enregistrée sur un ordinateur portable et non sur un Raspberry Pi. Il est donc possible que vous voyiez un nombre d'images par seconde différent.

Accélérer le prétraitement 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 est adapté aux opérations volumineuses et parallélisables. Toutefois, cette application n'en effectue pas beaucoup dans la phase de prétraitement (la seule opération qu'elle utilise est expandDims, qui n'est pas parallèle). Vous pouvez passer au backend CPU pour éviter la latence supplémentaire liée au transfert des Tensors vers et depuis le GPU. Pour ce faire, ajoutez la ligne suivante après les importations en haut du fichier.

tf.setBackend(‘cpu');

Cela affecte également le prétraitement du modèle TFLite pour le processeur, qui est parallélisé. Le modèle s'exécute donc beaucoup plus lentement avec cette modification.

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

Si vous ne possédez pas d'accélérateur Coral ou si vous souhaitez simplement essayer une autre méthode pour accélérer le modèle, vous pouvez utiliser le délégué WebNN TFLite. Ce délégué utilise le matériel de machine learning intégré aux processeurs Intel pour accélérer l'inférence de modèle avec la boîte à outils 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. Vous devrez installer le kit d'outils OpenVINO. Avant de continuer, assurez-vous de vérifier votre configuration par rapport aux plates-formes de système cible compatibles. Notez toutefois que le délégué WebNN n'est pas encore compatible avec macOS.

Installer le kit d'outils OpenVINO

La boîte à outils OpenVINO utilise le 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 depuis Intel ou la compiler à partir de la source. Il existe plusieurs façons d'installer OpenVINO, mais pour cet atelier de programmation, nous vous recommandons d'utiliser le script 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, assurez-vous de 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 concernant Windows : La commande 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.

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 situé 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

Le résultat doit ressembler à ce qui suit :

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.

Si vous obtenez un résultat semblable à celui-ci, cela 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.

Cette sortie signifie très probablement que vous n'avez pas défini les variables d'environnement d'OpenVINO. Pour l'instant, vous pouvez les définir en exécutant la commande setupvars.sh (Linux) ou setupvars.bat (Windows). Toutefois, vous pouvez les définir de manière permanente en suivant les instructions pour Linux ou Windows ( solution permanente). Si vous utilisez Windows, le

setupvars.bat

La commande ne prend pas en charge Git Bash. Assurez-vous donc de l'exécuter, ainsi que les autres commandes de cet atelier de programmation, à partir de l'invite de commandes Windows.

Installer le délégué WebNN

Maintenant qu'OpenVINO est installé, vous êtes prêt à 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 la section "Exécuter le modèle de CPU dans votre application". Vous pouvez utiliser le code que vous avez écrit à cette étape, mais si vous avez déjà terminé la section Coral, 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 cette ligne en haut du fichier renderer.js :

CODELAB part 2: Import the delegate here.

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

Le délégué WebNN est compatible avec l'exécution sur le CPU ou le GPU. WebNNDevice vous permet de choisir celui à utiliser.

Charger le modèle

Vous êtes maintenant prêt à charger le modèle avec le délégué WebNN activé. Pour Coral, vous deviez charger un fichier de modèle différent, mais WebNN est compatible avec 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 :

CODELAB, partie 2 : Chargez le modèle délégué ici.

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

Vous n'avez pas besoin de charger à nouveau les libellés, car il s'agit du même modèle.

Ajouter un bouton pour basculer entre le processeur TFLite et WebNN

Maintenant que la version WebNN du modèle est prête, ajoutez un bouton pour basculer entre l'inférence WebNN et l'inférence CPU TfLite. Si vous les exécutez en même temps, il sera difficile de voir les différences de performances.

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

CODELAB : créez le bouton de délégué 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 que vous utiliserez pour configurer les paramètres WebNN dans la section suivante.

Ajouter un menu déroulant pour basculer entre les appareils WebNN

WebNN est compatible avec l'exécution sur CPU et GPU. Ajoutez donc un menu déroulant pour basculer entre les deux. Ajoutez ce code après celui 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 à présent, un menu déroulant affichant "Default" (Par défaut), "GPU" et "CPU" s'affiche. Pour le moment, le fait de choisir l'une d'elles n'aura aucun effet, car le menu déroulant n'a pas encore été associé.

Faire en sorte que le menu déroulant modifie l'appareil

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

Ajoutez le code suivant après le code qui a ajouté le menu déroulant :

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 ce changement, le menu déroulant crée un modèle avec les paramètres corrects chaque fois qu'il est modifié. 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 WebNN et le processeur TfLite ne change pas encore de modèle. Pour changer de modèle, vous devez d'abord renommer la variable model à partir du moment où vous avez chargé le modèle CPU TfLite dans la première section de l'atelier de programmation.

Modifiez la ligne suivante…

const model = await loadTFLiteModel(modelPath);

… pour qu'elle corresponde à cette ligne.

const cpuModel = await loadTFLiteModel(modelPath);

La variable model ayant été renommée cpuModel, ajoutez-la à la fonction run pour choisir le bon modèle en fonction de l'état du bouton :

CODELAB, partie 2 : Vérifiez s'il faut utiliser le délégué ici.

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

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

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

Remarque sur les performances

La fréquence d'images que vous voyez inclut le prétraitement et le post-traitement. Elle n'est donc pas représentative des capacités de WebNN. Pour mieux comprendre les performances, cliquez sur le compteur FPS jusqu'à ce qu'il affiche la latence (en millisecondes), 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 de TFLite. Il ne s'agit donc pas d'une mesure parfaite.

7. Félicitations

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

Essayez-le et testez-le sur différentes images. Vous pouvez également entraîner un nouveau modèle sur Teachable Machine pour classer quelque chose de complètement différent.

Résumé

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

• Comment installer et configurer le package npm tfjs-tflite-node pour exécuter des modèles TFLite dans Node.js.
• Découvrez comment installer la bibliothèque d'exécution Edge TPU pour exécuter des modèles sur un appareil Coral.
• Découvrez comment accélérer l'inférence de modèle à l'aide d'un Coral Edge TPU.
• Découvrez 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 mettre en place pour étendre ce runner de modèle de machine learning à un cas d'utilisation réel sur lequel vous travaillez peut-être ? Vous pourriez révolutionner votre secteur d'activité grâce à une inférence rapide et abordable, ou modifier un grille-pain pour qu'il arrête de griller le pain quand il est juste à point. Les possibilités sont infinies.

Pour aller plus loin et en savoir plus sur la façon dont Teachable Machine 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 fonctionnant avec Coral, comme la reconnaissance vocale et l'estimation de pose, consultez coral.ai/models. Vous trouverez également des versions CPU de ces modèles et de nombreux 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 à innover.

N'oubliez pas de nous taguer sur les réseaux sociaux avec le hashtag #MadeWithTFJS. Votre projet sera peut-être mis en avant sur notre blog TensorFlow ou lors de prochains événements. 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 & Tell