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

1. Présentation

54e81d02971f53e8.png

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 créez une application Electron qui affiche les images d'une webcam et les classe à l'aide d'un TPU Edge TPU. Une version entièrement opérationnelle 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 suivre cet atelier de programmation sans utiliser un appareil Coral et obtenir de bonnes performances sur un ordinateur 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 les 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 augmenter les performances, le cas échéant.
  • Utilise WebNN pour augmenter les performances, si cette fonctionnalité est compatible avec votre plate-forme.

Points abordés

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

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

Prérequis

Pour suivre cet atelier de programmation, vous avez besoin des éléments suivants:

2. Configuration

Récupérer le code

Nous avons placé tout le code nécessaire 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 exécutant Raspberry Pi OS (64 bits) avec ordinateur de bureau. Cela vous permet de connecter facilement un accélérateur Coral.

Fortement recommandé: utilisez 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 dans cet atelier de programmation sont situés 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. Voici les 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 effectuer des tests afin de vous assurer que votre environnement est correctement configuré.

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

Pour utiliser des appareils Coral, vous devez installer la bibliothèque d'exécution Edge TPU. Installez-le en suivant les instructions applicables à votre plate-forme.

Sous Linux / Raspberry Pi

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

Exécutez la commande suivante pour ajouter le CPP de Google et installer la bibliothèque d'environnements d'exécution Edge TPU.

# 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 / Autres systèmes d'exploitation

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

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 que le programme d'installation a ajoutée.

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 du package coral-tflite-delegate. Ce package se trouve dans le répertoire racine du dépôt. Pour lancer les tests d'intégration, branchez votre accélérateur Coral et exécutez ces commandes dans le répertoire du package:

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

Vous devez obtenir le résultat suivant:

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.

Vous n'avez pas besoin d'installer @tensorflow/tfjs-node, comme indiqué dans les journaux, car vous allez exécuter le modèle dans TFLite.

Si la sortie contient à la place la valeur 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 sur 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, veuillez nous en informer en envoyant 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 vous lancer.

  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 montrant un flux vidéo provenant de la webcam de votre ordinateur doit s'ouvrir.

Quel est notre point de départ ?

Vous allez utiliser une application basique de caméra Electron conçue pour cet atelier de programmation. Nous avons simplifié le code pour montrer les concepts abordés dans l'atelier de programmation, car il permet de gérer très facilement les erreurs. Si vous décidez de réutiliser le code dans une application en production, vérifiez que vous gérez toutes les erreurs et testez l'ensemble du code.

Application de base pour l'électron avec flux en direct de la caméra de l'appareil.

Explorez le code de démarrage

Ce code de démarrage contient beaucoup de fichiers, mais seul celui que vous devez modifier est renderer.js. Elle contrôle le contenu de la page, y compris le flux vidéo et les éléments HTML, et vous y ajoutez votre modèle de machine learning. Parmi les autres fichiers se trouve un fichier index.html, qui se charge simplement du fichier renderer.js. Il contient également un fichier main.js, qui correspond au point d'entrée d'Electron. Elle contrôle le cycle de vie de l'application, y compris ce qui doit être affiché à l'ouverture et la marche à suivre lorsqu'elle est fermée. Toutefois, 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. Comme cette application est basée sur Electron, elle dispose du débogueur Chrome intégré. Sur la plupart des plates-formes, vous pouvez l'ouvrir en appuyant sur 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 beaucoup d'autres choses à découvrir ici. Alors, passons à l'entraînement du classificateur d'images.

3. Entraîner un classificateur d'images

Dans cette section, vous allez entraîner les versions de 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. 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 un ordinateur portable au lieu d'un Raspberry Pi, mais vous devrez copier les fichiers obtenus dans 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 un cadre.

  1. Ouvrez la page d'entraînement de Teachable Machine dans un nouvel onglet.
  2. Sélectionnez Image Project (Projet d'image), puis Standard image model (Modèle d'image standard).
  3. Ajoutez des échantillons d'images pour chaque classe. Pour cela, la méthode la plus simple consiste à utiliser une webcam. Vous pouvez aussi renommer les classes.
  4. Lorsque vous avez recueilli suffisamment de données pour chaque classe (50 échantillons sont généralement suffisants), appuyez sur le modèle d'entraînement.

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

Un modèle est entraîné à partir d'images de deux classes, "Person" (Personne) et "No Person" (Aucune personne). Une démonstration du modèle entraîné s'exécute sur des images issues de l'appareil photo de l'appareil, et le modèle lui-même peut être téléchargé dans plusieurs formats.

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

  1. Une fois que 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.
  2. Exporter votre modèle en tant que modèle à virgule flottante TensorFlow Lite Un fichier nommé converted_tflite.zip est alors téléchargé. exécuté sur le processeur.
  3. Exportez votre modèle en tant que modèle TPU Lite TensorFlow. Un fichier nommé converted_edgetpu.zip s'exécute sur le TPU Edge TPU.

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 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é lors de l'entraînement du classificateur. L'archive contient deux fichiers. model_uquant.tflite correspond au modèle TFLite enregistré, y compris le graphique et les pondérations. labels.txt contient les étiquettes lisibles pour les classes prédites par le modèle. Placez les deux fichiers dans l'annuaire de modèles.

Installer les 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 la commande suivante:

npm install --save tfjs-tflite-node

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

Partie 1 de l'atelier de programmation: importer tfjs-tflite-node.

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

Charger le modèle

Vous êtes maintenant prêt à 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 de fichier, d'un ArrayBuffer ou d'une URL TFHub. Pour charger votre modèle et ses pondérations, ajoutez ce qui suit à la fonction main:

Partie 1 du code LAB: 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 s'effectue en trois étapes. Tout d'abord, vous allez extraire et prétraiter une image de saisie à partir de la webcam. Vous exécutez ensuite le modèle sur cette image et obtenez une prédiction. La prédiction s'affiche ensuite sur la page.

Prétraiter la saisie par webcam

Pour le moment, la webcam n'est qu'un élément HTML, et les images qu'elle affiche ne sont pas disponibles avec le fichier JavaScript renduer.js. Pour extraire des images de la webcam, TensorFlow.js propose l'outil tf.data.webcam. Il s'agit d'une méthode capture() facile à utiliser qui permet de capturer des images de l'appareil photo.

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 image, ajoutez les lignes suivantes à run():

Partie 1 de l'atelier de programmation: capturez les images de la webcam ici.

const image = await tensorCam.capture();

Vous devez également prétraiter chaque image pour la rendre compatible avec le modèle. Le modèle utilisé par cet atelier de programmation présente 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 [224, 224, 3]. Vous devez donc ajouter une dimension supplémentaire devant le Tensor avec tf.expandDims. En outre, le modèle de processeur attend une entrée Float32 entre -1 et 1, mais la webcam enregistre des valeurs comprises entre 0 et 255. Vous pouvez diviser le Tensor d'entrée par 127 pour remplacer la plage [0, 255] par [0, ~2], puis soustraire 1 pour obtenir la plage [-1, ~1] souhaitée. Pour ce faire, ajoutez les lignes suivantes à tf.tidy() dans la fonction run():

CODELAB 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 se débarrasser des Tensors après les avoir utilisés. tf.tidy() s'en charge 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().

Supprimez l'image d'image des webcams figurant dans le CODELAB (partie 1).

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 unidimensionnel contenant la probabilité prédite de chaque étiquette. Multipliez cette probabilité par 100 pour obtenir le pourcentage de probabilité de chaque étiquette et utilisez la fonction showPrediction incluse avec le code de démarrage pour afficher la prédiction du modèle à l'écran.

Ce code utilise également stats.js pour mesurer la durée de la prédiction en passant des appels à stats.begin et stats.end autour de model.predict.

Partie 1 de l'atelier de programmation: 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.

Le modèle de processeur TFLite s'exécute dans l'application Electron. Il classe les images provenant de la webcam et affiche les valeurs de confiance pour chaque classe ci-dessous.

Performances

Comme il est actuellement configuré, le modèle s'exécute sur le processeur. Ce n'est pas un problème pour les ordinateurs de bureau et la plupart des ordinateurs portables, mais il n'est pas souhaitable qu'il soit exécuté sur un Raspberry Pi ou un autre appareil à faible consommation d'énergie. 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 avoir à utiliser une machine plus rapide, vous pouvez utiliser du silicium spécifique à l'application, sous la forme d'un TPU Coral Edge.

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 s'appuie sur le code que vous avez rédigé dans la section précédente, mais vous pouvez utiliser le point de contrôle cpu_inference_working si vous souhaitez commencer avec un écran épuré.

Les étapes à suivre pour exécuter le modèle Coral sont presque identiques à celles pour l'exécution du modèle de processeur. La principale différence est 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. Autre différence : les modèles doivent être compilés à l'aide du compilateur Edge TPU pour s'exécuter sur un TPU TPU. TeachableMachine 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 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 correspond au modèle TFLite enregistré, y compris le graphique et les pondérations. labels.txt contient les étiquettes lisibles pour les classes prédites par le modèle. Placez le fichier de modèle dans le répertoire coral_model.

Installer les dépendances

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

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:

Partie 2 de l'atelier de programmation: 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. Vous pouvez procéder de la même manière que pour le modèle de processeur, mais vous devez désormais transmettre des options à la fonction loadTFLiteModel pour charger le délégué Coral.

PARTIE 2 du CODELAB: chargez le modèle de délégation 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 étiquettes, car elles sont identiques à celles du modèle de processeur.

Ajoutez un bouton pour passer du processeur au coral

Vous allez ajouter le modèle de corail avec le modèle de processeur que vous avez ajouté dans la section précédente. Il est difficile de constater les différences de performances lorsque vous exécutez les deux en même temps. Un bouton d'activation/de désactivation bascule donc entre l'exécution en corail et l'exécution du processeur.

Ajoutez le bouton avec le code suivant:

Partie 2 de l'atelier de programmation: créer le bouton de délégation.

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

Associez cette condition à la fonction run(). Lorsque useCoralDelegate est défini sur "False", il doit exécuter la version du processeur. Sinon, il exécute la version Coral (mais pour l'instant, il ne fait rien). Encapsulez le code pour exécuter le 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.

Partie 2 de l'atelier de programmation: vérifiez si le délégué peut être utilisé 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 attend un Tensor uint8 de 0 à 255. Son entrée n'a donc pas besoin d'être normalisée. Toutefois, 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 pouvoir être affichée.

CODELAB partie 2: Exécutez la prédiction Coral ici. (Il 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 de nouveau l'application avec yarn start. Elle devrait afficher les classifications issues de l'accélérateur Coral.

Les modèles de processeur et de corail s'exécutent un par un dans l'application, et un bouton permet de passer de l'un à l'autre. Le processeur CPU et les coraux représentent environ 20 FPS.

Vous pouvez passer du mode corail à l'inférence du processeur en appuyant sur le bouton. Vous remarquerez peut-être que le niveau de confiance du modèle de corail est moins précis que celui du modèle de processeur et se termine généralement par une décimale. Cette perte de précision est un compromis entre l'exécution d'un modèle quantifié sur Coral. En pratique, ce n'est pas important, mais il est important de garder cela à l'esprit.

Remarque sur les performances

La fréquence d'images affichée inclut le prétraitement et le post-traitement. Elle n'est donc pas représentative de la capacité du matériel Coral. Pour vous faire une meilleure idée des performances, cliquez sur l'outil de mesure du débit FPS jusqu'à ce qu'il affiche la latence (en millisecondes), ce qui mesure uniquement l'appel de model.predict. Cependant, cela inclut le temps nécessaire pour déplacer les Tensors vers les liaisons C natives de TFLite, puis vers l'appareil Coral. Ce n'est donc pas une mesure idéale. Pour obtenir des benchmarks de performances plus précis écrits en C++, consultez la page de benchmark Edge TPU.

Notez également que la vidéo a été enregistrée sur un ordinateur portable et non sur un Raspberry Pi. Par conséquent, il se peut qu'un autre FPS soit utilisé.

Accélérer le prétraitement de corail

Dans certains cas, vous pouvez accélérer le prétraitement en basculant les backends TFJS. Le backend par défaut est WebGL, ce qui est utile pour les opérations volumineuses et parallèles, mais cette application n'effectue pas beaucoup de cela pendant 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 du processeur pour éviter la latence supplémentaire du 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èle, de sorte que le modèle s'exécute beaucoup plus lentement avec cette modification.

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

Si vous n'avez pas d'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é TFLite WebNN. 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 à l'aide du kit OpenVINO. Par conséquent, elle présente des exigences supplémentaires qui n'ont pas été abordées dans la section de configuration de cet atelier de programmation. Vous devez donc installer le kit OpenVINO. Avant de continuer, vérifiez votre configuration sur les plates-formes système cibles. 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 depuis Intel ou la créer depuis la source. Il existe plusieurs façons d'installer OpenVINO. Toutefois, pour les besoins 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 2021.4.2 LTS, car d'autres versions peuvent ne pas être compatibles. Après avoir exécuté le programme d'installation, veillez à configurer les variables d'environnement de votre interface système, 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.

Vérifier le fonctionnement du délégué WebNN

Pour vérifier que le délégué WebNN fonctionne correctement, exécutez les tests d'intégration du package webnn-tflite-delegate situé dans le répertoire racine du dépôt. Pour lancer 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 devez obtenir le résultat suivant:

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 un résultat de ce type s'affiche, cela signifie qu'une erreur de configuration s'est produite:

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 aussi les définir définitivement en suivant Linux ou . Instructions Windows ( solution permanente) Si vous utilisez Windows, les

setupvars.bat

commande non compatible avec Git bash. Assurez-vous donc de l'exécuter, ainsi que d'autres commandes de cet atelier de programmation, depuis l'invite de commande Windows.

Installer le délégué WebNN

Une fois OpenVINO installé, vous êtes prêt à accélérer le modèle de processeur avec WebNN. Cette section de l'atelier de programmation repose sur le code que vous avez écrit dans la section "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 Coral, utilisez plutôt le point de contrôle cpu_inference_working pour commencer avec un bon écran.

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

npm install --save webnn-tflite-delegate

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

Partie 2 de l'atelier de programmation: importez le délégué ici.

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

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

Charger le modèle

Vous pouvez à présent charger le modèle avec le délégué WebNN activé. Pour Corail, vous devez charger un fichier de modèle différent, mais WebNN accepte le même format de modèle que TFLite. Ajoutez WebWebDelegate à la liste des délégués transmis au modèle pour l'activer:

PARTIE 2 du CODELAB: chargez le modèle de délégation ici.

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

Vous n'avez pas besoin de charger à nouveau les étiquettes, car le modèle est identique.

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 permettant de passer de WebNN à l'inférence du processeur TfLite. Il peut être difficile de constater les différences de performances si vous les exécutez simultanément.

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

Partie 2 de l'atelier de programmation: créer le bouton de délégation.

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 peut être exécuté sur le processeur et le GPU. Ajoutez un menu déroulant pour passer de l'un à l'autre. Ajoutez ce code 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, un menu déroulant s'affiche. Il s'affiche par défaut, "GPU" et "Processeur". Le fait de choisir l'une de ces options n'a aucun effet sur le moment, car le menu déroulant n'est pas encore connecté. L&#39;application affiche un menu déroulant dans lequel l&#39;appareil WebNN peut être sélectionné par défaut : GPU, GPU ou CPU.

Modifier le menu déroulant pour l'appareil

Pour associer le menu déroulant afin de modifier 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égation.

Après le code de la liste déroulante, ajoutez le code suivant:

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

Désormais, le menu déroulant crée un modèle avec les paramètres appropriés à chaque modification. Vous allez maintenant associer le modèle WebNN et 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 n'entraîne pas encore la conversion du 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);

...pour qu'elle corresponde à cette ligne.

const cpuModel = await loadTFLiteModel(modelPath);

Avec la variable model renommée cpuModel, ajoutez la valeur suivante à la fonction run pour choisir le modèle approprié en fonction de l'état du bouton:

Partie 2 de l'atelier de programmation: vérifiez si le délégué peut être utilisé ici

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

Désormais, lorsque vous exécutez l'application, le bouton passe du processeur TfLite au WebNN. Le modèle de processeur TFLite, ainsi que les modèles de processeur et de GPU WebNN, s&#39;exécutent dans l&#39;application. Lorsque l&#39;un des modèles WebNN est actif, un menu déroulant s&#39;affiche. Le processeur processeur et le modèle WebNN obtiennent environ 15 FPS.

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

Remarque sur les performances

La fréquence d'images affichée inclut le prétraitement et le post-traitement. Elle n'est donc pas représentative de la capacité de WebNN. Pour vous faire une meilleure idée des performances, cliquez sur l'outil de mesure du débit FPS jusqu'à ce qu'il affiche la latence (en millisecondes), ce qui mesure uniquement l'appel de model.predict. Cependant, cela inclut toujours le temps nécessaire pour déplacer les Tensors vers les liaisons C natives de TFLite. Ce n'est donc pas la mesure idéale.

7. Félicitations

Félicitations ! Vous venez de terminer votre tout premier projet Coral / WebNN à l'aide de tfjs-tflite-node dans Electron.

Essayez sur différentes images. Vous pouvez également entraîner un nouveau modèle sur TeachableMachine à classer des éléments complètement différents.

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 dans Node.js.
  • Installer la bibliothèque d'exécution Edge TPU pour exécuter des modèles sur un appareil Coral.
  • Accélérez l'inférence de modèle à l'aide d'un TPU Edge TPU.
  • Accélérer une 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 modèle de machine learning à un cas d'utilisation réel sur lequel vous travaillez ? Vous pouvez révolutionner le secteur avec une inférence rapide et abordable, ou modifier un grille-pain pour qu'il ne s'arrête pas lorsque le pain vous convienne. Les possibilités sont innombrables.

Pour 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 de la posture, consultez la page coral.ai/models. Vous pouvez également trouver des versions de ces modèles de processeur et bien d'autres sur TensorFlow Hub.

Partagez vos créations

Vous pouvez facilement étendre vos créations pour d'autres cas d'utilisation créatifs, et nous vous encourageons à sortir du lot et à pirater votre chaîne.

N'oubliez pas de nous taguer sur les réseaux sociaux à l'aide du hashtag #MadeWithTFJS, et votre projet sera peut-être mis en avant sur notre blog TensorFlow ou même événements futurs. Nous serions ravis de découvrir vos créations.

Sites Web à consulter