使用keras处理深度学习中的回归问题——波士顿房价预测

简介

---

与以往解决分类问题不同，它输出的是一些离散的值，本例解决的是回归问题，输出的是连续的值。

本例将用于预测上个世纪70年代中期波士顿郊区房屋价格的中位数。

已知当时的一些数据点，如犯罪率、房地产税等。

注意，本例中包含的数据点较少，只有506个，分为404个训练样本和102个测试样本。且输入数据的每个特征都有不同的取值范围。

有些特征是比率，取值范围为0-1，有些特征是取值为1-12，还有些特征取值为0-100等。

下面开始。

加载数据

---

该数据集内置为keras，直接加载即可：

from keras.datasets import boston_housing

# 我已经下载好数据了，直接加载
path = r"E:\practice\tf2\boston_house_price\boston_housing.npz"
(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data(path) # 使用不带参数的load_data会从网络上下载数据

查看数据：

数据预处理

---

将取值范围差别很大的数据，直接输入网络是有问题的。

网络可能会自动适应这些数据，但学习会变得更加困难。

对于这样的样本，通常的做法是对每个特征进行标准化，即对样本的每个特征，减去平均值，再除以标准差，这样得到的特征平均值为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

注意，测试数据直接使用了训练数据的结果，因为这只是个demo，且它们的值相同。

但在实际的工作流程中，不能使用任何在训练数据集中得到的任何结果，即使像这样明显相同的值。

构建网络

---

这里使用2个隐藏层，每层有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

可以看到，网络的最后一层只有一个单元，没有激活，这是个线性层，这是标量回归的典型设置。它会预测任意范围内的值。

添加激活函数将会限制输出范围，比如添加signoid激活函数，网络只能学会预测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个验证分数的平均值。

代码如下：

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)
	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)
	
	model = build_model()
	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)

过程如下：

每次运行模型得到的验证分数有很大差异。平均分数是比单一分数更可靠的指标，这就是k折验证的关键。

查看分数：

在这个例子中，预测房价与实际价格平均相差2550元（我这个训练出来的效果比书上的好，书上的近3000元），考虑到房价实际价格，这个差别还是比较大的。

那么，我们可以把训练时间更长一点，达到500轮次：

num_epochs = 500
all_mae_histories = []

for i in range(k):
	print('processing fold #', i)
	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)
	
	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()) # 查看所有的key，输出：dict_keys(['loss', 'mae', 'val_loss', 'val_mae'])
	mae_history = history.history['val_mae'] # 书中此处的key为val_mean_absolute_error，会报错
	all_mae_histories.append(mae_history)
	
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_targets)

最终结果如下：

可见，该模型在测试集上的表现，是与真实房价相差2660元，还不如第一次得到的模型。这也再次证明了，当数据量较小时，对训练出的模型的效果进行验证是相当困难的。越是细小的差别，越难得到准确验证。

小结

---

• 回归问题常用的损失函数是均方误差MSE
• 回归问题常用的评估指标是平均绝对误差MAE
• 如果输入数据特征具有不同的取值范围，应先进行预处理，对每个特征进行单独缩放
• 如果可用的数据量很少，可以使用k折验证以可靠地评估模型
• 如果可用的训练数量很少，可以使用隐藏层数较少的网络（通常1-2个隐藏层），以避免严重的过拟合

参考资料

---

《Python深度学习》