3.6 房价预测：线性回归

前面两个例子都可以看成是分类问题，它的目标是预测某个输入数据点的单个离散label。常见的另外一类机器学习问题是线性回归，其预测的是一个连续值，而不是离散label。比如，根据气象信息预测明天的气温；根据软件项目计划书预测实现时间。

注意：不要混淆线性回归和逻辑回归算法。逻辑回归不是回归算法，而是分类算法。

3.6.1 波士顿房价数据集

波士顿房价数据集是1970年代中期波士顿郊区的数据样本，包含犯罪率、不动产税税率等。你将用该数据集预测当地房价的中间价。波士顿房价数据集与前面两个例子都不太一样，数据样本点相当少：只有506个，其中404个作为训练样本和102个测试样本。输入数据的每个特征都有不同的scale。例如，一些比例值，取值范围在0和1之间；另一些取值在1到12之间；还有些取值在0到100之间，等等。

#Listing 3.24 Loading the Boston housing dataset
from keras.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个数值型特征，比如犯罪率，每个住处的房屋平均数量，高速可达性，等等。

target是自住房屋的中间价，单位为千美元：

>>> train_targets
[ 15.2, 42.3, 50. ... 19.4, 19.4, 29.1]

房价普遍在$10000和$50000之间。价格看起来便宜，但是要记住这是1970年代中期。

3.6.2 准备数据

把不同取值范围的变量值赋给神经网络会出现问题。虽然神经网络会自适应各种各样的数据，但是这会造成模型学习的过程变得困难。一个广泛使用的最佳实践是对此类数据集特征进行归一化：对输入数据的每个特征（输入矩阵的一个列），减去该特征的均值并除以标准方差，这样每个特征的均值为0、均方差为1。

#Listing 3.25 Normalizing the data
mean = train_data.mean(axis=0)
train_data -= mean
std = train_data.std(axis=0)
train_data /= std
test_data -= mean
test_data /= std

注意，测试集的归一化使用的是训练集的均值和均方差。一般来说，你不用对测试集数据进行数量计算，即使是简单的数据归一化。

3.6.3 构建神经网络

由于这个例子中的样本量比较少，所以选用两个隐藏单元为64的hidden layer的神经网络。一般来说，训练数据集越小，过拟合的情况越糟糕。这里使用小规模神经网络以减轻过拟合。

#Listing 3.26 Model definition
from keras import models
from keras import layers

def build_model():
'''
Because you’ll need to instantiate
the same model multiple times, you
use a function to construct it.
'''
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(train_data.shape[1],)))
model.add(layers.Dense(64, activation='rely'))
model.add(layers.Dense(1))
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
return model

上面的神经网络以单元大小为1且不带激活函数的Dense layer为结束，意味着这是标量回归（线性回归）。应用激活函数可以限制输出结果的取值范围，比如，如果你在最后一个layer应用sigmoid激活函数，神经网络只会学习0到1之间的预测值。本例中最后一个layer是纯线性的，神经网络学习任意取值范围的预测值。

神经网络模型编译使用的mse损失函数：均方误差（mean squared error）。其损失函数广泛应用在回归问题当中。

你也可以在模型训练中使用平均绝对误差MAE（mean absolute error）。它监测的是预测值和目标值差值的绝对值，比如，MAE为0.5意味着你的预测值偏离均值$500。

3.6.4 使用K-fold验证模型

为了评估神经网络模型的同时调整网络模型超参（比如模型训练的epoch数量），你可以将数据集分割成训练集和验证集。但是由于数据样本点太少，所以验证集数量也非常少（比如，大约100个样本）。这会导致验证集上的分数更多的依赖于你选择哪部分数据作为验证集哪部分数据作为训练集：可能因为分割到验证集的数据点不同而产生较高的variance。这会影响模型评估的真实性。

解决上面问题的最佳方法是使用K-fold交叉验证，见图3.11。它将数据样本点分割为K个partition（一般K=4或者5），实例化K个相同的模型，分别在K-1个partition数据集训练每个模型并在余下的partition数据集上进行评估。然后将得到的K个模型的验证集上的分数求平均。下面的代码看起来更直白。

image

图3.11 3-fold交叉验证

#Listing 3.27 K-fold validation
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)
    '''
    Prepares the validation data: data from partition #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]

    '''
    Prepares the training data: data from all other partitions
    '''
    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)

    '''
    Builds the Keras model (already compiled)
    '''
    model = build_model()
    '''
    Trains the model (in silent mode, verbose = 0)
    '''
    model.fit(partial_train_data, partial_train_targets, epochs=num_epochs,
              batch_size=1, verbose=0)
    '''
    Evaluates the model on the validation data
    '''
    val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
    all_scores.append(val_mae)

设置num_epochs = 100，运行得到如下的结果：

>>> all_scores
[2.588258957792037, 3.1289568449719116, 3.1856116051248984, 3.0763342615401386]
>>> np.mean(all_scores)
2.9947904173572462

每次运行的确得到不同的验证分数，从2.6到3.2。平均值为3.0，这比任意单个分数都要稳定，这也是K-fold交叉验证的价值所在。在本例中，偏离平均的大小为$3000，这明显对于$10000到$50000范围的价格还是可以的。

下面将神经网络模型训练epoch设为500。修改迭代训练的代码保存每个epoch的验证分数：

#Listing 3.28 Saving the validation logs at each fold
num_epochs = 500
all_mae_histories = []

for i in range(k):
    print('processing fold #', i)
    '''
    Prepares the validation data: data from partition #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]

    '''
    Prepares the training data: data from all other partitions
    '''
    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)

    '''
    Builds the Keras model (already compiled)
    '''
    model = build_model()
    '''
    Trains the model (in silent mode, verbose = 0)
    '''
    history = model.fit(partial_train_data, partial_train_targets,
                        epochs=num_epochs,
                        validation_data=(val_data, val_targets),
                        batch_size=1, verbose=0)
    mae_history = history.history['val_mean_absolute_error']
    all_mae_histories.append(mae_history)

接下来计算每个epoch的K个fold所对应的MAE的平均值：

#Listing 3.29 Building the history of successive mean K-fold validation scores
average_mae_history = [
    np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)]

下面绘制验证分数图表，见3.12。

#Listing 3.30 Plotting validation scores
import matplotlib.pyplot as pet

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

image

图3.12 每个epoch验证集MAE的趋势图

看上面的图表可能有点困难，因为数量级的问题和相当高的variance。下面对其进行处理：

• 忽略前十个数据点，因为它们与曲线上剩余的值不在同一个量级上；
• 用每个数据点的指数滑动平均值代替原数据点，来平滑曲线

对应的结果见图3.13。

#Listing 3.31 Plotting validation scores, excluding the first 10 data points

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()

image

图3.13 每个epoch验证集MAE的趋势图（排除前十个数据点）

根据上面的图表可以看出，验证集的MAE在80个epoch之后没有什么显著的提升。意味着该点之后模型开始过拟合。

一旦你完成模型其它参数的调优（除了epoch数量，你可以调整hidden layer的隐藏单元数量），你可以用最佳的参数在所有训练集上训练最终的生产上使用的模型，然后看下该模型在测试集上的效果。

#Listing 3.32 Training the final model

#Gets a fresh, compiled model
model = build_model()

#Trains it on the entirety of the data
model.fit(train_data, train_targets,
          epochs=80, batch_size=16, verbose=0)
test_mse_score, test_mae_score = model.evaluate(test_data, test_targets)

最终结果如下：

>>> test_mae_score
2.5532484335057877

最后得到的结果偏离平均为$2550。

3.6.5 小结

从本例你应该学到以下知识点：

• 回归模型的损失函数与分类问题的不同，常用均方差损失函数（MSE）
• 相应的，常用的回归模型指标是平均绝对误差（MAE），确切地说，回归模型没有准确度的概念
• 输入数据的取值范围不同时，应该在数据预处理阶段将每个特征进行归一化
• 当数据样本太少时，可以使用K-fold交叉验证稳定的评估一个模型
• 当训练集数据比较少时，倾向于使用小规模神经网络（一般是一到两个隐藏层），避免过拟合

未完待续。。。

Enjoy!

翻译本书系列的初衷是，觉得其中把深度学习讲解的通俗易懂。不光有实例，也包含作者多年实践对深度学习概念、原理的深度理解。最后说不重要的一点，François Chollet是Keras作者。
声明本资料仅供个人学习交流、研究，禁止用于其他目的。如果喜欢，请购买英文原版。

侠天，专注于大数据、机器学习和数学相关的内容，并有个人公众号分享相关技术文章。

若发现以上文章有任何不妥，请联系我。