Esta página foi traduzida pela API Cloud Translation.
Switch to English

Visualização de dados usando o projetor de incorporação no TensorBoard

Ver em TensorFlow.org Executar no Google Colab Ver fonte no GitHub

Visão geral

Usando o projetor de incorporação TensorBoard , você pode representar graficamente incorporações de alta dimensão. Isso pode ser útil para visualizar, examinar e entender suas camadas de incorporação.

Captura de tela do projetor de incorporação

Neste tutorial, você aprenderá como visualizar esse tipo de camada treinada.

Configuração

Neste tutorial, usaremos o TensorBoard para visualizar uma camada de incorporação gerada para classificar os dados de revisão de filmes.

 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

 

Dados IMDB

Usaremos um conjunto de dados de 25.000 críticas de filmes do IMDB, rotuladas por sentimentos (positivas / negativas). As revisões foram pré-processadas e cada revisão é codificada como uma sequência de índices de palavras (números inteiros). Por conveniência, as palavras são indexadas pela frequência geral no conjunto de dados, de modo que, por exemplo, o número inteiro "3" codifica a terceira palavra mais frequente nos dados. Isso permite operações de filtragem rápida, como: "considere apenas as 10.000 palavras mais comuns, mas elimine as 20 palavras mais comuns".

Como convenção, "0" não representa uma palavra específica, mas é usado para codificar qualquer palavra desconhecida. Posteriormente no tutorial, removeremos esta linha da visualização.

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

 

Camada de incorporação Keras

Uma Camada de incorporação Keras pode ser usada para treinar uma incorporação para cada palavra no seu vocabulário. Cada palavra (ou sub-palavra neste caso) será associada a um vetor de 16 dimensões (ou incorporação) que será treinado pelo modelo.

Consulte este tutorial para saber mais sobre incorporação de palavras.

 # 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

Salvando dados para o TensorBoard

O TensorBoard lê tensores e metadados de seus projetos de tensorflow a partir dos logs no diretório log_dir especificado. Neste tutorial, usaremos /logs/imdb-example/ .

Para visualizar esses dados, salvaremos um ponto de verificação nesse diretório, juntamente com metadados para entender qual camada 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álise

O projetor TensorBoard é uma ótima ferramenta para analisar seus dados e ver valores de incorporação relativos um ao outro. O painel permite pesquisar termos específicos e destaca as palavras que estão próximas no espaço de incorporação. A partir deste exemplo, podemos ver que Wes Anderson e Alfred Hitchcock são termos bastante neutros, mas que são referenciados em contextos diferentes.

Hitchcock está mais associado a palavras como nightmare , que provavelmente se relacionam com seu trabalho em filmes de terror. Enquanto Anderson está mais perto da palavra heart , refletindo seu estilo emocionante.