Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Visualisieren von Daten mit dem Einbettungsprojektor in TensorBoard

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen

Überblick

Mit dem TensorBoard-Einbettungsprojektor können Sie hochdimensionale Einbettungen grafisch darstellen. Dies kann hilfreich sein, um Ihre Einbettungsebenen zu visualisieren, zu untersuchen und zu verstehen.

Screenshot des Einbettungsprojektors

In diesem Tutorial erfahren Sie, wie Sie diese Art von trainierter Ebene visualisieren.

Konfiguration

In diesem Tutorial verwenden wir TensorBoard, um eine Einbettungsebene zu visualisieren, die zum Klassifizieren von Filmkritikdaten generiert wurde.

 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

 

IMDB-Daten

Wir werden einen Datensatz mit 25.000 Filmkritiken von IMDB verwenden, der nach Stimmung (positiv / negativ) gekennzeichnet ist. Überprüfungen wurden vorverarbeitet, und jede Überprüfung wird als Folge von Wortindizes (Ganzzahlen) codiert. Der Einfachheit halber werden Wörter im Datensatz nach der Gesamthäufigkeit indiziert, so dass beispielsweise die Ganzzahl "3" das dritthäufigste Wort in den Daten codiert. Dies ermöglicht schnelle Filtervorgänge wie: "Berücksichtigen Sie nur die 10.000 häufigsten Wörter, eliminieren Sie jedoch die 20 häufigsten Wörter."

Als Konvention steht "0" nicht für ein bestimmtes Wort, sondern wird verwendet, um ein unbekanntes Wort zu codieren. Später im Tutorial werden wir diese Zeile aus der Visualisierung entfernen.

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

 

Keras-Einbettungsschicht

Eine Keras-Einbettungsebene kann verwendet werden, um eine Einbettung für jedes Wort in Ihrem Wortschatz zu trainieren. Jedes Wort (oder in diesem Fall jedes Unterwort) wird einem 16-dimensionalen Vektor (oder einer Einbettung) zugeordnet, der vom Modell trainiert wird.

In diesem Tutorial erfahren Sie mehr über Worteinbettungen.

 # 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

Daten für TensorBoard speichern

TensorBoard liest Tensoren und Metadaten aus Ihren Tensorflow-Projekten aus den Protokollen im angegebenen Verzeichnis log_dir . Für dieses Tutorial verwenden wir /logs/imdb-example/ .

Um diese Daten zu visualisieren, speichern wir einen Prüfpunkt in diesem Verzeichnis zusammen mit Metadaten, um zu verstehen, welche Ebene visualisiert werden soll.

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

Analyse

Der TensorBoard-Projektor ist ein großartiges Tool zum Analysieren Ihrer Daten und zum Anzeigen von Einbettungswerten relativ zueinander. Das Dashboard ermöglicht die Suche nach bestimmten Begriffen und hebt Wörter hervor, die sich im Einbettungsbereich in der Nähe befinden. An diesem Beispiel können wir sehen, dass Wes Anderson und Alfred Hitchcock beide eher neutrale Begriffe sind, aber dass sie in unterschiedlichen Kontexten referenziert werden.

Hitchcock ist eher mit Worten wie nightmare , was wahrscheinlich mit seiner Arbeit in Horrorfilmen zusammenhängt. Während Anderson dem Wort heart näher ist und seinen herzerwärmenden Stil widerspiegelt.