TensorFlow.js: convertir un SavedModel Python au format TensorFlow.js

1. Introduction

Vous avez fait vos premiers pas avec TensorFlow.js, essayé nos modèles prédéfinis ou peut-être même créé le vôtre. Mais vous avez découvert des recherches de pointe en Python et vous vous demandez si elles fonctionneront dans le navigateur Web pour concrétiser votre idée géniale et la rendre accessible à des millions de personnes de manière évolutive. Cela vous rappelle quelque chose ? Si c'est le cas, ce Code lab est fait pour vous !

L'équipe TensorFlow.js a créé un outil pratique pour convertir les modèles au format SavedModel en TensorFlow.js à l'aide d'un convertisseur de ligne de commande. Vous pouvez ainsi utiliser ces modèles avec la portée et l'évolutivité 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é en Python au format model.json requis pour l'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
• Comment installer et utiliser le convertisseur TensorFlow.js sur le modèle SavedModel que vous avez exporté depuis Python.
• Prenez les fichiers résultant de la conversion et utilisez-les dans votre application Web JS.
• Découvrez ce qu'il faut faire en cas de problème (tous les modèles ne seront pas convertis) et les options dont vous disposez.

Imaginez pouvoir prendre une étude récemment publiée et rendre ce modèle disponible pour des millions de développeurs JS dans le monde entier. Vous pouvez également l'utiliser vous-même dans votre propre création, que n'importe qui dans le monde peut ensuite découvrir si elle s'exécute dans le navigateur Web, car aucune dépendance complexe ni configuration d'environnement ne sont requises. Prêt à pirater ? C'est parti !

Remarque : Cet atelier de programmation se concentre sur l'utilisation et la prise en main du convertisseur TensorFlow.js. La création du modèle lui-même utilisera donc un code passe-partout afin que nous puissions obtenir des fichiers à utiliser dans notre tutoriel. Pour savoir comment créer vos propres modèles plus en détail, consultez nos autres ateliers de programmation.

Partagez vos conversions avec nous !

Vous pourrez utiliser ce que vous avez appris aujourd'hui pour essayer de convertir certains de vos modèles Python préférés. Si vous réussissez à créer un site Web de démonstration fonctionnel du modèle en action, taguez-nous 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 Show and Tell. Nous aimerions voir davantage de recherches exceptionnelles portées sur le Web et permettre à un plus grand nombre de personnes d'utiliser ces modèles de manière innovante ou créative, comme cet excellent 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 le peut. Elle est basée 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ù peut-on l'utiliser ?

Grâce à la portabilité de JavaScript, vous pouvez désormais écrire dans une seule langue et effectuer du machine learning sur toutes les plates-formes suivantes en toute simplicité :

• Côté client dans le navigateur Web à l'aide de JavaScript vanilla
• Côté serveur et même sur des appareils IoT comme Raspberry Pi à l'aide de Node.js
• Applications de bureau utilisant Electron
• Applications mobiles natives utilisant React Native

TensorFlow.js est également compatible avec plusieurs backends dans chacun de ces environnements (les environnements matériels réels dans lesquels il peut s'exécuter, tels que le processeur ou WebGL, par exemple). Dans ce contexte, le terme "backend" ne désigne pas un environnement côté serveur (le backend d'exécution peut être côté client dans WebGL, par exemple) pour assurer la compatibilité et maintenir la rapidité d'exécution. TensorFlow.js est actuellement compatible avec :

• Exécution WebGL sur la carte graphique (GPU) de l'appareil : il s'agit du moyen le plus rapide d'exécuter des modèles plus volumineux (de plus de 3 Mo) avec l'accélération GPU.
• Exécution WebAssembly (WASM) sur le processeur : pour améliorer les performances du processeur sur les appareils, y compris les téléphones mobiles de l'ancienne génération, par exemple. Cette approche est mieux adaptée aux modèles plus petits (moins de 3 Mo), qui peuvent en fait s'exécuter plus rapidement sur le processeur avec WASM qu'avec WebGL en raison de la surcharge liée à l'importation de contenu dans un processeur graphique.
• Exécution du CPU : solution de repli si aucun autre environnement n'est disponible. Il s'agit de la plus lente des trois, mais elle est toujours disponible.

Remarque : Vous pouvez choisir d'imposer l'un de ces backends si vous savez sur quel appareil vous allez exécuter le code, ou vous pouvez simplement laisser TensorFlow.js décider pour vous si vous ne le spécifiez pas.

Super-pouvoirs côté client

L'exécution de TensorFlow.js dans le navigateur Web sur la machine cliente peut présenter plusieurs avantages à prendre en compte.

Confidentialité

Vous pouvez entraîner et classer des données sur la machine cliente sans jamais envoyer de données à un serveur Web tiers. Il peut arriver que cela soit nécessaire pour se conformer aux lois locales, comme le RGPD par exemple, ou lors du traitement de données que l'utilisateur peut souhaiter conserver sur sa machine et ne pas envoyer à un tiers.

Speed

Comme vous n'avez pas à envoyer de données à un serveur distant, l'inférence (l'acte de classification des données) peut être plus rapide. Mieux encore, vous avez un accès direct aux capteurs de l'appareil (caméra, micro, GPS, accéléromètre, etc.) si l'utilisateur vous y autorise.

Couverture et évolutivité

En un clic, n'importe qui dans le monde peut cliquer sur un lien que vous lui envoyez, ouvrir la page Web dans son navigateur et utiliser ce que vous avez créé. Vous n'avez 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

Sans serveur, vous n'avez besoin que d'un CDN pour héberger vos fichiers HTML, CSS, JS et de modèle. Le coût d'un CDN est beaucoup moins élevé que celui d'un serveur fonctionnant 24h/24 et 7j/7 (potentiellement avec une carte graphique).

Fonctionnalités côté serveur

L'utilisation de l'implémentation Node.js de TensorFlow.js permet les fonctionnalités suivantes.

Prise en charge complète de CUDA

Côté serveur, pour 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 et ne nécessite aucune installation). Toutefois, avec la prise en charge complète de CUDA, vous pouvez exploiter pleinement les capacités de bas niveau de la carte graphique, ce qui permet d'accélérer 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 pouvez travailler avec des modèles très volumineux, peut-être de plusieurs gigaoctets. Ces modèles ne peuvent pas être exécutés dans le navigateur Web pour le moment en raison des limites d'utilisation de la mémoire par onglet de navigateur. Pour exécuter ces modèles plus volumineux, vous pouvez utiliser Node.js sur votre propre serveur avec les spécifications matérielles requises pour exécuter efficacement un tel modèle.

IOT

Node.js est compatible avec les ordinateurs monocartes populaires tels que Raspberry Pi, ce qui signifie que vous pouvez également exécuter des modèles TensorFlow.js sur ces appareils.

Speed

Node.js est écrit en JavaScript, ce qui signifie qu'il bénéficie de la compilation juste-à-temps. Cela signifie que vous pouvez souvent constater des améliorations de performances lorsque vous utilisez Node.js, car il sera optimisé au moment de l'exécution, en particulier pour tout prétraitement que vous pourriez effectuer. Un excellent exemple est présenté dans cette étude de cas, qui montre comment Hugging Face a utilisé Node.js pour doubler les performances de son modèle de traitement du langage naturel.

Maintenant que vous connaissez les bases de TensorFlow.js, où il peut s'exécuter et certains de ses avantages, commençons à faire des choses utiles avec !

3. Configurer votre système

Pour ce tutoriel, nous allons utiliser Ubuntu, une distribution Linux populaire que de nombreuses personnes utilisent et qui est disponible sur Google Cloud Compute Engine en tant qu'image de base si vous choisissez de suivre le tutoriel sur une machine virtuelle basée sur le cloud.

Au moment de la rédaction de cet article, nous pouvons sélectionner l'image Ubuntu 18.04.4 LTS lors de la création d'une instance Compute Engine standard, 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)

Maintenant, comme 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 fichier "SavedModel" à partir de Python, vous devrez configurer la version Python de TensorFlow sur votre instance si le "SavedModel" n'est pas déjà disponible au téléchargement.

Connectez-vous en SSH à la machine cloud que vous avez créée ci-dessus, puis saisissez la commande suivante dans la fenêtre du terminal :

Fenêtre du terminal :

sudo apt update
sudo apt-get install python3

Cela nous permettra de nous assurer que Python 3 est installé sur la machine. Python 3.4 ou version ultérieure doit être installé pour utiliser TensorFlow.

Pour vérifier que la bonne version est installée, saisissez la commande suivante :

Fenêtre du terminal :

python3 --version

Vous devriez obtenir un résultat indiquant le numéro de version, tel que Python 3.6.9. Si la valeur imprimée est correcte et supérieure à 3,4, vous pouvez continuer.

Nous allons ensuite installer PIP pour Python 3, qui est le gestionnaire de packages de Python, puis le mettre à jour. Type :

Fenêtre du terminal :

sudo apt install python3-pip
pip3 install --upgrade pip

Nous pouvons à nouveau vérifier l'installation de pip3 en exécutant la commande suivante :

Fenêtre du terminal :

pip3 --version

Au moment de la rédaction de cet article, pip 20.2.3 s'affiche dans le terminal après l'exécution de cette commande.

Avant d'installer TensorFlow, vous devez vous assurer que le package Python "setuptools" est en version 41.0.0 ou ultérieure. Exécutez la commande suivante pour vous assurer qu'il est à jour :

Fenêtre du terminal :

pip3 install -U setuptools

Enfin, nous pouvons maintenant installer TensorFlow pour Python :

Fenêtre du terminal :

pip3 install tensorflow

Cette opération peut prendre un certain temps. Veuillez donc patienter jusqu'à ce qu'elle soit terminée.

Avertissement : Dans ce tutoriel, nous installons la version de TensorFlow pour processeur uniquement afin de configurer rapidement l'environnement. Si vous souhaitez utiliser le GPU de votre instance, vous devez installer la version GPU de TensorFlow, ce qui peut vous permettre de réduire considérablement les temps d'entraînement. Toutefois, cette version dépend de l'installation des pilotes NVIDIA CUDA, ce qui dépasse le cadre de cet atelier de programmation. Pour en savoir plus sur l'installation de la version GPU de TensorFlow, cliquez ici.

Vérifions que TensorFlow est correctement installé. Créez un fichier Python nommé test.py dans votre répertoire actuel :

Fenêtre du terminal :

nano test.py

Une fois nano ouvert, nous pouvons écrire du code Python pour afficher 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 afficher la version de TensorFlow à l'écran :

Fenêtre du terminal :

python3 test.py

Au moment de la rédaction, 2.3.1 s'affiche dans la console pour notre version de TensorFlow Python installée.

Avertissement : Si de nombreux avertissements liés à NumPy s'affichent, saisissez simplement la commande suivante dans le terminal pour mettre à niveau votre version de NumPy :

pip uninstall numpy

pip install numpy==1.16.4

Il est possible que des avertissements concernant le GPU / libcudart s'affichent encore. Ce n'est pas un problème, car nous avons installé la version CPU de TensorFlow et non celle du GPU. Vous pouvez les ignorer.

4. Créer un modèle Python

L'étape suivante de cet atelier de programmation vous guidera dans la création d'un modèle Python simple pour vous montrer comment enregistrer le modèle entraîné obtenu au format "SavedModel" afin de l'utiliser ensuite avec notre convertisseur en ligne de commande TensorFlow.js. Le principe serait le même pour tout modèle Python que vous essayez de convertir, mais nous allons simplifier ce code pour que tout le monde puisse le comprendre.

Modifions 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 entraînera une régression linéaire très simple pour apprendre à estimer la relation entre nos x (entrées) et nos 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 l'exécution de 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 maintenant généré les fichiers dont nous avons besoin pour que le convertisseur TensorFlow.js puisse convertir ce modèle afin qu'il s'exécute dans le navigateur.

5. Convertir un modèle SavedModel au format TensorFlow.js

Installer le convertisseur TensorFlow.js

Pour installer le convertisseur, exécutez la commande suivante :

Fenêtre du terminal :

pip3 install tensorflowjs

C'était facile.

Remarque : Un assistant est également disponible. Vous pouvez l'installer à l'aide de pip3 install tensorflowjs[wizard].

Une fois installé, vous pouvez exécuter la commande tensorflowjs_wizard, qui vous guidera plus facilement dans le processus de conversion, comme indiqué ici :

En supposant que nous utilisions le convertisseur de ligne de commande (tensorflowjs_converter) et non la version de l'assistant présenté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 du terminal :

tensorflowjs_converter \
    --input_format=keras_saved_model \
    ./ \
    ./predict_houses_tfjs

Que se passe-t-il ? 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 : pour 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 poids figés.
• tf_hub : permet de charger un modèle généré à partir de TensorFlow Hub.

Pour en savoir plus sur ces autres formats, cliquez ici.

Les deux paramètres suivants spécifient le dossier dans lequel se trouve le modèle enregistré. Dans notre démonstration ci-dessus, nous spécifions le répertoire actuel, puis nous spécifions le répertoire dans lequel nous souhaitons exporter notre conversion, que nous spécifions ci-dessus comme un 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
• Group1-shard1of1.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.

Remarque : Les fichiers TensorFlow.js côté client se composent toujours d'un fichier model.json et d'au moins un fichier .bin. Les fichiers binaires sont fragmentés en blocs de 4 Mo pour optimiser la diffusion parallèle de ces éléments au navigateur Web côté client.

6. Utiliser notre modèle converti dans le navigateur

Héberger les fichiers convertis

Nous devons d'abord placer nos fichiers model.json et *.bin générés sur un serveur Web afin de pouvoir y accéder depuis notre page Web. Pour cette démonstration, nous utiliserons Glitch.com afin que vous puissiez facilement suivre les étapes. Toutefois, si vous avez une expérience en ingénierie Web, vous pouvez choisir de lancer un serveur HTTP simple sur votre instance de serveur Ubuntu actuelle pour le faire à la place. À vous de choisir.

Importer des fichiers dans Glitch

1. Connectez-vous à Glitch.com.
2. Utilisez ce lien pour cloner notre projet TensorFlow.js standard. Il contient des fichiers HTML, CSS et JS squelettiques qui importent la bibliothèque TensorFlow.js pour que nous puissions l'utiliser.
3. Cliquez sur le dossier "assets" dans le panneau de gauche.
4. Cliquez sur "Importer un composant" et sélectionnez group1-shard1of1.bin à importer dans ce dossier. Une fois importé, il devrait se présenter comme suit :
5. Si vous cliquez sur le fichier group1-shard1of1.bin que vous venez d'importer, vous pourrez copier l'URL de son emplacement. Copiez ce chemin d'accès comme indiqué :
6. Modifiez maintenant model.json à l'aide de votre éditeur de texte préféré sur votre machine locale et recherchez (à l'aide de CTRL+F) le fichier group1-shard1of1.bin qui sera mentionné quelque part dans le fichier.

Remplacez ce nom de fichier par l'URL que vous avez copiée à l'étape 5, mais supprimez le https://cdn.glitch.com/ en début de chemin d'accès généré par le bug.

Après modification, il devrait ressembler à ceci (notez que le chemin d'accès au serveur de début a été supprimé, de sorte que seul le nom de fichier importé résultant est conservé) :  7. Enregistrez et importez ce fichier model.json modifié dans Glitch en cliquant sur "Assets" (Éléments), puis sur le bouton "Upload an asset" (Importer un élément) (important). Si vous n'utilisez pas le bouton physique et que vous faites glisser et déposez le fichier, il sera importé en tant que fichier modifiable au lieu d'être importé sur le CDN. Il ne se trouvera pas dans le même dossier et le chemin d'accès relatif est supposé lorsque TensorFlow.js tente de télécharger les fichiers binaires pour un modèle donné. Si vous avez correctement suivi les étapes, vous devriez voir deux fichiers dans le dossier assets, comme ceci : .

Parfait ! Nous sommes maintenant prêts à utiliser nos fichiers enregistrés avec du code réel dans le navigateur.

Avertissement : Si vous avez décidé de ne pas utiliser Glitch.com et d'exécuter votre propre serveur Web, aucune modification du fichier model.json n'est requise tant que vous diffusez les fichiers à partir du même répertoire sur votre serveur Web. Assurez-vous simplement qu'ils se trouvent dans le même dossier et qu'ils sont accessibles depuis le code côté client.

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 votre 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 une sortie comme celle ci-dessous.

Remarque : Pour exécuter votre code, cliquez simplement sur "show" (afficher) en haut du site Web Glitch, puis choisissez "new window" (nouvelle fenêtre) ou "next to code" (à côté du code) pour afficher un aperçu en direct de l'exécution du code.

Si nous inspectons la console du navigateur Web (appuyez sur F12 pour afficher les outils de développement dans le navigateur), nous pouvons également voir la description du modèle chargé, qui s'affiche comme suit :

En comparant cela 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é Python converti dans le navigateur Web.

7. Modèles qui ne génèrent pas de conversions

Il peut arriver que des modèles plus complexes qui sont compilés pour utiliser des opérations moins courantes ne soient pas compatibles avec la conversion. La version navigateur de TensorFlow.js est une réécriture complète de TensorFlow. Par conséquent, nous ne prenons pas en charge toutes les opérations de bas niveau de l'API C++ TensorFlow (il y en a des milliers). Toutefois, nous en ajoutons au fur et à mesure de notre croissance et de la stabilisation des opérations de base.

Au moment de la rédaction de cet article, linalg.diag est une fonction TensorFlow Python qui génère une opération non compatible lorsqu'elle est exportée en tant que SavedModel. Si nous essayons de convertir un SavedModel qui utilise cette fonction en Python (qui prend en charge les opérations résultantes qu'il produit), nous verrons une erreur semblable à celle ci-dessous :

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 prise en charge par TensorFlow.js dans le navigateur Web au moment de la rédaction de cet atelier de programmation.

Remarque : Vous trouverez la liste des opérations TensorFlow.js actuellement compatibles ici. Veuillez noter que cela ne concerne que l'implémentation du navigateur Web côté client de TensorFlow.js et ne s'applique pas à la version Node.js de TensorFlow.js qui utilise les mêmes liaisons C++ que Python. Tous les modèles enregistrés peuvent donc s'exécuter sans conversion dans Node.js lorsque vous utilisez TensorFlow.js côté serveur.

Que dois-je faire ?

Deux options s'offrent à vous :

1. Implémentez cette opération manquante dans TensorFlow.js. Nous sommes un projet Open Source et nous acceptons les contributions pour les 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_check sur notre convertisseur de ligne de commande pour ignorer cette erreur et continuer la conversion malgré tout (il supposera que cette opération est disponible dans la nouvelle version de TensorFlow.js que vous avez créée et qui prend en charge l'opération manquante).
2. Déterminez quelle partie de votre code Python a produit l'opération non compatible dans le fichier savedmodel que vous avez exporté. Dans un petit ensemble de code, cela peut être facile à localiser, mais dans des modèles plus complexes, cela peut nécessiter une enquête assez approfondie, car il n'existe actuellement aucune méthode pour identifier l'appel de fonction Python de haut niveau qui a produit une opération donnée une fois au format de fichier savedmodel. Une fois que vous l'avez trouvée, vous pouvez potentiellement la modifier pour 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 le navigateur Web.

Résumé

Dans cet atelier de programmation, nous avons appris à :

1. Configurer notre environnement Linux pour installer TensorFlow basé sur Python
2. Exporter un "SavedModel" Python
3. Installer le convertisseur de ligne de commande TensorFlow.js
4. Utilisez le convertisseur de ligne de commande TensorFlow.js pour créer les fichiers côté client requis.
5. Utiliser les fichiers générés dans une application Web réelle
6. Identifiez les modèles qui ne seront pas convertis et ce qui devra être implémenté pour qu'ils puissent l'être à l'avenir.

Et ensuite ?

N'oubliez pas de nous taguer sur les contenus que vous créez grâce au hashtag #MadeWithTFJS. Votre projet sera peut-être mis en avant sur les réseaux sociaux, ou même présenté lors d'événements futurs TensorFlow. Nous serions ravis de découvrir ce que vous convertissez et utilisez côté client dans le navigateur.

Plus d'ateliers de programmation TensorFlow.js pour aller plus loin

• Créer un réseau de neurones à partir de zéro dans TensorFlow.js
• Créer une webcam intelligente capable de détecter des objets
• Classification d'images personnalisées à l'aide de l'apprentissage par transfert dans TensorFlow.js

Sites Web à consulter

• Site Web officiel de TensorFlow.js
• Modèles prédéfinis TensorFlow.js
• API TensorFlow.js
• Démos#MadeWithTFJS de la communauté