Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Strojenie hiperparametrów za pomocą HParams Dashboard

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub

Budując modele uczenia maszynowego, musisz wybrać różne hiperparametry , takie jak współczynnik porzucania w warstwie lub szybkość uczenia się. Te decyzje wpływają na metryki modelu, takie jak dokładność. Dlatego ważnym krokiem w przepływie pracy uczenia maszynowego jest zidentyfikowanie najlepszych hiperparametrów dla danego problemu, co często wiąże się z eksperymentowaniem. Ten proces jest znany jako „Optymalizacja hiperparametrów” lub „Dostrajanie hiperparametrów”.

Pulpit nawigacyjny HParams w TensorBoard zapewnia kilka narzędzi pomocnych w procesie identyfikacji najlepszego eksperymentu lub najbardziej obiecujących zestawów hiperparametrów.

Ten samouczek skupi się na następujących krokach:

  1. Konfiguracja eksperymentu i podsumowanie HParams
  2. Dostosuj działanie TensorFlow do rejestrowania hiperparametrów i metryk
  3. Uruchom działa i rejestruj je wszystkie w jednym katalogu nadrzędnym
  4. Wizualizuj wyniki na pulpicie nawigacyjnym HParams TensorBoard

Zacznij od zainstalowania TF 2.0 i załadowania rozszerzenia notebooka TensorBoard:

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

Importuj TensorFlow i wtyczkę TensorBoard HParams:

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

Pobierz zestaw danych FashionMNIST i skaluj go:

 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. Przygotowanie eksperymentu i podsumowanie eksperymentu HParams

Poeksperymentuj z trzema hiperparametrami w modelu:

  1. Liczba jednostek w pierwszej gęstej warstwie
  2. Wskaźnik rezygnacji w warstwie rezygnacji
  3. Optimizer

Wypisz wartości do wypróbowania i zarejestruj konfigurację eksperymentu w TensorBoard. Ten krok jest opcjonalny: możesz podać informacje o domenie, aby włączyć bardziej precyzyjne filtrowanie hiperparametrów w interfejsie użytkownika, a także określić, które metryki mają być wyświetlane.

 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')],
  )
 

Jeśli zdecydujesz się pominąć ten krok, możesz użyć literału łańcuchowego wszędzie tam, gdzie w innym przypadku HParam wartości HParam : np. hparams['dropout'] zamiast hparams[HP_DROPOUT] .

2. Dostosuj działanie TensorFlow do rejestrowania hiperparametrów i metryk

Model będzie dość prosty: dwie gęste warstwy z warstwą zanikającą między nimi. Kod szkoleniowy będzie wyglądał znajomo, chociaż hiperparametry nie są już zakodowane na stałe. Zamiast tego hiperparametry są dostarczane w słowniku hparams i używane w całej funkcji szkoleniowej:

 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
 

Dla każdego przebiegu zapisz podsumowanie hparams z hiperparametrami i ostateczną dokładnością:

 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)
 

Podczas trenowania modeli Keras możesz używać wywołań zwrotnych zamiast pisać je bezpośrednio:

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

3. Uruchom przebiegi i zarejestruj je wszystkie w jednym katalogu nadrzędnym

Możesz teraz wypróbować wiele eksperymentów, trenując każdy z innym zestawem hiperparametrów.

Dla uproszczenia użyj wyszukiwania w siatce: wypróbuj wszystkie kombinacje parametrów dyskretnych i tylko dolną i górną granicę parametru o wartościach rzeczywistych. W przypadku bardziej złożonych scenariuszy bardziej efektywne może być losowe wybieranie każdej wartości hiperparametru (nazywane jest to wyszukiwaniem losowym). Istnieją bardziej zaawansowane metody, których można użyć.

Przeprowadź kilka eksperymentów, które potrwają kilka minut:

 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. Wizualizuj wyniki we wtyczce HParams firmy TensorBoard

Można teraz otworzyć pulpit nawigacyjny HParams. Uruchom TensorBoard i kliknij „HParams” u góry.

 %tensorboard --logdir logs/hparam_tuning
 

Lewe okienko pulpitu nawigacyjnego zapewnia możliwości filtrowania, które są aktywne we wszystkich widokach na pulpicie HParams:

  • Filtruj, które hiperparametry / metryki są wyświetlane na pulpicie nawigacyjnym
  • Filtruj, które wartości hiperparametrów / metryk są wyświetlane na pulpicie nawigacyjnym
  • Filtruj po statusie uruchomienia (działa, powodzenie, ...)
  • Sortuj według hiperparametru / metryki w widoku tabeli
  • Liczba grup sesji do wyświetlenia (przydatne w przypadku wielu eksperymentów)

Pulpit nawigacyjny HParams ma trzy różne widoki z różnymi przydatnymi informacjami:

  • Widok tabeli zawiera przebiegi, ich hiperparametry i metryki.
  • Widok współrzędnych równoległych przedstawia każdy przebieg jako linię przechodzącą przez oś dla każdego hiperparametru i metryki. Kliknij i przeciągnij myszą na dowolnej osi, aby zaznaczyć region, który podświetli tylko przebiegi, które przez niego przechodzą. Może to być przydatne do określenia, które grupy hiperparametrów są najważniejsze. Same osie można zmienić w kolejności, przeciągając je.
  • Widok wykresu punktowego przedstawia wykresy porównujące każdy hiperparametr / metrykę z każdą metryką. Może to pomóc w identyfikacji korelacji. Kliknij i przeciągnij, aby wybrać region na określonym wykresie i zaznacz te sesje na innych wykresach.

Można kliknąć wiersz tabeli, równoległą linię współrzędnych i rynek wykresów punktowych, aby wyświetlić wykres metryk jako funkcję kroków szkoleniowych dla tej sesji (chociaż w tym samouczku dla każdego przebiegu używany jest tylko jeden krok).

Aby dokładniej zbadać możliwości pulpitu HParams, pobierz zestaw wstępnie wygenerowanych dzienników z większą liczbą eksperymentów:

 %%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
 

Wyświetl te dzienniki w TensorBoard:

 %tensorboard --logdir logs/hparam_demo
 

Możesz wypróbować różne widoki na pulpicie nawigacyjnym HParams.

Na przykład, przechodząc do widoku współrzędnych równoległych i klikając i przeciągając na osi dokładności, można wybrać przebiegi z największą dokładnością. Ponieważ przebiegi te przechodzą przez „adam” na osi optymalizatora, można wywnioskować, że „adam” osiągnął lepsze wyniki niż „sgd” w tych eksperymentach.