深度学习回归案例：房价预测
机器学习的另一个重要问题：回归。它预测的是一个连续值而不是离散的标签
逻辑回归不是回归算法，而是分类算法
波士顿房价数据集
506个样本，其中404个训练样本，102个测试样本
In [1]:
代码语言：javascript复制import numpy as np
from keras.datasets import boston_housing划分数据集
In [2]:
代码语言：javascript复制# 限制前10000个最常见的单词
(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()In [3]:
代码语言：javascript复制train_data.shape # 每个样本都是13个特征Out[3]:
代码语言：javascript复制(404, 13)In [4]:
代码语言：javascript复制test_data.shapeOut[4]:
代码语言：javascript复制(102, 13)In [5]:
代码语言：javascript复制train_targets[:10]Out[5]:
代码语言：javascript复制array([15.2, 42.3, 50. , 21.1, 17.7, 18.5, 11.3, 15.6, 15.6, 14.4])数据标准化
神经网络中不能输入取值范围差异很大的数据集，需要进行标准化处理。
每个特征的标准化：(原数据 - 特征平均值) / 标准差。 得到的就是特征平均值为0，标准差为1
In [6]:
代码语言：javascript复制# numpy实现
mean = train_data.mean(axis=0)
train_data -= mean # 等价于 train_data = train_data - mean
std = train_data.std(axis=0)
train_data /= std
# 测试集
test_data -= mean # 训练集的均值和标准差
test_data /= std注意的点：
- 测试集的标准化使用的是训练集的均值和方差
- 我们不能使用在测试上计算得到的任何结果
构建网络
样本量少，可构建2个隐藏层，每层64个单元。较小的网络能够降低过拟合
建模
In [7]:
代码语言：javascript复制import tensorflow as tf # add
from keras import models
from keras import layers
def build_model():
model = models.Sequential() # 需要将同一个模型多次实例化，使用同一个函数来构建模型
model.add(tf.keras.layers.Dense(64,
activation="relu",
# 训练集的shape的第二个取值
input_shape=(train_data.shape[1], )
))
model.add(tf.keras.layers.Dense(64,
activation="relu"))
model.add(tf.keras.layers.Dense(1))
model.compile(optimizer="rmsprop",
loss="mse",
metrics=["mae"]
)
return model网络的特点：
- 最后一层：一个单元，没有激活，是一个线性层（标量回归的典型设置）
- 损失函数mse-均方误差，(y_predict- y_true)^2；回归问题的常用损失函数
- 监控指标mae-平均绝对误差，|y_predict- y_true|；预测值和目标值之差的绝对值
K折交叉验证
原理
当样本数量很少的时候，验证集的划分方式可能会造成验证分数上有很大的方差，无法对模型进行可靠的评估。
最佳方法：使用K折交叉验证
- 将数据划分为K个分区，通常是4或者5
- 实例化K个模型，将模型在K-1个分区上训练，剩下的一个区上进行评估
- 模型的验证分数等于K个验证分数的均值。
如何K折交叉验证：以3折交叉验证为例
代码实现
In [8]:
代码语言：javascript复制import numpy as np
k = 4
num_val_samples = len(train_data) // k
for i in range(k):
print("procesing 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]
# 训练数据集的合并：axis=0方向
# train_data合并
partial_train_data = np.concatenate(
[train_data[:i*num_val_samples],
train_data[(i 1)*num_val_samples:]],
axis=0
)
# train_targets合并
partial_train_targets = np.concatenate(
[train_targets[:i*num_val_samples],
train_targets[(i 1)*num_val_samples:]],
axis=0
)
procesing fold ...... 0
procesing fold ...... 1
procesing fold ...... 2
procesing fold ...... 3训练模型 验证集评估模型
In [9]:
代码语言：javascript复制import numpy as np
k = 4
num_val_samples = len(train_data) // k
number_epochs = 100
all_scores = []
for i in range(k):
print("procesing 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]
# 训练数据集的合并：axis=0方向
# train_data合并
partial_train_data = np.concatenate(
[train_data[:i*num_val_samples],
train_data[(i 1)*num_val_samples:]],
axis=0
)
# train_targets合并
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=number_epochs,
batch_size=1,
verbose=0 # 静默模式
)
# 验证数据上评估模型
val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
all_scores.append(val_mae)
procesing fold ...... 0
procesing fold ...... 1
procesing fold ...... 2
procesing fold ...... 3In [10]:
代码语言：javascript复制all_scoresOut[10]:
代码语言：javascript复制[2.6683619022369385,
2.8356902599334717,
2.8533785343170166,
2.9509527683258057]In [11]:
代码语言：javascript复制np.mean(all_scores)Out[11]:
代码语言：javascript复制2.827095866203308每次运行模型得到的数值还是有很大的差异，但是均值最终还是在2.94接近3，是一个比较可靠的结果。
增加模型训练轮次（修改）
- 将模型训练500次
- 保存每轮的验证分数记录
代码实现
In [14]:
代码语言：javascript复制import numpy as np
k = 4
num_val_samples = len(train_data) // k
number_epochs = 500
# 修改：统计mae得分
all_mae_histories = []
for i in range(k):
print("procesing 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]
# 训练数据集的合并：axis=0方向
# train_data合并
partial_train_data = np.concatenate(
[train_data[:i*num_val_samples],
train_data[(i 1)*num_val_samples:]],
axis=0
)
# train_targets合并
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=number_epochs,
batch_size=1,
verbose=0 # 静默模式
)
# 验证数据上评估模型：记录mae
# 原文使用的是全称
# mae_history = history.history["val_mean_absolute_error"]
# 目前版本已经使用缩写形式
mae_history = history.history["val_mae"]
all_mae_histories.append(mae_history)
procesing fold ...... 0
procesing fold ...... 1
procesing fold ...... 2
procesing fold ...... 3计算每个轮次中所有折的MAE的平均值：
In [24]:
代码语言：javascript复制len(all_mae_histories)Out[24]:
代码语言：javascript复制4In [25]:
代码语言：javascript复制len(all_mae_histories[0])Out[25]:
代码语言：javascript复制500In [26]:
代码语言：javascript复制average_mae_history = [np.mean([x[i] for x in all_mae_histories]) for i in range(number_epochs)]
average_mae_history[:10]Out[26]:
代码语言：javascript复制[6.998382568359375,
5.590555667877197,
6.159129858016968,
5.215211391448975,
5.865886926651001,
5.083814740180969,
5.314043760299683,
4.525156497955322,
4.432371437549591,
5.098088502883911]In [27]:
代码语言：javascript复制len(average_mae_history)Out[27]:
代码语言：javascript复制500可视化：绘制验证分数
In [31]:
代码语言：javascript复制import matplotlib.pyplot as plt
plt.plot(range(1, len(average_mae_history) 1), average_mae_history)
plt.xlabel("Epochs")
plt.ylabel("Validation MEA")
plt.show()可视化改进版
上面的图形纵轴范围大，且数据的方差大，很难看清图形，重新绘制：
- 删除前面10个点，它们的取值和其他点的取值差异大
- 将每个数据点替换为前面数据点的指数移动平均值，得到光滑的曲线
In [38]:
代码语言：javascript复制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:])
import matplotlib.pyplot as plt
plt.plot(range(1, len(smooth_mae_history) 1), smooth_mae_history)
plt.xlabel("Epochs")
plt.ylabel("Validation MEA")
plt.show()训练最终模型
使用最佳参数在整个训练集上进行训练，然后在测试集上进行测试：
In [40]:
代码语言：javascript复制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)
4/4 [==============================] - 0s 3ms/step - loss: 372.9089 - mae: 18.3248In [41]:
代码语言：javascript复制test_mae_scoreOut[41]:
代码语言：javascript复制18.324810028076172可以看到预测的房价和真实的房价的相差约为1.8万美元
总结
- 回归问题中，损失函数使用的是均方误差MSE
- 回归问题中，评价指标使用的是平均绝对误差MAE
- 如果数据的特征具有不同的取值范围，需要进行数据的归一化，进行数据缩放
- 当数据少的时候，使用K折交叉验证来可靠的评估模型
- 如果训练的数据少，最好使用隐藏层较少的小型网络，以避免严重的过拟合
