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

Escalares TensorBoard: registrando métricas de treinamento em Keras

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

Visão geral

O aprendizado de máquina invariavelmente envolve a compreensão de métricas importantes, como perda e como elas mudam à medida que o treinamento avança. Essas métricas podem ajudá-lo a entender se você está se adaptando demais, por exemplo, ou se está treinando desnecessariamente por muito tempo. Convém comparar essas métricas em diferentes execuções de treinamento para ajudar a depurar e melhorar seu modelo.

O painel de escalares do TensorBoard permite visualizar essas métricas usando uma API simples com muito pouco esforço. Este tutorial apresenta exemplos muito básicos para ajudar você a aprender como usar essas APIs com o TensorBoard ao desenvolver seu modelo Keras. Você aprenderá como usar as APIs de retorno de chamada Keras TensorBoard e Resumo de TensorFlow para visualizar escalares padrão e personalizados.

Configuração

 # Load the TensorBoard notebook extension.
%load_ext tensorboard
 
 from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras

import numpy as np

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."
 
TensorFlow version:  2.2

Configurar dados para uma regressão simples

Agora você vai usar o Keras para calcular uma regressão, ou seja, encontrar a melhor linha de ajuste para um conjunto de dados emparelhado. (Embora o uso de redes neurais e descida de gradiente seja um exagero para esse tipo de problema , ele facilita um exemplo muito fácil de entender.)

Você usará o TensorBoard para observar como o treinamento e a perda de teste mudam entre as épocas. Felizmente, você verá a perda de treinamento e teste diminuir ao longo do tempo e permanecerá estável.

Primeiro, gere 1000 pontos de dados aproximadamente ao longo da linha y = 0,5x + 2 . Divida esses pontos de dados em conjuntos de treinamento e teste. Sua esperança é que a rede neural aprenda esse relacionamento.

 data_size = 1000
# 80% of the data is for training.
train_pct = 0.8

train_size = int(data_size * train_pct)

# Create some input data between -1 and 1 and randomize it.
x = np.linspace(-1, 1, data_size)
np.random.shuffle(x)

# Generate the output data.
# y = 0.5x + 2 + noise
y = 0.5 * x + 2 + np.random.normal(0, 0.05, (data_size, ))

# Split into test and train pairs.
x_train, y_train = x[:train_size], y[:train_size]
x_test, y_test = x[train_size:], y[train_size:]
 

Treinando o Modelo e Perda de Log

Agora você está pronto para definir, treinar e avaliar seu modelo.

Para registrar o escalar de perda à medida que você treina, faça o seguinte:

  1. Criar o retorno de chamada Keras TensorBoard
  2. Especifique um diretório de log
  3. Passe o retorno de chamada TensorBoard para Model.fit () de Keras.

O TensorBoard lê dados de log da hierarquia do diretório de log. Neste bloco de notas, o diretório de log raiz é logs/scalars , com o sufixo de um subdiretório com carimbo de data e hora. O subdiretório com registro de data e hora permite identificar e selecionar facilmente as execuções de treinamento à medida que você usa o TensorBoard e itera no seu modelo.

 logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(lr=0.2),
)

print("Training ... With default parameters, this takes less than 10 seconds.")
training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback],
)

print("Average test loss: ", np.average(training_history.history['loss']))
 
Training ... With default parameters, this takes less than 10 seconds.
Average test loss:  0.05271831926424056

Examinando a perda usando o TensorBoard

Agora, inicie o TensorBoard, especificando o diretório de log raiz usado acima.

Aguarde alguns segundos para a interface do usuário do TensorBoard girar.

 %tensorboard --logdir logs/scalars
 

Você pode ver o TensorBoard exibir a mensagem "Nenhum painel está ativo para o conjunto de dados atual". Isso ocorre porque os dados de log inicial ainda não foram salvos. À medida que o treinamento avança, o modelo Keras começará a registrar dados. O TensorBoard atualiza periodicamente e mostra suas métricas escalares. Se estiver impaciente, toque na seta Atualizar no canto superior direito.

Ao assistir o progresso do treinamento, observe como as perdas de treinamento e validação diminuem rapidamente e permanecem estáveis. Na verdade, você poderia ter parado de treinar após 25 épocas, porque o treinamento não melhorou muito depois desse ponto.

Passe o mouse sobre o gráfico para ver pontos de dados específicos. Você também pode tentar aumentar o zoom com o mouse ou selecionar parte deles para ver mais detalhes.

Observe o seletor "Executa" à esquerda. Uma "execução" representa um conjunto de logs de uma rodada de treinamento, neste caso, o resultado de Model.fit (). Os desenvolvedores normalmente têm muitas execuções, à medida que experimentam e desenvolvem seu modelo ao longo do tempo.

Use o seletor de execuções para escolher execuções específicas ou escolher apenas treinamento ou validação. A comparação de execuções ajudará você a avaliar qual versão do seu código está resolvendo melhor o seu problema.

Ok, o gráfico de perdas do TensorBoard demonstra que a perda diminuiu consistentemente para treinamento e validação e depois estabilizou. Isso significa que as métricas do modelo provavelmente são muito boas! Agora veja como o modelo realmente se comporta na vida real.

Dados os dados de entrada (60, 25, 2), a linha y = 0,5x + 2 deve render (32, 14,5, 3). O modelo concorda?

 print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
 
[[32.234306 ]
 [14.5974245]
 [ 3.0074697]]

Não é ruim!

Registrando escalares personalizados

E se você deseja registrar valores personalizados, como uma taxa de aprendizado dinâmico ? Para fazer isso, você precisa usar a API de resumo do TensorFlow.

Treine novamente o modelo de regressão e registre uma taxa de aprendizado personalizada. Aqui está como:

  1. Crie um gravador de arquivos usando tf.summary.create_file_writer() .
  2. Defina uma função de taxa de aprendizado personalizada. Isso será passado para o retorno de chamada do Keras LearningRateScheduler .
  3. Dentro da função taxa de aprendizado, use tf.summary.scalar() para registrar a taxa de aprendizado personalizada.
  4. Passe o retorno de chamada LearningRateScheduler para Model.fit ().

Em geral, para registrar um escalar personalizado, você precisa usar tf.summary.scalar() com um gravador de arquivo. O gravador de arquivos é responsável por gravar dados para esta execução no diretório especificado e é implicitamente usado quando você usa o tf.summary.scalar() .

 logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

def lr_schedule(epoch):
  """
  Returns a custom learning rate that decreases as epochs progress.
  """
  learning_rate = 0.2
  if epoch > 10:
    learning_rate = 0.02
  if epoch > 20:
    learning_rate = 0.01
  if epoch > 50:
    learning_rate = 0.005

  tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
  return learning_rate

lr_callback = keras.callbacks.LearningRateScheduler(lr_schedule)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(),
)

training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback, lr_callback],
)
 

Vamos olhar para o TensorBoard novamente.

 %tensorboard --logdir logs/scalars
 

Usando o seletor "Executa" à esquerda, observe que você tem uma <timestamp>/metrics . A seleção desta execução exibe um gráfico de "taxa de aprendizado" que permite verificar a progressão da taxa de aprendizado durante essa execução.

Você também pode comparar as curvas de perda de treinamento e validação dessa corrida com as anteriores.

Como esse modelo funciona?

 print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
 
[[32.234013 ]
 [14.5973015]
 [ 3.0074618]]