1. Introduction
Vous venez de faire vos premiers pas avec TensorFlow.js, d'essayer nos modèles prédéfinis ou même de créer vos propres modèles. Mais vous avez vu que des recherches de pointe ont été menées dans Python et vous aimeriez savoir si elles peuvent s'exécuter dans le navigateur Web et faire en sorte que cette idée intéressante soit devenue réalité pour des millions de personnes de manière évolutive. Cela vous rappelle quelque chose ? Si oui, l'atelier de programmation est fait pour vous !
L'équipe TensorFlow.js a créé un outil pratique pour convertir des modèles au format SavedModel en TensorFlow.js, via un convertisseur de ligne de commande. Vous pouvez ainsi utiliser ces modèles avec la portée et l'échelle du Web.
Points abordés
Dans cet atelier de programmation, vous allez apprendre à utiliser le convertisseur de ligne de commande TensorFlow.js pour transférer un SavedModel généré par Python au format model.json requis pour une exécution côté client dans un navigateur Web.
Plus spécifiquement :
- Créer un modèle de ML Python simple et l'enregistrer au format requis par le convertisseur TensorFlow.js
- Installer et utiliser le convertisseur TensorFlow.js sur le SavedModel que vous avez exporté à partir de Python
- Prenez les fichiers obtenus lors de la conversion et utilisez-les dans votre application Web JavaScript.
- Découvrez ce que vous devez faire en cas de problème (tous les modèles ne sont pas convertis) et les options qui s'offrent à vous.
Imaginez que vous soyez en mesure de mettre ce modèle à la disposition de millions de développeurs JS dans le monde entier, via de nouvelles recherches. Vous pouvez également l'utiliser vous-même dans votre propre création, que n'importe quel internaute peut expérimenter s'il s'exécute dans un navigateur Web, car aucune dépendance complexe ni aucune configuration de l'environnement n'est requise. Prêt à pirater ? C'est parti !
Dites-nous ce que vous convertissez
Vous pouvez utiliser ce que nous avons appris aujourd'hui pour essayer de convertir certains de vos modèles préférés à partir de Python. Si vous parvenez à créer un site Web fonctionnel de démonstration du modèle en action, taguez-nous sur les réseaux sociaux avec le hashtag #MadeWithTFJS. Votre projet sera peut-être présenté sur notre blog TensorFlow, voire sur notre prochain événement show and talk. Nous aimerions que davantage de recherches incroyables soient transposées sur le Web et permettre à un plus grand nombre d'utilisateurs d'utiliser ces modèles de manière innovante ou créative, à l'image de cet exemple.
2. Qu'est-ce que TensorFlow.js ?
TensorFlow.js est une bibliothèque de machine learning Open Source qui peut s'exécuter partout où JavaScript peut être exécuté. Il est basé sur la bibliothèque TensorFlow d'origine écrite en Python et vise à recréer cette expérience de développement et cet ensemble d'API pour l'écosystème JavaScript.
Où l'utiliser ?
Étant donné la portabilité de JavaScript, vous pouvez désormais écrire dans un seul langage et exécuter facilement des modèles de machine learning sur l'ensemble des plates-formes suivantes:
- Côté client dans le navigateur Web en utilisant vanilla JavaScript
- Côté serveur et même appareils IoT comme Raspberry Pi avec Node.js
- Applications de bureau avec Electron
- Applications mobiles natives utilisant React Native
TensorFlow.js est également compatible avec plusieurs backends dans chacun de ces environnements (les environnements matériels dans lesquels il peut s'exécuter, tels que le processeur ou WebGL, par exemple). Un "backend" dans ce contexte ne signifie pas qu'il s'agit d'un environnement côté serveur (le backend d'exécution peut par exemple être côté client dans WebGL) pour assurer la compatibilité et garantir un fonctionnement rapide. Actuellement, TensorFlow.js est compatible avec:
- Exécution WebGL sur la carte graphique de l'appareil (GPU) : il s'agit du moyen le plus rapide d'exécuter des modèles plus volumineux (plus de 3 Mo) avec l'accélération du GPU.
- Exécution de Web Assembly (WASM) sur le processeur : permet d'améliorer les performances du processeur sur tous les appareils, y compris les téléphones mobiles d'ancienne génération, par exemple. Cela est mieux adapté aux modèles plus petits (moins de 3 Mo) qui peuvent s'exécuter plus rapidement sur processeur avec WASM qu'avec WebGL en raison de la surcharge de l'importation de contenu sur un processeur graphique.
- Exécution du processeur : le remplacement si aucun des autres environnements n'est disponible. C'est la plus lente des trois, mais elle est toujours là pour vous.
Remarque:Vous pouvez choisir de forcer l'un de ces backends si vous savez sur quel appareil vous allez exécuter l'exécution, ou laisser TensorFlow.js décider à votre place si vous ne le spécifiez pas.
Super-pouvoirs côté client
L'exécution de TensorFlow.js dans un navigateur Web sur la machine cliente peut offrir plusieurs avantages qu'il convient de prendre en compte.
Confidentialité
Vous pouvez à la fois entraîner et classer les données sur la machine cliente sans jamais envoyer de données à un serveur Web tiers. Dans certains cas, il peut être nécessaire de se conformer à des lois locales, telles que le RGPD, ou de traiter des données que l'utilisateur souhaite conserver sur son ordinateur et non envoyées à un tiers.
Vitesse
Comme vous n'avez pas besoin d'envoyer de données à un serveur distant, l'inférence (autrement dit, la classification des données) peut être plus rapide. Qui plus est, vous pouvez accéder directement aux capteurs de l'appareil (appareil photo, micro, GPS, accéléromètre, etc.) si l'utilisateur vous y autorise.
Portée et évolutivité
En un clic, n'importe quel internaute peut cliquer sur un lien que vous lui envoyez, ouvrir la page Web dans son navigateur et utiliser votre création. Pas besoin d'une configuration Linux complexe côté serveur avec des pilotes CUDA et bien plus encore pour utiliser le système de machine learning.
Coût
L'absence de serveur signifie que vous ne payez qu'un CDN pour héberger vos fichiers HTML, CSS et JS, ainsi que vos fichiers de modèle. Le coût d'un CDN est bien moins cher que d'avoir un serveur (éventuellement connecté à une carte graphique) fonctionnant 24h/24, 7j/7.
Fonctionnalités côté serveur
L'implémentation Node.js de TensorFlow.js permet d'activer les fonctionnalités suivantes.
Compatibilité CUDA complète
Côté serveur, pour accélérer l'accélération de la carte graphique, vous devez installer les pilotes NVIDIA CUDA pour permettre à TensorFlow de fonctionner avec la carte graphique (contrairement au navigateur qui utilise WebGL ; aucune installation n'est requise). Cependant, grâce à la prise en charge complète de CUDA, vous pouvez exploiter pleinement les capacités de niveau inférieur de la carte graphique, ce qui accélère les temps d'entraînement et d'inférence. Les performances sont équivalentes à celles de l'implémentation Python de TensorFlow, car elles partagent le même backend C++.
Taille du modèle
Pour les modèles de pointe issus de la recherche, vous travaillez peut-être avec des modèles très volumineux, pouvant atteindre plusieurs gigaoctets. Ces modèles ne peuvent actuellement pas être exécutés dans le navigateur Web en raison des limites d'utilisation de la mémoire par onglet du navigateur. Pour exécuter ces modèles plus volumineux, vous pouvez utiliser Node.js sur votre propre serveur avec les caractéristiques matérielles requises pour exécuter efficacement un tel modèle.
Internet des objets
Node.js est compatible avec les ordinateurs à carte unique courants tels que Raspberry Pi, ce qui signifie que vous pouvez également exécuter des modèles TensorFlow.js sur ces appareils.
Vitesse
Node.js est écrit en JavaScript, ce qui signifie qu'il bénéficie d'une compilation juste à temps. Cela signifie que vous pouvez souvent constater une amélioration des performances lorsque vous utilisez Node.js, car il sera optimisé au moment de l'exécution, en particulier pour les éventuels prétraitements que vous effectuez. Cette étude de cas en est un bon exemple. Elle montre comment Hugging Face a utilisé Node.js pour multiplier par deux les performances de son modèle de traitement du langage naturel.
Vous connaissez désormais les principes de base de TensorFlow.js, ses emplacements d'exécution et certains de ses avantages. Commençons à l'utiliser !
3. Configuration de votre système
Pour ce tutoriel, nous allons utiliser Ubuntu, une distribution Linux populaire utilisée par de nombreux utilisateurs. Elle est disponible sur Google Cloud Compute Engine en tant qu'image de base si vous choisissez de suivre les instructions d'une machine virtuelle basée sur le cloud.
Au moment de la rédaction de ce document, nous pouvons sélectionner l'image d'Ubuntu 18.04.4 LTS lors de la création d'une instance Compute Engine vanilla, ce que nous allons utiliser. Vous pouvez bien sûr utiliser votre propre machine, ou même un autre système d'exploitation si vous le souhaitez, mais les instructions d'installation et les dépendances peuvent varier d'un système à l'autre.
Installer TensorFlow (version Python)
Étant donné que vous essayez probablement de convertir un modèle existant basé sur Python que vous avez trouvé / ou que vous allez écrire, avant de pouvoir exporter un "SavedModel" de Python, la version Python de TensorFlow doit être configurée sur votre instance si le "SavedModel" n'est pas encore disponible en téléchargement.
Connectez-vous en SSH à la machine cloud que vous avez créée précédemment, puis saisissez la commande suivante dans la fenêtre de terminal:
Fenêtre de terminal:
sudo apt update
sudo apt-get install python3
Cela permet de s'assurer que Python 3 est installé sur la machine. Pour utiliser TensorFlow, vous devez installer Python 3.4 ou une version ultérieure.
Pour vérifier que la version installée est correcte, saisissez la commande suivante:
Fenêtre de terminal:
python3 --version
Vous devriez obtenir un résultat indiquant le numéro de version, par exemple Python 3.6.9. Si la valeur affichée est correcte et qu'elle est supérieure à 3,4, nous pouvons continuer.
Nous allons maintenant installer PIP pour Python 3, le gestionnaire de packages de Python, et le mettre à jour. Type :
Fenêtre de terminal:
sudo apt install python3-pip
pip3 install --upgrade pip
Là encore, nous pouvons vérifier l'installation de pip3 via:
Fenêtre de terminal:
pip3 --version
Au moment de la rédaction de cet article, la commande pip 20.2.3 s'affiche sur le terminal après l'exécution de cette commande.
Avant de pouvoir installer TensorFlow, nous avons besoin du package Python "setuptools" être à partir de la version 41.0.0. Exécutez la commande suivante pour vous assurer qu'elle a bien été mise à jour vers la dernière version:
Fenêtre de terminal:
pip3 install -U setuptools
Enfin, nous pouvons maintenant installer TensorFlow pour Python:
Fenêtre de terminal:
pip3 install tensorflow
Cette opération peut prendre un certain temps. Veuillez donc patienter jusqu'à la fin de son exécution.
Vérifions que TensorFlow est correctement installé. Créez un fichier Python nommé test.py dans votre répertoire actuel:
Fenêtre de terminal:
nano test.py
Une fois nano ouvert, nous pouvons écrire du code Python pour imprimer la version de TensorFlow installée:
test.py:
import tensorflow as tf
print(tf.__version__)
Appuyez sur CTRL + O pour écrire les modifications sur le disque, puis sur CTRL + X pour quitter l'éditeur nano.
Nous pouvons maintenant exécuter ce fichier Python pour voir la version de TensorFlow affichée à l'écran:
Fenêtre de terminal:
python3 test.py
Au moment de la rédaction de ce document, 2.3.1 est affiché sur la console pour la version de TensorFlow Python installée.
4. Créer un modèle Python
La prochaine étape de cet atelier de programmation consiste à créer un modèle Python simple pour montrer comment enregistrer le modèle entraîné obtenu dans le "SavedModel". à utiliser avec notre convertisseur de ligne de commande TensorFlow.js. Le principe serait similaire pour n'importe quel modèle Python que vous essayez de convertir, mais nous allons faire en sorte que ce code reste simple afin que tout le monde puisse le comprendre.
Modifions à présent le fichier test.py que nous avons créé dans la première section et mettons à jour le code comme suit:
test.py:
import tensorflow as tf
print(tf.__version__)
# Import NumPy - package for working with arrays in Python.
import numpy as np
# Import useful keras functions - this is similar to the
# TensorFlow.js Layers API functionality.
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
# Create a new dense layer with 1 unit, and input shape of [1].
layer0 = Dense(units=1, input_shape=[1])
model = Sequential([layer0])
# Compile the model using stochastic gradient descent as optimiser
# and the mean squared error loss function.
model.compile(optimizer='sgd', loss='mean_absolute_error')
# Provide some training data! Here we are using some fictional data
# for house square footage and house price (which is simply 1000x the
# square footage) which our model must learn for itself.
xs = np.array([800.0, 850.0, 900.0, 950.0, 980.0, 1000.0, 1050.0, 1075.0, 1100.0, 1150.0, 1200.0, 1250.0, 1300.0, 1400.0, 1500.0, 1600.0, 1700.0, 1800.0, 1900.0, 2000.0], dtype=float)
ys = np.array([800000.0, 850000.0, 900000.0, 950000.0, 980000.0, 1000000.0, 1050000.0, 1075000.0, 1100000.0, 1150000.0, 1200000.0, 1250000.0, 1300000.0, 1400000.0, 1500000.0, 1600000.0, 1700000.0, 1800000.0, 1900000.0, 2000000.0], dtype=float)
# Train the model for 500 epochs.
model.fit(xs, ys, epochs=500, verbose=0)
# Test the trained model on a test input value
print(model.predict([1200.0]))
# Save the model we just trained to the "SavedModel" format to the
# same directory our test.py file is located.
tf.saved_model.save(model, './')
Ce code va entraîner une régression linéaire très simple pour apprendre à estimer la relation entre les x (entrées) et les y (sorties) fournis. Nous enregistrerons ensuite le modèle entraîné obtenu sur le disque. Consultez les commentaires intégrés pour en savoir plus sur le rôle de chaque ligne.
Si nous vérifions notre répertoire après avoir exécuté ce programme (en appelant python3 test.py), nous devrions maintenant voir de nouveaux fichiers et dossiers créés dans notre répertoire actuel:
- test.py
- saved_model.pb.
- éléments
- variables
Nous avons généré les fichiers que le convertisseur TensorFlow.js doit utiliser pour convertir ce modèle afin qu'il s'exécute dans le navigateur.
5. Convertir un SavedModel au format TensorFlow.js
Installer le convertisseur TensorFlow.js
Pour installer le convertisseur, exécutez la commande suivante:
Fenêtre de terminal:
pip3 install tensorflowjs
C'était facile.
En supposant que nous utilisions le convertisseur de ligne de commande (tensorflowjs_converter) et non la version de l'assistant illustrée ci-dessus, nous pouvons appeler la commande suivante pour convertir le modèle enregistré que nous venons de créer et transmettre explicitement les paramètres au convertisseur:
Fenêtre de terminal:
tensorflowjs_converter \
--input_format=keras_saved_model \
./ \
./predict_houses_tfjs
Que se passe-t-il ici ? Nous appelons d'abord le binaire tensorflowjs_converter que nous venons d'installer et spécifions que nous essayons de convertir un modèle Keras enregistré.
Dans l'exemple de code ci-dessus, vous remarquerez que nous avons importé Keras et utilisé ses API de couches de niveau supérieur pour créer notre modèle. Si vous n'avez pas utilisé Keras dans votre code Python, vous pouvez utiliser un autre format d'entrée:
- keras : permet de charger le format Keras (type de fichier HDF5).
- tf_saved_model : permet de charger un modèle qui utilise les API TensorFlow Core au lieu de Keras.
- tf_frozen_model : permet de charger un modèle contenant des pondérations figées.
- tf_hub : permet de charger un modèle généré à partir de TensorFlow Hub.
En savoir plus sur ces autres formats
Les deux paramètres suivants spécifient le dossier dans lequel se trouve le modèle enregistré. Dans la démonstration ci-dessus, nous spécifions le répertoire actuel, puis nous spécifions le répertoire vers lequel nous souhaitons générer la conversion, que nous avons spécifié ci-dessus en tant que dossier appelé "predict_houses_tfjs". dans le répertoire actuel.
L'exécution de la commande ci-dessus crée un dossier nommé predict_houses_tfjs dans le répertoire actuel, qui contient :.
- model.json
- Groupe1-segment1sur1.bin
Il s'agit des fichiers dont nous avons besoin pour exécuter le modèle dans le navigateur Web. Enregistrez ces fichiers, car nous les utiliserons dans la section suivante.
6. Utiliser notre modèle converti dans le navigateur
Héberger les fichiers convertis
Vous devez d'abord placer les fichiers model.json et *.bin générés sur un serveur Web afin de pouvoir y accéder via notre page Web. Pour cette démonstration, nous allons utiliser Glitch.com afin que vous puissiez facilement suivre la procédure. Toutefois, si vous êtes ingénieur Web, vous pouvez choisir de lancer un simple serveur HTTP sur votre instance de serveur Ubuntu actuelle pour effectuer cette opération. À vous de choisir.
Importer des fichiers dans Glitch
- Connectez-vous à Glitch.com.
- Cliquez sur ce lien pour cloner notre projet TensorFlow.js récurrent. Ce fichier contient un squelette de fichiers html, css et js qui importent la bibliothèque TensorFlow.js, prête à l'emploi.
- Cliquez sur l'onglet "Composants" dans le panneau de gauche.
- Cliquez sur "Importer un asset". et sélectionnez
group1-shard1of1.binpour l'importer dans ce dossier. Une fois l'importation terminée, l'image devrait maintenant ressembler à ceci:
- Si vous cliquez sur le fichier
group1-shard1of1.binque vous venez d'importer, vous pourrez copier l'URL à son emplacement. Copiez maintenant ce chemin d'accès comme indiqué ci-dessous:
- Modifiez maintenant
model.jsonà l'aide de votre éditeur de texte préféré sur votre ordinateur local, puis recherchez (à l'aide de CTRL+F) le fichiergroup1-shard1of1.binqui sera mentionné quelque part dans ce fichier.
Remplacez ce nom de fichier par l'URL que vous avez copiée à l'étape 5, mais supprimez le https://cdn.glitch.com/ initial généré par le glitch à partir du chemin copié.
Une fois la modification effectuée, le résultat devrait ressembler à ceci (notez que le chemin d'accès au serveur principal a été supprimé afin que seul le nom de fichier importé correspondant soit conservé): 
7. Enregistrez et importez ce fichier model.json modifié pour résoudre les problèmes en cliquant sur "Assets", puis sur "Importer un asset" bouton (important). Si vous n'utilisez pas le bouton physique et que vous n'effectuez pas de glisser-déposer, le fichier sera importé en tant que fichier modifiable et non sur le CDN, qui ne se trouvera pas dans le même dossier, et le chemin relatif sera pris en compte lorsque TensorFlow.js tentera de télécharger les fichiers binaires d'un modèle donné. Si vous l'avez fait correctement, vous devriez voir deux fichiers dans le dossier assets comme suit: 
Parfait ! Nous sommes maintenant prêts à utiliser nos fichiers enregistrés avec du code réel dans le navigateur.
Charger le modèle
Maintenant que nous avons hébergé nos fichiers convertis, nous pouvons écrire une page Web simple pour charger ces fichiers et les utiliser pour faire une prédiction. Ouvrez script.js dans le dossier du projet Glitch et remplacez le contenu de ce fichier par ce qui suit après avoir modifié const MODEL_URL pour qu'il pointe vers le lien Glitch.com généré pour le fichier model.json que vous avez importé sur Glitch:
script.js:
// Grab a reference to our status text element on the web page.
// Initially we print out the loaded version of TFJS.
const status = document.getElementById('status');
status.innerText = 'Loaded TensorFlow.js - version: ' + tf.version.tfjs;
// Specify location of our Model.json file we uploaded to the Glitch.com CDN.
const MODEL_URL = ‘YOUR MODEL.JSON URL HERE! CHANGE THIS!';
// Specify a test value we wish to use in our prediction.
// Here we use 950, so we expect the result to be close to 950,000.
const TEST_VALUE = 950.0
// Create an asynchronous function.
async function run() {
// Load the model from the CDN.
const model = await tf.loadLayersModel(MODEL_URL);
// Print out the architecture of the loaded model.
// This is useful to see that it matches what we built in Python.
console.log(model.summary());
// Create a 1 dimensional tensor with our test value.
const input = tf.tensor1d([TEST_VALUE]);
// Actually make the prediction.
const result = model.predict(input);
// Grab the result of prediction using dataSync method
// which ensures we do this synchronously.
status.innerText = 'Input of ' + TEST_VALUE +
'sqft predicted as $' + result.dataSync()[0];
}
// Call our function to start the prediction!
run();
L'exécution du code ci-dessus une fois que vous avez modifié la constante MODEL_URL pour qu'elle pointe vers le chemin d'accès model.json génère le résultat ci-dessous.
Si nous inspectons la console du navigateur Web (appuyez sur F12 pour afficher les outils pour les développeurs dans le navigateur), nous pouvons également voir la description du modèle chargé, qui affiche:
En comparant ce code avec notre code Python au début de cet atelier de programmation, nous pouvons confirmer qu'il s'agit du même réseau que celui que nous avons créé, avec une entrée dense et une couche dense avec un nœud.
Félicitations ! Vous venez d'exécuter un modèle entraîné en Python converti dans le navigateur Web.
7. Modèles ne générant pas de conversion
Il peut arriver que des modèles plus complexes, compilés pour utiliser des opérations moins courantes, ne soient pas pris en charge pour la conversion. La version de TensorFlow.js basée sur navigateur est une réécriture complète de TensorFlow. Par conséquent, elle n'est actuellement pas compatible avec toutes les opérations de bas niveau de l'API TensorFlow C++ (il y en a des milliers). Toutefois, au fil du temps, d'autres opérations sont ajoutées à mesure que nous nous développons et que les opérations principales deviennent plus stables.
Au moment de la rédaction de ce document, linalg.diag est une fonction dans TensorFlow Python qui génère une opération non compatible lorsqu'elle est exportée en tant que modèle enregistré. Si nous essayons de convertir un modèle enregistré qui l'utilise dans Python (qui prend en charge les opérations qu'il produit), une erreur semblable à celle ci-dessous s'affiche:
Ici, nous pouvons voir en rouge que l'appel linalg.diag a été compilé pour produire une opération nommée MatrixDiagV3, qui n'est pas compatible avec TensorFlow.js dans le navigateur Web au moment de la rédaction de cet atelier de programmation.
Que faire ?
Deux options s'offrent à vous :
- Implémentez cette opération manquante dans TensorFlow.js. Il s'agit d'un projet Open Source, pour lequel vous êtes invité à apporter votre contribution pour de nouvelles opérations, par exemple. Consultez ce guide sur l'écriture de nouvelles opérations pour TensorFlow.js. Si vous parvenez à le faire, vous pouvez ensuite utiliser l'indicateur
Skip_op_checksur notre convertisseur de ligne de commande pour ignorer cette erreur et continuer la conversion (cela supposera que cette opération est disponible dans la nouvelle version de TensorFlow.js que vous avez créée et pour laquelle l'opération manquante est prise en charge). - Déterminez quelle partie de votre code Python a produit l'opération non compatible dans le fichier
savedmodelque vous avez exporté. Cette méthode peut être facile à localiser avec un petit ensemble de code, mais dans les modèles plus complexes, cela peut nécessiter un peu d'investigation, car il n'existe actuellement aucune méthode permettant d'identifier l'appel de fonction Python de haut niveau qui a généré une opération donnée une seule fois au format de fichiersavedmodel. Une fois l'emplacement localisé, vous pouvez toutefois le modifier afin d'utiliser une autre méthode compatible.
8. Félicitations
Félicitations ! Vous venez de faire vos premiers pas dans l'utilisation d'un modèle Python via TensorFlow.js dans un navigateur Web.
Résumé
Dans cet atelier de programmation, nous avons appris à effectuer les tâches suivantes:
- Configurer notre environnement Linux pour installer TensorFlow basé sur Python
- Exporter un "SavedModel" Python
- Installer le convertisseur de ligne de commande TensorFlow.js
- Utiliser le convertisseur de ligne de commande TensorFlow.js pour créer les fichiers requis côté client
- Utiliser les fichiers générés dans une application Web réelle
- Identifiez les modèles qui ne généreront pas de conversions et ce qu'il faudrait implémenter pour leur permettre d'effectuer des conversions à l'avenir.
Et ensuite ?
N'oubliez pas de nous taguer dans tout ce que vous créez à l'aide du hashtag #MadeWithTFJS. Vous aurez peut-être une chance de figurer sur les réseaux sociaux ou même d'être présenté lors de futurs événements TensorFlow. Nous aimerions savoir ce que vous convertissez et utiliser côté client dans le navigateur !
Autres ateliers de programmation TensorFlow.js pour aller plus loin
- Écrire entièrement un réseau de neurones dans TensorFlow.js
- Fabriquer une webcam intelligente capable de détecter des objets
- Classification d'images personnalisées à l'aide de l'apprentissage par transfert dans TensorFlow.js