Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Hyperparameter-Optimierung mit dem HParams Dashboard

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen

Beim Erstellen von Modellen für maschinelles Lernen müssen Sie verschiedene Hyperparameter auswählen, z. B. die Abbrecherquote in einer Ebene oder die Lernrate. Diese Entscheidungen wirken sich auf Modellmetriken wie die Genauigkeit aus. Ein wichtiger Schritt im Workflow für maschinelles Lernen besteht daher darin, die besten Hyperparameter für Ihr Problem zu ermitteln, was häufig mit Experimenten verbunden ist. Dieser Prozess wird als "Hyperparameter Optimization" oder "Hyperparameter Tuning" bezeichnet.

Das HParams-Dashboard in TensorBoard bietet verschiedene Tools, mit denen Sie das beste Experiment oder die vielversprechendsten Sätze von Hyperparametern ermitteln können.

Dieses Tutorial konzentriert sich auf die folgenden Schritte:

  1. Versuchsaufbau und HParams-Zusammenfassung
  2. TensorFlow wird ausgeführt, um Hyperparameter und Metriken zu protokollieren
  3. Starten Sie die Läufe und protokollieren Sie sie alle in einem übergeordneten Verzeichnis
  4. Visualisieren Sie die Ergebnisse im HParams-Dashboard von TensorBoard

Beginnen Sie mit der Installation von TF 2.0 und dem Laden der TensorBoard-Notebook-Erweiterung:

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

Importieren Sie TensorFlow und das TensorBoard HParams-Plugin:

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

Laden Sie den FashionMNIST- Datensatz herunter und skalieren Sie ihn:

 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. Versuchsaufbau und Zusammenfassung des HParams-Versuchs

Experimentieren Sie mit drei Hyperparametern im Modell:

  1. Anzahl der Einheiten in der ersten dichten Schicht
  2. Abbrecherquote in der Abbrecherschicht
  3. Optimierer

Listen Sie die zu versuchenden Werte auf und protokollieren Sie eine Experimentkonfiguration in TensorBoard. Dieser Schritt ist optional: Sie können Domäneninformationen bereitstellen, um eine genauere Filterung von Hyperparametern in der Benutzeroberfläche zu ermöglichen, und Sie können angeben, welche Metriken angezeigt werden sollen.

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

Wenn Sie diesen Schritt überspringen, können Sie ein Zeichenfolgenliteral überall dort verwenden, wo Sie sonst einen HParam Wert verwenden würden: z. B. hparams['dropout'] anstelle von hparams[HP_DROPOUT] .

2. Passen Sie TensorFlow-Läufe an, um Hyperparameter und Metriken zu protokollieren

Das Modell wird recht einfach sein: zwei dichte Schichten mit einer Dropout-Schicht dazwischen. Der Trainingscode kommt mir bekannt vor, obwohl die Hyperparameter nicht mehr fest codiert sind. Stattdessen werden die Hyperparameter in einem hparams Wörterbuch hparams und während der gesamten Trainingsfunktion verwendet:

 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
 

Protokollieren Sie für jeden Lauf eine hparams-Zusammenfassung mit den Hyperparametern und der endgültigen Genauigkeit:

 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)
 

Wenn Sie Keras-Modelle trainieren, können Sie Rückrufe verwenden, anstatt diese direkt zu schreiben:

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

3. Starten Sie die Läufe und protokollieren Sie sie alle in einem übergeordneten Verzeichnis

Sie können jetzt mehrere Experimente ausprobieren und jedes mit einem anderen Satz von Hyperparametern trainieren.

Verwenden Sie der Einfachheit halber eine Rastersuche: Probieren Sie alle Kombinationen der diskreten Parameter und nur die Unter- und Obergrenze des reellen Parameters aus. In komplexeren Szenarien ist es möglicherweise effektiver, jeden Hyperparameterwert zufällig auszuwählen (dies wird als zufällige Suche bezeichnet). Es gibt fortgeschrittenere Methoden, die verwendet werden können.

Führen Sie einige Experimente durch, die einige Minuten dauern:

 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. Visualisieren Sie die Ergebnisse im HParams-Plugin von TensorBoard

Das HParams-Dashboard kann jetzt geöffnet werden. Starten Sie TensorBoard und klicken Sie oben auf "HParams".

 %tensorboard --logdir logs/hparam_tuning
 

Der linke Bereich des Dashboards bietet Filterfunktionen, die in allen Ansichten des HParams-Dashboards aktiv sind:

  • Filtern Sie, welche Hyperparameter / Metriken im Dashboard angezeigt werden
  • Filtern Sie, welche Hyperparameter- / Metrikwerte im Dashboard angezeigt werden
  • Filter nach Laufstatus (Laufen, Erfolg, ...)
  • In der Tabellenansicht nach Hyperparameter / Metrik sortieren
  • Anzahl der anzuzeigenden Sitzungsgruppen (nützlich für die Leistung, wenn viele Experimente vorhanden sind)

Das HParams-Dashboard verfügt über drei verschiedene Ansichten mit verschiedenen nützlichen Informationen:

  • In der Tabellenansicht werden die Läufe, ihre Hyperparameter und ihre Metriken aufgelistet.
  • In der Ansicht "Parallele Koordinaten" wird jeder Lauf als Linie angezeigt, die für jeden Hyperparameter und jede Metrik durch eine Achse verläuft. Klicken und ziehen Sie die Maus auf eine beliebige Achse, um einen Bereich zu markieren, der nur die Läufe hervorhebt, die durch ihn verlaufen. Dies kann nützlich sein, um festzustellen, welche Gruppen von Hyperparametern am wichtigsten sind. Die Achsen selbst können durch Ziehen neu angeordnet werden.
  • Die Streudiagrammansicht zeigt Diagramme, in denen jeder Hyperparameter / jede Metrik mit jeder Metrik verglichen wird. Dies kann helfen, Korrelationen zu identifizieren. Klicken und ziehen Sie, um eine Region in einem bestimmten Diagramm auszuwählen und diese Sitzungen in den anderen Diagrammen hervorzuheben.

Eine Tabellenzeile, eine parallele Koordinatenlinie und ein Streudiagrammmarkt können angeklickt werden, um ein Diagramm der Metriken als Funktion der Trainingsschritte für diese Sitzung anzuzeigen (obwohl in diesem Lernprogramm nur ein Schritt für jeden Lauf verwendet wird).

Laden Sie eine Reihe vorgenerierter Protokolle mit weiteren Experimenten herunter, um die Funktionen des HParams-Dashboards weiter zu erkunden:

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

Zeigen Sie diese Protokolle in TensorBoard an:

 %tensorboard --logdir logs/hparam_demo
 

Sie können die verschiedenen Ansichten im HParams-Dashboard ausprobieren.

Wenn Sie beispielsweise zur Ansicht der parallelen Koordinaten gehen und auf die Genauigkeitsachse klicken und ziehen, können Sie die Läufe mit der höchsten Genauigkeit auswählen. Da diese Läufe in der Optimierungsachse durch "adam" verlaufen, können Sie daraus schließen, dass "adam" bei diesen Experimenten eine bessere Leistung als "sgd" erbrachte.