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 allez examiner est fourni ici, mais il est vivement recommandé de suivre également le code dans Google Colab.
Prérequis
- Cet atelier de programmation a été écrit pour les développeurs expérimentés qui ne connaissent pas le machine learning.
- Cet atelier de programmation fait partie du parcours "Premiers pas avec la classification de texte sur mobile". Si vous n'avez pas encore terminé les activités précédentes, veuillez le faire maintenant avant de continuer.
Points abordés
- Installer TensorFlow Lite Model Maker à l'aide de Google Colab
- Télécharger les données du serveur Cloud sur votre appareil
- Utiliser un chargeur de données
- Créer le modèle
Prérequis
- Un accès à Google Colab
2. Installer TensorFlow Lite Model Maker
Ouvrez le notebook 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 exécutez 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 Cloud sur votre appareil et définir 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. Vous verrez comment faire cela plus loin dans l'atelier de programmation.
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.
Pour les modèles de langage comme celui-ci, cela implique d'utiliser 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. Vous trouverez ainsi une solution beaucoup plus rapidement que si vous partiez de zéro.
Model Maker propose plusieurs représentations vectorielles continues pré-entraînées que vous pouvez utiliser, mais l'option la plus simple et la plus rapide pour commencer est 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. Un nombre plus élevé générera un modèle plus grand, mais plus lent. Il est essentiel de trouver le juste équilibre.
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. 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. 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 classification 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 à l'étape 4), ainsi qu'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 (50/50), 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é. Dans ce cas, il est de 99 %.
Sur la droite, vous verrez les chiffres de précision de la validation. Ces chiffres sont généralement un peu inférieurs à la justesse 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 nous avons précédemment mises de côté.
8. Exporter 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 TFLITE pour être utilisé dans une application mobile. Model Maker gère cette complexité pour vous.
Il vous suffit d'exporter le modèle en spécifiant un répertoire :
model.export(export_dir='/mm_spam')
Dans ce répertoire, vous trouverez un fichier model.tflite. Téléchargez. Vous en aurez besoin dans le prochain atelier de programmation, où vous l'ajouterez à votre application Android.
Remarques concernant iOS
Le modèle .tflite que vous venez d'exporter fonctionne bien pour Android, car des métadonnées sur le modèle y sont intégrées et Android Studio peut les lire.
Ces métadonnées sont très importantes, car elles incluent un dictionnaire de jetons représentant les mots tels que le modèle les reconnaît. Vous vous souvenez que les mots deviennent des jetons, et que ces jetons reçoivent ensuite des vecteurs pour leur sentiment ? Votre application mobile devra connaître ces jetons. Par exemple, si "chien" a été tokenisé en 42 et que vos utilisateurs saisissent "chien" dans une phrase, votre application devra ensuite convertir "chien" en 42 pour que le modèle le comprenne. En tant que développeur Android, vous disposerez d'une "bibliothèque de tâches TensorFlow Lite" qui facilitera l'utilisation de cette fonctionnalité. Toutefois, sur iOS, vous devrez traiter le vocabulaire et donc le rendre disponible. Model Maker peut l'exporter pour vous en spécifiant le paramètre export_format. Pour obtenir les libellés et le vocabulaire de votre modèle, vous pouvez utiliser le code suivant :
model.export(export_dir='/mm_spam/',
export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])
9. Félicitations
Dans cet atelier de programmation, vous avez appris à créer un modèle codé en Python et à l'exporter. Vous obtiendrez un fichier .tflite à la fin.
Dans le prochain atelier de programmation, vous allez apprendre à modifier votre application Android pour utiliser ce modèle et commencer à classer les commentaires contenant du spam.