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

Visualisation des données à l'aide du projecteur d'intégration dans TensorBoard

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher la source sur GitHub

Aperçu

En utilisant le projecteur d'intégration TensorBoard , vous pouvez représenter graphiquement des plongements de grande dimension. Cela peut être utile pour visualiser, examiner et comprendre vos couches d'incorporation.

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

Dans ce didacticiel, vous apprendrez à visualiser ce type de couche entraînée.

Installer

Pour ce didacticiel, nous utiliserons TensorBoard pour visualiser une couche d'incorporation générée pour classer les données de revue de film.

 try:
  # %tensorflow_version only exists in Colab.
  %tensorflow_version 2.x
except Exception:
  pass

%load_ext tensorboard
 
 import os
import tensorflow as tf
import tensorflow_datasets as tfds
from tensorboard.plugins import projector

 

Données IMDB

Nous utiliserons un ensemble de données de 25 000 critiques de films d'IMDB, étiquetées par sentiment (positif / négatif). Les révisions ont été prétraitées et chaque révision est codée sous la forme d'une séquence d'index de mots (entiers). Par commodité, les mots sont indexés par fréquence globale dans l'ensemble de données, de sorte que, par exemple, l'entier «3» code le 3ème mot le plus fréquent dans les données. Cela permet des opérations de filtrage rapides telles que: "Ne considérez que les 10 000 mots les plus courants, mais supprimez les 20 mots les plus courants".

Par convention, "0" ne représente pas un mot spécifique, mais est plutôt utilisé pour coder tout mot inconnu. Plus tard dans le didacticiel, nous supprimerons cette ligne de la visualisation.

 (train_data, test_data), info = tfds.load(
    "imdb_reviews/subwords8k",
    split=(tfds.Split.TRAIN, tfds.Split.TEST),
    with_info=True,
    as_supervised=True,
)
encoder = info.features["text"].encoder

# shuffle and pad the data.
train_batches = train_data.shuffle(1000).padded_batch(
    10, padded_shapes=((None,), ())
)
test_batches = test_data.shuffle(1000).padded_batch(
    10, padded_shapes=((None,), ())
)
train_batch, train_labels = next(iter(train_batches))

 

Couche d'intégration Keras

Un calque d'intégration Keras peut être utilisé pour former une intégration pour chaque mot de votre volcabulaire. Chaque mot (ou sous-mot dans ce cas) sera associé à un vecteur à 16 dimensions (ou incorporation) qui sera formé par le modèle.

Consultez ce didacticiel pour en savoir plus sur l'intégration de mots.

 # Create an embedding layer
embedding_dim = 16
embedding = tf.keras.layers.Embedding(encoder.vocab_size, embedding_dim)
# Train this embedding as part of a keras model
model = tf.keras.Sequential(
    [
        embedding, # The embedding layer should be the first layer in a model.
        tf.keras.layers.GlobalAveragePooling1D(),
        tf.keras.layers.Dense(16, activation="relu"),
        tf.keras.layers.Dense(1),
    ]
)

# Compile model
model.compile(
    optimizer="adam",
    loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
    metrics=["accuracy"],
)

# Train model
history = model.fit(
    train_batches, epochs=1, validation_data=test_batches, validation_steps=20
)
 
2500/2500 [==============================] - 13s 5ms/step - loss: 0.5330 - accuracy: 0.6769 - val_loss: 0.4043 - val_accuracy: 0.7800

Sauvegarde des données pour TensorBoard

TensorBoard lit les tenseurs et les métadonnées de vos projets tensorflow à partir des journaux dans le répertoire log_dir spécifié. Pour ce tutoriel, nous utiliserons /logs/imdb-example/ .

Afin de visualiser ces données, nous enregistrerons un point de contrôle dans ce répertoire, ainsi que des métadonnées pour comprendre la couche à visualiser.

 # Set up a logs directory, so Tensorboard knows where to look for files
log_dir='/logs/imdb-example/'
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# Save Labels separately on a line-by-line manner.
with open(os.path.join(log_dir, 'metadata.tsv'), "w") as f:
  for subwords in encoder.subwords:
    f.write("{}\n".format(subwords))
  # Fill in the rest of the labels with "unknown"
  for unknown in range(1, encoder.vocab_size - len(encoder.subwords)):
    f.write("unknown #{}\n".format(unknown))


# Save the weights we want to analyse as a variable. Note that the first
# value represents any unknown word, which is not in the metadata, so
# we will remove that value.
weights = tf.Variable(model.layers[0].get_weights()[0][1:])
# Create a checkpoint from embedding, the filename and key are
# name of the tensor.
checkpoint = tf.train.Checkpoint(embedding=weights)
checkpoint.save(os.path.join(log_dir, "embedding.ckpt"))

# Set up config
config = projector.ProjectorConfig()
embedding = config.embeddings.add()
# The name of the tensor will be suffixed by `/.ATTRIBUTES/VARIABLE_VALUE`
embedding.tensor_name = "embedding/.ATTRIBUTES/VARIABLE_VALUE"
embedding.metadata_path = 'metadata.tsv'
projector.visualize_embeddings(log_dir, config)
 
 %tensorboard --logdir /logs/imdb-example/
 

Une analyse

Le projecteur TensorBoard est un excellent outil pour analyser vos données et voir les valeurs d'intégration les unes par rapport aux autres. Le tableau de bord permet de rechercher des termes spécifiques et met en évidence les mots qui se trouvent à proximité dans l'espace d'intégration. À partir de cet exemple, nous pouvons voir que Wes Anderson et Alfred Hitchcock sont tous deux des termes plutôt neutres, mais qu'ils sont référencés dans des contextes différents.

Hitchcock est plus étroitement associé à des mots comme nightmare , ce qui est probablement lié à son travail dans les films d'horreur. Alors qu'Anderson est plus proche du mot heart , reflétant son style réconfortant.