Esta página foi traduzida pela API Cloud Translation.
Switch to English

Ajuste de hiperparâmetros com o painel HParams

Ver no TensorFlow.org Executar no Google Colab Ver fonte no GitHub

Ao construir modelos de aprendizado de máquina, você precisa escolher vários hiperparâmetros , como a taxa de evasão em uma camada ou a taxa de aprendizado. Essas decisões afetam as métricas do modelo, como a precisão. Portanto, uma etapa importante no fluxo de trabalho do aprendizado de máquina é identificar os melhores hiperparâmetros para o seu problema, o que geralmente envolve experimentação. Este processo é conhecido como "Otimização de hiperparâmetros" ou "Ajuste de hiperparâmetros".

O painel HParams no TensorBoard fornece várias ferramentas para ajudar neste processo de identificação do melhor experimento ou dos conjuntos mais promissores de hiperparâmetros.

Este tutorial se concentrará nas seguintes etapas:

  1. Configuração da experiência e resumo de HParams
  2. O Adapt TensorFlow é executado para registrar hiperparâmetros e métricas
  3. Iniciar execuções e registrá-los todos em um diretório pai
  4. Visualize os resultados no painel HParams do TensorBoard

Comece instalando o TF 2.0 e carregando a extensão do notebook TensorBoard:

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

Importe o TensorFlow e o plug-in TensorBoard HParams:

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

Baixe o conjunto de dados FashionMNIST e dimensione-o:

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. Configuração do experimento e o resumo do experimento HParams

Experimente três hiperparâmetros no modelo:

  1. Número de unidades na primeira camada densa
  2. Taxa de evasão na camada de evasão
  3. Otimizador

Liste os valores a serem testados e registre uma configuração de experimento no TensorBoard. Esta etapa é opcional: você pode fornecer informações de domínio para permitir uma filtragem mais precisa de hiperparâmetros na IU e pode especificar quais métricas devem ser exibidas.

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 você escolher pular esta etapa, você pode usar um literal de string sempre que você usaria um valor HParam : por exemplo, hparams['dropout'] vez de hparams[HP_DROPOUT] .

2. Adapte o TensorFlow para registrar hiperparâmetros e métricas

O modelo será bastante simples: duas camadas densas com uma camada de dropout entre elas. O código de treinamento parecerá familiar, embora os hiperparâmetros não sejam mais codificados. Em vez disso, os hiperparâmetros são fornecidos em um dicionário hparams e usados ​​em toda a função de treinamento:

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

Para cada execução, registre um resumo de hparams com os hiperparâmetros e a precisão final:

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)

Ao treinar modelos Keras, você pode usar callbacks em vez de escrever diretamente:

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

3. Inicie as execuções e registre-as todas em um diretório pai

Agora você pode tentar vários experimentos, treinando cada um com um conjunto diferente de hiperparâmetros.

Para simplificar, use uma pesquisa de grade: tente todas as combinações dos parâmetros discretos e apenas os limites inferior e superior do parâmetro de valor real. Para cenários mais complexos, pode ser mais eficaz escolher cada valor de hiperparâmetro aleatoriamente (isso é chamado de pesquisa aleatória). Existem métodos mais avançados que podem ser usados.

Faça alguns experimentos, que levarão alguns minutos:

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. Visualize os resultados no plug-in HParams do TensorBoard

O painel de HParams agora pode ser aberto. Inicie o TensorBoard e clique em "HParams" na parte superior.

%tensorboard --logdir logs/hparam_tuning

O painel esquerdo do painel fornece recursos de filtragem que estão ativos em todas as visualizações no painel do HParams:

  • Filtre quais hiperparâmetros / métricas são mostrados no painel
  • Filtre quais valores de hiperparâmetros / métricas são mostrados no painel
  • Filtro no status de execução (em execução, sucesso, ...)
  • Classificar por hiperparâmetro / métrica na visualização da tabela
  • Número de grupos de sessão a serem mostrados (útil para desempenho quando há muitos experimentos)

O painel HParams tem três visualizações diferentes, com várias informações úteis:

  • O Table View lista as execuções, seus hiperparâmetros e suas métricas.
  • A Visualização de Coordenadas Paralelas mostra cada execução como uma linha passando por um eixo para cada hiperparâmetro e métrica. Clique e arraste o mouse em qualquer eixo para marcar uma região que irá destacar apenas os trechos que passam por ela. Isso pode ser útil para identificar quais grupos de hiperparâmetros são mais importantes. Os próprios eixos podem ser reordenados arrastando-os.
  • A exibição de gráfico de dispersão mostra gráficos comparando cada hiperparâmetro / métrica com cada métrica. Isso pode ajudar a identificar correlações. Clique e arraste para selecionar uma região em um gráfico específico e destacar essas sessões nos outros gráficos.

Uma linha de tabela, uma linha de coordenadas paralelas e um mercado de gráfico de dispersão podem ser clicados para ver um gráfico das métricas como uma função das etapas de treinamento para aquela sessão (embora neste tutorial apenas uma etapa seja usada para cada execução).

Para explorar ainda mais os recursos do painel HParams, baixe um conjunto de registros pré-gerados com mais experimentos:

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

Veja estes registros no TensorBoard:

%tensorboard --logdir logs/hparam_demo

Você pode experimentar as diferentes visualizações no painel HParams.

Por exemplo, indo para a visualização de coordenadas paralelas e clicando e arrastando no eixo de precisão, você pode selecionar as corridas com a maior precisão. Conforme essas execuções passam por 'adam' no eixo do otimizador, você pode concluir que 'adam' teve um desempenho melhor do que 'sgd' nesses experimentos.