Python深度学习笔记05--使用Kears进行回归

import keras
from keras.datasets import boston_housing
import numpy as np
from keras import models
from keras import layers
import matplotlib.pyplot as plt
from keras import backend as K
# Some memory clean-up
K.clear_session()

#1. 获取数据集
(train_data, train_targets), (test_data, test_targets) =  boston_housing.load_data()

#2. 数据处理
#2.1 数据归一化处理
mean = train_data.mean(axis=0)#按列计算均值
train_data -= mean#矩阵逐元素减法
std = train_data.std(axis=0)#按列计算标准差
train_data /= std#矩阵逐元素除法

test_data -= mean
test_data /= std

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'])
    #损失函数mse:均方误差
    #监控指标mae:平均绝对误差
    return model

# #5. K折交叉验证确定超参数
# #5.1开始 K折交叉验证的代码
# k = 4 #4折，将训练集分4份，其中3份做训练，1份做验证
# num_val_samples = len(train_data) // k #每一份的样本个数
# num_epochs = 100 #迭代轮数
# # all_scores = [] #保存每次的验证分数
# all_mae_histories = []
# for i in range(k):
#     print('processing fold #', 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)
#     partial_train_targets = np.concatenate(
#         [train_targets[:i * num_val_samples],
#          train_targets[(i + 1) * num_val_samples:]],
#         axis=0)

#     # 建立网络
#     model = build_model()
#     # 训练模型 (in silent mode, verbose=0)
#     # 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)
#     history = model.fit(partial_train_data, partial_train_targets,
#                         validation_data=(val_data, val_targets),
#                         epochs=num_epochs, batch_size=1, verbose=0)
#     #print(history.history)
#     #{'loss': [413.8923645019531], 'mae': [18.39319610595703], 'val_loss': [219.52098083496094], 'val_mae': [12.841739654541016]}
#     mae_history = history.history['val_mae']
#     all_mae_histories.append(mae_history)

# # print(all_scores)
# #[1.8973649740219116, 2.338238000869751, 2.5596060752868652, 2.437340497970581]
# #5.1结束 K折交叉验证的代码


# #5.2开始 根据图形确定迭代轮数等超参数
# average_mae_history = [
#     np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)]


#5.2.1 直接绘图
# plt.plot(range(1, len(average_mae_history) + 1), average_mae_history)
# plt.xlabel('Epochs')
# plt.ylabel('Validation MAE')
# plt.show()


# #5.2.2 使曲线平滑
# 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()
#5.2结束


#6. 调整好超参数，使用全部训练集来训练模型
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)

print(test_mae_score) # 2.891572952270508

小结：

(1)回归问题使用的损失函数与分类问题不同。回归常用的损失函数是均方误差（MSE）。

(2)同样，回归问题使用的评估指标也与分类问题不同。显而易见，精度的概念不适用于回归问题。常见的回归指标是平均绝对误差（MAE）。

(3)如果输入数据的特征具有不同的取值范围，应该先进行预处理，对每个特征单独进行缩放。

(4)如果可用的数据很少，使用 K 折验证可以可靠地评估模型。

(5)如果可用的训练数据很少，最好使用隐藏层较少（通常只有一到两个）的小型网络，以避免严重的过拟合。