1. Avant de commencer
Dans cet atelier de programmation, vous allez examiner le code créé avec TensorFlow et TensorFlow Lite Model Maker pour créer 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. Il a été regroupé en un seul fichier CSV et nettoyé 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 a été fourni ici, mais nous vous recommandons vivement de suivre le code dans Google Colab.
Prérequis
- Cet atelier de programmation a été rédigé pour les développeurs expérimentés qui ne connaissent pas le machine learning.
- Cet atelier de programmation fait partie de la section "Premiers pas avec la classification de texte pour le parcours mobile". Si vous n'avez pas encore terminé les activités précédentes, veuillez arrêter la procédure.
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 installe 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')
Cet article vérifie également si 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 depuis le 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 de ce type. Il vous suffit de spécifier les colonnes qui contiennent le texte et celles qui contiennent les libellés. Nous verrons comment procéder plus tard dans l'atelier de programmation.
5. Représentations vectorielles continues pré-entraînées
Généralement, lorsque vous utilisez Model Maker, vous ne devez pas créer de modèles de A à Z. Vous utilisez les modèles existants que vous personnalisez pour répondre à vos besoins.
Pour les modèles de langage, comme celui-ci, représentations vectorielles continues pré-entraînées dans le menu déroulant ; L'idée sous-jacente d'une représentation vectorielle est que les mots sont convertis en nombres, et que chaque mot de votre corpus se voit attribuer un nombre. Une intégration est un vecteur qui permet de déterminer le sentiment de ce mot en établissant une "direction" pour le mot. Par exemple, les mots utilisés fréquemment dans les messages de spam dans les commentaires seront orientés dans une direction similaire, et les autres dans une direction opposée.
En utilisant des représentations vectorielles continues pré-entraînées, vous pouvez commencer par un corpus, ou une collection, de mots pour lesquels des sentiments sont déjà issus d'un grand nombre de textes. Vous accéderez ainsi à une solution beaucoup plus rapidement que si vous ne reprenez pas à zéro.
Model Maker propose plusieurs représentations vectorielles continues pré-entraînées, mais la plus simple et la plus rapide de 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 pouvez penser que "plus il y a de choses", mais il existe généralement un nombre approprié en fonction de la fréquence utilisée pour chaque mot. Si vous utilisez tous les mots de l'ensemble du corpus, vous risquez de vous retrouver avec un modèle qui apprend à apprendre et à identifier les mots qui ne sont utilisés qu'une seule fois. Vous constaterez que dans de nombreux textes, de nombreux mots ne sont utilisés qu'une seule fois ou deux, et qu'il n'est généralement pas intéressant 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 sur le nombre de mots souhaités à l'aide du paramètre num_words.
Dans ce cas, un nombre plus réduit peut donner un modèle plus petit et plus rapide, mais être moins précis, car il permet de reconnaître moins de mots. Plus la taille est élevée, plus le modèle est grand et lent. Trouver le bon endroit est la clé !
Paramètre "wordvec_dim"
Le paramètre wordved_dim correspond au nombre de dimensions que vous souhaitez utiliser pour le vecteur pour chaque mot. La règle de base déterminée par la recherche est qu'elle est la quatrième racine du nombre de mots. Par exemple, si vous utilisez 2 000 mots, un bon point de départ est 7. 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. Avec un modèle de langage, cela signifie qu'il peut classer des phrases d'une longueur spécifique ou statique. Cela est déterminé par le paramètre seq_len ou longueur de la séquence.
Lorsque vous convertissez des mots en chiffres (ou jetons), une phrase devient une séquence de ces jetons. Ainsi, votre modèle sera entraîné (dans le cas présent) à classifier et à reconnaître les phrases de 20 jetons. Si la phrase est plus longue, elle sera tronquée. S'il est plus court, il sera rempli. Vous verrez un jeton dédié <PAD> dans le corpus qui sera utilisé pour cela.
6. Utiliser un chargeur de données
Vous avez précédemment téléchargé le fichier CSV. Utilisez maintenant 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 verrez que chaque ligne a deux valeurs et sont décrites avec du texte sur la première ligne du fichier. Généralement, chaque entrée est considérée comme une colonne.
Vous constaterez que la description 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 pour la deuxième colonne est spam, et vous constatez que 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, ainsi qu'un caractère délimiteur. Dans ce cas, il s'agit d'une virgule, car les fichiers sont séparés par une virgule. Vous allez utiliser ces données pour entraîner le modèle. is_Training est donc défini sur True.
Vous devrez retenir une partie des données pour tester le modèle. Divisez les données pour 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 qu'elles ne correspondent pas aux 10% inférieurs de l'ensemble de données. Vous utilisez donc shuffle=True lors du chargement des données de manière aléatoire.
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éé avec Model Maker. Vous devez spécifier les données d'entraînement que vous voulez utiliser (comme configuré à l'étape 4), les spécifications du modèle (telles que configurées à l'étape 4) et un certain nombre d'époques. 50 :
Le principe de base du machine learning est qu'il s'agit d'une forme de correspondance de structure. Dans un premier temps, il chargera les pondérations pré-entraînées pour les mots et essayera de les regrouper avec une prédiction indiquant ceux qui ne le sont pas, puis ceux qui ne le sont pas. La première fois qu'il est lancé, il est possible qu'il soit proche de 50:50, car le modèle ne fait que commencer.
Les résultats seront ensuite mesurés, et le code d'optimisation s'exécutera pour ajuster la prédiction, puis réessayer. Il s'agit d'une époque. Ainsi, en spécifiant epochs=50, la boucle s'appliquera 50 fois.
Lorsque vous atteignez la 50e époque, le modèle fournit un niveau de précision bien plus élevé. Dans ce cas, la valeur 99 % est affichée.
Sur la droite, vous trouverez des chiffres de précision de la validation. Elles sont généralement légèrement inférieures à la justesse de l'entraînement, car elles indiquent la classification des 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é plus tô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. Pour l'utiliser dans une application mobile, vous devez le convertir au format TFLITE. Model Maker gère cette complexité à votre place.
Exportez simplement le modèle en spécifiant un répertoire:
model.export(export_dir='/mm_spam')
Dans ce répertoire, vous verrez un fichier model.tflite. Téléchargez-le. Vous en aurez besoin dans l'atelier de programmation suivant, où vous l'ajouterez à votre application Android.
Remarques sur iOS
Le modèle .tflite que vous venez d'exporter fonctionne bien pour Android, car les métadonnées associées à ce modèle sont intégrées dans Android Studio.
Ces métadonnées sont très importantes, car elles incluent un dictionnaire de jetons représentant des mots lorsque le modèle les reconnaît. Vous vous êtes déjà rappelé lorsque vous avez appris que les mots se transformaient en jetons, et qu'ils obtenaient ensuite les vecteurs de leur sentiment ? Votre application mobile doit connaître ces jetons. Par exemple, si la valeur de "chien" est de 42 et que les utilisateurs saisissent "chien" en une phrase, votre application devra alors convertir "chien" en 42 pour que le modèle la comprenne. En tant que développeur Android, vous disposerez d'une "bibliothèque de tâches TensorFlow Lite" qui facilite l'utilisation de ce langage. Toutefois, sous iOS, vous devez traiter le vocabulaire. Celui-ci doit donc être disponible. Model Maker peut exporter ces données pour vous en spécifiant le paramètre export_format. Pour obtenir les étiquettes et le vocabulaire de votre modèle, vous pouvez utiliser la commande suivante:
model.export(export_dir='/mm_spam/',
export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])
9. Félicitations
Cet atelier de programmation vous a permis de parcourir Python Code pour créer et exporter votre modèle. À la fin, vous trouverez un fichier .tflite.
Dans l'atelier de programmation suivant, vous découvrirez comment modifier votre application Android afin d'utiliser ce modèle afin de commencer à classer des commentaires indésirables.