【动手学深度学习v2】深度学习，从零理解Kaggle房价预测 + 课程竞赛——李沐老师的课程笔记

深度学习，从零理解Kaggle房价预测 + 课程竞赛——李沐老师的课程笔记

对于深度学习，非常推荐李沐老师的课程，受益匪浅

课程视频实战 Kaggle 比赛：预测房价_哔哩哔哩_bilibili

这里对源码做一些注释，希望大家可以更好理解这里面的意思

没有基础不知道软件如何安装的可以看Python深度学习：安装Anaconda、PyTorch（GPU版）库与PyCharm_哔哩哔哩_bilibili

有基础的也可以直接看代码，来加深理解

若有差错，请与我联系探讨

这一章节基本就是看代码了：

首先先下载数据集，然后替换代码中文件位置即可

文件来自b友：

数据集度盘自取： 链接：https://pan.baidu.com/s/1Byx4c1PCYKsuIRpYkEFn1g

提取码：x0j9

下面给出官网地址： https://www.kaggle.com/c/house-prices-advanced-​编辑regression-techniques/data

下面代码中参数调整我最多就只能调成这样了，还需要加深理解，继续精进

%matplotlib inline
import numpy as np
import pandas as pd
import torch
from torch import nn
from d2l import torch as d2l

# 使用前缀 r 来避免路径中的转义字符问题。
train_data = pd.read_csv(r'D:\Jupyter\learning\data\train.csv')
test_data = pd.read_csv(r'D:\Jupyter\learning\data\test.csv')

print(train_data.shape)
print(test_data.shape)
# 取1-4行，并取一些列，如下
print(train_data.iloc[0:4, [0,1,2,-3,-2,-1]])
print(type(train_data))
# 删除数据,这里1到-1是第二列到倒数第二列
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
# 提取数值特征
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index
# 标准化，均值变为0，方差变为1
all_features[numeric_features] = all_features[numeric_features].apply(
    lambda x: (x - x.mean())/(x.std()))
# 填充nan为0
all_features[numeric_features] = all_features[numeric_features].fillna(0)
# 字符串变为one-hot编码encoding
# pd.get_dummies将all_features里的字符串自动变为one-hot编码，
#后面的是是否将nan也编为一个类
all_features = pd.get_dummies(all_features, dummy_na = True)
all_features.shape
# 分组
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)

print(train_features.shape)
print(test_features.shape)
# 损失函数
loss = nn.MSELoss()
in_features = train_features.shape[1]

def get_net():
    net = nn.Sequential(nn.Linear(in_features, 1))
    return net
# 对比较大的值做回归用log和相对误差
def log_rmse(net, features, labels):
#     inf是infinite无穷大，clamp是设置最小和最大值
    clipped_preds = torch.clamp(net(features), 1, float('inf'))
#     sqrt是开根号，这里loss的括号里两个log，为的是防止房价差距大了，而作相对误差
#     比如100w的差了10w，和10w差了10w这样子，所以用log，这样就能作除法，
#     这样就可以里面看和1的程度，外面看和0的接近程度
    rmse = torch.sqrt(loss(torch.log(clipped_preds), torch.log(labels)))
#     张量 torch.Tensor转为标量float 类型返回
    return rmse.item()


# 训练，调整权重，并将误差添加到train_ls, test_ls并返回
def train(net, train_features, train_labels, test_features, test_labels,
          num_epochs, learning_rate, weight_decay, batch_size):
    train_ls, test_ls = [], []
    train_iter = d2l.load_array((train_features, train_labels), batch_size)
    #     这里的Adam和sgd差不多，但更为平滑，且对学习率不是特别敏感
    optimizer = torch.optim.Adam(net.parameters(), 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(X), y)
            l.backward()
            optimizer.step()
        #       计算得到的 Log RMSE 添加到 train_ls 列表中。
        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
# k折交叉验证
# 就是把一个数据集分为k分，把第i份单独放在valid里，其他的放在train里
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):
#         slice（a，b，c）是在括号里，从a到b，步长为c走一遍
        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
# 返回训练和验证误差的平均值
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()
#         这里*data是解包，即将data解开成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]
#         下面d2l.plot是绘制图片
        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'fold {i + 1}, train log rmse {float(train_ls[-1]):f}, '
              f'valid log rmse {float(valid_ls[-1]):f}')
    return train_l_sum / k, valid_l_sum / k
# 调参数，进行k折交叉验证和画图
k, num_epochs, lr, weight_decay, batch_size = 10, 100, 5, 0.0001, 16
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='epochs',
             ylabel='log rmse', xlim=[1, num_epochs], yscale='log')
    print(f'train log rmse {float(train_ls[-1]):f}')
    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)


train_and_pred(train_features, test_features, train_labels, test_data,
               num_epochs, lr, weight_decay, batch_size)