TensorFlow is back at Google I/O on May 14! Register now

TensorBoard Scalar：在 Keras 中记录训练指标

在 TensorFlow.org 上查看

在 Google Colab 中运行

在 GitHub 上查看源代码

概述

机器学习总是涉及理解关键指标，例如损失，以及它们如何随着训练的进行而变化。例如，这些指标可以帮助您了解模型是否过拟合，或者是否不必要地训练了太长时间。您可能需要比较不同训练中的这些指标，以帮助调试和改善模型。

TensorBoard 的 Time Series Dashboard 允许您轻松地使用简单的 API 呈现这些指标。本教程提供了非常基本的示例，可帮助您在开发 Keras 模型时学习如何在 TensorBoard 中使用这些 API。您将学习如何使用 Keras TensorBoard 回调和 TensorFlow Summary API 来呈现默认和自定义标量。

安装

# Load the TensorBoard notebook extension.
%load_ext tensorboard

from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras
from keras import backend as K

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

# Clear any logs from previous runs
rm -rf ./logs/

配置数据用来训练回归

您现在将使用 Keras 计算回归，即找到对应数据集的最佳拟合。（虽然使用神经网络和梯度下降解决此类问题多此一举，但这却是一个非常容易理解的示例。）

您将使用 TensorBoard 观察训练和测试损失在各个时期之间如何变化。希望您会看到训练集和测试集损失随着时间的流逝而减少，然后保持稳定。

首先，大致沿 y = 0.5x + 2 线生成1000个数据点。将这些数据点分为训练和测试集。您希望神经网络学会 x 与 y 的对应关系。

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

训练模型和记录损失 (loss)

您现在可以定义，训练和评估模型了。

要在训练时记录损失标量，请执行以下操作：

创建 Keras TensorBoard 回调
指定日志目录
将 TensorBoard 回调传递给 Keras' Model.fit().

TensorBoard 从日志目录层次结构中读取日志数据。在此 notebook 中，根日志目录是 logs/scalars ，后缀有时间戳的子目录。带时间戳的子目录使您可以在使用 TensorBoard 并在模型上进行迭代时轻松识别并选择训练运行。

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

使用 TensorBoard 检查损失 (loss)

现在，启动 TensorBoard ，并指定您在上面使用的根日志目录。

等待几秒钟以使 TensorBoard 进入载入界面。

%tensorboard --logdir logs/scalars

您可能会看到 TensorBoard 显示消息“当前数据集没有活动的仪表板”。这是因为尚未保存初始日志记录数据。随着训练的进行，Keras 模型将开始记录数据。TensorBoard 将定期刷新并显示您的标量指标。如果您不耐烦，可以点击右上角的刷新箭头。

在观看训练进度时，请注意训练和验证损失如何迅速减少，然后保持稳定。实际上，您可能在25个 epochs 后就停止了训练，因为在此之后训练并没有太大改善。

将鼠标悬停在图形上可以查看特定的数据点。您也可以尝试使用鼠标放大，或选择其中的一部分以查看更多详细信息。

注意左侧的 “Runs” 选择器。 “Runs” 表示来自一轮训练的一组日志，在本例中为 Model.fit() 的结果。随着时间的推移，开发人员进行实验和开发模型时，通常会有很多运行。

使用 “Runs” 选择器选择特定的 Runs，或仅从训练或验证中选择。比较运行将帮助您评估哪个版本的代码可以更好地解决您的问题。

TensorBoard 的损失图表明，对于训练和验证，损失持续减少，然后稳定下来。这意味着该模型的指标可能非常好！现在来看模型在现实生活中的实际行为。

给定 (60, 25, 2), 方程式 y = 0.5x + 2 应该会输出 (32, 14.5, 3). 模型会输出一样的结果吗?

print(model.predict([60, 25, 2]))
# 理想的输出结果是: 
# [[32.0]
#  [14.5]
#  [ 3.0]]

[[32.148884 ]
 [14.562463 ]
 [ 3.0056725]]

并不差！

记录自定义 scalars

如果要记录自定义值，例如动态学习率，该怎么办？为此，您需要使用 TensorFlow Summary API。

重新训练回归模型并记录自定义学习率。如以下步骤所示：

使用 tf.summary.create_file_writer() 创建文件编写器。
定义一个自定义学习率函数。这将传递给 Keras LearningRateScheduler 回调。
在学习率函数内部，使用 tf.summary.scalar() 记录自定义学习率。
将 LearningRateScheduler 回调传递给 Model.fit()。

通常，要记录自定义标量，您需要将 tf.summary.scalar() 与文件写入器一起使用。文件写入器负责将此运行的数据写入指定目录，并在您使用 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],
)

查看 TensorBoard

%tensorboard --logdir logs/scalars

使用左侧的 “Runs” 选择器，请注意您运行了 <timestamp>/metrics。选择此运行将显示一个 "learning rate" 图，您可以在此运行过程中验证学习率的进度。

您还可以将此运行的训练和验证损失曲线与您之前的运行进行比较。您可能还注意到学习率计划返回离散值，具体取决于时期，但学习率图可能看起来很平滑TensorBoard 有一个平滑参数，您可能需要将其调低至零才能查看未平滑的值。

模型会输出什么呢？

print(model.predict([60, 25, 2]))
# 理想的输出结果是: 
# [[32.0]
#  [14.5]
#  [ 3.0]]

[[31.958094 ]
 [14.482997 ]
 [ 2.9993598]]

批量日志记录

首先，我们加载 MNIST 数据集，归一化数据并编写一个函数来创建一个用于将图像分成 10 类的简单 Keras 模型。

mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

def create_model():
  return tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
  ])

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step

瞬时批次级日志记录

以瞬时方式在批次级别记录指标可以向我们展示在每个周期内进行训练时批次间的波动程度，这对于调试而言非常有用。

将摘要编写器设置到其他日志目录：

log_dir = 'logs/batch_level/' + datetime.now().strftime("%Y%m%d-%H%M%S") + '/train'
train_writer = tf.summary.create_file_writer(log_dir)

要启用批次级日志记录，应通过重写模型类定义中的 train_step() 来定义自定义 tf.summary 指标，并将其包含在摘要编写器上下文中。这可以简单地组合成子类化模型定义，也可以扩展以编辑我们之前的函数式 API 模型，如下所示：

class MyModel(tf.keras.Model):
  def __init__(self, model):
    super().__init__()
    self.model = model

  def train_step(self, data):
    x, y = data
    with tf.GradientTape() as tape:
      y_pred = self.model(x, training=True)
      loss = self.compiled_loss(y, y_pred)
      mse = tf.keras.losses.mean_squared_error(y, K.max(y_pred, axis=-1))
    self.optimizer.minimize(loss, self.trainable_variables, tape=tape)
    with train_writer.as_default(step=self._train_counter):
      tf.summary.scalar('batch_loss', loss)
      tf.summary.scalar('batch_mse', mse)
    return self.compute_metrics(x, y, y_pred, None)

  def call(self, x):
    x = self.model(x)
    return x

# Adds custom batch-level metrics to our previous Functional API model
model = MyModel(create_model())
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

定义我们的 TensorBoard 回调以将周期级和批次级指标记录到我们的日志目录中，并使用我们选择的 batch_size 调用 model.fit()：

tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir)

model.fit(x=x_train, 
          y=y_train,
          epochs=5,
          batch_size=500, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])

Epoch 1/5
120/120 [==============================] - 5s 36ms/step - loss: 0.4379 - accuracy: 0.8788 - val_loss: 0.2041 - val_accuracy: 0.9430
Epoch 2/5
120/120 [==============================] - 4s 31ms/step - loss: 0.1875 - accuracy: 0.9471 - val_loss: 0.1462 - val_accuracy: 0.9591
Epoch 3/5
120/120 [==============================] - 3s 27ms/step - loss: 0.1355 - accuracy: 0.9613 - val_loss: 0.1170 - val_accuracy: 0.9670
Epoch 4/5
120/120 [==============================] - 3s 27ms/step - loss: 0.1058 - accuracy: 0.9694 - val_loss: 0.0954 - val_accuracy: 0.9723
Epoch 5/5
120/120 [==============================] - 3s 27ms/step - loss: 0.0872 - accuracy: 0.9752 - val_loss: 0.0843 - val_accuracy: 0.9749
<keras.callbacks.History at 0x7fce165a2fd0>

以新的日志目录打开 TensorBoard 并查看周期级和批次级指标：

%tensorboard --logdir logs/batch_level

累积批次级日志记录

批次级日志记录也可累积式实现，对每个批次的指标与之前批次的指标求平均值，并在记录批次级指标时生成更加平滑的训练曲线。

将摘要编写器设置到其他日志目录：

log_dir = 'logs/batch_avg/' + datetime.now().strftime("%Y%m%d-%H%M%S") + '/train'
train_writer = tf.summary.create_file_writer(log_dir)

创建可以按批次记录的有状态指标：

batch_loss = tf.keras.metrics.Mean('batch_loss', dtype=tf.float32)
batch_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('batch_accuracy')

同样，请在被重写的 train_step 方法中添加自定义 tf.summary 指标。要使批次级日志记录成为累积式，请使用我们定义的有状态指标基于每个训练步骤的数据计算累积结果。

class MyModel(tf.keras.Model):
  def __init__(self, model):
    super().__init__()
    self.model = model

  def train_step(self, data):
    x, y = data
    with tf.GradientTape() as tape:
      y_pred = self.model(x, training=True)
      loss = self.compiled_loss(y, y_pred)
    self.optimizer.minimize(loss, self.trainable_variables, tape=tape)
    batch_loss(loss)
    batch_accuracy(y, y_pred)
    with train_writer.as_default(step=self._train_counter):
      tf.summary.scalar('batch_loss', batch_loss.result())
      tf.summary.scalar('batch_accuracy', batch_accuracy.result())
    return self.compute_metrics(x, y, y_pred, None)

  def call(self, x):
    x = self.model(x)
    return x

# Adds custom batch-level metrics to our previous Functional API model
model = MyModel(create_model())
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

同样，定义我们的 TensorBoard 回调并使用我们选择的 batch_size 调用 model.fit()：

tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir)

model.fit(x=x_train, 
          y=y_train,
          epochs=5,
          batch_size=500, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])

Epoch 1/5
120/120 [==============================] - 4s 27ms/step - loss: 0.4266 - accuracy: 0.8813 - val_loss: 0.2055 - val_accuracy: 0.9415
Epoch 2/5
120/120 [==============================] - 3s 26ms/step - loss: 0.1864 - accuracy: 0.9476 - val_loss: 0.1417 - val_accuracy: 0.9613
Epoch 3/5
120/120 [==============================] - 3s 27ms/step - loss: 0.1352 - accuracy: 0.9614 - val_loss: 0.1148 - val_accuracy: 0.9665
Epoch 4/5
120/120 [==============================] - 3s 26ms/step - loss: 0.1066 - accuracy: 0.9702 - val_loss: 0.0932 - val_accuracy: 0.9716
Epoch 5/5
120/120 [==============================] - 3s 27ms/step - loss: 0.0859 - accuracy: 0.9749 - val_loss: 0.0844 - val_accuracy: 0.9754
<keras.callbacks.History at 0x7fce15c39f50>

以新的日志目录打开 TensorBoard 并查看周期级和批次级指标：

%tensorboard --logdir logs/batch_avg

就是这样！您现已知道如何在 TensorBoard 中为各种用例创建自定义训练指标了。