《python深度学习》笔记（八）：回归问题

分类问题的目标：预测输入数据点所对应的单一离散变量。

回归问题的目标：预测一个连续值而不是单一的标签。例如，温度预测、房价预测。

1.数据集：波士顿房价数据集

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

# 1.加载数据集
from keras.datasets import boston_housing
(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()

2.准备数据：数据标准化

对于取值范围差异很大的数据，我们采取的数据预处理的方法是数据标准化，即对于输入数据的每个特征，减去特征的平均值，再除以标准差，这样得到均值为0，标准差为1。用numpy很容易实现标准化。

# 数据集中的数据有不同的取值范围，且差异较大。
# 准备数据。数据标准化：对于输入数据矩阵中的列，减去特征平均值，再除以标准差。
mean = train_data.mean(axis=0)  # axis = 0 对列运算，变成一行，实际上是求每列均值
train_data -= mean  # 减去平均值
std = train_data.std(axis=0)
train_data /= std  # 除以标准差

test_data -= mean
test_data /= std

3.构建网络

一般来说，训练数据越少，过拟合越严重，而较小的网络可以降低过拟合，所以我们使用一个非常小的网络。

# 构建神经网络
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

"""
Q：为什么这个网络最后一层不使用激活函数？
    A：不使用激活函数的话这就是一个线性层。
       这是标量回归（标量回归是预测单一连续值的回归）的典型设置。
       添加激活函数将会限制输出范围。
       例如，如果向最后一层添加sigmoid激活函数，网络只能学会预测0~1范围内的值。
       这里最后一层是纯线性的，所以网络可以学会预测任意范围内的值
"""

4.K折交叉验证

由于数据点非常少，验证集也会非常少，验证分数可以会有很大波动，这样情况下，我们使用K折验证法。

K折交叉验证：K折交叉验证使用了无重复抽样技术的好处：每次迭代过程中每个样本点只有一次被划入训练集或测试集的机会。将可用数据划分为K个分区（K通常取4或5），实例化K个相同的模型，将每个模型在K-1个分区上训练，并在剩下的一个分区上进行评估。模型的验证分数等于K个验证分数的平均值。

 

a.如果训练集相对较小，则增大k值。

增大k值，在每次迭代过程中将会有更多的数据用于模型训练，能够得到最小偏差，同时算法时间延长。且训练块间高度相似，导致评价结果方差较高。

b.如果训练集相对较大，则减小k值。

减小k值，降低模型在不同的数据块上进行重复拟合的性能评估的计算成本，在平均性能的基础上获得模型的准确评估。

 

#  K折验证
import numpy as np
#  训练网络，用K折验证法对数据进行训练验证
k = 4
num_val_samples = len(train_data) // k  # 除以K商取整。把训练数据分成4份，每份是多少
num_epochs = 100  # 训练100次
all_scores = []  # 建立一个存放分数的列表
for i in range(k):  # i=0,1,2,3 循环4次
    print('processing fold #', i)
    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]  # i=0,第一批数据，i=1第一批数据
    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]

    partial_train_data = np.concatenate(  # 剩余的数据，其他所有分区的数据/ concatenate()能够一次完成多个数组的拼接。
        [train_data[:i * num_val_samples],
         train_data[(i + 1) * num_val_samples:]],
        axis=0)  # i=0,就是[1~最后]。i=1,就是合并[0~1]和[2~最后]
    partial_train_targets = np.concatenate(  # concatenate合并两个array数组，axis =0 ，纵向合并
        [train_targets[:i * num_val_samples],
         train_targets[(i + 1) * num_val_samples:]],
        axis=0)


    model = build_model()  #构建keras模型

    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)  # 在列表末尾添加新对象，平均绝对误差
print(all_scores)
mean = np.mean(all_scores)
print(mean)

5.保存每折的验证结果

# 保存每折的验证结果
from keras import backend as K
# Some memory clean-up

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)
    # 就是不输出日志信息 ，进度条、loss、acc这些都不输出，verbose=0
    mae_history = history.history['val_mae']  # fit返回一个history对象，这个对象有一个history字典，
    all_mae_histories.append(mae_history)
print(all_mae_histories)

# 计算所有轮次中的K折验证分数平均值。
average_mae_history = [np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)]
print(average_mae_history)

6.绘制验证分数图像

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

结果：

---

 由于纵轴的范围较大，且数据方差相对较大，难以看清这张图的规律，我们重新绘制一张图。

a.删除前10个数据点，因为他们的取值范围与曲线上的其他点不同

b.将每个数据点替换为前面数据点的指数移动平均值，得到光滑的曲线。

# 纵轴范围太大，方差较大，把每个数据点替换成
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))
            #  指数移动平均值EMA,前一个数据点*加权系数+当前数据点*（1-加权系数）
        else:
            smoothed_points.append(point)  # append添加到列表中最后面
    return smoothed_points


smooth_mae_history = smooth_curve(average_mae_history[10:])
# 输入K折验证平均值，删除前前10个取值范围与曲线不同的点
plt.plot(range(1, len(smooth_mae_history) + 1), smooth_mae_history)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

# 训练最终模型
model = build_model()
model.fit(train_data, train_targets, epochs=80, batch_size=16, verbose=0)
test_mes_score, test_mae_score = model.evaluate(test_data, test_targets)

# 输出最终结果
print(test_mae_score)
# 2.509598970413208

 

---

EMA例子

import matplotlib.pyplot as plt

points = [1, 5, 3, 9, 4]
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))
            #  指数移动平均值EMA,前一个数据点*加权系数+当前数据点*（1-加权系数）
        else:
            smoothed_points.append(point)  # append添加到列表中最后面
    return smoothed_points


results = smooth_curve(points)
print(results)
plt.plot(range(1, len(points) + 1), results)
plt.show()

 

---

回归问题总结：

1.损失函数与分类问题不同，回归问题常用均方误差（MSE）

2.评估指标与分类问题不同，回归问题常用平均绝对误差（MAE）

3.可用数据很少，可使用K折验证，减小网络模型