TensorFlow.js: réentraîner un modèle de détection de spam dans les commentaires pour gérer les cas spéciaux

1. Avant de commencer

Cet atelier de programmation est conçu pour s'appuyer sur le résultat de l'atelier de programmation précédent de cette série sur la détection du spam dans les commentaires à l'aide de TensorFlow.js.

Dans le dernier atelier de programmation, vous avez créé une page Web entièrement fonctionnelle pour un blog vidéo fictif. Vous avez pu filtrer les commentaires indésirables avant qu'ils ne soient envoyés au serveur pour stockage ou à d'autres clients connectés, à l'aide d'un modèle pré-entraîné de détection des spams dans les commentaires optimisé par TensorFlow.js dans le navigateur.

Le résultat final de cet atelier de programmation est présenté ci-dessous :

Bien que cela ait très bien fonctionné, il existe des cas extrêmes à explorer qu'il n'a pas pu détecter. Vous pouvez réentraîner le modèle pour qu'il tienne compte des situations qu'il n'a pas pu gérer.

Cet atelier de programmation se concentre sur l'utilisation du traitement du langage naturel (l'art de comprendre le langage humain avec un ordinateur) et vous montre comment modifier une application Web existante que vous avez créée (il est fortement conseillé de suivre les ateliers de programmation dans l'ordre) pour résoudre le problème très réel du spam dans les commentaires, que de nombreux développeurs Web rencontreront certainement en travaillant sur l'une des applications Web populaires de plus en plus nombreuses qui existent aujourd'hui.

Dans cet atelier de programmation, vous irez encore plus loin en réentraînant votre modèle de ML pour tenir compte des modifications du contenu des spams qui peuvent évoluer au fil du temps, en fonction des tendances actuelles ou des sujets de discussion populaires. Vous pourrez ainsi maintenir le modèle à jour et tenir compte de ces modifications.

Prérequis

• Vous avez terminé le premier atelier de programmation de cette série.
• Connaissances de base des technologies Web, y compris HTML, CSS et JavaScript

Objectifs de l'atelier

Vous allez réutiliser le site Web créé précédemment pour un faux blog vidéo avec une section de commentaires en temps réel. Vous allez le mettre à niveau pour charger une version entraînée personnalisée du modèle de détection du spam à l'aide de TensorFlow.js. Il sera ainsi plus performant pour les cas particuliers pour lesquels il aurait échoué auparavant. Bien sûr, en tant que développeurs et ingénieurs Web, vous pouvez modifier cette UX hypothétique pour la réutiliser sur n'importe quel site Web sur lequel vous travaillez au quotidien et adapter la solution à n'importe quel cas d'utilisation client (blog, forum ou CMS, comme Drupal par exemple).

C'est parti pour le piratage !

Points abordés

Vous découvrirez comment :

• Identifier les cas extrêmes pour lesquels le modèle pré-entraîné échouait
• Réentraînez le modèle de classification du spam créé à l'aide de Model Maker.
• Exportez ce modèle basé sur Python au format TensorFlow.js pour l'utiliser dans les navigateurs.
• Mettez à jour le modèle hébergé et son dictionnaire avec le nouveau modèle entraîné, puis vérifiez les résultats.

Dans cet atelier, nous partons du principe que vous connaissez bien HTML5, CSS et JavaScript. Vous exécuterez également du code Python via un notebook "co lab" pour réentraîner le modèle créé à l'aide de Model Maker, mais aucune connaissance de Python n'est requise pour cela.

2. Se préparer à coder

Une fois de plus, vous utiliserez Glitch.com pour héberger et modifier l'application Web. Si vous n'avez pas déjà suivi l'atelier de programmation prérequis, vous pouvez cloner le résultat final ici comme point de départ. Si vous avez des questions sur le fonctionnement du code, nous vous recommandons vivement de suivre l'atelier de programmation précédent qui explique comment créer cette application Web fonctionnelle avant de continuer.

Sur Glitch, il vous suffit de cliquer sur le bouton Remix this (Remixer) pour créer un fork et un nouvel ensemble de fichiers que vous pouvez modifier.

Autre option : Utilisez l'éditeur Web de votre choix ou travaillez en local Si vous souhaitez télécharger le code et travailler en local avec votre propre serveur ou sur un autre éditeur en ligne, il vous suffit de recréer les fichiers affichés dans un environnement Node.js Express de votre choix, puis de copier et coller le code du boilerplate Glitch dans votre environnement local pour chaque fichier.

3. Découvrir les cas limites dans la solution précédente

Si vous ouvrez le site Web cloné et que vous essayez de saisir des commentaires, vous remarquerez que, la plupart du temps, il fonctionne comme prévu, en bloquant les commentaires qui ressemblent à du spam et en autorisant les réponses légitimes.

Toutefois, si vous faites preuve d'ingéniosité et que vous essayez de formuler des requêtes pour déjouer le modèle, vous finirez probablement par y parvenir. En procédant par essais et erreurs, vous pouvez créer manuellement des exemples comme ceux présentés ci-dessous. Essayez de coller ces éléments dans l'application Web existante, vérifiez la console et consultez les probabilités de spam pour le commentaire :

Commentaires légitimes publiés sans problème (vrais négatifs) :

1. "Waouh, j'adore cette vidéo, super travail !" Probabilité de spam : 47,91854 %
2. "J'ai adoré ces démos ! Avez-vous d'autres détails à nous communiquer ?" Probabilité de spam : 47,15898 %
3. "Sur quel site Web puis-je en savoir plus ?" Probabilité de spam : 15,32495 %

C'est parfait ! Les probabilités pour tous les éléments ci-dessus sont assez faibles et passent avec succès le SPAM_THRESHOLD par défaut d'une probabilité minimale de 75 % avant qu'une action ne soit entreprise (défini dans le code script.js de l'atelier de programmation précédent).

Essayons maintenant d'écrire des commentaires plus audacieux qui sont marqués comme spam alors qu'ils ne le sont pas…

Commentaires légitimes marqués comme spam (faux positifs) :

1. "Quelqu'un peut-il m'envoyer le lien vers le site Web du masque qu'il porte ?" Probabilité de spam : 98,46466 %
2. "Can I buy this song on Spotify? Quelqu'un peut-il me renseigner ?" Probabilité de spam : 94,40953 %
3. "Quelqu'un peut-il me contacter pour m'expliquer comment télécharger TensorFlow.js ?" Probabilité de spam : 83,20084 %

Oh non ! Il semble que ces commentaires légitimes soient marqués comme spam alors qu'ils devraient être autorisés. Comment résoudre ce problème ?

Une option simple consiste à augmenter le SPAM_THRESHOLD pour atteindre un niveau de confiance supérieur à 98,5 %. Dans ce cas, les commentaires mal classés seraient publiés. Dans cette optique, examinons les autres résultats possibles ci-dessous…

Commentaires de spam marqués comme tels (vrais positifs) :

1. "C'est sympa, mais consultez les liens de téléchargement sur mon site Web, ils sont mieux !" Probabilité de spam : 99,77873 %
2. "Je connais des personnes qui peuvent vous procurer des médicaments. Consultez mon profil pour en savoir plus." Probabilité de spam : 98,46955 %
3. "Consultez mon profil pour télécharger encore plus de vidéos incroyables et encore mieux ! http://example.com" Probabilité de spam : 96,26383 %

OK, cela fonctionne comme prévu avec notre seuil initial de 75 %, mais étant donné que, lors de l'étape précédente, vous avez défini SPAM_THRESHOLD sur un niveau de confiance supérieur à 98,5 %, cela signifie que deux exemples seraient acceptés ici.Le seuil est donc peut-être trop élevé. Peut-être que 96 % est mieux ? Toutefois, si vous le faites, l'un des commentaires de la section précédente (faux positifs) sera marqué comme spam alors qu'il était légitime, car il a été évalué à 98,46466 %.

Dans ce cas, il est probablement préférable de capturer tous ces vrais commentaires de spam et de simplement réentraîner pour les échecs ci-dessus. En définissant le seuil à 96 %, tous les vrais positifs sont toujours capturés et deux des faux positifs ci-dessus sont éliminés. Pas mal pour une simple modification de chiffre.

Continuons…

Commentaires de spam qui ont été autorisés à être publiés (faux négatifs) :

1. "Consultez mon profil pour télécharger encore plus de vidéos incroyables et encore plus intéressantes !" Probabilité de spam : 7,54926 %
2. "Profitez d'une remise sur nos cours de sport en salle. Consultez mon profil !" Probabilité de spam : 17,49849 %
3. "OMG, l'action GOOG vient de grimper en flèche ! Profitez-en avant qu'il ne soit trop tard !" Probabilité de spam : 20,42894 %

Pour ces commentaires, vous ne pouvez rien faire en modifiant simplement la valeur SPAM_THRESHOLD. Si vous réduisez le seuil de spam de 96 % à environ 9 %, des commentaires authentiques seront marqués comme spam. L'un d'eux a même une note de 58 %, alors qu'il est légitime. La seule façon de traiter ce type de commentaires est de réentraîner le modèle en incluant ces cas extrêmes dans les données d'entraînement. Il apprendra ainsi à ajuster sa vision du monde pour déterminer ce qui est un spam ou non.

Bien que la seule option restante pour le moment soit de réentraîner le modèle, vous avez également vu comment affiner le seuil à partir duquel vous décidez de considérer quelque chose comme du spam afin d'améliorer également les performances. En tant qu'humain, 75 % semble assez confiant, mais pour ce modèle, vous deviez augmenter la confiance à environ 81,5 % pour être plus efficace avec les exemples d'entrées.

Il n'existe pas de valeur magique qui fonctionne bien pour tous les modèles. Cette valeur seuil doit être définie pour chaque modèle après avoir testé ce qui fonctionne bien avec des données réelles.

Dans certains cas, un faux positif (ou négatif) peut avoir de graves conséquences (par exemple, dans le secteur médical). Vous pouvez donc ajuster votre seuil pour qu'il soit très élevé et demander plus d'examens manuels pour ceux qui ne l'atteignent pas. C'est à vous de choisir en tant que développeur, et cela nécessite quelques tests.

4. Réentraîner le modèle de détection de spam dans les commentaires

Dans la section précédente, vous avez identifié un certain nombre de cas extrêmes qui échouaient pour le modèle, la seule option étant de réentraîner le modèle pour tenir compte de ces situations. Dans un système de production, vous pouvez les trouver au fil du temps lorsque des utilisateurs signalent manuellement comme spam un commentaire qui a été autorisé ou lorsque des modérateurs qui examinent les commentaires signalés se rendent compte que certains ne sont pas du spam et peuvent les marquer pour l'entraînement. En supposant que vous ayez collecté un grand nombre de nouvelles données pour ces cas extrêmes (pour obtenir les meilleurs résultats, vous devriez avoir quelques variantes de ces nouvelles phrases si possible), nous allons maintenant vous montrer comment réentraîner le modèle en tenant compte de ces cas extrêmes.

Récapitulatif des modèles prédéfinis

Le modèle prédéfini que vous avez utilisé a été créé par un tiers à l'aide de Model Maker et utilise un modèle d'embedding de mots moyen pour fonctionner.

Conseil : Bien que Model Maker ait été conçu pour les utilisateurs de TF Lite (développeurs d'applications natives), il permet également d'exporter des modèles au format TensorFlow.js. Nous pouvons ainsi utiliser le modèle de détection du spam dans les commentaires dans l'environnement Web.

Comme le modèle a été créé avec Model Maker, vous devrez passer brièvement à Python pour l'entraîner à nouveau, puis exporter le modèle créé au format TensorFlow.js afin de pouvoir l'utiliser dans le navigateur. Heureusement, Model Maker simplifie l'utilisation de ses modèles. Vous devriez donc pouvoir suivre facilement ce tutoriel. Nous vous guiderons tout au long du processus. Ne vous inquiétez pas si vous n'avez jamais utilisé Python auparavant.

Conseil : Les ingénieurs en ML JavaScript effectuent généralement tout leur travail avec TensorFlow.js, peut-être via Node.js pour entraîner des modèles dans un environnement côté serveur. Aujourd'hui, nous allons vous montrer comment utiliser le code de Model Maker pour que vous puissiez travailler en toute confiance avec des modèles créés dans d'autres langages comme Python, puis comment exporter ces modèles pour qu'ils fonctionnent dans TensorFlow.js. Il s'agit d'une compétence intéressante à acquérir, car de nombreuses recherches universitaires sont initialement publiées en Python au moment de la rédaction.

Colabs

Comme vous ne souhaitez pas configurer un serveur Linux avec tous les utilitaires Python installés dans cet atelier de programmation, vous pouvez simplement exécuter le code via le navigateur Web à l'aide d'un "notebook Colab". Ces notebooks peuvent se connecter à un "backend", qui est simplement un serveur avec des éléments préinstallés, à partir duquel vous pouvez ensuite exécuter du code arbitraire dans le navigateur Web et voir les résultats. Cette fonctionnalité est très utile pour le prototypage rapide ou pour une utilisation dans des tutoriels comme celui-ci.

Il vous suffit d'accéder à colab.research.google.com pour afficher l'écran de bienvenue, comme illustré ci-dessous :

Cliquez ensuite sur le bouton New Notebook (Nouveau notebook) en bas à droite de la fenêtre pop-up. Vous devriez voir un notebook Colab vide comme celui-ci :

Parfait ! L'étape suivante consiste à connecter le notebook Colab de l'interface à un serveur backend afin que vous puissiez exécuter le code Python que vous allez écrire. Pour ce faire, cliquez sur Connecter en haut à droite, puis sélectionnez Se connecter à un environnement d'exécution hébergé.

Une fois connecté, vous devriez voir les icônes RAM et Disque apparaître à la place, comme ceci :

Bravo ! Vous pouvez maintenant commencer à coder en Python pour réentraîner le modèle Model Maker. Il vous suffit de procéder comme suit :

Étape 1

Dans la première cellule vide, copiez le code ci-dessous. Il installera TensorFlow Lite Model Maker pour vous à l'aide du gestionnaire de packages Python appelé "pip" (il est semblable à npm, que la plupart des lecteurs de cet atelier de programmation connaissent peut-être mieux dans l'écosystème JS) :

!apt-get install libasound-dev portaudio19-dev libportaudio2 libportaudiocpp0
!pip install -q tflite-model-maker

Toutefois, si vous collez du code dans la cellule, il ne sera pas exécuté. Ensuite, pointez sur la cellule grise dans laquelle vous avez collé le code ci-dessus. Une petite icône de lecture s'affiche à gauche de la cellule, comme indiqué ci-dessous :

 Cliquez sur le bouton de lecture pour exécuter le code que vous venez de saisir dans la cellule.

Remarque : Il est important d'exécuter le code dans l'ordre indiqué dans ce tutoriel. Sinon, les bibliothèques importées ou les variables calculées que vous utiliserez plus tard dans d'autres cellules risquent de ne pas être disponibles.

L'installation de Model Maker s'affiche :

Une fois l'exécution de cette cellule terminée, comme indiqué, passez à l'étape suivante ci-dessous.

Étape 2

Ensuite, ajoutez une cellule de code comme indiqué ci-dessous pour pouvoir coller du code après la première cellule et l'exécuter séparément :

La cellule suivante exécutée comportera un certain nombre d'importations que le code du reste du notebook devra utiliser. Copiez et collez le code ci-dessous dans la nouvelle cellule créée :

import numpy as np
import os

from tflite_model_maker import configs
from tflite_model_maker import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import text_classifier
from tflite_model_maker.text_classifier import DataLoader

import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')

Il s'agit d'une procédure assez standard, même si vous n'êtes pas familier avec Python. Vous importez simplement certains utilitaires et les fonctions Model Maker nécessaires au classificateur de spam. Elle permet également de vérifier si vous exécutez TensorFlow 2.x, condition préalable à l'utilisation de Model Maker.

Enfin, comme précédemment, exécutez la cellule en appuyant sur l'icône de lecture lorsque vous pointez sur la cellule, puis ajoutez une cellule de code pour l'étape suivante.

Étape 3

Vous allez ensuite télécharger les données d'un serveur distant sur votre appareil et définir la variable training_data sur le chemin d'accès du fichier local téléchargé :

data_file = tf.keras.utils.get_file(fname='comment-spam-extras.csv', origin='https://storage.googleapis.com/jmstore/TensorFlowJS/EdX/code/6.5/jm_blog_comments_extras.csv', extract=False)

Model Maker peut entraîner des modèles à partir de fichiers CSV simples comme celui que vous avez téléchargé. Il vous suffit de spécifier les colonnes qui contiennent le texte et celles qui contiennent les étiquettes. Vous découvrirez comment procéder à l'étape 5. N'hésitez pas à télécharger directement le fichier CSV pour voir ce qu'il contient.

Les plus observateurs d'entre vous remarqueront que le nom de ce fichier est jm_blog_comments_extras.csv. Il s'agit simplement des données d'entraînement d'origine que nous avons utilisées pour générer le premier modèle de détection de spam dans les commentaires combinées avec les nouvelles données de cas particuliers que vous avez découvertes, le tout dans un seul fichier. En plus des nouvelles phrases à partir desquelles vous souhaitez apprendre, vous avez également besoin des données d'entraînement d'origine utilisées pour entraîner le modèle.

Facultatif : Si vous téléchargez ce fichier CSV et que vous vérifiez les dernières lignes, vous verrez des exemples de cas extrêmes qui ne fonctionnaient pas correctement auparavant. Elles viennent d'être ajoutées à la fin des données d'entraînement existantes que le modèle prédéfini a utilisées pour s'entraîner.

Exécutez cette cellule, puis, une fois l'exécution terminée, ajoutez une cellule et passez à l'étape 4.

Étape 4

Lorsque vous utilisez Model Maker, vous n'avez pas à créer de modèles à partir de zéro. Vous utilisez généralement des modèles existants que vous personnalisez ensuite pour répondre à vos besoins.

Model Maker propose plusieurs représentations vectorielles continues de modèles pré-entraînées que vous pouvez utiliser. Toutefois, l'option la plus simple et la plus rapide pour commencer est average_word_vec, que vous avez utilisée dans l'atelier de programmation précédent pour créer votre site Web. Voici le code :

spec = model_spec.get('average_word_vec')
spec.num_words = 2000
spec.seq_len = 20
spec.wordvec_dim = 7

Une fois que vous l'avez collé dans la nouvelle cellule, exécutez-le.

Comprendre le

num_words

parameter

Il s'agit du nombre de mots que vous souhaitez que le modèle utilise. Vous pourriez penser que "plus il y en a, mieux c'est". Cependant, il existe généralement un nombre de mots adéquat selon la fréquence d'utilisation de chaque mot. Si vous utilisez tous les mots de l'ensemble du corpus, le modèle va tenter d'apprendre et d'équilibrer les pondérations des mots qui ne sont utilisés qu'une seule fois, ce qui n'est pas très utile. Dans un corpus de textes, de nombreux mots ne sont utilisés qu'une ou deux fois. Leur intégration dans votre modèle n'a donc aucun intérêt, car leur impact sur le sentiment général est négligeable. Le paramètre num_words vous permet d'ajuster le modèle en fonction du nombre de mots souhaité. Un nombre limité de mots produira un modèle plus petit et plus rapide, mais moins précis, car il reconnaît moins de mots. Un nombre élevé de mots générera un modèle plus grand, mais potentiellement plus lent. Il est essentiel de trouver le juste milieu. En tant qu'ingénieur en machine learning, c'est à vous de déterminer ce qui convient le mieux à votre cas d'utilisation.

Comprendre le

wordvec_dim

parameter

Le paramètre wordvec_dim correspond au nombre de dimensions que vous souhaitez utiliser dans le vecteur pour chaque mot. Ces dimensions sont essentiellement les différentes caractéristiques (créées par l'algorithme de machine learning lors de l'entraînement) selon lesquelles un mot donné peut être mesuré. Le programme les utilise pour essayer d'associer au mieux les mots qui se ressemblent d'une manière significative.

Par exemple, si vous aviez une dimension pour déterminer le caractère "médical" d'un mot, un mot comme "pilules" pourrait obtenir un score élevé dans cette dimension et être associé à d'autres mots à score élevé comme "radiographie", mais "chat" obtiendrait un score faible dans cette dimension. Il peut s'avérer qu'une "dimension médicale" est utile pour déterminer le spam lorsqu'elle est combinée à d'autres dimensions potentielles qu'elle peut décider d'utiliser si elles sont significatives.

Dans le cas de mots qui obtiennent un score élevé dans la "dimension médicale", il peut être utile d'ajouter une deuxième dimension qui met en corrélation les mots avec le corps humain. Les mots "jambe", "bras" et "cou" peuvent obtenir un score élevé dans cette dimension, mais aussi dans la dimension médicale.

Le modèle peut utiliser ces dimensions pour détecter les mots plus susceptibles d'être associés au spam. Les spams contiennent peut-être plus souvent des mots liés au corps humain et à la médecine.

D'après certaines recherches, la règle de base consiste à retenir la quatrième racine du nombre de mots pour ce paramètre. Par exemple, si j'utilise 2 000 mots, un bon point de départ est de 7 dimensions. Vous pouvez également modifier le nombre de mots utilisés.

Comprendre le

seq_len

parameter

Les modèles sont généralement très rigides en ce qui concerne les valeurs d'entrée. Pour un modèle de langage, cela signifie qu'il peut classer des phrases d'une longueur statique spécifique. Ce classement est déterminé par le paramètre seq_len, qui signifie "longueur de la séquence". Lorsque vous convertissez des mots en chiffres (ou en jetons), une phrase devient une séquence de ces jetons. Votre modèle sera donc entraîné (dans ce cas) à classer et à reconnaître les phrases correspondant à 20 jetons. Si la phrase est plus longue, elle sera tronquée. Si elle est plus courte, elle sera complétée, comme dans le premier atelier de programmation de cette série.

Étape 5 : Charger les données d'entraînement

Précédemment, vous avez téléchargé le fichier CSV. Vous allez maintenant utiliser un chargeur de données pour transformer les données en données d'entraînement reconnues par le modèle.

data = DataLoader.from_csv(
      filename=data_file,
      text_column='commenttext', 
      label_column='spam', 
      model_spec=spec,
      delimiter=',',
      shuffle=True,
      is_training=True)

train_data, test_data = data.split(0.9)

Si vous ouvrez le fichier CSV dans un éditeur, vous pouvez voir que chaque ligne comporte deux valeurs et un texte de description sur la première ligne du fichier. Généralement, chaque entrée est considérée comme une "colonne". Notez que le descripteur de la première colonne est commenttext et que la première entrée de chaque ligne est le texte du commentaire.

De même, le descripteur de la deuxième colonne est spam, et la deuxième entrée de chaque ligne est TRUE ou FALSE pour indiquer si le texte est considéré comme du spam ou non. Les autres propriétés définissent la spécification du modèle que vous avez créée à l'étape 4, avec un caractère délimiteur, ici une virgule, car les valeurs du fichier sont séparées par une virgule. Vous définissez également un paramètre de mélange pour réorganiser aléatoirement les données d'entraînement. Ainsi, les éléments qui auraient pu être similaires ou collectés ensemble sont répartis de manière aléatoire dans l'ensemble de données.

Vous utiliserez ensuite data.split() pour répartir les données entre données d'entraînement et données de test. Le chiffre 0, 9 indique que 90 % de l'ensemble de données seront utilisés pour l'entraînement et le reste pour les tests.

Info amusante : lorsque vous entraînez des modèles de machine learning, vous mettez souvent de côté 10 à 20 % des données d'origine pour tester le modèle après son entraînement complet. Cela nous permet de tester le modèle obtenu sur des données qu'il n'a jamais vues auparavant. Cela nous permet de tester son efficacité comme il se comporterait dans le monde réel. Si vous avez entraîné le modèle sur toutes les données, vous risquez de l'adapter uniquement à ces données et de ne pas créer un modèle généralisable qui peut fonctionner dans des circonstances inconnues.

Étape 6 : Créer le modèle

Ajoutez une autre cellule dans laquelle nous ajouterons du code pour créer le modèle :

model = text_classifier.create(train_data, model_spec=spec, epochs=50)

Ce code crée un modèle de classification de texte avec Model Maker. Vous indiquez les données d'entraînement à utiliser (définies à l'étape 4), la spécification du modèle (également définie à l'étape 4) et un nombre d'époques, soit 50 dans ce cas.

Selon son principe de base, le machine learning est une forme de correspondance de modèles. Dans un premier temps, le modèle chargera les pondérations de mots pré-entraînées et tentera de grouper les mots pour prédire lesquels, lorsqu'ils sont regroupés, sont probablement du spam et lesquels ne le sont pas. Lors de la première séquence, les résultats se répartissent généralement de façon égale, car le modèle vient juste de commencer, comme illustré ci-dessous :

Les résultats de cette époque d'entraînement sont ensuite mesurés et les pondérations du modèle sont modifiées pour ajuster la prédiction, puis une nouvelle séquence démarre. Chaque séquence représente une époque. Ainsi, en spécifiant "epochs=50", le modèle effectuera chaque séquence en "boucle" 50 fois, comme indiqué ci-dessous :

Lorsque vous arrivez à la 50e époque, le niveau de justesse fourni par le modèle est bien plus élevé. Dans ce cas, il est de 99,1 %.

Étape 7 : Exportez le modèle

Une fois l'entraînement terminé, vous pouvez exporter le modèle. TensorFlow entraîne un modèle dans son propre format, qui doit être converti au format TensorFlow.js pour être utilisé sur une page Web. Il vous suffit de coller le code suivant dans une nouvelle cellule et de l'exécuter :

model.export(export_dir="/js_export/", export_format=[ExportFormat.TFJS, ExportFormat.LABEL, ExportFormat.VOCAB])
!zip -r /js_export/ModelFiles.zip /js_export/

Après avoir exécuté ce code, si vous cliquez sur la petite icône de dossier à gauche de Colab, vous pouvez accéder au dossier dans lequel vous avez exporté les fichiers ci-dessus (dans le répertoire racine, vous devrez peut-être remonter d'un niveau) et trouver le bundle ZIP des fichiers exportés dans ModelFiles.zip.

Téléchargez ce fichier ZIP sur votre ordinateur dès maintenant, car vous utiliserez ces fichiers comme dans le premier atelier de programmation :

Parfait ! La partie Python est terminée. Vous pouvez maintenant revenir à JavaScript, que vous connaissez et appréciez. Ouf !

Conseil : Le notebook Colab que vous venez d'écrire sera enregistré par défaut dans votre dossier Google Drive, dans un dossier intitulé "Notebooks Colab". Vous pourrez ainsi réexécuter tout votre code avec un nouveau fichier CSV pour l'entraîner à nouveau. Si vous choisissez de le faire plus tard, n'oubliez pas de commencer par le haut et d'exécuter chaque cellule dans l'ordre pour éviter tout problème. Vous pouvez également modifier n'importe quelle cellule avant de l'exécuter, si vous le souhaitez.

5. Mettre en service le nouveau modèle de machine learning

Vous êtes maintenant presque prêt à charger le modèle. Toutefois, avant de pouvoir le faire, vous devez importer les nouveaux fichiers de modèle téléchargés précédemment dans l'atelier de programmation afin qu'ils soient hébergés et utilisables dans votre code.

Tout d'abord, si vous ne l'avez pas déjà fait, décompressez les fichiers du modèle que vous venez de télécharger à partir du notebook Model Maker Colab que vous venez d'exécuter. Vous devriez voir les fichiers suivants dans ses différents dossiers :

Qu'est-ce que vous avez ici ?

• model.json : il s'agit de l'un des fichiers qui composent le modèle TensorFlow.js entraîné. Vous ferez référence à ce fichier spécifique dans le code JS.
• group1-shard1of1.bin : il s'agit d'un fichier binaire contenant la plupart des données enregistrées pour le modèle TensorFlow.js exporté. Il devra être hébergé quelque part sur votre serveur pour être téléchargé dans le même répertoire que model.json ci-dessus.
• vocab : ce fichier étrange sans extension provient de Model Maker. Il nous montre comment encoder les mots dans les phrases pour que le modèle comprenne comment les utiliser. Vous en apprendrez davantage à ce sujet dans la section suivante.
• labels.txt : contient simplement les noms de classe résultants que le modèle prédira. Si vous ouvrez ce fichier dans votre éditeur de texte, vous verrez simplement les valeurs "false" et "true", qui indiquent respectivement "non-spam" et "spam" comme résultat de prédiction.

Héberger les fichiers du modèle TensorFlow.js

Commencez par placer les fichiers model.json et *.bin générés sur un serveur Web pour pouvoir y accéder depuis votre page Web.

Remarque : Si vous n'utilisez pas Glitch et que vous suivez plutôt le tutoriel en exécutant votre propre serveur Node.js Express, vous pouvez simplement placer ces fichiers sans les modifier dans votre dossier www pour les diffuser. Ne suivez les étapes d'importation ci-dessous que si vous utilisez Glitch.com pour héberger les fichiers.

Supprimer les fichiers de modèle existants

Comme vous allez vous appuyer sur le résultat final du premier atelier de programmation de cette série, vous devez d'abord supprimer les fichiers de modèle importés existants. Si vous utilisez Glitch.com, il vous suffit de vérifier le panneau des fichiers sur la gauche pour trouver model.json et group1-shard1of1.bin. Cliquez sur le menu déroulant à trois points pour chaque fichier, puis sélectionnez delete (supprimer), comme indiqué :

Importer de nouveaux fichiers dans Glitch

Parfait ! Importez maintenant les nouveaux :

1. Ouvrez le dossier assets (éléments) dans le panneau de gauche de votre projet Glitch et supprimez les anciens éléments importés s'ils portent le même nom.
2. Cliquez sur Importer un composant, puis sélectionnez group1-shard1of1.bin à importer dans ce dossier. Une fois importé, il devrait se présenter comme suit :

3. Parfait ! Faites de même pour le fichier model.json. Vous devriez donc avoir deux fichiers dans votre dossier "assets", comme ceci :

4. 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é :

5. En bas à gauche de l'écran, cliquez sur Outils > Terminal. Attendez que la fenêtre du terminal se charge.
6. Une fois le fichier chargé, saisissez la commande suivante, puis appuyez sur Entrée pour accéder au dossier www :

terminal:

cd www

7. Ensuite, utilisez wget pour télécharger les deux fichiers que vous venez d'importer. Pour cela, remplacez les URL ci-dessous par celles que vous avez générées pour les fichiers du dossier "assets" sur Glitch (vérifiez le dossier "assets" pour connaître l'URL personnalisée de chaque fichier).

Notez l'espace entre les deux URL. Celles que vous devrez utiliser seront différentes de celles affichées, mais elles y ressembleront :

terminal

wget https://cdn.glitch.com/1cb82939-a5dd-42a2-9db9-0c42cab7e407%2Fmodel.json?v=1616111344958 https://cdn.glitch.com/1cb82939-a5dd-42a2-9db9-0c42cab7e407%2Fgroup1-shard1of1.bin?v=1616017964562

Super ! Vous avez maintenant créé une copie des fichiers importés dans le dossier www.

Toutefois, pour le moment, ils seront téléchargés avec des noms étranges. Si vous saisissez ls dans le terminal et que vous appuyez sur Entrée, vous verrez quelque chose comme ceci :

8. Renommez les fichiers à l'aide de la commande mv. Saisissez ce qui suit dans la console, en appuyant sur Entrée après chaque ligne :

terminal:

mv *group1-shard1of1.bin* group1-shard1of1.bin
mv *model.json* model.json

9. Enfin, actualisez le projet Glitch en saisissant refresh dans le terminal et en appuyant sur Entrée :

terminal:

refresh

Après l'actualisation, model.json et group1-shard1of1.bin devraient s'afficher dans le dossier www de l'interface utilisateur :

Parfait ! La dernière étape consiste à mettre à jour le fichier dictionary.js.

10. Convertissez le fichier de vocabulaire que vous venez de télécharger au format JS approprié, soit manuellement à l'aide de votre éditeur de texte, soit à l'aide de cet outil. Enregistrez ensuite le résultat sous le nom dictionary.js dans votre dossier www. Si vous disposez déjà d'un fichier dictionary.js, vous pouvez simplement copier et coller le nouveau contenu par-dessus, puis enregistrer le fichier.

Excellent ! Vous avez réussi à mettre à jour tous les fichiers modifiés. Si vous essayez maintenant d'utiliser le site Web, vous remarquerez que le modèle réentraîné devrait être en mesure de tenir compte des cas extrêmes découverts et appris, comme indiqué ci-dessous :

Comme vous pouvez le constater, les six premiers e-mails sont désormais correctement classés comme non spams, et les six suivants sont tous identifiés comme spams. Parfait !

Essayons également quelques variantes pour voir si la généralisation est bonne. À l'origine, une phrase non conforme était présente, par exemple :

"OMG, l'action GOOG vient de grimper en flèche ! Profitez-en avant qu'il ne soit trop tard !"

Il est désormais correctement classé comme spam, mais que se passe-t-il si vous le remplacez par :

"Le cours de l'action XYZ vient d'augmenter ! Achetez-en avant qu'il ne soit trop tard !"

Ici, vous obtenez une prédiction de 98 % de probabilité de spam, ce qui est correct même si vous avez légèrement modifié le symbole boursier et la formulation.

Bien sûr, si vous essayez vraiment de mettre à mal ce nouveau modèle, vous y parviendrez. Il faudra alors collecter encore plus de données d'entraînement pour avoir les meilleures chances de capturer davantage de variations uniques pour les situations courantes que vous êtes susceptible de rencontrer en ligne. Dans un prochain atelier de programmation, nous vous montrerons comment améliorer en continu votre modèle avec des données en direct lorsqu'elles sont signalées.

6. Félicitations !

Félicitations ! Vous avez réussi à réentraîner un modèle de machine learning existant pour qu'il fonctionne avec les cas extrêmes que vous avez trouvés, et vous avez déployé ces modifications dans le navigateur avec TensorFlow.js pour une application concrète.

Résumé

Dans cet atelier de programmation, vous avez découvert :

1. Découverte de cas extrêmes qui ne fonctionnaient pas avec le modèle prédéfini de détection de spam dans les commentaires
2. Réentraînement du modèle Model Maker pour tenir compte des cas extrêmes que vous avez découverts
3. Exportation du nouveau modèle entraîné au format TensorFlow.js
4. Vous avez mis à jour votre application Web pour utiliser les nouveaux fichiers.

Et ensuite ?

Cette mise à jour fonctionne très bien, mais comme pour toute application Web, des modifications se produiront au fil du temps. Il serait préférable que l'application s'améliore en continu au fil du temps, plutôt que nous ayons à le faire manuellement à chaque fois. Pouvez-vous imaginer comment vous auriez pu automatiser ces étapes pour réentraîner automatiquement un modèle après avoir, par exemple, reçu 100 nouveaux commentaires marqués comme mal classés ? Si vous êtes un ingénieur Web, vous savez probablement comment créer un pipeline pour automatiser ce processus. Si ce n'est pas le cas, ne vous inquiétez pas. Le prochain atelier de programmation de la série vous montrera comment faire.

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 le blog TensorFlow ou lors de prochains événements. Nous serions ravis de découvrir vos créations.

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

• Déployez et hébergez un modèle TensorFlow.js à grande échelle à l'aide de Firebase Hosting.
• Créer une webcam intelligente à l'aide d'un modèle de détection d'objets prédéfini avec TensorFlow.js

Sites Web à consulter

• Site Web officiel de TensorFlow.js
• Modèles prédéfinis TensorFlow.js
• API TensorFlow.js
• TensorFlow.js Show & Tell : inspirez-vous et découvrez ce que d'autres ont créé.