Reserve a data! O Google I / O retorna de 18 a 20 de maio Registre-se agora
Esta página foi traduzida pela API Cloud Translation.
Switch to English

TensorBoard Scalars: registro de métricas de treinamento em Keras

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

Visão geral

O aprendizado de máquina invariavelmente envolve a compreensão das principais métricas, como perdas, e como elas mudam à medida que o treinamento avança. Essas métricas podem ajudá-lo a entender se você está overfitting , por exemplo, ou se está treinando desnecessariamente por muito tempo. Você pode querer 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 que você visualize essas métricas usando uma API simples com muito pouco esforço. Este tutorial apresenta exemplos básicos para ajudá-lo a aprender como usar essas APIs com o TensorBoard ao desenvolver seu modelo Keras. Você aprenderá a usar o retorno de chamada Keras TensorBoard e as APIs de resumo do TensorFlow para visualizar escalares padrão e personalizados.

Configurar

# 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

Configure os dados para uma regressão simples

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

Você usará o TensorBoard para observar como a perda de treinamento e teste muda ao longo das épocas. Com sorte, você verá que a perda de treinamento e teste diminuirá com o 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 essa relação.

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:]

Treinamento do modelo e perda de registro

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

Para registrar o escalar de perda durante o treinamento, você fará o seguinte:

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

O TensorBoard lê os dados de registro da hierarquia do diretório de registros. Neste bloco de notas, o diretório raiz do log é logs/scalars , sufixado por um subdiretório com carimbo de data / hora. O subdiretório com carimbo de data / hora permite que você identifique e selecione facilmente as execuções de treinamento à medida que usa o TensorBoard e itera em 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 perda usando TensorBoard

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

Aguarde alguns segundos para que a IU do TensorBoard comece a funcionar.

%tensorboard --logdir logs/scalars

Você pode ver o TensorBoard exibir a mensagem "Nenhum painel está ativo para o conjunto de dados atual". Isso porque os dados de registro iniciais ainda não foram salvos. Conforme o treinamento avança, o modelo Keras começará a registrar os dados. O TensorBoard será atualizado periodicamente e mostrará suas métricas escalares. Se você estiver impaciente, pode tocar na seta Atualizar no canto superior direito.

Ao observar o progresso do treinamento, observe como as perdas de treinamento e validação diminuem rapidamente e, em seguida, permanecem estáveis. Na verdade, você poderia ter parado de treinar depois de 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 "Execuções" à esquerda. Uma "corrida" representa um conjunto de registros de uma rodada de treinamento, neste caso o resultado de Model.fit (). Os desenvolvedores normalmente têm muitas, 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 escolha apenas treinamento ou validação. Comparar as execuções ajudará você a avaliar qual versão do seu código está resolvendo melhor o seu problema.

Ok, o gráfico de perda do TensorBoard demonstra que a perda diminuiu de forma consistente para o treinamento e validação e, em seguida, 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]]

Nada mal!

Registro de escalares personalizados

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

Treine novamente o modelo de regressão e registre uma taxa de aprendizagem personalizada. Veja como:

  1. Crie um gravador de arquivo, usando tf.summary.create_file_writer() .
  2. Defina uma função de taxa de aprendizagem personalizada. Isso será passado para o retorno de chamada de Keras LearningRateScheduler .
  3. Dentro da função de taxa de aprendizagem, use tf.summary.scalar() para registrar a taxa de aprendizagem 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 do arquivo é responsável por gravar os dados dessa 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],
)

Vejamos o TensorBoard novamente.

%tensorboard --logdir logs/scalars

Usando o seletor "Runs" à esquerda, observe que você tem um <timestamp>/metrics executado. Selecionar esta execução exibe um gráfico de "taxa de aprendizado" que permite verificar a progressão da taxa de aprendizado durante esta execução.

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

Como este modelo se sai?

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