Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Ottimizzazione dell'iperparametro con la dashboard di HParams

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza sorgente su GitHub

Quando si creano modelli di apprendimento automatico, è necessario scegliere vari iperparametri , come il tasso di abbandono in un livello o il tasso di apprendimento. Queste decisioni influiscono sulle metriche del modello, come l'accuratezza. Pertanto, un passaggio importante nel flusso di lavoro dell'apprendimento automatico è l'identificazione dei migliori iperparametri per il tuo problema, che spesso comporta la sperimentazione. Questo processo è noto come "Ottimizzazione dell'iperparametro" o "Ottimizzazione dell'iperparametro".

La dashboard HParams in TensorBoard fornisce diversi strumenti per aiutare con questo processo di identificazione dell'esperimento migliore o dei set più promettenti di iperparametri.

Questo tutorial si concentrerà sui seguenti passaggi:

  1. Configurazione dell'esperimento e riepilogo di HParams
  2. Adattare le corse TensorFlow per registrare iperparametri e metriche
  3. Avviare le esecuzioni e registrarle tutte in un'unica directory principale
  4. Visualizza i risultati nella dashboard HParams di TensorBoard

Inizia installando TF 2.0 e caricando l'estensione per notebook TensorBoard:

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

Importa TensorFlow e il plug-in HParams TensorBoard:

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

Scarica il set di dati FashionMNIST e ridimensionalo:

 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. Configurazione dell'esperimento e riepilogo dell'esperimento HParams

Sperimenta con tre iperparametri nel modello:

  1. Numero di unità nel primo strato denso
  2. Tasso di abbandono nel livello di abbandono
  3. Optimizer

Elencare i valori da provare e registrare una configurazione dell'esperimento su TensorBoard. Questo passaggio è facoltativo: puoi fornire informazioni sul dominio per consentire un filtro più preciso degli iperparametri nell'interfaccia utente e puoi specificare quali metriche devono essere visualizzate.

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

Se si sceglie di saltare questo passaggio, è possibile utilizzare una stringa letterale ovunque si utilizzerebbe altrimenti un valore HParam : ad esempio, hparams['dropout'] anziché hparams[HP_DROPOUT] .

2. Adattare le corse TensorFlow per registrare iperparametri e metriche

Il modello sarà abbastanza semplice: due strati densi con uno strato di dropout tra di loro. Il codice di allenamento apparirà familiare, sebbene gli iperparametri non siano più codificati. Invece, gli iperparametri sono forniti in un dizionario hparams e utilizzati in tutta la funzione di allenamento:

 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
 

Per ogni corsa, registra un riepilogo di hparam con gli iperparametri e la precisione finale:

 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)
 

Durante l'addestramento dei modelli Keras, è possibile utilizzare i callback invece di scriverli direttamente:

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

3. Avviare le esecuzioni e registrarle tutte in un'unica directory principale

Ora puoi provare più esperimenti, allenandoli ciascuno con un diverso set di iperparametri.

Per semplicità, usa una ricerca in griglia: prova tutte le combinazioni dei parametri discreti e solo i limiti inferiore e superiore del parametro con valori reali. Per scenari più complessi, potrebbe essere più efficace scegliere ogni valore di iperparametro in modo casuale (questa è chiamata una ricerca casuale). Esistono metodi più avanzati che possono essere utilizzati.

Esegui alcuni esperimenti, che richiederà alcuni minuti:

 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. Visualizza i risultati nel plugin HParams di TensorBoard

Ora è possibile aprire la dashboard di HParams. Avviare TensorBoard e fare clic su "HParams" nella parte superiore.

 %tensorboard --logdir logs/hparam_tuning
 

Il riquadro sinistro della dashboard offre funzionalità di filtro attive in tutte le visualizzazioni nella dashboard di HParams:

  • Filtra quali iperparametri / metriche vengono visualizzati nella dashboard
  • Filtra quali valori di iperparametro / metrica vengono visualizzati nella dashboard
  • Filtro sullo stato della corsa (corsa, successo, ...)
  • Ordina per iperparametro / metrica nella vista tabella
  • Numero di gruppi di sessioni da mostrare (utile per le prestazioni in presenza di numerosi esperimenti)

La dashboard di HParams ha tre diverse visualizzazioni, con varie informazioni utili:

  • La vista tabella elenca le esecuzioni, i loro iperparametri e le loro metriche.
  • La vista Coordinate parallele mostra ciascuna corsa come una linea che attraversa un asse per ciascun hyperparemeter e metrica. Fare clic e trascinare il mouse su qualsiasi asse per contrassegnare una regione che evidenzierà solo le piste che la attraversano. Questo può essere utile per identificare quali gruppi di iperparametri sono più importanti. Gli assi stessi possono essere riordinati trascinandoli.
  • La vista Grafico a dispersione mostra i grafici che confrontano ogni iperparametro / metrica con ciascuna metrica. Questo può aiutare a identificare le correlazioni. Fare clic e trascinare per selezionare una regione in un grafico specifico ed evidenziare quelle sessioni negli altri grafici.

È possibile fare clic su una riga della tabella, una linea di coordinate parallele e un mercato del diagramma a dispersione per visualizzare un diagramma delle metriche in funzione dei passaggi di allenamento per quella sessione (sebbene in questo tutorial venga utilizzato solo un passaggio per ogni corsa).

Per esplorare ulteriormente le funzionalità della dashboard di HParams, scaricare una serie di registri pregenerati con altri esperimenti:

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

Visualizza questi registri in TensorBoard:

 %tensorboard --logdir logs/hparam_demo
 

Puoi provare le diverse visualizzazioni nella dashboard di HParams.

Ad esempio, andando nella vista coordinate parallele e facendo clic e trascinando sull'asse della precisione, è possibile selezionare le piste con la massima precisione. Mentre queste corse passano attraverso "adam" nell'asse dell'ottimizzatore, puoi concludere che "adam" ha funzionato meglio di "sgd" in questi esperimenti.