7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें

TensorBoard Scalars: Keras . में लॉगिंग ट्रेनिंग मेट्रिक्स

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

अवलोकन

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

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

सेट अप

# 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

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

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

आप 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. Keras बनाएं TensorBoard कॉलबैक
  2. लॉग निर्देशिका निर्दिष्ट करें
  3. Keras 'के लिए TensorBoard कॉलबैक दर्रा Model.fit ()

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

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(learning_rate=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 सारांश API का उपयोग करने की आवश्यकता है।

प्रतिगमन मॉडल को फिर से प्रशिक्षित करें और एक कस्टम सीखने की दर लॉग करें। ऐसे:

  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 रन। इस रन का चयन एक "सीखने की दर" ग्राफ प्रदर्शित करता है जो आपको इस दौड़ के दौरान सीखने की दर की प्रगति को सत्यापित करने की अनुमति देता है।

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

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

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