1. Avant de commencer
Dans cet atelier de programmation, vous allez examiner du code créé à l'aide de TensorFlow et de TensorFlow Lite Model Maker pour créer un modèle basé sur un ensemble de données basé sur le spam dans les commentaires. Les données d'origine sont disponibles sur Kaggle. Elles ont été regroupées dans un seul fichier CSV et nettoyées en supprimant le texte corrompu, le balisage, les mots répétés et plus encore. 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 nous vous recommandons vivement de suivre 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 pour 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
- Accès à Google Colab
2. Installer TensorFlow Lite Model Maker
Ouvrez le 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')
Cela vous permet également de vérifier que vous exécutez TensorFlow 2.x, qui est nécessaire pour utiliser 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'il 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 libellés. Nous verrons comment procéder dans la suite de cet atelier de programmation.
5. Représentations vectorielles continues pré-entraînées
En règle générale, lorsque vous utilisez Model Maker, vous ne créez pas 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. L'idée derrière une représentation vectorielle continue est que les mots sont convertis en nombres, chaque mot de votre corpus global étant associé à un nombre. Une représentation vectorielle continue est un vecteur qui permet de déterminer le sentiment de ce mot en établissant une "direction" pour ce mot. Par exemple, les vecteurs de mots fréquemment utilisés dans les messages de spam dans les commentaires finissent par pointer dans une direction similaire, tandis que les mots qui ne le sont pas pointeront dans la direction opposée.
En utilisant des représentations vectorielles continues pré-entraînées, vous pouvez partir d'un corpus, ou d'une collection, de mots dont le sentiment a déjà été tiré d'un vaste corps de texte. Cela vous permettra d'obtenir une solution beaucoup plus rapidement que de partir de zéro.
Model Maker propose plusieurs représentations vectorielles continues pré-entraînées que vous pouvez utiliser, mais 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 spécifier le nombre de mots que votre modèle doit utiliser.
Vous pourriez penser
« plus il y en a, mieux c’est », mais il y a généralement un nombre correct en fonction
de la fréquence à laquelle chaque mot est utilisé. Si vous reteniez tous les mots du corpus, le modèle pourrait essayer d'apprendre et d'établir la direction de mots qui ne sont utilisés qu'une seule fois. Dans un corpus de textes, vous constaterez que de nombreux mots ne sont utilisés qu'une ou deux fois et qu'il n'est généralement pas utile de les utiliser dans votre modèle, car ils ont un impact négligeable sur le sentiment général. Vous pouvez ajuster votre modèle en fonction du nombre de mots de votre choix à l'aide du paramètre num_words.
Un plus petit nombre peut donner un modèle plus petit et plus rapide, mais il peut être moins précis, car il reconnaît moins de mots. Plus le nombre est élevé, plus le modèle est volumineux et plus lent. Trouver le bon emplacement est essentiel !
Paramètre wordvec_dim
Le paramètre wordved_dim correspond au nombre de dimensions que vous souhaitez utiliser pour le vecteur de chaque mot. La règle de base déterminée à partir de recherches est qu'il s'agit de 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. Dans le cas d'un modèle de langage, cela signifie qu'il peut classifier des phrases d'une longueur statique particulière. Cela est déterminé par le paramètre seq_len ou la longueur de la séquence.
Lorsque vous convertissez des mots en nombres (ou jetons), une phrase devient une séquence de ces jetons. Votre modèle sera donc entraîné (ici) à classer et à reconnaître les phrases comportant 20 jetons. Si la phrase est plus longue, elle sera tronquée. Si elle est plus courte, elle sera remplie. Un jeton <PAD> dédié s'affichera dans le corpus pour cela.
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 l'élément model_spec que vous avez créé précédemment, avec un caractère délimiteur. Dans ce cas, il s'agit d'une virgule, car le fichier est séparé 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)
Un modèle de classificateur de texte est alors créé à l'aide de Model Maker. Vous spécifiez les données d'entraînement que vous souhaitez utiliser (configurées à l'étape 4), la spécification du modèle (configurée à l'étape 4) et un nombre d'époques, dans ce cas 50.
Le principe de base du machine learning est qu'il s'agit d'une forme de correspondance de modèles. Dans un premier temps, il chargera les pondérations pré-entraînées pour les mots et tentera de les regrouper pour prédire ceux qui, une fois regroupés, indiquent du spam et ceux qui ne le sont pas. La première fois, il devrait se rapprocher des 50 min 50 s, car le modèle ne fait que commencer.
Il mesurera ensuite les résultats et exécutera le code d'optimisation pour ajuster sa prédiction, puis retentera. 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 atteignez la 50e époque, le niveau de précision du modèle est bien supérieur. Dans ce cas, il s'agit de 99 %.
Sur la droite, vous pouvez voir les chiffres de justesse de la validation. Elles sont généralement un peu inférieures à la justesse de l'entraînement, car elles indiquent la manière dont le modèle classe les données qu'il n'a pas encore vues. Il utilise les données de test de 10% que nous avons mises de côté précédemment.
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. Celui-ci doit être converti au format TFLITE pour être utilisé dans une application mobile. Model Maker gère cette complexité à votre place.
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 les métadonnées concernant 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 que le modèle les reconnaît. Vous vous souvenez que vous avez appris plus tôt que les mots deviennent des jetons, et que ces jetons reçoivent ensuite des vecteurs correspondant à leur sentiment ? Votre application mobile doit connaître ces jetons. Par exemple, si "chien" a été tokenisée à 42, et que vos utilisateurs saisissent "chien" en phrase, votre application devra convertir le mot "chien" à 42 pour que le modèle les comprenne. En tant que développeur Android, vous disposez d'une "bibliothèque de tâches TensorFlow Lite" Cela facilite l'utilisation. Toutefois, sur iOS, vous devrez traiter le vocabulaire. Vous devrez donc l'avoir à disposition. Model Maker peut exporter cela pour vous en spécifiant le paramètre export_format. Ainsi, pour obtenir les étiquettes et le vocabulaire de votre modèle, vous pouvez utiliser ceci:
model.export(export_dir='/mm_spam/',
export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])
9. Félicitations
Cet atelier de programmation vous a présenté le code Python pour créer et exporter votre modèle. Vous aurez un fichier .tflite à la fin.
Dans l'atelier de programmation suivant, vous découvrirez comment modifier votre application Android pour utiliser ce modèle afin de commencer à classer les commentaires indésirables.