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

एचपीआर्म्स डैशबोर्ड के साथ हाइपरपरमीटर ट्यूनिंग

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

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

TensorBoard में HParams का डैशबोर्ड हाइपरपरमेटर के सबसे अच्छे प्रयोग या सबसे आशाजनक सेट की पहचान करने की इस प्रक्रिया में मदद करने के लिए कई उपकरण प्रदान करता है।

यह ट्यूटोरियल निम्नलिखित चरणों पर ध्यान केंद्रित करेगा:

  1. प्रयोग सेटअप और HParams सारांश
  2. Adapt TensorFlow हाइपरपरमेटर्स और मेट्रिक्स लॉग करने के लिए चलता है
  3. रन शुरू करें और उन सभी को एक मूल निर्देशिका के तहत लॉग इन करें
  4. TensorBoard के HParams डैशबोर्ड में परिणामों की कल्पना करें

TF 2.0 स्थापित करके और TensorBoard नोटबुक एक्सटेंशन लोड करके प्रारंभ करें:

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

TensorFlow और TensorBoard HParams प्लगइन आयात करें:

 import tensorflow as tf
from tensorboard.plugins.hparams import api as hp
 

FashionMNIST डाटासेट डाउनलोड करें और इसे स्केल करें:

 fashion_mnist = tf.keras.datasets.fashion_mnist

(x_train, y_train),(x_test, y_test) = fashion_mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

1. प्रयोग सेटअप और HParams प्रयोग सारांश

मॉडल में तीन हाइपर पैरामीटर्स के साथ प्रयोग:

  1. पहले घने परत में इकाइयों की संख्या
  2. ड्रॉपआउट दर में ड्रॉपआउट दर
  3. अनुकूलक

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

 HP_NUM_UNITS = hp.HParam('num_units', hp.Discrete([16, 32]))
HP_DROPOUT = hp.HParam('dropout', hp.RealInterval(0.1, 0.2))
HP_OPTIMIZER = hp.HParam('optimizer', hp.Discrete(['adam', 'sgd']))

METRIC_ACCURACY = 'accuracy'

with tf.summary.create_file_writer('logs/hparam_tuning').as_default():
  hp.hparams_config(
    hparams=[HP_NUM_UNITS, HP_DROPOUT, HP_OPTIMIZER],
    metrics=[hp.Metric(METRIC_ACCURACY, display_name='Accuracy')],
  )
 

यदि आप इस चरण को छोड़ना चुनते हैं, तो आप एक स्ट्रिंग शाब्दिक का उपयोग कर सकते हैं जहाँ भी आप अन्यथा एक HParam मूल्य का उपयोग करेंगे: जैसे, hparams['dropout'] बजाय hparams[HP_DROPOUT]

2. Adapt TensorFlow हाइपरपैरामीटर और मेट्रिक्स लॉग करने के लिए चलता है

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

 def train_test_model(hparams):
  model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(hparams[HP_NUM_UNITS], activation=tf.nn.relu),
    tf.keras.layers.Dropout(hparams[HP_DROPOUT]),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax),
  ])
  model.compile(
      optimizer=hparams[HP_OPTIMIZER],
      loss='sparse_categorical_crossentropy',
      metrics=['accuracy'],
  )

  model.fit(x_train, y_train, epochs=1) # Run with 1 epoch to speed things up for demo purposes
  _, accuracy = model.evaluate(x_test, y_test)
  return accuracy
 

प्रत्येक रन के लिए, हाइपरपैरामीटर और अंतिम सटीकता के साथ एक हैम्पर्स सारांश लॉग करें:

 def run(run_dir, hparams):
  with tf.summary.create_file_writer(run_dir).as_default():
    hp.hparams(hparams)  # record the values used in this trial
    accuracy = train_test_model(hparams)
    tf.summary.scalar(METRIC_ACCURACY, accuracy, step=1)
 

केरेस मॉडल का प्रशिक्षण लेते समय, आप इन्हें सीधे लिखने के बजाय कॉलबैक का उपयोग कर सकते हैं:

 model.fit(
    ...,
    callbacks=[
        tf.keras.callbacks.TensorBoard(logdir),  # log metrics
        hp.KerasCallback(logdir, hparams),  # log hparams
    ],
)
 

3. रन शुरू करें और उन सभी को एक मूल निर्देशिका के तहत लॉग इन करें

अब आप कई प्रयोगों की कोशिश कर सकते हैं, हाइपरपैरमीटर के एक अलग सेट के साथ प्रत्येक को प्रशिक्षित कर सकते हैं।

सादगी के लिए, ग्रिड खोज का उपयोग करें: असतत मापदंडों के सभी संयोजनों का प्रयास करें और वास्तविक-मूल्यवान पैरामीटर के निचले और ऊपरी सीमाएं। अधिक जटिल परिदृश्यों के लिए, प्रत्येक हाइपरपरमेटर मान को यादृच्छिक रूप से चुनना अधिक प्रभावी हो सकता है (इसे यादृच्छिक खोज कहा जाता है)। अधिक उन्नत तरीके हैं जिनका उपयोग किया जा सकता है।

कुछ प्रयोग करें, जिसमें कुछ मिनट लगेंगे:

 session_num = 0

for num_units in HP_NUM_UNITS.domain.values:
  for dropout_rate in (HP_DROPOUT.domain.min_value, HP_DROPOUT.domain.max_value):
    for optimizer in HP_OPTIMIZER.domain.values:
      hparams = {
          HP_NUM_UNITS: num_units,
          HP_DROPOUT: dropout_rate,
          HP_OPTIMIZER: optimizer,
      }
      run_name = "run-%d" % session_num
      print('--- Starting trial: %s' % run_name)
      print({h.name: hparams[h] for h in hparams})
      run('logs/hparam_tuning/' + run_name, hparams)
      session_num += 1

 
--- Starting trial: run-0
{'num_units': 16, 'dropout': 0.1, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 62us/sample - loss: 0.6872 - accuracy: 0.7564
10000/10000 [==============================] - 0s 35us/sample - loss: 0.4806 - accuracy: 0.8321
--- Starting trial: run-1
{'num_units': 16, 'dropout': 0.1, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 54us/sample - loss: 0.9428 - accuracy: 0.6769
10000/10000 [==============================] - 0s 36us/sample - loss: 0.6519 - accuracy: 0.7770
--- Starting trial: run-2
{'num_units': 16, 'dropout': 0.2, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 60us/sample - loss: 0.8158 - accuracy: 0.7078
10000/10000 [==============================] - 0s 36us/sample - loss: 0.5309 - accuracy: 0.8154
--- Starting trial: run-3
{'num_units': 16, 'dropout': 0.2, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 50us/sample - loss: 1.1465 - accuracy: 0.6019
10000/10000 [==============================] - 0s 36us/sample - loss: 0.7007 - accuracy: 0.7683
--- Starting trial: run-4
{'num_units': 32, 'dropout': 0.1, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 65us/sample - loss: 0.6178 - accuracy: 0.7849
10000/10000 [==============================] - 0s 38us/sample - loss: 0.4645 - accuracy: 0.8395
--- Starting trial: run-5
{'num_units': 32, 'dropout': 0.1, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 55us/sample - loss: 0.8989 - accuracy: 0.6896
10000/10000 [==============================] - 0s 37us/sample - loss: 0.6335 - accuracy: 0.7853
--- Starting trial: run-6
{'num_units': 32, 'dropout': 0.2, 'optimizer': 'adam'}
60000/60000 [==============================] - 4s 64us/sample - loss: 0.6404 - accuracy: 0.7782
10000/10000 [==============================] - 0s 37us/sample - loss: 0.4802 - accuracy: 0.8265
--- Starting trial: run-7
{'num_units': 32, 'dropout': 0.2, 'optimizer': 'sgd'}
60000/60000 [==============================] - 3s 54us/sample - loss: 0.9633 - accuracy: 0.6703
10000/10000 [==============================] - 0s 36us/sample - loss: 0.6516 - accuracy: 0.7755

4. TensorBoard के HParams प्लगइन में परिणामों की कल्पना करें

HPARams डैशबोर्ड अब खोला जा सकता है। TensorBoard प्रारंभ करें और शीर्ष पर "HParams" पर क्लिक करें।

 %tensorboard --logdir logs/hparam_tuning
 

डैशबोर्ड का बायाँ फलक फ़िल्टरिंग क्षमताएं प्रदान करता है जो HParams डैशबोर्ड के सभी दृश्यों में सक्रिय हैं:

  • फ़िल्टर जो हाइपरपरमेटर्स / मीट्रिक डैशबोर्ड में दिखाए गए हैं
  • डैशबोर्ड में फ़िल्टर किए गए हाइपरपरमेट / मेट्रिक्स मान दिखाए जाते हैं
  • रन स्थिति पर फ़िल्टर करें (चल रहा है, सफलता, ...)
  • तालिका दृश्य में हाइपरपरमीटर / मैट्रिक द्वारा क्रमबद्ध करें
  • दिखाने के लिए सत्र समूहों की संख्या (प्रदर्शन के लिए उपयोगी जब कई प्रयोग हों)

HPARams डैशबोर्ड में तीन अलग-अलग विचार हैं, विभिन्न उपयोगी जानकारी के साथ:

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

एक तालिका पंक्ति, एक समानांतर निर्देशांक रेखा, और एक तितर बितर भूखंड बाजार में उस सत्र के लिए प्रशिक्षण चरणों के एक समारोह के रूप में मैट्रिक्स के एक भूखंड को देखने के लिए क्लिक किया जा सकता है (हालांकि इस ट्यूटोरियल में प्रत्येक चरण के लिए केवल एक कदम का उपयोग किया जाता है)।

आगे HPARAMS डैशबोर्ड की क्षमताओं का पता लगाने के लिए, अधिक प्रयोगों के साथ पूर्वगामी लॉग का एक सेट डाउनलोड करें:

 %%bash
wget -q 'https://storage.googleapis.com/download.tensorflow.org/tensorboard/hparams_demo_logs.zip'
unzip -q hparams_demo_logs.zip -d logs/hparam_demo
 

TensorBoard में ये लॉग देखें:

 %tensorboard --logdir logs/hparam_demo
 

आप HPARams डैशबोर्ड में अलग-अलग दृश्य आज़मा सकते हैं।

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