Pytorch实战Kaggle房价预测比赛

矫情吗；* 2023-06-13 13:27 2阅读 0赞

# 前言 #

这是分享的第一个Kaggle比赛，也是Kaggle中难度最低的比赛之一，房价预测是一个回归问题，给出了房子的一些特征要求预测房子的价格。本文使用Pytorch构建一个线性模型来完成预测。  
比赛地址为：我们可以在房价预测⽐赛的⽹⻚上了解⽐赛信息和参赛者成绩，也可以下载数据集并提交⾃⼰的预测结果。该⽐赛的⽹⻚地址是 https://www.kaggle.com/c/house-prices-advanced-regression-techniques 。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1c3Rfc29ydA_size_16_color_FFFFFF_t_70]

# 1. 获取和读取数据集 #

⽐赛数据分为训练数据集和测试数据集。两个数据集都包括每栋房⼦的特征，如街道类型、建造年份、  
房顶类型、地下室状况等特征值。这些特征值有连续的数字、离散的标签甚⾄是缺失值“na”。只有训练数据集包括了每栋房⼦的价格，也就是标签。我们可以访问⽐赛⽹⻚，点击的“Data”标签，并下载这些数据集。

导入头文件

import torch
    import torch.utils.data
    from IPython import display
    import torch.nn as nn
    import numpy as np
    import pandas as pd
    import sys
    import matplotlib.pyplot as plt

解压后的数据集被我放在F盘的根目录下，下面用pandas读取训练和测试文件。

train_data = pd.read_csv("F:\\house\\train.csv")
    test_data = pd.read_csv("F:\\house\\test.csv")

训练数据集包含1460个样本，80个特征和1个标签。

train_data.shape

(1460, 81)

test_data.shape

(1459, 80)

让我们来查看前4个样本的前4个特征，后2个特征和标签(SalePrice):

train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]]

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>Id</th> 
   <th>MSSubClass</th> 
   <th>MSZoning</th> 
   <th>LotFrontage</th> 
   <th>SaleType</th> 
   <th>SaleCondition</th> 
   <th>SalePrice</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>1</td> 
   <td>60</td> 
   <td>RL</td> 
   <td>65.0</td> 
   <td>WD</td> 
   <td>Normal</td> 
   <td>208500</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>2</td> 
   <td>20</td> 
   <td>RL</td> 
   <td>80.0</td> 
   <td>WD</td> 
   <td>Normal</td> 
   <td>181500</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>3</td> 
   <td>60</td> 
   <td>RL</td> 
   <td>68.0</td> 
   <td>WD</td> 
   <td>Normal</td> 
   <td>223500</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>4</td> 
   <td>70</td> 
   <td>RL</td> 
   <td>60.0</td> 
   <td>WD</td> 
   <td>Abnorml</td> 
   <td>140000</td> 
  </tr> 
 </tbody> 
</table>

可以看到第⼀个特征是Id，它能帮助模型记住每个训练样本，但难以推⼴到测试样本，所以我们不使⽤  
它来训练。我们将所有的训练数据和测试数据的79个特征按样本连结。

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

# 2. 预处理数据 #

我们对连续数值的特征做标准化（standardization）：设该特征在整个数据集上的均值为 μ \\mu μ，标准差为 σ \\sigma σ 。那么，我们可以将该特征的每个值先减去 再除以 得到标准化后的每个特征值。对于缺失的特征值，我们将其替换成该特征的均值。

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来替换缺失值
    all_features = all_features.fillna(0)

接下来将离散数值转成指示特征。举个例⼦，假设特征MSZoning⾥⾯有两个不同的离散值RL和RM，那  
么这⼀步转换将去掉MSZoning特征，并新加两个特征MSZoning\_RL和MSZoning\_RM，其值为0或1。  
如果⼀个样本原来在MSZoning⾥的值为RL，那么有MSZoning\_RL=1且MSZoning\_RM=0。

# dummy_na=True将缺失值也当作合法的特征值并为其创建指示特征
    all_features = pd.get_dummies(all_features, dummy_na=True)
    all_features.shape

(2919, 354)

可以看到这⼀步转换将特征数从79增加到了354。  
最后，通过 values 属性得到NumPy格式的数据，并转成 NDArray ⽅便后⾯的训练。

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)

# 3. 训练模型 #

我们使用一个基本的线性回归模型和平方损失函数来训练模型。

loss = torch.nn.MSELoss()
    
    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

下⾯定义⽐赛⽤来评价模型的对数均⽅根误差。给定预测值 y 1 ^ , . . . , y n ^ \\hat\{y\_1\},...,\\hat\{y\_n\} y1^,...,yn^和对应的真实标签 y 1 , . . . , y n y\_1,...,y\_n y1,...,yn，它的定义为：  
 1 n ∑ i = 1 n ( l o g ( y i ) − l o g ( y i ^ ) ) 2 \\sqrt\{\\frac\{1\}\{n\}\\sum\_\{i=1\}^n(log(y\_i)-log(\\hat\{y\_i\}))^2\} n1∑i=1n(log(yi)−log(yi^))2

对数均⽅根误差的实现如下:

def log_rmse(net, features, labels):
        with torch.no_grad():
            # 将小于1的值设成1，使得取对数时数值更稳定
            clipped_preds = torch.max(net(features), torch.tensor(1.0))
            rmse = torch.sqrt(2 * loss(clipped_preds.log(), labels.log()).mean())
        return rmse.item()

下⾯的训练函数跟本章中前⼏节的不同在于使⽤了Adam优化算法。相对之前使⽤的⼩批量随机梯度下  
降，它对学习率相对不那么敏感。

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

# 4. K折交叉验证 #

下⾯实现了⼀个函数，它返回第 i 折交叉验证时所需要的训练和验证数据。

def get_k_fold_data(k, i, X, y):
        # 返回第i折交叉验证时所需要的训练和验证数据
        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), dim=0)
                y_train = torch.cat((y_train, y_part), dim=0)
        return X_train, y_train, X_valid, y_valid

在k折交叉验证中我们训练k次并返回训练和验证的平均误差。有时候你会发现⼀组参数的训练误差可以达到很低，但是在k折交叉验证上的误差可能反⽽较⾼。这种现象很可能是由过拟合造成的。因此，当训练误差降低时，我们要观察k折交叉验证上的误差是否也相应降低。

我们先定义作图函数`semilogy`，其中y轴使用了对数尺度。

def use_svg_display():
        # 用矢量图表示
        display.set_matplotlib_formats('svg')
    def set_figsize(figsize=(3.5, 2.5)):
        use_svg_display()
        # 设置图的尺寸
        plt.rcParams['figure.figsize'] = figsize

def semilogy(x_vals, y_vals, x_label, y_label, x2_vals=None, y2_vals=None, 
                 legend=None, figsize=(3.5, 2.5)):
        set_figsize(figsize)
        plt.xlabel(x_label)
        plt.ylabel(y_label)
        plt.semilogy(x_vals, y_vals)
        if x2_vals and y2_vals:
            plt.semilogy(x2_vals, y2_vals, linestyle=':')
            plt.legend(legend)
        plt.show()

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(X_train.shape[1])
            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:
                semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'rmse', 
                         range(1, num_epochs + 1), valid_ls, ['train', 'valid'])
            print('flod %d, train rmse %f, valid rmse %f' % (i, train_ls[-1], valid_ls[-1]))
        return train_l_sum / k, valid_l_sum / 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)
    print('%d-fold validation: avg train rmse %f, avg valid rmse %f'%(k, train_l, valid_l))

![在这里插入图片描述][2019111717241813.png]

flod 0, train rmse 0.239874, valid rmse 0.221404
    flod 1, train rmse 0.229332, valid rmse 0.269407
    flod 2, train rmse 0.232131, valid rmse 0.238519
    flod 3, train rmse 0.238633, valid rmse 0.218897
    flod 4, train rmse 0.231179, valid rmse 0.258849
    5-fold validation: avg train rmse 0.234230, avg valid rmse 0.241415

有时候你会发现⼀组参数的训练误差可以达到很低，但是在k折交叉验证上的误差可能反⽽较⾼。这种  
现象很可能是由过拟合造成的。因此，当训练误差降低时，我们要观察k折交叉验证上的误差是否也相  
应降低。

# 5. 预测并在KAGGLE上提交结果 #

下⾯定义预测函数。在预测之前，我们会使⽤完整的训练数据集来᯿新训练模型，并将预测结果存成提交所需要的格式。

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)
        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)

设计好模型并调好超参数之后，下⼀步就是对测试数据集上的房屋样本做价格预测。如果我们得到与交叉验证时差不多的训练误差，那么这个结果很可能是理想的，可以在Kaggle上提交结果。

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

![在这里插入图片描述][20191117172355284.png]

train rmse 0.229618

上述代码执⾏完之后会⽣成⼀个submission.csv⽂件。这个⽂件是符合Kaggle⽐赛要求的提交格式的。这时，我们可以在Kaggle上提交我们预测得出的结果，并且查看与测试数据集上真实房价（标签）的误差。具体来说有以下⼏个步骤：登录Kaggle⽹站，访问房价预测⽐赛⽹⻚，并点击右侧“Submit Predictions”或“Late Submission”按钮；然后，点击⻚⾯下⽅“Upload Submission File”图标所在的虚线框选择需要提交的预测结果⽂件；最后，点击⻚⾯最下⽅ “Make Submission”按钮就可以了。

--------------------

欢迎关注我的微信公众号GiantPadaCV，期待和你一起交流机器学习，深度学习，图像算法，优化技术，比赛及日常生活等。

![图片.png][.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1c3Rfc29ydA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019111717442293.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1c3Rfc29ydA==,size_16,color_FFFFFF,t_70
[2019111717241813.png]: https://img-blog.csdnimg.cn/2019111717241813.png
[20191117172355284.png]: https://img-blog.csdnimg.cn/20191117172355284.png
[.png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xOTIzNzExNS01M2E3NWVmOTQ2YjA0OTE3LnBuZw?x-oss-process=image/format,png