《动手学深度学习》学习记录—kaggle竞赛房价预测

---

一、下载和读取数据集

1.下载数据集

从kaggle上下载所需数据集，链接如下https://www.kaggle.com/c/house-prices-advanced-regression-techniques，数据集分为训练集和测试集。 包括房屋的属性值和属性，如街道类型、施工年份、屋顶类型、地下室状况等。 这些特征由各种数据类型组成。 例如，建筑年份由整数表示，屋顶类型由离散类别表示，其他特征由浮点数表示。 这就是现实让事情变得复杂的地方：例如，一些数据完全丢失了，缺失值被简单地标记为“NA”。

2.读取数据集

引入库

import numpy as np
import pandas as pd
import torch
from torch import nn
from d2l import torch as d2l

使用pandas分别加载包含训练数据和测试数据的两个CSV文件,同时查看样本数量和特征，训练数据集含1460个样本，每个样本80个特征和1个标签， 测试数据集含1459个样本，每个样本80个特征不含标签。

train_data = pd.read_csv('data/train.csv')
test_data = pd.read_csv('data/test.csv')
print(train_data.shape)
print(test_data.shape)

数据集内容如下

二、数据集处理

去除第一列的id项

all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))

数据集中数组类型的特征值中含有缺失项NuLL，将缺失项用所有样本此特征值的平均值替换，为了将所有特征放在一个共同的尺度上， 我们通过将特征重新缩放到零均值和单位方差来标准化数据。具体如下将测试集和验证集按列合并，取出其中的数组特征值的索引，对数据进行标准化，标准化后，所有均值消失可以将缺失值设置为0。
标准化数据有两个原因： 首先，它方便优化。 其次，因为我们不知道哪些特征是相关的， 所以我们不想让惩罚分配给一个特征的系数比分配给其他任何特征的系数更大。

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()))
all_features[numeric_features] = all_features[numeric_features].fillna(0)

将文字类型特征通过pandas.get_dummies转换为独热向量的形式，dummy_na=True参数将NUlLL作为特殊的一项

all_features = pd.get_dummies(all_features, dummy_na=True)
all_features.shape

独热向量具体格式如下

最后通过value属性从pandas格式中提取NumPy格式，并将其转换为张量表示用于训练。

n_train = train_data.shape[0]
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)
train_labels = torch.tensor(train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)

三、训练

设定损失函数，确定输入特征，构建神经网络，书中使用的损失函数为均方误差损失函数，选取所有特征值作为输入，构建了一层线性神经网络。

loss = nn.MSELoss()
in_features = train_features.shape[1]
 
def get_net():
    net = nn.Sequential(nn.Linear(in_features,1))
    return net

房价就像股票价格一样，我们关心的是相对数量，而不是绝对数量。 因此，我们更关心相对误差，而不是绝对误差。解决这个问题的一种方法是用价格预测的对数来衡量差异，这使得预测价格的对数与真实标签价格的对数之间出现以下均方根误差。

def log_rmse(net, features, labels):
    clipped_preds = torch.clamp(net(features), 1, float('inf'))#为取对数将输入限制在1到无穷之间
    rmse = torch.sqrt(loss(torch.log(clipped_preds),
                           torch.log(labels)))
    return rmse.item()

训练函数：

1.初始化损失函数列表，记录训练记录每个训练周期结束时，模型在训练集和测试集上的损失。
2.载入数据集
3.设置优化器，此次选择Adam作为优化器，Adam优化器的主要吸引力在于它对初始学习率不那么敏感，使用权重衰减，有助于防止过拟合。
4.训练过程：梯度清零，计算损失，反向传播，更新参数
5.如果提供了测试标签，也会计算并记录模型在测试集上的损失。

def train(net, train_features, train_labels, test_features, test_labels, num_epochs, learning_rate, weight_decay,
          batchsize):
    train_list, test_list = [], []
    train_iter = d2l.load_array((train_features, train_labels), batchsize)
    optimizer = torch.optim.Adam(net.paramaters(), lr=learning_rate, weight_decay=weight_decay)
    for epoch in range(num_epochs):
        for X, y in train_iter:
            optimizer.zero_grad()
            l = loss(net(train_features), train_labels)
            l.backward()
            optimizer.step()
            train_list.append(log_rmse(net,train_features,train_labels))
        if test_labels is not None:
            test_list.append(log_rmse(net,test_features,test_labels))
    return train_list,test_list

k折交叉验证：

输入参数k：把数据分成多少份，i：第几份数据作为验证集。具体如下：
声明k>1确保至少含有一个训练集和一个验证集，再确认划成k份后每份的样本数
初始化记录特征和标签的参数，遍历数据集，选取出当前轮数划分后的数据集，最后确定验证集，将剩余的拼接在一起。

def get_k_fold_data(k, i, X, y):
    assert k > 1
    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[idx, :], y[idx]
        if j == i:
            X_valid, y_valid = X_part, y_part
        elif X_train is None:
            X_train, y_train = X_part, y_part
        else:
            X_train = torch.cat([X_train, X_part], 0)
            y_train = torch.cat([y_train, y_part], 0)
    return X_train, y_train, X_valid, y_valid

记录在训练集和验证集上的损失，使用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):
        data = get_k_fold_data(k, i, X_train, y_train)
        net = get_net()
        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.plot(list(range(1, num_epochs + 1)), [train_ls, valid_ls],
                     xlabel='epoch', ylabel='rmse', xlim=[1, num_epochs],
                     legend=['train', 'valid'], yscale='log')
        print(f'折{i + 1}，训练log rmse{float(train_ls[-1]):f}, '
              f'验证log rmse{float(valid_ls[-1]):f}')
    return train_l_sum / k, valid_l_sum / k

设置训练所需要的参数，开始训练过程，将预测的结果生成为csv文件上传到kaggle

k, num_epochs, lr, weight_decay, batch_size = 5, 100, 5, 0, 64
train_l, valid_l = k_fold(k, train_features, train_labels, num_epochs, lr,
                          weight_decay, batch_size)
print(f'{k}-折验证: 平均训练log rmse: {float(train_l):f}, '
      f'平均验证log rmse: {float(valid_l):f}')
      def train_and_pred(train_features, test_features, train_labels, test_data,
                   num_epochs, lr, weight_decay, batch_size):
    net = get_net()
    train_ls, _ = train(net, train_features, train_labels, None, None,
                        num_epochs, lr, weight_decay, batch_size)
    d2l.plot(np.arange(1, num_epochs + 1), [train_ls], xlabel='epoch',
             ylabel='log rmse', xlim=[1, num_epochs], yscale='log')
    print(f'训练log rmse：{float(train_ls[-1]):f}')
    # 将网络应用于测试集。
    preds = net(test_features).detach().numpy()
    # 将其重新格式化以导出到Kaggle
    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)
train_and_pred(train_features, test_features, train_labels, test_data,
               num_epochs, lr, weight_decay, batch_size)