Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Visualizzazione dei dati utilizzando il proiettore per inclusione in TensorBoard

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza sorgente su GitHub

Panoramica

Utilizzando il proiettore per inclusione TensorBoard , è possibile rappresentare graficamente incorporamenti ad alta dimensione. Questo può essere utile per visualizzare, esaminare e comprendere i livelli di incorporamento.

Schermata del proiettore per incorporamento

In questo tutorial imparerai come visualizzare questo tipo di livello addestrato.

Impostare

Per questo tutorial, useremo TensorBoard per visualizzare un livello di incorporamento generato per classificare i dati di revisione dei filmati.

 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

 

Dati IMDB

Utilizzeremo un set di dati di 25.000 recensioni di film da IMDB, etichettate per sentimento (positivo / negativo). Le recensioni sono state preelaborate e ogni recensione è codificata come una sequenza di indici di parole (numeri interi). Per comodità, le parole sono indicizzate in base alla frequenza complessiva nel set di dati, in modo che ad esempio il numero intero "3" codifichi la terza parola più frequente nei dati. Ciò consente operazioni di filtro rapido come: "considera solo le prime 10.000 parole più comuni, ma elimina le prime 20 parole più comuni".

Come convenzione, "0" non rappresenta una parola specifica, ma viene invece utilizzato per codificare qualsiasi parola sconosciuta. Più avanti nel tutorial, rimuoveremo questa riga dalla visualizzazione.

 (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 Embedding Layer

Un livello di incorporamento di Keras può essere utilizzato per addestrare un incorporamento per ogni parola nel tuo volcabolario. Ogni parola (o sotto-parola in questo caso) sarà associata a un vettore (o incorporamento) a 16 dimensioni che verrà addestrato dal modello.

Vedi questo tutorial per saperne di più sulle parole incorporate.

 # 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

Salvataggio dei dati per TensorBoard

TensorBoard legge tensori e metadati dai progetti tensorflow dai registri nella directory log_dir specificata. Per questo tutorial, useremo /logs/imdb-example/ .

Per visualizzare questi dati, salveremo un checkpoint in quella directory, insieme ai metadati per capire quale layer visualizzare.

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

Analisi

Il proiettore TensorBoard è un ottimo strumento per analizzare i tuoi dati e vedere i valori di incorporamento reciproci. La dashboard consente di cercare termini specifici ed evidenzia le parole vicine nello spazio di incorporamento. Da questo esempio possiamo vedere che Wes Anderson e Alfred Hitchcock sono entrambi termini piuttosto neutrali, ma che sono citati in contesti diversi.

Hitchcock è più vicino a parole come nightmare , che probabilmente si riferisce al suo lavoro nei film horror. Mentre Anderson è più vicino alla parola heart , che riflette il suo stile commovente.