本节将要预测 20 世纪 70 年代中期波士顿郊区房屋价格的中位数，已知当时郊区的一些数据点，比如犯罪率、当地房产税率等。本节用到的数据集与前面两个例子有一个有趣的区别。它包含的数据点相对较少，只有 506 个，分为 404 个训练样本和 102 个测试样本。输入数据的每个特征（比如犯罪率）都有不同的取值范围。例如，有些特性是比例，取值范围为 0~1；有的取值范围为 1~12；还有的取值范围为 0~100，等等。

1. 加载数据集

  1. from keras.datasets import boston_housing
  3. (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()
  • 如你所见，我们有 404 个训练样本和 102 个测试样本，每个样本都有 13 个数值特征，比如
    人均犯罪率、每个住宅的平均房间数、高速公路可达性等。
  • 目标是房屋价格的中位数，单位是千美元。

2. 准备数据

将取值范围差异很大的数据输入到神经网络中，这是有问题的。网络可能会自动适应这种 取值范围不同的数据，但学习肯定变得更加困难。

对于这种数据，普遍采用的最佳实践是对每个特征做标准化，即对于输入数据的每个特征（输入数据矩阵中的列），减去特征平均值，再除以标准差，这样得到的特征平均值为 0，标准差为 1。

  1. # 数据标准化
  2. mean = train_data.mean(axis=0)
  3. train_data -= mean
  4. std = train_data.std(axis=0)
  5. train_data /= std
  7. test_data -= mean
  8. test_data /= std

注意，用于测试数据标准化的均值和标准差都是在训练数据上计算得到的。在工作流程中，你不能使用在测试数据上计算得到的任何结果，即使是像数据标准化这么简单的事情也不行。

3. 构建网络

一般来说，训练数据越少，过拟合会越严重，而较小的网络可以降低过拟合。

由于样本数量很少，我们将使用一个非常小的网络，其中包含两个隐藏层，每层有 64 个单元。

  1. from keras import models, layers, losses, metrics, optimizers
  3. def build_model() -> models.Sequential:
  4.     model = models.Sequential()
  5.     model.add(layers.Dense(64, activation='relu'))
  6.     model.add(layers.Dense(64, activation='relu'))
  7.     model.add(layers.Dense(1))
  9.     model.compile(optimizer='rmsprop',
  10.                   loss='mse',
  11.                   metrics=['mae'])
  12.     return model

网络的最后一层只有一个单元，没有激活，是一个线性层。这是标量回归（标量回归是预测单一连续值的回归）的典型设置。添加激活函数将会限制输出范围。例如，如果向最后一层添加 sigmoid 激活函数，网络只能学会预测 0~1 范围内的值。这里最后一层是纯线性的，所以网络可以学会预测任意范围内的值。

  • 编译网络用的是 mse 损失函数，即均方误差（ MSE， mean squared error），预测值与
    目标值之差的平方。这是回归问题常用的损失函数。
  • 在训练过程中还监控一个新指标： 平均绝对误差（ MAE， mean absolute error）。它是预测值
    与目标值之差的绝对值。比如，如果这个问题的 MAE 等于 0.5，就表示你预测的房价与实际价
    格平均相差 500 美元。

4. 模型训练并数据验证

由于数据点很少，验证集会非常小 ，验证集的划分方式可能会造成验证分数上有很大的方差，这样就无法对模型进行可靠的评估 。

在这种情况下，最佳做法是使用 K 折交叉验证

这种方法将可用数据划分为 K个分区（ K 通常取 4 或 5），实例化 K 个相同的模型，将每个模型在 K-1 个分区上训练，并在剩下的一个分区上进行评估。模型的验证分数等于 K 个验证分数的平均值。

Keras 实现 “波士顿房价数据集” 的房价预测（简单回归问题） - 图1

  1. # K-折验证
  3. K = 4
  4. num_val_samples = len(train_data)  // K  # 每个分区的样本数
  5. num_epochs = 100  # epoch 轮数
  6. all_scores = []  # 保存中间过程中验证集的MAE得分
  8. for i in range(K):
  9.     print('Processing fold #', i)
  10.     val_begin = i * num_val_samples  # 验证区的开启索引
  11.     val_end = (i + 1) * num_val_samples  # 验证区的结束索引
  12.     val_data = train_data[val_begin: val_end]  # 切割出的验证集
  13.     val_targets = train_targets[val_begin: val_end]
  15.     partial_train_data = np.concatenate(
  16.         [ train_data[: val_begin], train_data[val_end:] ],
  17.         axis=0
  18.     )
  19.     partial_train_targets = np.concatenate(
  20.         [ train_targets[: val_begin], train_targets[val_end:] ],
  21.         axis=0
  22.     )
  24.     model = build_model()
  25.     model.fit(partial_train_data, partial_train_targets,
  26.               epochs=num_epochs, batch_size=1, verbose=0)
  27.     val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)  # 在验证数据上评估模型
  28.     all_scores.append(val_mae)
  • fit 中的 verbose 参数表示日志显示：
    • = 0：不在标准输出流中输出日志信息
    • = 1：输出进度条记录（默认）
    • = 2：为每个 epoch 输出一条记录

完成训练后，查看 MAE 得分：

Keras 实现 “波士顿房价数据集” 的房价预测（简单回归问题） - 图2

每次运行模型得到的验证分数有很大差异，从 2.6 到 3.2 不等。平均分数（ 3.0）是比单一分数更可靠的指标——这就是 K 折交叉验证的关键。在这个例子中，预测的房价与实际价格平均相差 3000 美元，考虑到实际价格范围在 10 000~50 000 美元，这一差别还是很大的。

我们让训练时间更长一点，达到 500 个轮次以观察效果：

  1. >>> all_mae_histories

然后就可以看到每个轮次中所有折 MAE 的平均值：

  1. average_mae_histories = [
  2.      np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)
  3. ]

画图如下：

  1. %matplotlib inline
  2. import matplotlib.pyplot as plt
  4. plt.plot(range(1, len(average_mae_histories) + 1), average_mae_histories)
  5. plt.xlabel('Epochs')
  6. plt.ylabel('Validation MAE')
  7. plt.show()

Keras 实现 “波士顿房价数据集” 的房价预测（简单回归问题） - 图3

因为纵轴的范围较大，且数据方差相对较大，所以难以看清这张图的规律。我们来重新绘
制一张图。

  • 删除前 10 个数据点，因为它们的取值范围与曲线上的其他点不同。
  • 将每个数据点替换为前面数据点的指数移动平均值，以得到光滑的曲线。
  1. def smooth_curve(points, factor=0.9):
  2.     smoothed_points = []
  3.     for point in points:
  4.         if smoothed_points:
  5.             previous = smoothed_points[-1]
  6.             smoothed_points.append(previous * factor + point * (1 - factor))
  7.         else:
  8.             smoothed_points.append(point)
  9.     return smoothed_points
  11. smooth_mae_history = smooth_curve(average_mae_history[10:])
  13. plt.plot(range(1, len(smooth_mae_history) + 1), smooth_mae_history)
  14. plt.xlabel('Epochs')
  15. plt.ylabel('Validation MAE')
  16. plt.show()

Keras 实现 “波士顿房价数据集” 的房价预测（简单回归问题） - 图4

验证 MAE 在 80 轮后不再显著降低，之后就开始过拟合。

完成模型调参之后（除了轮数，还可以调节隐藏层大小），你可以使用最佳参数在所有训练数据上训练最终的生产模型，然后观察模型在测试集上的性能。

  1. model = build_model()
  2. model.fit(train_data, train_targets,
  3.           epochs=80,
  4.           batch_size=16,
  5.           verbose=1)
  6. test_mse_score, test_mae_score  = model.evaluate(test_data, test_targets)

最终结果如下：

  1. >>> test_mae_score
  2. 2.9359490871429443

最终预测的房价还是和实际价格相差约 2550 美元。

小结

  • 回归问题使用的损失函数与分类问题不同。回归常用的损失函数是均方误差（ MSE）。
  • 回归问题使用的评估指标也与分类问题不同。显而易见，精度的概念不适用于回归问题。常见的回归指标是平均绝对误差（ MAE）
  • 如果输入数据的特征具有不同的取值范围，应该先进行预处理，对每个特征单独进行缩放。
  • 如果可用的数据很少，使用 K 折验证可以可靠地评估模型。
  • 如果可用的训练数据很少，最好使用隐藏层较少（通常只有一到两个）的小型网络，以避免严重的过拟合