预测房价：回归问题

本文章参考《python深度学习》

预测房价：回归问题

回归问题预测一个连续值而不是离散的标签，例如，根据气象数据预测明天的气温，或者根据软件说明书预测完成软件项目所需要的时间。

注意：不要将回归问题与logistic回归算法混为一谈；logistic回归不是回归算法，而是分类算法

波士顿房价数据集

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

加载数据

from keras.datasets import boston_housing

(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()
print(train_data[0])
print(train_data.shape)  # (404, 13)
print(test_data.shape)  # (102, 13)

print(train_targets[:10])
print(train_targets.shape)  # (404,)
print(test_targets.shape)  # (102,)

# 输出如下：
[1.23247    0.    8.14    0.    0.538    6.142    91.7    3.9769    4.    307.    21.    396.9    18.72]
(404, 13)
(102, 13)
[15.2 42.3 50.  21.1 17.7 18.5 11.3 15.6 15.6 14.4]
(404,)
(102,)

如你所见，我们有 404 个训练样本和 102 个测试样本，每个样本都有 13 个数值特征，比如人均犯罪率、每个住宅的平均房间数、高速公路可达性等。目标是房屋价格的中位数，单位是千美元。

准备数据

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

标准差（Standard Deviation），标准差是方差的算术平方根。标准差能反映一个数据集的离散程度。平均数相同的两组数据，标准差未必相同。

# 数据标准化，减去平均值再除以标准差
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折验证来验证你的方法

为了在调节网络参数（比如训练的轮数）的同时对网络进行评估，你可以将数据划分为训练集和验证集。但由于数据点很少，验证集会非常小（比如大约 100 个样本）。因此，验证分数可能会有很大波动，这取决于你所选择的验证集和训练集。也就是说，验证集的划分方式可能会造成验证分数上有很大的方差，这样就无法对模型进行可靠的评估。在这种情况下，最佳做法是使用 K 折交叉验证。这种方法将可用数据划分为 K 个分区（K 通常取 4 或 5），实例化 K 个相同的模型，将每个模型在 K-1 个分区上训练，并在剩下的一个分区上进行评估。模型的验证分数等于 K 个验证分数的平均值。

#  K折交叉验证
def k_cross_validation():
    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]

        # 准备训练数据，其他所有分区的数据
        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)
        model.fit(partial_train_data, partial_train_targets, epochs=num_epochs, batch_size=1, verbose=0)
        val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
        all_scores.append(val_mae)

    print(all_scores)
    print(np.mean(all_scores))

设置num_epochs=100,训练结果如下：

1 2	[2.0074284076690674, 2.353276491165161, 2.722170114517212, 2.6431825160980225] 2.4315143823623657

每次运行模型得到的验证分数有很大差异，从 2.0 到 2.7 不等。平均分数（2.4）是比单一分数更可靠的指标——这就是 K 折交叉验证的关键。

我这里的测试结果比书上效果好一些

在这个例子中，预测的房价与实际价格平均相差 2400 美元，考虑到实际价格范围在 10 000~50 000 美元，这一差别还是很大的。我们让训练时间更长一点，达到 500 个轮次。为了记录模型在每轮的表现，我们需要修改训练循环，以保存每轮的验证分数记录。

上面调用fit方法时没有传入验证集，下面的方法与上面的区别就是这个

def k_cross_validation_new():
    k = 4
    num_val_samples = len(train_data) // k
    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()
        # 保存每折的验证结果
        history = model.fit(partial_train_data, partial_train_targets, validation_data=(val_data, val_targets), epochs=num_epochs, batch_size=1, verbose=0)
        print(history.history.keys())
        mae_history = history.history['val_mae']
        all_mae_histories.append(mae_history)

这里打印了history的key，输出为dict_keys(['val_loss', 'val_mae', 'loss', 'mae']),并没有val_mean_absolute_error，所以这里改成了val_mae。

这里每折训练完成后，得到的mae_history是一个长度为500的列表，所以4折训练结束后，all_mae_histories是一个4x500的二维数组。

然后你可以计算每个轮次中所有折 MAE 的平均值

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

将验证误差绘制成图形：

import matplotlib.pyplot as plt

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

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

1、删除前 10 个数据点，因为它们的取值范围与曲线上的其他点不同。

2、将每个数据点替换为前面数据点的指数移动平均值，以得到光滑的曲线。


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

# 这两行代码实际在k_cross_validation_new方法内部
smooth_mae_history = smooth_curve(average_mae_history[10:])
plt_plot(smooth_mae_history)

从图中可以看出，验证 MAE 在 60 轮(图上是50，再加上去掉的前10个点，这里与书上的结果80不一致)后不再显著降低，之后就开始过拟合。

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

训练最终模型

model = build_model()
model.fit(train_data, train_targets, epochs=60, batch_size=16, verbose=0)
test_mse_score, test_mae_score = model.evaluate(test_data, test_targets)
print(test_mae_score)

这里设置60轮训练完成后，得到的误差是2.593416690826416(而且貌似每次执行结果都有一些差距)

总之预测的房价还是和实际价格相差约2590美元。

总结

下面是你应该从这个例子中学到的要点。

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