Cette page a été traduite par l'API Cloud Translation.
Switch to English

Intégration de mots

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher la source sur GitHub Télécharger le carnet

Ce didacticiel contient une introduction à l'intégration de mots. Vous allez entraîner vos propres incorporations de mots à l'aide d'un modèle Keras simple pour une tâche de classification des sentiments, puis les visualiser dans le projecteur d'intégration (illustré dans l'image ci-dessous).

Capture d'écran du projecteur d'intégration

Représenter le texte sous forme de nombres

Les modèles d'apprentissage automatique prennent des vecteurs (tableaux de nombres) en entrée. Lorsque vous travaillez avec du texte, la première chose que vous devez faire est de trouver une stratégie pour convertir des chaînes en nombres (ou pour "vectoriser" le texte) avant de l'alimenter dans le modèle. Dans cette section, vous examinerez trois stratégies pour y parvenir.

Encodages à chaud

Comme première idée, vous pourriez encoder "one-hot" chaque mot de votre vocabulaire. Considérez la phrase "Le chat s'est assis sur le tapis". Le vocabulaire (ou les mots uniques) de cette phrase est (cat, mat, on, sat, the). Pour représenter chaque mot, vous allez créer un vecteur nul de longueur égale au vocabulaire, puis en placer un dans l'index qui correspond au mot. Cette approche est illustrée dans le diagramme suivant.

Schéma des encodages one-hot

Pour créer un vecteur contenant le codage de la phrase, vous pouvez ensuite concaténer les vecteurs one-hot pour chaque mot.

Encodez chaque mot avec un numéro unique

Une deuxième approche que vous pourriez essayer consiste à encoder chaque mot en utilisant un numéro unique. En poursuivant l'exemple ci-dessus, vous pouvez attribuer 1 à "cat", 2 à "mat", etc. Vous pouvez ensuite encoder la phrase "Le chat s'est assis sur le tapis" comme un vecteur dense comme [5, 1, 4, 3, 5, 2]. Cette approche est efficace. Au lieu d'un vecteur clairsemé, vous en avez maintenant un dense (où tous les éléments sont pleins).

Cependant, cette approche présente deux inconvénients:

  • Le codage entier est arbitraire (il ne capture aucune relation entre les mots).

  • Un codage entier peut être difficile à interpréter pour un modèle. Un classificateur linéaire, par exemple, apprend un poids unique pour chaque entité. Comme il n'y a pas de relation entre la similitude de deux mots quelconques et la similitude de leurs codages, cette combinaison caractéristique-poids n'est pas significative.

Intégration de mots

Les intégrations de mots nous permettent d'utiliser une représentation efficace et dense dans laquelle des mots similaires ont un codage similaire. Surtout, vous n'avez pas à spécifier ce codage à la main. Une incorporation est un vecteur dense de valeurs à virgule flottante (la longueur du vecteur est un paramètre que vous spécifiez). Au lieu de spécifier manuellement les valeurs pour l'incorporation, ce sont des paramètres pouvant être entraînés (poids appris par le modèle lors de l'apprentissage, de la même manière qu'un modèle apprend les poids pour une couche dense). Il est courant de voir des incorporations de mots en 8 dimensions (pour les petits ensembles de données), jusqu'à 1024 dimensions lorsque vous travaillez avec de grands ensembles de données. Une intégration dimensionnelle plus élevée peut capturer des relations fines entre les mots, mais nécessite plus de données à apprendre.

Schéma d'une intégration

Ci-dessus, un diagramme pour une incorporation de mots. Chaque mot est représenté comme un vecteur à 4 dimensions de valeurs à virgule flottante. Une autre façon de penser à une intégration est la "table de recherche". Une fois ces poids appris, vous pouvez encoder chaque mot en recherchant le vecteur dense auquel il correspond dans le tableau.

Installer

import io
import os
import re
import shutil
import string
import tensorflow as tf

from datetime import datetime
from tensorflow.keras import Model, Sequential
from tensorflow.keras.layers import Activation, Dense, Embedding, GlobalAveragePooling1D
from tensorflow.keras.layers.experimental.preprocessing import TextVectorization

Télécharger l'ensemble de données IMDb

Vous utiliserez l'ensemble de données Large Movie Review dans le cadre du didacticiel. Vous allez former un modèle de classificateur de sentiment sur cet ensemble de données et dans le processus apprendre les incorporations à partir de zéro. Pour en savoir plus sur le chargement d'un ensemble de données à partir de zéro, consultez le didacticiel Chargement de texte .

Téléchargez l'ensemble de données à l'aide de l'utilitaire de fichiers Keras et jetez un œil aux répertoires.

url = "https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz"

dataset = tf.keras.utils.get_file("aclImdb_v1.tar.gz", url,
                                    untar=True, cache_dir='.',
                                    cache_subdir='')

dataset_dir = os.path.join(os.path.dirname(dataset), 'aclImdb')
os.listdir(dataset_dir)
Downloading data from https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
84131840/84125825 [==============================] - 7s 0us/step

['imdbEr.txt', 'README', 'test', 'imdb.vocab', 'train']

Jetez un œil au répertoire train/ . Il a des dossiers pos et neg avec des critiques de films étiquetées respectivement comme positives et négatives. Vous utiliserez les avis des dossiers pos et neg pour former un modèle de classification binaire.

train_dir = os.path.join(dataset_dir, 'train')
os.listdir(train_dir)
['labeledBow.feat',
 'urls_pos.txt',
 'urls_neg.txt',
 'urls_unsup.txt',
 'unsup',
 'neg',
 'pos',
 'unsupBow.feat']

Le répertoire du train contient également des dossiers supplémentaires qui doivent être supprimés avant de créer un jeu de données d'entraînement.

remove_dir = os.path.join(train_dir, 'unsup')
shutil.rmtree(remove_dir)

Ensuite, créez un tf.data.Dataset aide de tf.keras.preprocessing.text_dataset_from_directory . Vous pouvez en savoir plus sur l'utilisation de cet utilitaire dans ce didacticiel de classification de texte .

Utilisez le répertoire de train pour créer des ensembles de données de train et de validation avec une répartition de 20% pour la validation.

batch_size = 1024
seed = 123
train_ds = tf.keras.preprocessing.text_dataset_from_directory(
    'aclImdb/train', batch_size=batch_size, validation_split=0.2, 
    subset='training', seed=seed)
val_ds = tf.keras.preprocessing.text_dataset_from_directory(
    'aclImdb/train', batch_size=batch_size, validation_split=0.2, 
    subset='validation', seed=seed)
Found 25000 files belonging to 2 classes.
Using 20000 files for training.
Found 25000 files belonging to 2 classes.
Using 5000 files for validation.

Jetez un œil à quelques critiques de films et à leurs étiquettes (1: positive, 0: negative) partir de l'ensemble de données du train.

for text_batch, label_batch in train_ds.take(1):
  for i in range(5):
    print(label_batch[i].numpy(), text_batch.numpy()[i])
0 b"Oh My God! Please, for the love of all that is holy, Do Not Watch This Movie! It it 82 minutes of my life I will never get back. Sure, I could have stopped watching half way through. But I thought it might get better. It Didn't. Anyone who actually enjoyed this movie is one seriously sick and twisted individual. No wonder us Australians/New Zealanders have a terrible reputation when it comes to making movies. Everything about this movie is horrible, from the acting to the editing. I don't even normally write reviews on here, but in this case I'll make an exception. I only wish someone had of warned me before I hired this catastrophe"
1 b'This movie is SOOOO funny!!! The acting is WONDERFUL, the Ramones are sexy, the jokes are subtle, and the plot is just what every high schooler dreams of doing to his/her school. I absolutely loved the soundtrack as well as the carefully placed cynicism. If you like monty python, You will love this film. This movie is a tad bit "grease"esk (without all the annoying songs). The songs that are sung are likable; you might even find yourself singing these songs once the movie is through. This musical ranks number two in musicals to me (second next to the blues brothers). But please, do not think of it as a musical per say; seeing as how the songs are so likable, it is hard to tell a carefully choreographed scene is taking place. I think of this movie as more of a comedy with undertones of romance. You will be reminded of what it was like to be a rebellious teenager; needless to say, you will be reminiscing of your old high school days after seeing this film. Highly recommended for both the family (since it is a very youthful but also for adults since there are many jokes that are funnier with age and experience.'
0 b"Alex D. Linz replaces Macaulay Culkin as the central figure in the third movie in the Home Alone empire. Four industrial spies acquire a missile guidance system computer chip and smuggle it through an airport inside a remote controlled toy car. Because of baggage confusion, grouchy Mrs. Hess (Marian Seldes) gets the car. She gives it to her neighbor, Alex (Linz), just before the spies turn up. The spies rent a house in order to burglarize each house in the neighborhood until they locate the car. Home alone with the chicken pox, Alex calls 911 each time he spots a theft in progress, but the spies always manage to elude the police while Alex is accused of making prank calls. The spies finally turn their attentions toward Alex, unaware that he has rigged devices to cleverly booby-trap his entire house. Home Alone 3 wasn't horrible, but probably shouldn't have been made, you can't just replace Macauley Culkin, Joe Pesci, or Daniel Stern. Home Alone 3 had some funny parts, but I don't like when characters are changed in a movie series, view at own risk."
0 b"There's a good movie lurking here, but this isn't it. The basic idea is good: to explore the moral issues that would face a group of young survivors of the apocalypse. But the logic is so muddled that it's impossible to get involved.<br /><br />For example, our four heroes are (understandably) paranoid about catching the mysterious airborne contagion that's wiped out virtually all of mankind. Yet they wear surgical masks some times, not others. Some times they're fanatical about wiping down with bleach any area touched by an infected person. Other times, they seem completely unconcerned.<br /><br />Worse, after apparently surviving some weeks or months in this new kill-or-be-killed world, these people constantly behave like total newbs. They don't bother accumulating proper equipment, or food. They're forever running out of fuel in the middle of nowhere. They don't take elementary precautions when meeting strangers. And after wading through the rotting corpses of the entire human race, they're as squeamish as sheltered debutantes. You have to constantly wonder how they could have survived this long... and even if they did, why anyone would want to make a movie about them.<br /><br />So when these dweebs stop to agonize over the moral dimensions of their actions, it's impossible to take their soul-searching seriously. Their actions would first have to make some kind of minimal sense.<br /><br />On top of all this, we must contend with the dubious acting abilities of Chris Pine. His portrayal of an arrogant young James T Kirk might have seemed shrewd, when viewed in isolation. But in Carriers he plays on exactly that same note: arrogant and boneheaded. It's impossible not to suspect that this constitutes his entire dramatic range.<br /><br />On the positive side, the film *looks* excellent. It's got an over-sharp, saturated look that really suits the southwestern US locale. But that can't save the truly feeble writing nor the paper-thin (and annoying) characters. Even if you're a fan of the end-of-the-world genre, you should save yourself the agony of watching Carriers."
0 b'I saw this movie at an actual movie theater (probably the $2.00 one) with my cousin and uncle. We were around 11 and 12, I guess, and really into scary movies. I remember being so excited to see it because my cool uncle let us pick the movie (and we probably never got to do that again!) and sooo disappointed afterwards!! Just boring and not scary. The only redeeming thing I can remember was Corky Pigeon from Silver Spoons, and that wasn\'t all that great, just someone I recognized. I\'ve seen bad movies before and this one has always stuck out in my mind as the worst. This was from what I can recall, one of the most boring, non-scary, waste of our collective $6, and a waste of film. I have read some of the reviews that say it is worth a watch and I say, "Too each his own", but I wouldn\'t even bother. Not even so bad it\'s good.'

Configurer l'ensemble de données pour les performances

Ce sont deux méthodes importantes que vous devez utiliser lors du chargement de données pour vous assurer que les E / S ne deviennent pas bloquantes.

.cache() garde les données en mémoire après leur chargement hors du disque. Cela garantira que l'ensemble de données ne deviendra pas un goulot d'étranglement lors de l'entraînement de votre modèle. Si votre ensemble de données est trop volumineux pour tenir dans la mémoire, vous pouvez également utiliser cette méthode pour créer un cache sur disque performant, qui est plus efficace à lire que de nombreux petits fichiers.

.prefetch() chevauche le prétraitement des données et l'exécution du modèle pendant l'entraînement.

Vous pouvez en savoir plus sur les deux méthodes, ainsi que sur la mise en cache des données sur le disque dans le guide des performances des données .

AUTOTUNE = tf.data.experimental.AUTOTUNE

train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

Utilisation du calque d'incorporation

Keras facilite l'utilisation de l'intégration de mots. Jetez un œil à la couche Embedding .

La couche Embedding peut être comprise comme une table de recherche qui mappe des indices entiers (qui représentent des mots spécifiques) aux vecteurs denses (leurs plongements). La dimensionnalité (ou largeur) de l'incorporation est un paramètre que vous pouvez expérimenter pour voir ce qui fonctionne bien pour votre problème, de la même manière que vous expérimenteriez avec le nombre de neurones dans une couche dense.

# Embed a 1,000 word vocabulary into 5 dimensions.
embedding_layer = tf.keras.layers.Embedding(1000, 5)

Lorsque vous créez un calque d'incorporation, les pondérations de l'incorporation sont initialisées de manière aléatoire (comme n'importe quel autre calque). Pendant l'entraînement, ils sont progressivement ajustés par rétropropagation. Une fois formés, les incorporations de mots appris coderont grossièrement les similitudes entre les mots (comme elles ont été apprises pour le problème spécifique sur lequel votre modèle est entraîné).

Si vous transmettez un entier à une couche d'incorporation, le résultat remplace chaque entier par le vecteur de la table d'incorporation:

result = embedding_layer(tf.constant([1,2,3]))
result.numpy()
array([[ 0.04530729, -0.04243072,  0.0484405 ,  0.04020107,  0.03276834],
       [-0.03076278,  0.0217622 , -0.02262014,  0.02947016,  0.00353047],
       [ 0.02572921, -0.03171467,  0.03230127, -0.02082225, -0.02455133]],
      dtype=float32)

Pour les problèmes de texte ou de séquence, le calque Embedding prend un tenseur 2D d'entiers, de forme (samples, sequence_length) , où chaque entrée est une séquence d'entiers. Il peut intégrer des séquences de longueurs variables. Vous pouvez alimenter la couche d'incorporation au-dessus des lots avec des formes (32, 10) (lot de 32 séquences de longueur 10) ou (64, 15) (lot de 64 séquences de longueur 15).

Le tenseur renvoyé a un axe de plus que l'entrée, les vecteurs d'incorporation sont alignés le long du nouveau dernier axe. Passez-lui un lot d'entrée (2, 3) et la sortie est (2, 3, N)

result = embedding_layer(tf.constant([[0,1,2],[3,4,5]]))
result.shape
TensorShape([2, 3, 5])

Lorsqu'on lui donne un lot de séquences en entrée, un calque d'incorporation renvoie un tenseur à virgule flottante 3D, de forme (samples, sequence_length, embedding_dimensionality) . Pour convertir cette séquence de longueur variable en une représentation fixe, il existe une variété d'approches standard. Vous pouvez utiliser une couche RNN, Attention ou pooling avant de la transmettre à une couche Dense. Ce didacticiel utilise la mise en commun car c'est le plus simple. La classification de texte avec un didacticiel RNN est une bonne étape suivante.

Prétraitement de texte

Ensuite, définissez les étapes de prétraitement de l'ensemble de données requises pour votre modèle de classification des sentiments. Initialisez un calque TextVectorization avec les paramètres souhaités pour vectoriser les critiques de films. Vous pouvez en savoir plus sur l'utilisation de cette couche dans le didacticiel sur la classification de texte .

# Create a custom standardization function to strip HTML break tags '<br />'.
def custom_standardization(input_data):
  lowercase = tf.strings.lower(input_data)
  stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')
  return tf.strings.regex_replace(stripped_html,
                                  '[%s]' % re.escape(string.punctuation), '')

# Vocabulary size and number of words in a sequence.
vocab_size = 10000
sequence_length = 100

# Use the text vectorization layer to normalize, split, and map strings to 
# integers. Note that the layer uses the custom standardization defined above. 
# Set maximum_sequence length as all samples are not of the same length.
vectorize_layer = TextVectorization(
    standardize=custom_standardization,
    max_tokens=vocab_size,
    output_mode='int',
    output_sequence_length=sequence_length)

# Make a text-only dataset (no labels) and call adapt to build the vocabulary.
text_ds = train_ds.map(lambda x, y: x)
vectorize_layer.adapt(text_ds)

Créer un modèle de classification

Utilisez l' API séquentielle Keras pour définir le modèle de classification des sentiments. Dans ce cas, il s'agit d'un modèle de style "Sac continu de mots".

  • La couche TextVectorization transforme les chaînes en indices de vocabulaire. Vous avez déjà initialisé vectorize_layer en tant que couche TextVectorization et construit le vocabulaire de en appelant adapt le text_ds . Maintenant, vectorize_layer peut être utilisé comme première couche de votre modèle de classification de bout en bout, en introduisant des chaînes transformées dans le calque Embedding.
  • La couche Embedding prend le vocabulaire codé en entier et recherche le vecteur d'incorporation pour chaque mot-index. Ces vecteurs sont appris au fur et à mesure que le modèle s'entraîne. Les vecteurs ajoutent une dimension au tableau de sortie. Les dimensions résultantes sont: (batch, sequence, embedding) .

  • La couche GlobalAveragePooling1D renvoie un vecteur de sortie de longueur fixe pour chaque exemple en calculant la moyenne sur la dimension de séquence. Cela permet au modèle de gérer des entrées de longueur variable, de la manière la plus simple possible.

  • Le vecteur de sortie de longueur fixe est acheminé à travers une couche ( Dense ) entièrement connectée avec 16 unités cachées.

  • La dernière couche est étroitement connectée avec un seul nœud de sortie.

embedding_dim=16

model = Sequential([
  vectorize_layer,
  Embedding(vocab_size, embedding_dim, name="embedding"),
  GlobalAveragePooling1D(),
  Dense(16, activation='relu'),
  Dense(1)
])

Compiler et former le modèle

Vous utiliserez TensorBoard pour visualiser les métriques, y compris la perte et la précision. Créez un tf.keras.callbacks.TensorBoard .

tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="logs")

Compilez et entraînez le modèle à l'aide de l'optimiseur Adam et de la perte BinaryCrossentropy .

model.compile(optimizer='adam',
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=['accuracy'])
model.fit(
    train_ds,
    validation_data=val_ds, 
    epochs=15,
    callbacks=[tensorboard_callback])
Epoch 1/15
 1/20 [>.............................] - ETA: 0s - loss: 0.6933 - accuracy: 0.4961WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/summary_ops_v2.py:1277: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.
20/20 [==============================] - 2s 96ms/step - loss: 0.6919 - accuracy: 0.5028 - val_loss: 0.6897 - val_accuracy: 0.4886
Epoch 2/15
20/20 [==============================] - 1s 73ms/step - loss: 0.6867 - accuracy: 0.5028 - val_loss: 0.6832 - val_accuracy: 0.4886
Epoch 3/15
20/20 [==============================] - 1s 72ms/step - loss: 0.6779 - accuracy: 0.5028 - val_loss: 0.6724 - val_accuracy: 0.4886
Epoch 4/15
20/20 [==============================] - 1s 73ms/step - loss: 0.6640 - accuracy: 0.5028 - val_loss: 0.6566 - val_accuracy: 0.4886
Epoch 5/15
20/20 [==============================] - 1s 73ms/step - loss: 0.6444 - accuracy: 0.5028 - val_loss: 0.6357 - val_accuracy: 0.4890
Epoch 6/15
20/20 [==============================] - 1s 73ms/step - loss: 0.6193 - accuracy: 0.5267 - val_loss: 0.6105 - val_accuracy: 0.5480
Epoch 7/15
20/20 [==============================] - 1s 73ms/step - loss: 0.5895 - accuracy: 0.6035 - val_loss: 0.5823 - val_accuracy: 0.6154
Epoch 8/15
20/20 [==============================] - 1s 74ms/step - loss: 0.5568 - accuracy: 0.6758 - val_loss: 0.5532 - val_accuracy: 0.6644
Epoch 9/15
20/20 [==============================] - 1s 73ms/step - loss: 0.5233 - accuracy: 0.7263 - val_loss: 0.5251 - val_accuracy: 0.7028
Epoch 10/15
20/20 [==============================] - 1s 73ms/step - loss: 0.4910 - accuracy: 0.7606 - val_loss: 0.4995 - val_accuracy: 0.7338
Epoch 11/15
20/20 [==============================] - 1s 73ms/step - loss: 0.4611 - accuracy: 0.7844 - val_loss: 0.4771 - val_accuracy: 0.7502
Epoch 12/15
20/20 [==============================] - 1s 73ms/step - loss: 0.4343 - accuracy: 0.8032 - val_loss: 0.4581 - val_accuracy: 0.7642
Epoch 13/15
20/20 [==============================] - 1s 73ms/step - loss: 0.4104 - accuracy: 0.8171 - val_loss: 0.4422 - val_accuracy: 0.7718
Epoch 14/15
20/20 [==============================] - 1s 73ms/step - loss: 0.3893 - accuracy: 0.8297 - val_loss: 0.4289 - val_accuracy: 0.7826
Epoch 15/15
20/20 [==============================] - 1s 73ms/step - loss: 0.3705 - accuracy: 0.8401 - val_loss: 0.4178 - val_accuracy: 0.7900

<tensorflow.python.keras.callbacks.History at 0x7fb7f045bc50>

Avec cette approche, le modèle atteint une précision de validation d'environ 84% (notez que le modèle est surajusté car la précision d'entraînement est plus élevée).

Vous pouvez consulter le résumé du modèle pour en savoir plus sur chaque couche du modèle.

model.summary()
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
text_vectorization (TextVect (None, 100)               0         
_________________________________________________________________
embedding (Embedding)        (None, 100, 16)           160000    
_________________________________________________________________
global_average_pooling1d (Gl (None, 16)                0         
_________________________________________________________________
dense (Dense)                (None, 16)                272       
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 17        
=================================================================
Total params: 160,289
Trainable params: 160,289
Non-trainable params: 0
_________________________________________________________________

Visualisez les métriques du modèle dans TensorBoard.

%tensorboard --logdir logs

embeddings_classifier_accuracy.png

Récupérez les incorporations de mots formés et enregistrez-les sur le disque

Ensuite, récupérez les mots incorporés appris pendant la formation. Les plongements sont des pondérations du calque Incorporation dans le modèle. La matrice de poids est de forme (vocab_size, embedding_dimension) .

vocab = vectorize_layer.get_vocabulary()
print(vocab[:10])
# Get weights matrix of layer named 'embedding'
weights = model.get_layer('embedding').get_weights()[0]
print(weights.shape) 
['', '[UNK]', 'the', 'and', 'a', 'of', 'to', 'is', 'in', 'it']
(10000, 16)

Écrivez les poids sur le disque. Pour utiliser le projecteur d'intégration , vous allez télécharger deux fichiers au format séparés par des tabulations: un fichier de vecteurs (contenant l'incorporation) et un fichier de métadonnées (contenant les mots).

  out_v = io.open('vecs.tsv', 'w', encoding='utf-8')
  out_m = io.open('meta.tsv', 'w', encoding='utf-8')

  for num, word in enumerate(vocab):
    if num == 0: continue # skip padding token from vocab
    vec = weights[num]
    out_m.write(word + "\n")
    out_v.write('\t'.join([str(x) for x in vec]) + "\n")
  out_v.close()
  out_m.close()

  try:
    from google.colab import files
  except ImportError:
    pass
  else:
    files.download('vecs.tsv')
    files.download('meta.tsv')

Si vous exécutez ce didacticiel dans Colaboratory , vous pouvez utiliser l'extrait de code suivant pour télécharger ces fichiers sur votre ordinateur local (ou utiliser le navigateur de fichiers, Affichage -> Table des matières -> Navigateur de fichiers ).

Visualisez les plongements

Pour visualiser les incorporations, téléchargez-les sur le projecteur d'intégration.

Ouvrez le projecteur d'intégration (cela peut également s'exécuter dans une instance locale de TensorBoard).

  • Cliquez sur "Charger les données".

  • Téléchargez les deux fichiers que vous avez créés ci-dessus: vecs.tsv et meta.tsv .

Les intégrations que vous avez entraînées seront désormais affichées. Vous pouvez rechercher des mots pour trouver leurs voisins les plus proches. Par exemple, essayez de rechercher «beau». Vous pouvez voir des voisins comme "merveilleux".

Prochaines étapes

Ce didacticiel vous a montré comment entraîner et visualiser des incorporations de mots à partir de zéro sur un petit ensemble de données.