TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

अवलोकन

TensorBoard एम्बेडिंग प्रोजेक्टर का उपयोग करके आप रेखांकन उच्च आयामी embeddings का प्रतिनिधित्व कर सकते हैं। यह आपकी एम्बेडिंग परतों को देखने, जांचने और समझने में सहायक हो सकता है।

इस ट्यूटोरियल में, आप सीखेंगे कि इस प्रकार की प्रशिक्षित परत की कल्पना कैसे की जाती है।

सेट अप

इस ट्यूटोरियल के लिए, हम मूवी समीक्षा डेटा को वर्गीकृत करने के लिए उत्पन्न एक एम्बेडिंग परत की कल्पना करने के लिए TensorBoard का उपयोग करेंगे।

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

आईएमडीबी डेटा

हम 25,000 IMDB मूवी समीक्षाओं के डेटासेट का उपयोग करेंगे, जिनमें से प्रत्येक का एक सेंटीमेंट लेबल (सकारात्मक/नकारात्मक) होगा। प्रत्येक समीक्षा शब्द सूचकांक (पूर्णांक) के अनुक्रम के रूप में पूर्व-संसाधित और एन्कोडेड है। सरलता के लिए, शब्दों को डेटासेट में समग्र आवृत्ति द्वारा अनुक्रमित किया जाता है, उदाहरण के लिए पूर्णांक "3" सभी समीक्षाओं में प्रदर्शित होने वाले तीसरे सबसे लगातार शब्द को एन्कोड करता है। यह त्वरित फ़िल्टरिंग संचालन की अनुमति देता है जैसे: "केवल शीर्ष 10,000 सबसे सामान्य शब्दों पर विचार करें, लेकिन शीर्ष 20 सबसे सामान्य शब्दों को समाप्त करें"।

एक सम्मेलन के रूप में, "0" किसी विशिष्ट शब्द के लिए नहीं है, बल्कि किसी अज्ञात शब्द को एन्कोड करने के लिए प्रयोग किया जाता है। बाद में ट्यूटोरियल में, हम विज़ुअलाइज़ेशन में "0" के लिए पंक्ति को हटा देंगे।

(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 एम्बेडिंग लेयर अपने शब्दावली में प्रत्येक शब्द के लिए एक एम्बेडिंग प्रशिक्षित करने के लिए इस्तेमाल किया जा सकता। प्रत्येक शब्द (या इस मामले में उप-शब्द) एक 16-आयामी वेक्टर (या एम्बेडिंग) से जुड़ा होगा जिसे मॉडल द्वारा प्रशिक्षित किया जाएगा।

देखें इस ट्यूटोरियल शब्द embeddings के बारे में अधिक जानने के लिए।

# Create an embedding layer.
embedding_dim = 16
embedding = tf.keras.layers.Embedding(encoder.vocab_size, embedding_dim)
# Configure the embedding layer 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 for one epoch.
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

TensorBoard के लिए डेटा सहेजना

TensorBoard आपके tensorflow प्रोजेक्ट के लॉग से टेंसर और मेटाडेटा पढ़ता है। लॉग निर्देशिका के लिए पथ के साथ निर्दिष्ट किया जाता है log_dir नीचे। इस ट्यूटोरियल के लिए, हम का उपयोग किया जाएगा /logs/imdb-example/ ।

डेटा को Tensorboard में लोड करने के लिए, हमें उस निर्देशिका में एक प्रशिक्षण चेकपॉइंट को सहेजना होगा, साथ ही मेटाडेटा जो मॉडल में रुचि की एक विशिष्ट परत के विज़ुअलाइज़ेशन की अनुमति देता है।

# 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 analyze as a variable. Note that the first
# value represents any unknown word, which is not in the metadata, here
# we will remove this value.
weights = tf.Variable(model.layers[0].get_weights()[0][1:])
# Create a checkpoint from embedding, the filename and key are the
# 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)

# Now run tensorboard against on log data we just saved.
%tensorboard --logdir /logs/imdb-example/

विश्लेषण

TensorBoard प्रोजेक्टर एम्बेडिंग की व्याख्या और विज़ुअलाइज़िंग के लिए एक बेहतरीन उपकरण है। डैशबोर्ड उपयोगकर्ताओं को विशिष्ट शब्दों की खोज करने की अनुमति देता है, और एम्बेडिंग (निम्न-आयामी) स्थान में एक-दूसरे से सटे शब्दों को हाइलाइट करता है। इस उदाहरण से हम कि वेस एंडरसन और अल्फ्रेड हिचकॉक दोनों बल्कि तटस्थ दृष्टि से हैं, लेकिन वे विभिन्न संदर्भों में संदर्भित कर रहे हैं कि देख सकते हैं।

इस स्थान में, हिचकॉक जैसे शब्दों के करीब है nightmare , है, जो तथ्य है कि वह "सस्पेंस के मास्टर" के रूप में जाना जाता है की वजह से होने की संभावना है, जबकि एंडरसन शब्द के करीब है heart है, जो अपने लगातार विस्तृत और दिल को छूने शैली के अनुरूप है .