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

टेन्सरफ्लो ग्राफ की जाँच करना

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

अवलोकन

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

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

सेट अप

 # Load the TensorBoard notebook extension.
%load_ext tensorboard
 
 from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."
 
TensorFlow version:  2.2.0

 import tensorboard
tensorboard.__version__
 
'2.2.1'
 # Clear any logs from previous runs
!rm -rf ./logs/ 
 

एक केरस मॉडल को परिभाषित करें

इस उदाहरण में, क्लासिफायर एक साधारण चार-परत अनुक्रमिक मॉडल है।

 # Define the model.
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'])
 

डाउनलोड करें और प्रशिक्षण डेटा तैयार करें।

 (train_images, train_labels), _ = keras.datasets.fashion_mnist.load_data()
train_images = train_images / 255.0
 

मॉडल और लॉग डेटा को प्रशिक्षित करें

प्रशिक्षण से पहले, लॉग निर्देशिका को निर्दिष्ट करते हुए केरस टेन्सरबोर्ड कॉलबैक को परिभाषित करें। इस कॉलबैक को Model.fit () में पास करके, आप यह सुनिश्चित करते हैं कि TensorBoard में विज़ुअलाइज़ेशन के लिए ग्राफ़ डेटा लॉग किया गया है।

 # Define the Keras TensorBoard callback.
logdir="logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

# Train the model.
model.fit(
    train_images,
    train_labels, 
    batch_size=64,
    epochs=5, 
    callbacks=[tensorboard_callback])
 
Epoch 1/5
938/938 [==============================] - 2s 2ms/step - loss: 0.6955 - accuracy: 0.7618
Epoch 2/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4877 - accuracy: 0.8296
Epoch 3/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4458 - accuracy: 0.8414
Epoch 4/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4246 - accuracy: 0.8476
Epoch 5/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4117 - accuracy: 0.8508

<tensorflow.python.keras.callbacks.History at 0x7f656ecc3fd0>

ऑप-लेवल ग्राफ

TensorBoard प्रारंभ करें और UI को लोड करने के लिए कुछ सेकंड प्रतीक्षा करें। शीर्ष पर "ग्राफ़" टैप करके ग्राफ़ डैशबोर्ड चुनें।

 %tensorboard --logdir logs
 

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

ग्राफ़ अक्सर बहुत बड़े होते हैं, इसलिए आप ग्राफ़ विज़ुअलाइज़ेशन में हेरफेर कर सकते हैं:

  • अंदर और बाहर ज़ूम करने के लिए स्क्रॉल करें
  • पैन पर खींचें
  • डबल क्लिकिंग टॉगल नोड विस्तार (एक नोड अन्य नोड्स के लिए एक कंटेनर हो सकता है)

आप नोड पर क्लिक करके मेटाडेटा भी देख सकते हैं। इससे आप इनपुट, आउटपुट, शेप और अन्य विवरण देख सकते हैं।

वैचारिक ग्राफ

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

वैचारिक ग्राफ को देखने के लिए, "करेस" टैग का चयन करें। इस उदाहरण के लिए, आपको एक ध्वस्त अनुक्रमिक नोड दिखाई देगा। मॉडल की संरचना देखने के लिए नोड पर डबल-क्लिक करें:


Tf.functions के रेखांकन

अब तक के उदाहरणों ने केरस मॉडलों के ग्राफ का वर्णन किया है, जहां ग्राफ को केर की परतों को परिभाषित करके और मॉडल.फिट () कहकर बनाया गया है।

आप ऐसी स्थिति का सामना कर सकते हैं जहां आपको "ऑटोग्राफ" के लिए tf.function एनोटेशन का उपयोग करने की आवश्यकता होती है, अर्थात, एक उच्च-प्रदर्शन TensorFlow ग्राफ में पायथन कम्प्यूटेशन फ़ंक्शन। इन स्थितियों के लिए, आप TensorBoard में विज़ुअलाइज़ेशन के लिए ऑटोग्राफ किए गए कार्यों को लॉग करने के लिए TensorFlow सारांश ट्रेस एपीआई का उपयोग करते हैं।

सारांश ट्रेस एपीआई का उपयोग करने के लिए:

  • परिभाषित करें और tf.function साथ एक फ़ंक्शन को एनोटेट करें
  • अपने फ़ंक्शन कॉल साइट से तुरंत पहले tf.summary.trace_on() उपयोग करें।
  • प्रोफ़ाइल जानकारी (मेमोरी, सीपीयू समय) को प्रोफाईल पास करके ग्राफ में जोड़ें profiler=True
  • सारांश फ़ाइल लेखक के साथ, लॉग डेटा को बचाने के लिए tf.summary.trace_export() पर कॉल करें

आप तब TensorBoard का उपयोग करके देख सकते हैं कि आपका कार्य कैसे व्यवहार करता है।

 # The function to be traced.
@tf.function
def my_func(x, y):
  # A simple hand-rolled layer.
  return tf.nn.relu(tf.matmul(x, y))

# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = 'logs/func/%s' % stamp
writer = tf.summary.create_file_writer(logdir)

# Sample data for your function.
x = tf.random.uniform((3, 3))
y = tf.random.uniform((3, 3))

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True, profiler=True)
# Call only one tf.function when tracing.
z = my_func(x, y)
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)
 
 %tensorboard --logdir logs/func
 

अब आप अपने फ़ंक्शन की संरचना को देख सकते हैं जैसा कि TensorBoard द्वारा समझा गया है। सीपीयू और मेमोरी आँकड़ों को देखने के लिए "प्रोफाइल" रेडियोबॉटन पर क्लिक करें।