Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Visualización de datos con el proyector incrustado en TensorBoard

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub

Visión general

Con el proyector de incrustaciones de TensorBoard , puede representar gráficamente incrustaciones de alta dimensión. Esto puede resultar útil para visualizar, examinar y comprender las capas de inserción.

Captura de pantalla del proyector de incrustación

En este tutorial, aprenderá a visualizar este tipo de capa entrenada.

Preparar

Para este tutorial, usaremos TensorBoard para visualizar una capa de inserción generada para clasificar los datos de reseñas de películas.

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

Datos IMDB

Usaremos un conjunto de datos de 25,000 reseñas de películas de IMDB, etiquetadas por sentimiento (positivo / negativo). Las reseñas se han procesado previamente y cada reseña está codificada como una secuencia de índices de palabras (números enteros). Por conveniencia, las palabras se indexan por frecuencia general en el conjunto de datos, de modo que, por ejemplo, el número entero "3" codifica la tercera palabra más frecuente en los datos. Esto permite operaciones de filtrado rápidas como: "solo considere las 10 000 palabras más comunes, pero elimine las 20 palabras más comunes".

Como convención, "0" no significa una palabra específica, sino que se usa para codificar cualquier palabra desconocida. Más adelante en el tutorial, eliminaremos esta fila de la visualización.

(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))

Capa de incrustación Keras

Se puede usar una capa de incrustación de Keras para entrenar una incrustación para cada palabra en su vocabulario. Cada palabra (o subpalabra en este caso) se asociará con un vector (o incrustación) de 16 dimensiones que será entrenado por el modelo.

Consulte este tutorial para obtener más información sobre las incrustaciones de palabras.

# 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

Guardando datos para TensorBoard

TensorBoard lee tensores y metadatos de tus proyectos de tensorflow de los registros en el directorio log_dir especificado. Para este tutorial, usaremos /logs/imdb-example/ .

Para visualizar estos datos, guardaremos un punto de control en ese directorio, junto con los metadatos para comprender qué capa visualizar.

# 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/

Análisis

El proyector TensorBoard es una gran herramienta para analizar sus datos y ver valores incrustados en relación con los demás. El tablero permite buscar términos específicos y resalta las palabras que están cerca en el espacio de inserción. En este ejemplo podemos ver que Wes Anderson y Alfred Hitchcock son términos bastante neutrales, pero que se hace referencia a ellos en diferentes contextos.

Hitchcock está más asociado a palabras como nightmare , que probablemente se relacione con su trabajo en películas de terror. Mientras que Anderson está más cerca de la palabra heart , lo que refleja su estilo conmovedor.