10.预测房价：回归问题

预测房价：回归问题

前面两个例子都是分类问题，目标是预测输入数据点所对应的单一离散的标签。另一种常见的机器学习问题是回归问题，它预测一个连续值而不是离散的标签，例如，根据气象数据预测明天的气温，或者根据软件说明书预测完成软件项目所需要的时间。（不要将回归问题与logistic回归算法混为一谈。logistic回归不是回归算法，而是分类算法。）

波士顿房价数据集

本次要预测20世纪70年代中期波士顿郊区房屋价格的中位数，已知当时教区的一些数据点，比如犯罪率、当地房产税率等。本次应到的数据集包含的数据点相对较少，只有506个，分为404个训练样本和102个测试样本。输入数据的每个特征都有不同的取值范围。

from kears.datasets import boston_housing

(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()

>>> train_data.shape
(404, 13)
>>> test_data.shape
(102, 13)

由此可见，有404个训练样本和102个测试样本，每个样本都有13个数值特征。

准备数据

将取值范围差异很大的数据输入到神经网络，这是错误的。网络可能会自动适应这种取值范围不同的数据，但学习肯定会变得更加困难。对于这种数据，普遍采用的最佳实践是对每个特征做标准化即对于输入数据的每个特征（输入矩阵中的列），减去特征平均值，再除以标准差，这样得到特征平均值为0，标准差为1。用Numpy可以很容易实现标准化。

mean = train_data.mean(axis=0)
train_data -= mean
std = train_data.std(axis=0)
train_data /= std

test_data -= mean
test_data /= std

注意：用于测试数据的标准化的均值和标准差都是再训练数据上计算得到的。在工作流程中，你不能使用在测试数据上计算的任何结果。

构建网络

由于样本数量很少，我们将使用一个非常小的网络，其中包含两个隐藏层，每层有64个单元。一般来说，训练数据越少，过拟合会越严重，而较小的网络可以降低过拟合。

from keras import models
from keras import layers

def build_model():
    model = models.Sequential()
    model.add(layers.Dense(64, activation='relu', input_shape=(train_data.shape[1],)))
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(1))
    model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
    return model

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

编译网络用的是mse损失函数，即均方误差（MSE，mean squared error)，预测值与目标值只差的平方。这是回归问题常用的损失函数。

在训练过程中还监控一个新指标：平均绝对误差（MAE，mean absolute error）。它是预测值与目标值之差的绝对值。比如，如果这个问题的MAE等于0.5，就表示你预测的房价与实际价格相差500美元。

利用 K折验证来验证你的方法

为了在调节网络参数（比如训练的轮次）的同时对网络进行评估，你可以将数据划分为训练集和验证集。但由于数据点很少，验证集会非常小。因此，验证分数可能会有很大的波动，这取决于所选择的验证集和训练集。也就是说，验证集的划分方式会造成验证分数上有很大的方差，这样就无法对模型进行可靠的评估。

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

这种方法代码如下：

import numpy as np

k = 4
num_val_samples = len(train_data) // k
num_epochs = 100
all_scores = []

for i in range(k):
    print('processing fold #', i)
    # 准备验证数据：第k个分区的数据。
    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]
    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]
    
    # concatenate函数用于沿指定轴连接相同形状的两个或多个数组
    # 准备训练数据：即其他所有分区的数据
    partial_train_data = np.concatenate(
        [train_data[:i * num_val_samples],
         train_data[(i + 1) * num_val_samples:]],
         axis=0)
    partial_train_targets = np.concatenate(
        [train_targets[:i * num_val_samples],
         train_targets[(i + 1) * num_val_samples:]],
        axis=0)
    
    model = build_model()
    # 训练模型（静默模式，verbose=0）
    model.fit(partial_train_data, partial_train_targets,
              epochs=num_epchs, batch_size=1, verbose=0)
    # 在验证数据上评估模型
    val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
    all_scores.append(val_mae)

运行结果如下：

>>> all_scores
[2.0759224891662598, 2.5367202758789062, 2.5614423751831055, 2.4778478145599365]
>>> np.mean(all_scores)
2.412983238697052

我们让训练时间更长，将轮次设为500。为了记录模型在每轮的表现，需要保存每轮的验证分数记录。

num_epochs = 500
all_mae_histories = []
for i in range(k):
	print('processing fold #', i)
    # 准备验证数据，即第k个分区的数据
    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]
    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]
    
    # 准备训练数据，即其他分区的数据
    partial_train_data = np.concatenate(
    	[train_data[:i * num_val_samples],
         train_data[(i + 1) * num_val_samples:]],
    	axis=0)
    
    partial_train_targets = np.concatenate(
    	[train_targets[:i * num_val_samples],
         train_targets[(i + 1) * num_val_samples:]],
    	axis=0)
    
    # 构建Keras模型
    model = build_model()
    # 训练模型（静默模式，verbose=0）
    history = model.fit(partial_train_data, partial_train_targets,
                        validation_data=(val_data, val_targets),
                        epochs=num_epochs, batch_size=1, verbose=0)
    mae_history = history.history['val_mae']
    all_mae_histories.append(mae_history)

由此可以计算每个轮次中所有折MAE的平均值

average_mae_history = [
	np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)
]

画图

import matplotlib.pyplot as plt

plt.plot(range(1, len(average_mae_history) + 1), average_mae_history)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

因为纵轴的范围较大，且数据方差相对较大，所以难以看出图形的规律。以以下方法绘制一张图：

• 删除前10个数据点，因为他们的取值范围与曲线上的其他点不同。
• 将每个数据点替换为前面数据点的指数移动平均值，以得到光滑的曲线。

def smooth_curve(points, factor=0.9):
    smoothed_points = []
    for point in points:
        if smoothed_points:
            previous = smoothed_points[-1]
            smoothed_points.append(previous * factor + point * (1 - factor))
        else:
			smoothed_points.append(point)
    return smoothed_points

smooth_mae_history = smooth_curve(average_mae_history[10:])

plt.plot(range(1, len(smooth_mae_history) + 1), smooth_mae_history)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

有图可以看出，验证MAE在80轮后不再显著降低，之后就开始过拟合。

完成模型调参之后，可以使用最佳参数在所有训练数据上训练最终的生产模型，然后观察模型在训练集上的性能。

model = build_model()
# 一个全新的编译好的模型
model.fit(train_data, train_targets,
          epochs=80, batch_size=16, verbose=0)
# 在所有训练数据上训练模型
test_mse_score, test_mae_score = model.evaluate(test_data, test_tragets)

>>> test_mae_score
2.7902472019195557

预测的房价和实际价格相差2550美元。

小结

• 回归问题使用的损失函数与分类问题不同。回归常用的损失函数是均方误差（MSE）。
• 同样，回归问题使用的评估指标也与分类问题不同。显而易见，精度的概念不适用于回归问题。常见的回归指标是平均绝对误差（MAE）。
• 如果输入数据的特征值具有不同的取值范围，应该先进行预处理，对某个特折单独进行缩放。
• 如果可用的数据很少，使用 K折验证可以可靠地评估模型。

预测的房价和实际价格相差2550美元。

小结

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