李沐深度学习--kaggle比赛房价预测代码解析

不带下载版本，正常使用

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

train_data = pd.read_csv('../data/kaggle_house_pred/kaggle_house_pred_train.csv')# 下载并且读取训练集
test_data = pd.read_csv('../data/kaggle_house_pred/kaggle_house_pred_test.csv')# 下载并且读取测试集
# 训练集不要最后一行，测试集要最后一行,最后一行是售价，salePrice
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:])) #训练集和测试集和在一起
# 此处是数据处理
# 取出所有列名
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index
# 将所有数据进行标准化处理，  apply为数据处理方法
all_features[numeric_features] = all_features[numeric_features].apply(
    lambda x: (x - x.mean()) / (x.std()))# 标准差公式
# 在标准化数据之后，所有均值消失，因此我们可以将缺失值设置为0
all_features[numeric_features] = all_features[numeric_features].fillna(0)# 没值的 地方设置为0
# “Dummy_na=True”将“na”（缺失值）视为有效的特征值，并为其创建指示符特征
# 此处从80列扩充到331列因为同时把所有数据数字化了，
# 例如SaleType 可以取 oth、wd、nan 等数值，但是现在均设置为SaleType_Oth列、SaleType_WD、SaleType_nan列，
# 值为1或者0，表示值为此列的数，0表示不是，从而实现扩充
all_features = pd.get_dummies(all_features, dummy_na=True) # 独热编码，取值数字化，dummy_na=True是添加了 N 与 NAN 两列

n_train = train_data.shape[0] # 取训练集的行数
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32) #tensor 训练集数据
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)#tensor 测试集数据
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):
    # 为了在取对数时进一步稳定该值，将小于1的值设置为1
    clipped_preds = torch.clamp(net(features), 1, float('inf')) # float('inf')表示无穷大
    rmse = torch.sqrt(loss(torch.log(clipped_preds),
                           torch.log(labels)))
    return rmse.item()
# 使用Adam优化器训练，原因是对初始学习率不敏感
def train(net, train_features, train_labels, test_features, test_labels,
          num_epochs, learning_rate, weight_decay, batch_size): # weight_decay 是一个L2正则化数据，目的是权重衰退
    train_ls, test_ls = [], [] #列表
    train_iter = d2l.load_array((train_features, train_labels), batch_size) # 每个train_iter是64组数据
    # 这里使用的是Adam优化算法
    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) # 损失是一组数据64个的损失
            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 # 返回的是一个列表，即每一步的损失

def get_k_fold_data(k, i, X, y): # 获取K折后的训练集，以及验证集
    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)# slice(起始下标，结束下标)是取值范围，如100-200
        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)# 将X的训练集加入其中
            y_train = torch.cat([y_train, y_part], 0)# 将y的训练集加入其中
    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() # 线性模型
        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],# 此处train_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}, ' # 输出的是当前第i次的训练损失
              f'验证log rmse{float(valid_ls[-1]):f}') # 输出的是当前第i次的验证损失
    return train_l_sum / k, valid_l_sum / k # 返回的是K次下的平均损失

# 训练
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)# 获得的是K次平均损失
print(f'{k}-折验证: 平均训练log rmse: {float(train_l):f}, '
      f'平均验证log rmse: {float(valid_l):f}')