三、【keras实战】波士顿房价预测

系列文章：
一、搭建属于你的第一个神经网络
二、训练完的网络去哪里找

---

之前mnist的例子是一个分类问题，今天来讲的是回归问题，所谓回归就是根据过去的点来拟合曲线，然后根据曲线来预测以后的值。

from keras.datasets import boston_housing
(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()

这个数据集和之前的mnist不同，只有506个数据，而且每一个特征的取值范围也不尽相同。

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

我们可以看到训练数据包含404个点，每个数据点包含13个特征。
这十三个特征包括：
1.人均犯罪率
2.在25000平方英尺上住房的比例
3.每个镇上平均的非零售企业比例
4.Charles River dummy variable（= 1 if tract bounds river; 0 otherwise)）
5.一氧化氮的浓度，单位是千万分之一
6.每个住所的平均房间数
7.1940年以前自己修的建筑比例
8.波士顿五个就业中心的加权距离
9.径向公路适应性指标
10.每10000的税率的完全价值
11.镇上的学生-老师比例
12.其中Bk是黑人比例
13.低地位人口比例
而标签则是有房子人的房价的中位数。

数据准备

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

有必要解释一下axis，这个代表的是运算的方向，我们的train_data是两个维度的，为(404,13)，由于python从0开始计数，axis=0的意思就是考虑404这个维度上的数据，这里mean就是求这404个数据的均值，std则求这404个数据的标准差，然后剩下的就是减去均值除以标准差，这个过程叫做归一化，属于正则化的一种，目的是防止不收敛，这个之前提到过。

搭建网络

由于数据量小，我们搭建的网络的量级也小，才能够防止过拟合

from keras import models
from keras import layers
def build_model():
  # Because we will need to instantiate
  # the same model multiple time,
  # we 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='relu'))
  model.add(layers.Dense(1))
  model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
  return model

由于我们要实例化教学，这个模型将会用很多次，所以这里定义成一个函数来调用。
在这里有三点需要说明：

• 最后一次直接输出了一个值，这样就能够预测任意范围的值了，如果调用了什么激活函数，例如sigmoid，会导致最后得到的值限制在0，1之间，那么这不是我们想要的。
• 这里的loss采用了mse，均方误差，这在回归问题中很常用。
• metrics采用mae，代表绝对误差，即预测值和目标值的差值的绝对值。

k重验证集

数据量小导致了我们在进行验证的时候很可能结果会依赖于我们选取的验证集，为了解决这个问题，我们就把测试集划成几部分，这几部分轮流当验证集，分别训练验证，得到结果，最后平均一下，得到的结果就更具有说服力，这就叫做k-fold。

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)
  # Prepare 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]
  # Prepare 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)
  # Build the Keras model (already compiled)
  model = build_model()
  # Train the model (in silent mode, verbose=0)
  model.fit(partial_train_data, partial_train_targets,
  epochs=num_epochs, batch_size=1, verbose=0)
  # Evaluate the model on the validation data
  val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
  all_scores.append(val_mae)

代码本身没什么难度，最难的可能也就是concatenate没见过，这个就是把两个数组连在一起。

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

最后得到了结果，预测接近于3.0

保存每一次交换训练的结果

把训练批次调到500以后查看预测均值和预测的变换趋势

num_epochs = 500
all_mae_histories = []
for i in range(k):
  print('processing fold #', i)
  # Prepare 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]
  # Prepare 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)
  # Build the Keras model (already compiled)
  model = build_model()
  # Train the model (in silent mode, 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_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)]

绘出预测变化：

由于样本数量小，造成了方差大，波动比较大。
为了便于观察，选取十个点，滑动平均：

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

这幅图我们能比较 清楚的看到，在80epochs以后误差又开始上升，这说明开始过拟合了。
调整epochs再来一遍

# Get a fresh, compiled model.
model = build_model()
# Train 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