Python深度学习--学习笔记（四）

编写预测分析波士顿房价的线性回归模型

首先，导入数据

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

来看看数据大小：

print(train_data.shape,train_targets.shape)
print(test_data.shape,test_targets.shape)

print(train_data[0])
print(train_targets[0])

输出：
(404, 13) (404,)
(102, 13) (102,)
[ 1.23247 0. 8.14 0. 0.538 6.142 91.7
3.9769 4. 307. 21. 396.9 18.72 ]
15.2

训练集有404个，测试集有102个，即波士顿房价信息，（比如犯罪率、当地房产税率等）标签则是当时的房价（x 1000）。

可以看出数据中最小为0，最大有到396.9，数据分布太广，将取值范围差异很大的数据输入到神经网络中，这是有问题的。

所以，我们需要将数据进行标准化，得到的特征平均值为 0，标准差为 1。

import numpy as np

mean = np.mean(train_data,axis=0)
std = np.std(train_data,axis=0)

train_data -= mean
train_data /= std

test_data -= mean
test_data /= std

注意：用于测试数据标准化的均值和标准差都要在训练数据上计算得到的

我们的目的是求得预测的房价值，标签就是房价值，所以它不需要更改。

接着，建立网络层

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(1))
    
    model.compile(optimizer='rmsprop',
                  loss='mse',
                  metrics=['mae'])
    return model

• train_data.shape[1] == 13，即单个数据中的13个元素。
• 输出层，输出一个值，即预测房价的值，不需要激活函数来限制数值的大小。
• loss=‘mse’：预测值与目标值之差的平方。这是回归问题常用的损失函数。
• metrics=[“mae”]：输出标准为预测值与目标值之差的绝对值，数值接近 0 表示预测的越准确。

上面已查看过数据集的大小，只有 404 个数据，如果再在训练集上分出训练集和验证集，就使训练的量进一步减少。数据少十分不利于学习。这时的最佳方法是：K折交叉验证。

K折交叉验证的核心思想就是用数据集中的数据流动地充当训练集和验证集（大小比为 (k - 1) : 1 ）

用代码理解：

k = 4
num_val_samples = len(train_data) // k #整数除法
num_epochs = 500
all_mae_histories = [] 

for i in range(k):
    print('processing fold #',str(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)
    #np.concatenate:按轴axis连接array组成一个新的array
   
    
    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) 
    
    mae_history = history.history['val_mean_absolute_error']
    all_mae_histories.append(mae_history)

最后将求得的mae取平均值。

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,num_epochs + 1), average_mae_histroy)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

输出：

可以目测前二十个数据呈直线下降，不利于观测其余的数据，
我们截取前二十个数据之后。

import matplotlib.pyplot as plt

average_mae_history_1 = average_mae_history[20:]
plt.plot(range(21,num_epochs + 1), average_mae_histroy_1)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

可以看出，数据波动较大，我们让线变得平滑：

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[20:])

plt.plot(range(21,num_epochs + 1), smooth_mae_history)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

可以看出，数据平滑许多。

最后，我们来评估下模型：

test_mse_score,test_mae_score = model.evaluate(test_data,test_targets)
print(test_mse_score,test_mae_score)

输出：
(14.744306377336091, 2.5746399094076717)

得出结论：预测的房价还是和实际价格相差约 2575 美元。如此大的误差，由于数据集数量太少。
一般来说，训练模型所给的数据越多，泛化能力就越好。所以，想要训练一个优秀的模型，数据量至关重要。