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

TensorBoard स्केल: केरस में प्रशिक्षण मेट्रिक्स लॉगिंग

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

अवलोकन

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

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

सेट अप

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

import tensorflow as tf
from tensorflow import keras

import numpy as np

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

एक साधारण प्रतिगमन के लिए डेटा सेट करें

अब आप एक प्रतिगमन की गणना करने के लिए केरस का उपयोग करने जा रहे हैं, अर्थात, एक युग्मित डेटा सेट के लिए फिट की सबसे अच्छी पंक्ति ढूंढें। ( इस तरह की समस्या के लिए न्यूरल नेटवर्क और ग्रेडिएंट डिसेंट का उपयोग करना अधिक कठिन है, यह उदाहरण को समझने में बहुत आसान बनाता है।)

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

सबसे पहले, लाइन y = 0.5x + 2 के साथ लगभग 1000 डेटा पॉइंट उत्पन्न करते हैं। इन डेटा बिंदुओं को प्रशिक्षण और परीक्षण सेटों में विभाजित करें। आपकी आशा है कि तंत्रिका जाल इस संबंध को सीखता है।

 data_size = 1000
# 80% of the data is for training.
train_pct = 0.8

train_size = int(data_size * train_pct)

# Create some input data between -1 and 1 and randomize it.
x = np.linspace(-1, 1, data_size)
np.random.shuffle(x)

# Generate the output data.
# y = 0.5x + 2 + noise
y = 0.5 * x + 2 + np.random.normal(0, 0.05, (data_size, ))

# Split into test and train pairs.
x_train, y_train = x[:train_size], y[:train_size]
x_test, y_test = x[train_size:], y[train_size:]
 

मॉडल और लॉगिंग नुकसान का प्रशिक्षण

अब आप अपने मॉडल को परिभाषित करने, प्रशिक्षित करने और मूल्यांकन करने के लिए तैयार हैं।

ट्रेन के रूप में हानि स्केलर को लॉग करने के लिए, आप निम्नलिखित कार्य करेंगे:

  1. केरस टेन्सरबोर्ड कॉलबैक बनाएँ
  2. एक लॉग डायरेक्टरी निर्दिष्ट करें
  3. TensorBoard कॉलबैक को Keras ' Model.fit () में पास करें

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

 logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(lr=0.2),
)

print("Training ... With default parameters, this takes less than 10 seconds.")
training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback],
)

print("Average test loss: ", np.average(training_history.history['loss']))
 
Training ... With default parameters, this takes less than 10 seconds.
Average test loss:  0.05271831926424056

TensorBoard का उपयोग करके नुकसान की जांच करना

अब, TensorBoard शुरू करें, जो रूट लॉग डायरेक्टरी आप ऊपर इस्तेमाल करते हैं, निर्दिष्ट करें।

TensorBoard के UI को स्पिन करने के लिए कुछ सेकंड प्रतीक्षा करें।

 %tensorboard --logdir logs/scalars
 

आप देख सकते हैं कि TensorBoard ने संदेश दिखाया "वर्तमान डेटा सेट के लिए कोई डैशबोर्ड सक्रिय नहीं है"। ऐसा इसलिए है क्योंकि प्रारंभिक लॉगिंग डेटा अभी तक सहेजा नहीं गया है। जैसे-जैसे प्रशिक्षण आगे बढ़ेगा, केरस मॉडल डेटा लॉग करना शुरू कर देगा। TensorBoard समय-समय पर ताज़ा करेगा और आपको अपना स्केलर मेट्रिक्स दिखाएगा। यदि आप अधीर हैं, तो आप शीर्ष दाईं ओर ताज़ा तीर पर टैप कर सकते हैं।

जैसा कि आप प्रशिक्षण प्रगति को देखते हैं, ध्यान दें कि प्रशिक्षण और सत्यापन दोनों नुकसान तेजी से कैसे घटते हैं, और फिर स्थिर रहते हैं। वास्तव में, आप 25 युगों के बाद प्रशिक्षण रोक सकते थे, क्योंकि उस बिंदु के बाद प्रशिक्षण में बहुत सुधार नहीं हुआ था।

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

बाईं ओर "रन" चयनकर्ता को नोटिस करें। एक "रन" प्रशिक्षण के दौर से लॉग का एक सेट दर्शाता है, इस मामले में Model.fit () का परिणाम है। डेवलपर्स के पास आमतौर पर कई, कई रन होते हैं, जैसा कि वे समय के साथ अपने मॉडल का प्रयोग करते हैं और विकसित करते हैं।

विशिष्ट रन चुनने के लिए रन चयनकर्ता का उपयोग करें, या केवल प्रशिक्षण या मान्यता से चुनें। रन की तुलना करने से आपको यह मूल्यांकन करने में मदद मिलेगी कि आपके कोड का कौन सा संस्करण आपकी समस्या को बेहतर तरीके से हल कर रहा है।

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

इनपुट डेटा (60, 25, 2) को देखते हुए, लाइन y = 0.5x + 2 को उपज (32, 14.5, 3) चाहिए। क्या मॉडल सहमत है?

 print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
 
[[32.234306 ]
 [14.5974245]
 [ 3.0074697]]

बुरा नहीं!

कस्टम स्केलर लॉगिंग

यदि आप कस्टम मानों को लॉग इन करना चाहते हैं, जैसे कि गतिशील शिक्षण दर ? ऐसा करने के लिए, आपको TensorFlow समरी एपीआई का उपयोग करने की आवश्यकता है।

प्रतिगमन मॉडल को पुनः प्राप्त करें और एक कस्टम लर्निंग रेट लॉग करें। ऐसे:

  1. tf.summary.create_file_writer() का उपयोग करके एक फ़ाइल लेखक बनाएँ।
  2. एक कस्टम लर्निंग रेट फ़ंक्शन को परिभाषित करें। यह Keras को दे दिया जाएगा LearningRateScheduler कॉलबैक।
  3. सीखने की दर फ़ंक्शन के अंदर, कस्टम सीखने की दर को लॉग करने के लिए tf.summary.scalar() का उपयोग करें।
  4. LearningRateScheduler कॉलबैक को Model.fit () में पास करें।

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

 logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

def lr_schedule(epoch):
  """
  Returns a custom learning rate that decreases as epochs progress.
  """
  learning_rate = 0.2
  if epoch > 10:
    learning_rate = 0.02
  if epoch > 20:
    learning_rate = 0.01
  if epoch > 50:
    learning_rate = 0.005

  tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
  return learning_rate

lr_callback = keras.callbacks.LearningRateScheduler(lr_schedule)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(),
)

training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback, lr_callback],
)
 

चलिए फिर से TensorBoard को देखते हैं।

 %tensorboard --logdir logs/scalars
 

बाईं ओर "रन" चयनकर्ता का उपयोग करते हुए, ध्यान दें कि आपके पास एक <timestamp>/metrics रन है। इस रन का चयन करने से एक "सीखने की दर" ग्राफ प्रदर्शित होता है जो आपको इस रन के दौरान सीखने की दर की प्रगति को सत्यापित करने की अनुमति देता है।

आप इस रन के प्रशिक्षण और सत्यापन हानि घटता की तुलना अपने पहले के रन से भी कर सकते हैं।

यह मॉडल कैसे काम करता है?

 print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
 
[[32.234013 ]
 [14.5973015]
 [ 3.0074618]]