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

शुरुआत TensorBoard से करें

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

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

यह क्विकस्टार्ट दिखाएगा कि TensorBoard के साथ जल्दी कैसे शुरू किया जाए। इस वेबसाइट में शेष गाइड विशिष्ट क्षमताओं पर अधिक विवरण प्रदान करते हैं, जिनमें से कई यहां शामिल नहीं हैं।

# Load the TensorBoard notebook extension
%load_ext tensorboard
import tensorflow as tf
import datetime
# Clear any logs from previous runs
!rm -rf ./logs/ 

उदाहरण के रूप में MNIST डेटासेट का उपयोग करते हुए, डेटा को सामान्य करें और एक फ़ंक्शन लिखें जो छवियों को 10 वर्गों में वर्गीकृत करने के लिए एक सरल केरस मॉडल बनाता है।

mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

def create_model():
  return tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
  ])
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

Keras Model.fit के साथ TensorBoard का उपयोग करना ()

जब Keras के Model.fit () के साथ प्रशिक्षण, tf.keras.callbacks.TensorBoard कॉलबैक जोड़ना यह सुनिश्चित करता है कि लॉग बनाए और संग्रहीत किए गए हैं। इसके अलावा, histogram_freq=1 साथ हिस्टोग्राम गणना को सक्षम करें (यह डिफ़ॉल्ट रूप से बंद है)

विभिन्न प्रशिक्षण रन के आसान चयन की अनुमति के लिए लॉग को टाइमस्टैम्पड उपनिर्देशिका में रखें।

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

log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

model.fit(x=x_train, 
          y=y_train, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])
Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [==============================] - 15s 246us/sample - loss: 0.2217 - accuracy: 0.9343 - val_loss: 0.1019 - val_accuracy: 0.9685
Epoch 2/5
60000/60000 [==============================] - 14s 229us/sample - loss: 0.0975 - accuracy: 0.9698 - val_loss: 0.0787 - val_accuracy: 0.9758
Epoch 3/5
60000/60000 [==============================] - 14s 231us/sample - loss: 0.0718 - accuracy: 0.9771 - val_loss: 0.0698 - val_accuracy: 0.9781
Epoch 4/5
60000/60000 [==============================] - 14s 227us/sample - loss: 0.0540 - accuracy: 0.9820 - val_loss: 0.0685 - val_accuracy: 0.9795
Epoch 5/5
60000/60000 [==============================] - 14s 228us/sample - loss: 0.0433 - accuracy: 0.9862 - val_loss: 0.0623 - val_accuracy: 0.9823

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

TensorBoard कमांड लाइन के माध्यम से या एक नोटबुक अनुभव के भीतर शुरू करें। आम तौर पर दो इंटरफेस समान होते हैं। नोटबुक में, %tensorboard लाइन मैजिक का उपयोग करें। कमांड लाइन पर, "%" के बिना एक ही कमांड चलाएं।

%tensorboard --logdir logs/fit

दिखाए गए डैशबोर्ड का संक्षिप्त अवलोकन (शीर्ष नेविगेशन बार में टैब):

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

जब आप अन्य प्रकार के डेटा लॉग करते हैं तो अतिरिक्त TensorBoard प्लगइन्स स्वचालित रूप से सक्षम हो जाते हैं। उदाहरण के लिए, Keras TensorBoard कॉलबैक आपको छवियों को लॉग करने और साथ ही एम्बेड करने देता है। आप देख सकते हैं कि शीर्ष दाईं ओर "निष्क्रिय" ड्रॉपडाउन पर क्लिक करके TensorBoard में अन्य कौन से प्लगइन्स उपलब्ध हैं।

अन्य तरीकों के साथ TensorBoard का उपयोग करना

जब tf.GradientTape() जैसे तरीकों के साथ प्रशिक्षण, आवश्यक जानकारी लॉग करने के लिए tf.summary का उपयोग करें।

उपरोक्त के रूप में समान डेटासेट का उपयोग करें, लेकिन इसे बैचिंग क्षमताओं का लाभ उठाने के लिए tf.data.Dataset परिवर्तित करें:

train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))

train_dataset = train_dataset.shuffle(60000).batch(64)
test_dataset = test_dataset.batch(64)

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

loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()

प्रशिक्षण के दौरान मूल्यों को संचित करने के लिए और किसी भी बिंदु पर लॉग इन करने के लिए इस्तेमाल किया जा सकता है कि राज्यवार मैट्रिक्स बनाएँ:

# Define our metrics
train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32)
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32)
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('test_accuracy')

प्रशिक्षण और परीक्षण कार्यों को परिभाषित करें:

def train_step(model, optimizer, x_train, y_train):
  with tf.GradientTape() as tape:
    predictions = model(x_train, training=True)
    loss = loss_object(y_train, predictions)
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  train_loss(loss)
  train_accuracy(y_train, predictions)

def test_step(model, x_test, y_test):
  predictions = model(x_test)
  loss = loss_object(y_test, predictions)

  test_loss(loss)
  test_accuracy(y_test, predictions)

सारांश लिखने के लिए सारांश लेखकों को एक अलग लॉग निर्देशिका में डिस्क पर सेट करें:

current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'logs/gradient_tape/' + current_time + '/train'
test_log_dir = 'logs/gradient_tape/' + current_time + '/test'
train_summary_writer = tf.summary.create_file_writer(train_log_dir)
test_summary_writer = tf.summary.create_file_writer(test_log_dir)

प्रशिक्षण शुरू करो। सारांश लिखने के लिए सारांश लिखने के दायरे में प्रशिक्षण / परीक्षण के दौरान मैट्रिक्स (हानि और सटीकता) लॉग करने के लिए tf.summary.scalar() का उपयोग करें। लॉग करने के लिए और इसे कितनी बार करना है, इस पर आपका नियंत्रण है। अन्य tf.summary फ़ंक्शन अन्य प्रकार के डेटा को लॉग करने में सक्षम करते हैं।

model = create_model() # reset our model

EPOCHS = 5

for epoch in range(EPOCHS):
  for (x_train, y_train) in train_dataset:
    train_step(model, optimizer, x_train, y_train)
  with train_summary_writer.as_default():
    tf.summary.scalar('loss', train_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)

  for (x_test, y_test) in test_dataset:
    test_step(model, x_test, y_test)
  with test_summary_writer.as_default():
    tf.summary.scalar('loss', test_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', test_accuracy.result(), step=epoch)
  
  template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
  print (template.format(epoch+1,
                         train_loss.result(), 
                         train_accuracy.result()*100,
                         test_loss.result(), 
                         test_accuracy.result()*100))

  # Reset metrics every epoch
  train_loss.reset_states()
  test_loss.reset_states()
  train_accuracy.reset_states()
  test_accuracy.reset_states()
Epoch 1, Loss: 0.24321186542510986, Accuracy: 92.84333801269531, Test Loss: 0.13006582856178284, Test Accuracy: 95.9000015258789
Epoch 2, Loss: 0.10446818172931671, Accuracy: 96.84833526611328, Test Loss: 0.08867532759904861, Test Accuracy: 97.1199951171875
Epoch 3, Loss: 0.07096975296735764, Accuracy: 97.80166625976562, Test Loss: 0.07875105738639832, Test Accuracy: 97.48999786376953
Epoch 4, Loss: 0.05380449816584587, Accuracy: 98.34166717529297, Test Loss: 0.07712937891483307, Test Accuracy: 97.56999969482422
Epoch 5, Loss: 0.041443776339292526, Accuracy: 98.71833038330078, Test Loss: 0.07514958828687668, Test Accuracy: 97.5

TensorBoard को फिर से खोलें, इस बार नई लॉग डायरेक्टरी में इसे इंगित करें। हम TensorBoard को शुरू करने के लिए प्रशिक्षण की निगरानी कर सकते हैं जबकि यह प्रगति करता है।

%tensorboard --logdir logs/gradient_tape

बस! अब आपने देखा है कि केरस कॉलबैक के माध्यम से और अन्य कस्टम परिदृश्यों के लिए tf.summary के माध्यम से tf.summary का उपयोग कैसे करें।

TensorBoard.dev: होस्ट करें और अपने एमएल प्रयोग परिणामों को साझा करें

TensorBoard.dev एक निशुल्क सार्वजनिक सेवा है जो आपको अपने TensorBoard लॉग अपलोड करने और एक ऐसा पर्मलिंक प्राप्त करने में सक्षम बनाती है, जिसे अकादमिक पत्र-पत्रिकाओं, ब्लॉग पोस्ट, सोशल मीडिया आदि में सभी के साथ साझा किया जा सकता है। यह बेहतर प्रजनन क्षमता और सहयोग को सक्षम कर सकता है।

TensorBoard.dev का उपयोग करने के लिए, निम्नलिखित कमांड चलाएँ:

!tensorboard dev upload \
  --logdir logs/fit \
  --name "(optional) My latest experiment" \
  --description "(optional) Simple comparison of several hyperparameters" \
  --one_shot

ध्यान दें कि यह आह्वान विस्मयादिबोधक उपसर्ग ( ! ) का उपयोग करता है, ताकि कॉलब मैजिक को आकर्षित करने के लिए प्रतिशत उपसर्ग ( % ) के बजाय शेल को आमंत्रित किया जा सके। कमांड लाइन से इस कमांड को इनवॉइस करते समय किसी उपसर्ग की आवश्यकता नहीं है।

एक उदाहरण यहाँ देखें।

TensorBoard.dev का उपयोग करने के बारे में अधिक जानकारी के लिए, https://tensorboard.dev/#get-started देखें