K折交叉验证在KAGGLE比赛——房价预测的实现（pyTorch）
1 Intorduction
通过KAGGLE比赛上最简单的入门实例——房价预测，来完成一个神经网络从搭建到训练、调参、最后预测结果的完整实例。
包括利用pandas数据预处理、模型的设计、超参数的选择等，通过K折交叉验证不断调整超参数，以达到满意的预测结果。
2 K折交叉验证
所谓K折交叉验证，就是将数据集等比例划分成K份，以其中的一份作为测试数据，其他的K-1份数据作为训练数据。然后，这样算是一次实验，而K折交叉验证是将实验进行K次才算完成完整的一次，也就是说交叉验证实际是把实验重复做了K次，每次实验都是从K个部分选取一份不同的数据部分作为测试数据（保证K个部分的数据都分别做过测试数据），剩下的K-1个当作训练数据，最后把得到的K个实验结果进行平均化。
3 完整实例步骤
3.1 获取和读取数据集
比赛数据分为训练数据集和测试数据集。两个数据集都包括每栋房子的特征，如街道类型、建造年份、房顶类型、地下室状况等特征值。这些特征值有连续的数字、离散的标签甚至是缺失值“na”。只有训练数据集包括了每栋房子的价格，也就是标签。首先从比赛网页并下载这些数据集。
%matplotlib inline
import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import sys
sys.path.append('..')
import d2lzh_pytorch as d2l
torch.set_default_tensor_type(torch.FloatTensor)
# 使用函数pd.read_csv()加载数据集
train_data = pd.read_csv('E:/Coding/Jupyter_note/data/house-prices-advanced-regression-techniques/train.csv')
test_data = pd.read_csv('E:/Coding/Jupyter_note/data/house-prices-advanced-regression-techniques/test.csv')
# 观察导入数据的形状，train_data包含标签y， test_data的标签是待预测值，故test_data比train_data少一列。
print(train_data.shape)
print(test_data.shape)
(1460, 81)
(1459, 80)
#查看前4个样本的前4个特征、后2个特征和标签（SalePrice）：
train_data.iloc[0:4, [0,1,2,3,-3,-2,-1]]
| Id | MSSubClass | MSZoning | LotFrontage | SaleType | SaleCondition | SalePrice | |
|---|---|---|---|---|---|---|---|
| 0 | 1 | 60 | RL | 65.0 | WD | Normal | 208500 |
| 1 | 2 | 20 | RL | 80.0 | WD | Normal | 181500 |
| 2 | 3 | 60 | RL | 68.0 | WD | Normal | 223500 |
| 3 | 4 | 70 | RL | 60.0 | WD | Abnorml | 140000 |
#查看前4个测试集的前4个特征、后2个特征（没有标签）：
test_data.iloc[0:4, [0,1,2,3,-2,-1]]
| Id | MSSubClass | MSZoning | LotFrontage | SaleType | SaleCondition | |
|---|---|---|---|---|---|---|
| 0 | 1461 | 20 | RH | 80.0 | WD | Normal |
| 1 | 1462 | 20 | RL | 81.0 | WD | Normal |
| 2 | 1463 | 60 | RL | 74.0 | WD | Normal |
| 3 | 1464 | 60 | RL | 78.0 | WD | Normal |
# 数据集的第一个特征是Id，该特征对于测试结果不起任何实质性作用，故将所有的训练数据和测试数据去除Id特征后的79个特征按样本连结。
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
3.2 预处理数据
#归一化输入的好处：归一化数据集使得代价函数看起来更对称，运行梯度算法时能够更快的找到最小值。
#对连续数值的特征归一化的方法：设该特征在整个数据集上的均值为μ，标准差为σ。可以将该特征的每个值先减去μ再除σ得到标准化后的每个特征值。
#对于缺失的特征值，我们将其替换成该特征的均值。
# numeric_features为DataFrame中数据类型不属于object的集合
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index
# 执行输入特征归一化
all_features[numeric_features]=all_features[numeric_features].apply( lambda x: (x - x.mean()) / x.std())
#标准化后，每个特征的均值变为0， 所以可以用0来替换缺失值NaN
all_features = all_features.fillna(0)
# 离散特征的编码分为两种情况：
# 1、离散特征的取值之间没有大小的意义，比如color：[red,blue], 那么就使用one-hot编码
# 2、离散特征的取值有大小的意义，比如size:[X,XL,XXL], 那么就使用数值的映射{X:1,XL:2,XXL:3}
# 将离散数值转成指示特征 dummy_na=True将缺失值也当做合法的特征值并为其创建指示特征
all_features = pd.get_dummies(all_features, dummy_na=True)
all_features.shape
(2919, 354)
# pd.DataFrame.values 返回将DataFrame数据去掉index、colunms之后的array
# 通过values属性得到NumPy格式的数据，并转成Tensor方便后面的训练
n_train = train_data.shape[0]
train_features = torch.tensor(all_features[:n_train].values, dtype = torch.float)
test_features = torch.tensor(all_features[n_train:].values, dtype = torch.float)
train_labels = torch.tensor(train_data. SalePrice.values, dtype = torch.float).view(-1, 1)
以上从数据获取、数据离散值处理、数据DataFrame类型转换为array类型、数据输入归一化等一系列执行已经得到了比较规范的训练集及测试集。
3.3 训练模型
# 这里使用一个基本的线性回归模型和平方损失函数来训练模型。
loss = torch.nn.MSELoss() # torch提供的平方损失函数
# 自行定义线性回归模型并初始化参数
def get_net(feature_num):
net = nn.Linear(feature_num, 1)
for param in net.parameters():
nn.init.normal_(param, mean = 0, std = 0.01)
return net
#定义比赛用来评价模型的对数均方根误差
def log_rmse(net, feature, labels):
with torch.no_grad():
# 将小于1的值设成1，使得取对数时数值更稳定 （对小于1的数取对数为负数，数值不稳定）
clipped_preds = torch.max(net(feature), torch.tensor(1.0))
rmse = torch.sqrt(2 * loss(clipped_preds.log(), labels.log()).mean())
return rmse.item()
# 这里的训练函数跟使用了Adam优化算法，它是与SGD类似的一种优化算法，是Momentum和RMSprop结合在一起的算法，与相对之前使用的小批量随机梯度下降，它对学习率相对不那么敏感。
def train(net, train_features, train_labels, test_features, test_labels, num_epochs, learning_rate, weight_decay, batch_size):
train_ls, test_ls = [], []
dataset = torch.utils.data.TensorDataset(train_features, train_labels)
train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=True)
#这里使用了Adam优化算法
optimizer = torch.optim.Adam(params = net.parameters(), lr = learning_rate,weight_decay = weight_decay )
net = net.float()
for epoch in range(num_epochs):
for X,y in train_iter:
l = loss(net(X.float()), y.float())
optimizer.zero_grad()
l.backward()
optimizer.step()
train_ls.append(log_rmse(net,train_features, train_labels ))
if test_labels is not None:
test_ls.append(log_rmse(net,test_features, test_labels))
return train_ls, test_ls
3.4 K折交叉验证
# K折交叉验证，被用来选择模型设计并调节超参数。下面的函数返回第i折交叉验证时所需要的训练和验证数据
# 这个函数较难理解，附详细注释
def get_k_fold_data(k, i, X, y):
assert k > 1
# fold_size为整个大训练集X 整除 k
fold_size = X.shape[0] // k
# 将大训练集分为小训练集和一个验证集
X_train, y_train = None, None
for j in range(k):
# 取一个切片，该切片为取出的验证集
idx = slice( j * fold_size, (j+1) * fold_size)
# X_part, y_part起到过度的作用，用于存储取到的数据
X_part, y_part = X[idx, :], y[idx]
# 当j == i时，即当前取到的切片恰好为第i次交叉验证的验证集
if j == i:
x_valid, y_valid = X_part, y_part
# 否则判断X_train是否为空
elif X_train is None:
X_train, y_train = X_part, y_part
# 当X_train不为空时，且j != i时，将剩下的所有子训练集合并在一起
else:
X_train = torch.cat((X_train, X_part), dim = 0)
y_train = torch.cat((y_train, y_part), dim = 0)
# 函数返回第i折交叉验证时所需要的训练和验证数据
return X_train, y_train, x_valid, y_valid
# 在K折交叉验证中我们训练K次并返回训练和验证的平均误差。
def k_fold(k, X_train, y_train, num_epochs, learning_rate, weight_decay, batch_size):
train_l_sum, valid_l_sum = 0, 0
for i in range(k):
# 函数返回第i折交叉验证时所需要的训练和验证数据
data = get_k_fold_data(k, i, X_train, y_train)
net = get_net(X_train.shape[1])
# *data表示第i折交叉验证时对应的X_train, y_train, x_valid, y_valid
train_ls, valid_ls = train(net, *data ,num_epochs, learning_rate, weight_decay, batch_size)
train_l_sum += train_ls[-1]
valid_l_sum += valid_ls[-1]
if i ==0:
d2l.semilogy(range(1, num_epochs+1), train_ls, 'epochs', 'rmse', range(1, num_epochs+1), valid_ls, ['train', 'valid'])
print('fold %d, train rmse %f, valid rmse %f' % (i,train_ls[-1], valid_ls[-1] ))
return train_l_sum/k, valid_l_sum/k
3.5 模型选择
# 将超参数初始化为如下，可以通过结果不断调整5个超参数的值来得到更好的验证结果，这就是所谓的“调参”过程
# 需要注意，这里并未使用我们一开始的测试集，只是将训练集中的一部分作为验证集来调整模型
k, num_epochs, lr, weight_decay, batch_size = 7, 100, 7, 0, 64
train_l, valid_l = k_fold(k, train_features, train_labels, num_epochs, lr, weight_decay, batch_size)
print('%d-fold validation: avg train rmse %f, avg valid rmse %f' % (k, train_l, valid_l))
fold 0, train rmse 0.224037, valid rmse 0.229480
fold 1, train rmse 0.225873, valid rmse 0.208868
fold 2, train rmse 0.217650, valid rmse 0.262939
fold 3, train rmse 0.215008, valid rmse 0.242385
fold 4, train rmse 0.229091, valid rmse 0.181704
fold 5, train rmse 0.215994, valid rmse 0.244475
fold 6, train rmse 0.225376, valid rmse 0.252048
7-fold validation: avg train rmse 0.221861, avg valid rmse 0.231700
3.6 预测结果
# 在不断调整参数选择好合适的参数后，可以利用测试集进行预测。
# 在预测之前，使用完整的训练数据集来重新训练模型（这里与K折交叉验证已经毫无关系了），并将预测结果存成提交官网所需要的格式。
def train_and_pred(train_features, test_features, train_labels, test_data,
num_epochs, lr, weight_decay, batch_size):
net = get_net(train_features.shape[1])
train_ls, _ = train(net, train_features, train_labels, None, None,
num_epochs, lr, weight_decay, batch_size)
d2l.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'rmse')
print('train rmse %f' % train_ls[-1])
preds = net(test_features).detach().numpy()
test_data['SalePrice'] = pd.Series(preds.reshape(1, -1)[0])
submission = pd.concat([test_data['Id'], test_data['SalePrice']], axis=1)
submission.to_csv('./submission.csv', index=False)
# 通过K折交叉验证设计好模型并调好超参数之后，即可以对测试数据集上的房屋样本做价格预测。
train_and_pred(train_features, test_features,train_labels, test_data, num_epochs, lr, weight_decay, batch_size)
train rmse 0.212609
3.7 Final Results
其中可能使用到了许多关于numpy、pandas、matplotlib库的许多函数，将较难理解的很多函数总结如下，便于查询：
Pandas基本函数【持续更新······】
matplotlib速查表 | 2020新版 | 方便查询 | 【搬运分享自用】
欢迎关注【OAOA】
扫一扫
1466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
