kaggle比赛：房价预测（基于MXNet框架）

kaggle比赛：房价预测

1. 获取和读取数据集

%matplotlib inline
from mxnet import autograd, gluon, init, nd
from mxnet.gluon import data as gdata, loss as gloss, nn
import numpy as np
import pandas as pd

train_data = pd.read_csv('kaggle_house_pred_train.csv')
test_data = pd.read_csv('kaggle_house_pred_test.csv')

# 查看数据集大小
train_data.shape

(1460, 81)

test_data.shape

(1459, 80)

# 查看数据集的前4个特征、后2个特征和标签（SalePrice）
train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]]

	Id	MSSubClass	MSZoning	LotFrontage	SaleType	SaleCondition	SalePrice
0	1	60	RL	65.0	WD	Normal	208500
1	2	20	RL	80.0	WD	Normal	181500
2	3	60	RL	68.0	WD	Normal	223500
3	4	70	RL	60.0	WD	Abnorml	140000

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

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

2. 预处理数据

对连续数值的特征做标准化：设该特征在整个数据集上的均值为$\mu$，标准差为$\sigma$。那么，我们可以将该特征的每个值先减去$\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[numeric_features] = all_features[numeric_features].fillna(0)

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

(2919, 331)

# 转换为NumPy
n_train = train_data.shape[0]

train_features = nd.array(all_features[:n_train].values)

test_features = nd.array(all_features[n_train:].values)

train_labels = nd.array(train_data.SalePrice.values).reshape((-1, 1))

3. 训练模型

采用线性回归模型和平方损失函数来训练模型

loss = gloss.L2Loss()

def get_net():
    net = nn.Sequential()
    net.add(nn.Dense(1))
    net.initialize()
    return net

给定预测值$\widehat{y_1},...,\widehat{y_n}$和对应的真实标签$y_1,...,y_n$，它的定义为：
$$\sqrt{\frac{1}{n}\sum _{i=1}^n(\log (y_i)-\log (\widehat{y_i}){)}^2}$$
对数均方误差的实现如下：

def log_rmse(net, features, labels):
    # 将小于1的值设成1，使取得对数时数值更稳定
    clipped_preds = nd.clip(net(features), 1, float('inf'))
    rmse = nd.sqrt(2 * loss(clipped_preds.log(), labels.log()).mean())
    return rmse.asscalar()

# adam优化算法
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 = gdata.DataLoader(gdata.ArrayDataset(train_features, train_labels), batch_size, shuffle=True)
    # adam
    trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': learning_rate, 'wd': weight_decay})
    for epoch in range(num_epochs):
        for X, y in train_iter:
            with autograd.record():
                l = loss(net(X), y)
            l.backward()
            trainer.step(batch_size)
        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折交叉验证

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 = nd.concat(X_train, X_part, dim=0)
            y_train = nd.concat(y_train, y_part, dim=0)
    return X_train, y_train, X_valid, y_valid

from utils import semilogy
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:
            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

5. 模型选择

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

​

​

fold 0, train rmse 0.169587, valid rmse 0.156890
fold 1, train rmse 0.162094, valid rmse 0.190214
fold 2, train rmse 0.163576, valid rmse 0.167963
fold 3, train rmse 0.167884, valid rmse 0.154819
fold 4, train rmse 0.162563, valid rmse 0.182855
5-fold validation: avg train rmse 0.165141, avg valid rmse 0.170548

6. 预测结果

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)
    semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'rmse')
    print('train rmse %f'% train_ls[-1])
    preds = net(test_features).asnumpy()
    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)

​

​

train rmse 0.162728