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

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 ajudar você a entender se você está overfitting , por exemplo, ou se você 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.

Escalares Dashboard da TensorBoard permite visualizar 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ê está indo para usar Keras para calcular uma regressão, ou seja, encontrar a melhor linha de ajuste para um conjunto de dados emparelhados. (Enquanto estiver usando redes neurais e gradiente descendente é um exagero para este tipo de problema , faz para um exemplo muito fácil de entender.)

Você vai usar TensorBoard para observar como a mudança de treinamento e perda de teste através épocas. Com sorte, você verá que a perda de treinamento e teste diminuirá com o tempo e permanecerá estável.

Em primeiro lugar, gerar 1000 pontos de dados mais ou menos 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 a escalar perda como você treinar, você vai fazer o seguinte:

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

O TensorBoard lê os dados de registro da hierarquia do diretório de registros. Neste caderno, o diretório raiz do log é logs/scalars , o sufixo um subdiretório timestamped. 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(learning_rate=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 raiz do log que você usou acima.

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

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

Conforme você observa 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 logs de uma rodada de treinamento, neste caso o resultado de Model.fit (). Os desenvolvedores geralmente 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.

Dado que os dados de entrada (60, 25, 2), a linha y = 0,5x + 2 deve ceder (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, tais 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. Criar um escritor arquivo, usando tf.summary.create_file_writer() .
2. Defina uma função de taxa de aprendizagem personalizada. Isso vai ser passado para o Keras LearningRateScheduler callback.
3. Dentro da função taxa de aprendizagem, uso tf.summary.scalar() para registrar a taxa de aprendizagem personalizado.
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 escritor arquivo é responsável por escrever dados para esta corrida para o diretório especificado e é usado implicitamente 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 selector "Funciona", à esquerda, aviso de que você tem um <timestamp>/metrics run. 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 as suas corridas anteriores. Você também pode notar que a programação da taxa de aprendizado retornou valores discretos, dependendo da época, mas o gráfico da taxa de aprendizado pode parecer suave. O TensorBoard tem um parâmetro de suavização que pode ser necessário reduzir a zero para ver os valores não suavizados.

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