Fork me on GitHub

深度学习实战-房价预测

深度学习回归案例:房价预测

机器学习的另一个重要问题:回归。它预测的是一个连续值而不是离散的标签

逻辑回归不是回归算法,而是分类算法

波士顿房价数据集

506个样本,其中404个训练样本,102个测试样本

In [1]:

1
2
3
import numpy as np

from keras.datasets import boston_housing

划分数据集

In [2]:

1
2
3
# 限制前10000个最常见的单词

(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()

In [3]:

1
train_data.shape  # 每个样本都是13个特征

Out[3]:

1
(404, 13)

In [4]:

1
test_data.shape

Out[4]:

1
(102, 13)

In [5]:

1
train_targets[:10]

Out[5]:

1
array([15.2, 42.3, 50. , 21.1, 17.7, 18.5, 11.3, 15.6, 15.6, 14.4])

数据标准化

神经网络中不能输入取值范围差异很大的数据集,需要进行标准化处理。

每个特征的标准化:(原数据 - 特征平均值) / 标准差。 得到的就是特征平均值为0,标准差为1

In [6]:

1
2
3
4
5
6
7
8
9
10
# 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

注意的点:

  1. 测试集的标准化使用的是训练集的均值和方差
  2. 我们不能使用在测试上计算得到的任何结果

构建网络

样本量少,可构建2个隐藏层,每层64个单元。较小的网络能够降低过拟合

建模

In [7]:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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

网络的特点:

  1. 最后一层:一个单元,没有激活,是一个线性层(标量回归的典型设置
  2. 损失函数mse-均方误差,(y_predict- y_true)^2;回归问题的常用损失函数
  3. 监控指标mae-平均绝对误差,|y_predict- y_true|;预测值和目标值之差的绝对值

K折交叉验证

原理

当样本数量很少的时候,验证集的划分方式可能会造成验证分数上有很大的方差,无法对模型进行可靠的评估。

最佳方法:使用K折交叉验证

  • 将数据划分为K个分区,通常是4或者5
  • 实例化K个模型,将模型在K-1个分区上训练,剩下的一个区上进行评估
  • 模型的验证分数等于K个验证分数的均值。

如何K折交叉验证:以3折交叉验证为例

代码实现

In [8]:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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]:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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 ...... 3

In [10]:

1
all_scores

Out[10]:

1
2
3
4
[2.6683619022369385,
2.8356902599334717,
2.8533785343170166,
2.9509527683258057]

In [11]:

1
np.mean(all_scores)

Out[11]:

1
2.827095866203308

每次运行模型得到的数值还是有很大的差异,但是均值最终还是在2.94接近3,是一个比较可靠的结果。

增加模型训练轮次(修改)

  • 将模型训练500次
  • 保存每轮的验证分数记录

代码实现

In [14]:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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]:

1
len(all_mae_histories)

Out[24]:

1
4

In [25]:

1
len(all_mae_histories[0])

Out[25]:

1
500

In [26]:

1
2
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]:

1
2
3
4
5
6
7
8
9
10
[6.998382568359375,
5.590555667877197,
6.159129858016968,
5.215211391448975,
5.865886926651001,
5.083814740180969,
5.314043760299683,
4.525156497955322,
4.432371437549591,
5.098088502883911]

In [27]:

1
len(average_mae_history)

Out[27]:

1
500

可视化:绘制验证分数

In [31]:

1
2
3
4
5
6
7
8
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]:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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]:

1
2
3
4
5
6
7
8
9
10
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.3248

In [41]:

1
test_mae_score

Out[41]:

1
18.324810028076172

可以看到预测的房价和真实的房价的相差约为1.8万美元

总结

  • 回归问题中,损失函数使用的是均方误差MSE
  • 回归问题中,评价指标使用的是平均绝对误差MAE
  • 如果数据的特征具有不同的取值范围,需要进行数据的归一化,进行数据缩放
  • 当数据少的时候,使用K折交叉验证来可靠的评估模型
  • 如果训练的数据少,最好使用隐藏层较少的小型网络,以避免严重的过拟合

本文标题:深度学习实战-房价预测

发布时间:2022年04月02日 - 21:04

原始链接:http://www.renpeter.cn/2022/04/02/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E5%AE%9E%E6%88%98-%E6%88%BF%E4%BB%B7%E9%A2%84%E6%B5%8B.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

Coffee or Tea