 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 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:
- Criar o Keras callback TensorBoard
- Especifique um diretório de log
- 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:
- Criar um escritor arquivo, usando
tf.summary.create_file_writer(). - Defina uma função de taxa de aprendizagem personalizada. Isso vai ser passado para o Keras LearningRateScheduler callback.
- Dentro da função taxa de aprendizagem, uso
tf.summary.scalar()para registrar a taxa de aprendizagem personalizado. - 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]]