 Ver no TensorFlow.org |  Executar no Google Colab |  Ver fonte no GitHub |  Baixar caderno |
Quando a construção de modelos de aprendizagem de máquina, você precisa escolher vários hiperparâmetros , tais como a taxa de abandono em uma camada ou a taxa de aprendizagem. 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:
- Configuração da experiência e resumo de HParams
- O Adapt TensorFlow é executado para registrar hiperparâmetros e métricas
- Iniciar execuções e registrá-los todos em um diretório pai
- 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 runsrm -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 FashionMNIST conjunto de dados e escalá-lo:
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:
- Número de unidades na primeira camada densa
- Taxa de evasão na camada de evasão
- 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ê optar por pular esta etapa, você pode usar um literal de cadeia onde quer que você, caso contrário, utilizar um HParam valor: por exemplo, hparams['dropout'] em vez de hparams[HP_DROPOUT] .
2. Adapte as execuções do 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 hparams dicionário e usado em toda a função de formação:
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 retornos de chamada em vez de escrever diretamente:
model.fit(
...,
callbacks=[
tf.keras.callbacks.TensorBoard(logdir), # log metrics
hp.KerasCallback(logdir, hparams), # log hparams
],
)
3. Iniciar execuções e registrá-los todos 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 com 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 HParams agora pode ser aberto. Inicie o TensorBoard e clique em "HParams" no topo.
%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 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 do HParams tem três visualizações diferentes, com várias informações úteis:
- The View tabela lista os funcionamentos, suas hiperparâmetros, e suas métricas.
- O Parallel Coordenadas View mostra cada corrida como uma linha passando por um eixo para cada hyperparemeter 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.
- Os Scatter Plot View mostra gráficos que comparam 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 da 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 de 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.