इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TensorBoard में एंबेडिंग प्रोजेक्टर का उपयोग कर डेटा विज़ुअलाइज़ करना

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें

अवलोकन

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

एम्बेडिंग प्रोजेक्टर का स्क्रीनशॉट

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

सेट अप

इस ट्यूटोरियल के लिए, हम 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

IMDB डेटा

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

एक सम्मेलन के रूप में, "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))

केरस एंबेडिंग लेयर

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

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

# 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

TensorBoard के लिए डेटा की बचत

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

इस डेटा की कल्पना करने के लिए, हम मेटाडेटा के साथ उस निर्देशिका के लिए एक चेकपॉइंट की बचत करेंगे, जो समझने के लिए कि किस परत को देखना है।

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

विश्लेषण

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

हिचकॉक nightmare जैसे शब्दों से जुड़ा हुआ है, जो हॉरर फिल्मों में उनके काम से संबंधित है। जबकि एंडरसन heart शब्द के करीब है, उसकी दिलकश शैली को दर्शाता है।