Entraîner un modèle de détection de spam dans les commentaires avec TensorFlow Lite Model Maker

1. Avant de commencer

Dans cet atelier de programmation, vous allez examiner le code créé avec TensorFlow et TensorFlow Lite Model Maker pour concevoir un modèle à partir d'un ensemble de données basé sur le spam dans les commentaires. Les données d'origine sont disponibles sur Kaggle. Elles ont été rassemblées en un seul fichier CSV et nettoyées en supprimant le texte corrompu, le balisage, les mots répétés, etc. Vous pourrez ainsi vous concentrer plus facilement sur le modèle plutôt que sur le texte.

Le code que vous examinez est fourni ici, mais il est vivement recommandé de suivre également le code dans Colaboratory.

Prérequis

Cet atelier de programmation a été écrit pour les développeurs expérimentés qui ne connaissent pas le machine learning.
Il fait partie du parcours Premiers pas avec la classification de texte dans les applications Flutter. Si vous n'avez pas encore terminé les activités précédentes, veuillez le faire maintenant avant de continuer.

Objectifs de l'atelier

Installer TensorFlow Lite Model Maker avec Colab
Télécharger les données du serveur Colab sur votre appareil
Utiliser un chargeur de données
Créer le modèle

Ce dont vous avez besoin

Accès à Colab

2. Installer TensorFlow Lite Model Maker

Ouvrez Colab. La première cellule du notebook permet d'installer automatiquement TensorFLow Lite Model Maker :

!pip install -q tflite-model-maker

Une fois l'opération terminée, passez à la cellule suivante.

3. Importer le code

La cellule suivante comporte un certain nombre d'importations que le code du notebook devra utiliser :

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

Elle permet également de vérifier si vous avez exécuté TensorFlow 2.x, condition préalable à l'utilisation de Model Maker.

4. Télécharger les données

Vous allez ensuite télécharger les données du serveur Colab sur votre appareil et définir la variable data_file pour qu'elle pointe vers le fichier local :

data_file = tf.keras.utils.get_file(fname='comment-spam.csv',
  origin='https://storage.googleapis.com/laurencemoroney-blog.appspot.com/lmblog_comments.csv',
  extract=False)

Model Maker peut entraîner des modèles à partir de fichiers CSV simples comme celui-ci. Il vous suffit de spécifier les colonnes qui contiennent le texte et celles qui contiennent les étiquettes. Nous verrons plus tard dans cet atelier de programmation comment procéder.

5. Représentations vectorielles continues pré-entraînées

En règle générale, lorsque vous utilisez Model Maker, vous n'avez pas à créer de modèles à partir de zéro. Vous utilisez les modèles existants que vous personnalisez pour répondre à vos besoins.

Les modèles de langage comme celui-ci utilisent des représentations vectorielles continues pré-entraînées. Le but d'une représentation vectorielle est de convertir les mots en chiffres, chaque mot du corpus global étant associé à un chiffre. Une intégration est un vecteur qui permet de déterminer le sentiment de ce mot en attribuant une "direction" au mot. Par exemple, les vecteurs de mots fréquemment utilisés dans le spam de commentaires pointent dans une direction comparable, tandis que les vecteurs de mots sans direction pointent dans la direction opposée.

Lorsque vous utilisez des représentations vectorielles continues pré-entraînées, le point de départ est un corpus ou une collection de mots qui ont déjà obtenu des sentiments issus d'un grand nombre de texte. Parvenir à une solution est ainsi bien plus rapide qu'en partant de zéro.

Model Maker propose plusieurs représentations vectorielles continues pré-entraînées, mais l'option la plus simple et la plus rapide est de commencer par average_word_vec.

Voici le code :

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

Paramètre `num_words`

Vous devez également indiquer le nombre de mots à utiliser dans le modèle.

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'établir la direction des mots qui ne sont utilisés qu'une seule fois. 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. En revanche, un nombre élevé de mots générera un modèle plus grand, mais plus lent. L'essentiel est de trouver le bon compromis.

Paramètre `wordvec_dim`

Le paramètre wordved_dim correspond au nombre de dimensions que vous souhaitez utiliser dans le vecteur pour chaque mot. D'après certaines recherches, la règle de base consiste à retenir la quatrième racine du nombre de mots. Par exemple, si vous utilisez 2 000 mots, 7 est un bon point de départ. Vous pouvez également modifier le nombre de mots utilisés.

Paramètre `seq_len`

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 ou la longueur de la séquence.

Lorsque vous convertissez des mots en chiffres ou en jetons, une phrase devient une séquence de ces jetons. Dans ce cas, le modèle est entraîné à classer et à reconnaître les phrases correspondant à 20 jetons. Si la phrase est plus longue, elle est tronquée. Si elle est plus courte, elle est remplie. Un jeton <PAD> dédié apparaît alors dans le corpus.

6. Utiliser un chargeur de données

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 variable model_spec que vous avez créée précédemment, avec un caractère délimiteur, ici une virgule, car les valeurs du fichier sont séparées par une virgule. Vous allez utiliser ces données pour entraîner le modèle. is_Training est donc défini sur True.

Vous devez mettre de côté une partie des données pour tester le modèle. Pour ce faire, répartissez les données entre deux ensembles, 90 % pour l'entraînement et 10 % pour les tests/l'évaluation. Nous procédons ainsi pour nous assurer que les données de test sont choisies au hasard et non dans les 10 % du "bas" de l'ensemble de données. Vous allez donc utiliser shuffle=True au moment de charger les données à randomiser.

7. Créer le modèle

La cellule suivante sert simplement à créer le modèle. Elle se compose d'une seule ligne de code :

# Build the model
model = text_classifier.create(train_data, model_spec=spec, epochs=50,
                               validation_data=test_data)

Ce code crée un modèle de classificateur de texte à l'aide de Model Maker. Vous indiquez les données d'entraînement à utiliser et la spécification du modèle (comme défini à la quatrième étape), ainsi qu'un nombre d'époques, soit 50 dans ce cas.

Selon son principe de base, le ML est une forme de correspondance de modèles. Dans un premier temps, le modèle charge les pondérations de mots pré-entraînées et tente 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.

Les résultats de cette époque d'entraînement sont ensuite mesurés et le code d'optimisation est exécuté 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.

Lorsque vous arrivez à la 50e époque, le niveau de justesse fourni par le modèle est bien plus élevé. À ce moment-là, le pourcentage affiché est de 99%.

Les chiffres de justesse lors de la validation sont généralement un peu inférieurs à la justesse réelle de l'entraînement, car ils prennent en compte des données que le modèle n'a pas encore vues pour la classification. L'évaluation est effectuée sur les 10 % de données de test que vous avez précédemment mises de côté.

8. Exporter le modèle

Exécutez cette cellule pour spécifier un répertoire et exporter le modèle :

model.export(export_dire='/mm_spam_savedmodel', export_format=[ExportFormat.LABEL, ExportFormat.VOCAB, ExportFormat.SAVED_MODEL])

Compressez l'intégralité du dossier /mm_spam_savedmodel et enregistrez le fichier mm_spam_savedmodel.zip généré dans un sous-dossier. Vous en aurez besoin dans l'atelier de programmation suivant.

# Rename the SavedModel subfolder to a version number
!mv /mm_spam_savedmodel/saved_model /mm_spam_savedmodel/123
!zip -r mm_spam_savedmodel.zip /mm_spam_savedmodel/

9. Félicitations

Dans cet atelier de programmation, vous avez appris à créer un modèle codé en Python et à l'exporter. Vous disposez à présent d'un modèle SavedModel avec, à la fin, les étiquettes et le vocabulaire associés. Dans l'atelier de programmation suivant, vous allez apprendre à utiliser ce modèle pour commencer à classer des commentaires contenant du spam.