Google I/O एक लपेट है! TensorFlow सत्रों पर पकड़ बनाएं सत्र देखें

TensorFlow ग्राफ़ की जांच

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

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

प्रशिक्षण से पहले, परिभाषित Keras TensorBoard कॉलबैक , लॉग निर्देशिका निर्दिष्ट करती है। इस कॉलबैक को 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.dev का भी उपयोग कर सकते हैं।

!tensorboard dev upload \
  --logdir logs \
  --name "Sample op-level graph" \
  --one_shot

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

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

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

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

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

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

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


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

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

आप एक स्थिति का सामना कर सकते हैं जहाँ आप उपयोग करने की आवश्यकता tf.function को एनोटेशन "हस्ताक्षर" , यानी, एक उच्च प्रदर्शन TensorFlow ग्राफ में बदलना, एक अजगर गणना कार्य करते हैं। इन स्थितियों के लिए, आप TensorBoard में दृश्य के लिए हस्ताक्षर कार्यों लॉग इन करने के TensorFlow सारांश ट्रेस API का उपयोग करें।

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

  • परिभाषित करें और के साथ एक समारोह व्याख्या tf.function
  • का प्रयोग करें tf.summary.trace_on() तुरंत अपने समारोह कॉल साइट से पहले।
  • पास करके ग्राफ को प्रोफ़ाइल जानकारी (स्मृति, CPU समय) जोड़ें 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 द्वारा समझे गए अपने फ़ंक्शन की संरचना को देख सकते हैं। सीपीयू और मेमोरी के आंकड़े देखने के लिए "प्रोफाइल" रेडियो बटन पर क्लिक करें।