Kaggle比赛之房价预测

House Price房价预测

读取数据集

%matplotlib inline
import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import sys
sys.path.append("..")
from IPython import display
from matplotlib import pyplot as plt
torch.set_default_tensor_type(torch.FloatTensor)

train_data=pd.read_csv("train.csv")
test_data=pd.read_csv("test.csv")
# 看一下训练集和测试集的形状
#训练集是（1460,81），测试集是（1459,80）

#再看一下前四个样本的前四个特征，后两个特征和标签
train_data.iloc[0:4,[0,1,2,3,-3,-2,-1]]


#第一个特征用来标记样本，不用来训练。将所有的训练数据和测试数据的79个特征按样本连接
all_features=pd.concat((train_data.iloc[:,1:-1],test_data.iloc[:,1:]))

数据预处理

将连续数值的特征做标准化，对离散数值特征转成指示特征。
连续型：将特征的每个值减去均值再除以标准差。对于缺失的特征值，我们将其替换成该特征的均值。

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

接下来对离散数值特征进行转换，变为one hot型

all_features=pd.get_dummies(all_features,dummy_na=True) # dummy_na=True将缺失值也当作合法的特征值并为其创建指示特征
all_features.shape  #可以看到这一步转换将特征数从79增加到了331。

最后，通过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)

训练模型

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

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

接下来定义比赛用来评价模型的对数均方根误差。

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_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)
    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()         # 将参数更新值施加到net的parameters上
    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折交叉验证

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

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('fold %d, train rmse %f, valid rmse %f' % (i, train_ls[-1], valid_ls[-1]))
    return train_l_sum / k, valid_l_sum / k

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)

def set_figsize(figsize=(3.5, 2.5)):
    use_svg_display()
    # 设置图的尺寸
    plt.rcParams['figure.figsize'] = figsize

def use_svg_display():
    """Use svg format to display plot in jupyter"""
    display.set_matplotlib_formats('svg'

模型选择

我们使用一组未经调优的超参数并计算交叉验证误差，可以改动这些超参数来尽可能减小平均测试误差。

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

预测并在Kaggle提交结果

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

def train_and_pred(train_features,test_features,train_lables,test_data,num_epochs,lr,weifht_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(pred.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)