Kaggle实战之房价预测案例-阿里云开发者社区

房价预测案例（进阶版）

这是进阶版的notebook。主要是为了比较几种模型框架。所以前面的特征工程部分内容，我也并没有做任何改动，重点都在后面的模型建造section

Step 1: 检视源数据集

In [71]:
import numpy as np
import pandas as pd

读入数据

一般来说源数据的index那一栏没什么用，我们可以用来作为我们pandas dataframe的index。这样之后要是检索起来也省事儿。

有人的地方就有鄙视链。跟知乎一样。Kaggle的也是个处处呵呵的危险地带。Kaggle上默认把数据放在input文件夹下。所以我们没事儿写个教程什么的，也可以依据这个convention来，显得自己很有逼格。。

In [72]:
train_df = pd.read_csv(’…/input/train.csv’, index_col=0)
test_df = pd.read_csv(’…/input/test.csv’, index_col=0)

检视源数据

In [73]:
train_df.head()
Out[73]:
MSSubClass MSZoning LotFrontage LotArea Street Alley LotShape LandContour Utilities LotConfig … PoolArea PoolQC Fence MiscFeature MiscVal MoSold YrSold SaleType SaleCondition SalePrice
Id
1 60 RL 65.0 8450 Pave NaN Reg Lvl AllPub Inside … 0 NaN NaN NaN 0 2 2008 WD Normal 208500
2 20 RL 80.0 9600 Pave NaN Reg Lvl AllPub FR2 … 0 NaN NaN NaN 0 5 2007 WD Normal 181500
3 60 RL 68.0 11250 Pave NaN IR1 Lvl AllPub Inside … 0 NaN NaN NaN 0 9 2008 WD Normal 223500
4 70 RL 60.0 9550 Pave NaN IR1 Lvl AllPub Corner … 0 NaN NaN NaN 0 2 2006 WD Abnorml 140000
5 60 RL 84.0 14260 Pave NaN IR1 Lvl AllPub FR2 … 0 NaN NaN NaN 0 12 2008 WD Normal 250000
5 rows × 80 columns

这时候大概心里可以有数，哪些地方需要人为的处理一下，以做到源数据更加好被process。

Step 2: 合并数据

这么做主要是为了用DF进行数据预处理的时候更加方便。等所有的需要的预处理进行完之后，我们再把他们分隔开。

首先，SalePrice作为我们的训练目标，只会出现在训练集中，不会在测试集中（要不然你测试什么？）。所以，我们先把SalePrice这一列给拿出来，不让它碍事儿。

我们先看一下SalePrice长什么样纸：

In [74]:
%matplotlib inline
prices = pd.DataFrame({“price”:train_df[“SalePrice”], “log(price + 1)”:np.log1p(train_df[“SalePrice”])})
prices.hist()
Out[74]:
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x10c05b5f8>,
<matplotlib.axes._subplots.AxesSubplot object at 0x10c095860>]], dtype=object)

可见，label本身并不平滑。为了我们分类器的学习更加准确，我们会首先把label给“平滑化”（正态化）

这一步大部分同学会miss掉，导致自己的结果总是达不到一定标准。

这里我们使用最有逼格的log1p, 也就是 log(x+1)，避免了复值的问题。

记住哟，如果我们这里把数据都给平滑化了，那么最后算结果的时候，要记得把预测到的平滑数据给变回去。

按照“怎么来的怎么去”原则，log1p()就需要expm1(); 同理，log()就需要exp(), … etc.

In [75]:
y_train = np.log1p(train_df.pop(‘SalePrice’))

然后我们把剩下的部分合并起来

In [76]:
all_df = pd.concat((train_df, test_df), axis=0)

此刻，我们可以看到all_df就是我们合在一起的DF

In [77]:
all_df.shape
Out[77]:
(2919, 79)

而y_train则是SalePrice那一列

In [78]:
y_train.head()
Out[78]:
Id
1 12.247699
2 12.109016
3 12.317171
4 11.849405
5 12.429220
Name: SalePrice, dtype: float64

Step 3: 变量转化

类似『特征工程』。就是把不方便处理或者不unify的数据给统一了。

正确化变量属性

首先，我们注意到，MSSubClass 的值其实应该是一个category，

但是Pandas是不会懂这些事儿的。使用DF的时候，这类数字符号会被默认记成数字。

这种东西就很有误导性，我们需要把它变回成string

In [79]:
all_df[‘MSSubClass’].dtypes
Out[79]:
dtype(‘int64’)
In [80]:
all_df[‘MSSubClass’] = all_df[‘MSSubClass’].astype(str)

变成str以后，做个统计，就很清楚了

In [81]:
all_df[‘MSSubClass’].value_counts()
Out[81]:
20 1079
60 575
50 287
120 182
30 139
160 128
70 128
80 118
90 109
190 61
85 48
75 23
45 18
180 17
40 6
150 1
Name: MSSubClass, dtype: int64

把category的变量转变成numerical表达形式

当我们用numerical来表达categorical的时候，要注意，数字本身有大小的含义，所以乱用数字会给之后的模型学习带来麻烦。于是我们可以用One-Hot的方法来表达category。

pandas自带的get_dummies方法，可以帮你一键做到One-Hot。

In [82]:
pd.get_dummies(all_df[‘MSSubClass’], prefix=‘MSSubClass’).head()
Out[82]:
MSSubClass_120 MSSubClass_150 MSSubClass_160 MSSubClass_180 MSSubClass_190 MSSubClass_20 MSSubClass_30 MSSubClass_40 MSSubClass_45 MSSubClass_50 MSSubClass_60 MSSubClass_70 MSSubClass_75 MSSubClass_80 MSSubClass_85 MSSubClass_90
Id
1 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0
4 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0
5 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0

此刻MSSubClass被我们分成了12个column，每一个代表一个category。是就是1，不是就是0。

同理，我们把所有的category数据，都给One-Hot了

In [83]:
all_dummy_df = pd.get_dummies(all_df)
all_dummy_df.head()
Out[83]:
LotFrontage LotArea OverallQual OverallCond YearBuilt YearRemodAdd MasVnrArea BsmtFinSF1 BsmtFinSF2 BsmtUnfSF … SaleType_ConLw SaleType_New SaleType_Oth SaleType_WD SaleCondition_Abnorml SaleCondition_AdjLand SaleCondition_Alloca SaleCondition_Family SaleCondition_Normal SaleCondition_Partial
Id
1 65.0 8450 7 5 2003 2003 196.0 706.0 0.0 150.0 … 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0
2 80.0 9600 6 8 1976 1976 0.0 978.0 0.0 284.0 … 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0
3 68.0 11250 7 5 2001 2002 162.0 486.0 0.0 434.0 … 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0
4 60.0 9550 7 5 1915 1970 0.0 216.0 0.0 540.0 … 0.0 0.0 0.0 1.0 1.0 0.0 0.0 0.0 0.0 0.0
5 84.0 14260 8 5 2000 2000 350.0 655.0 0.0 490.0 … 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0
5 rows × 303 columns

处理好numerical变量

就算是numerical的变量，也还会有一些小问题。

比如，有一些数据是缺失的：

In [84]:
all_dummy_df.isnull().sum().sort_values(ascending=False).head(10)
Out[84]:
LotFrontage 486
GarageYrBlt 159
MasVnrArea 23
BsmtHalfBath 2
BsmtFullBath 2
BsmtFinSF2 1
GarageCars 1
TotalBsmtSF 1
BsmtUnfSF 1
GarageArea 1
dtype: int64

可以看到，缺失最多的column是LotFrontage

处理这些缺失的信息，得靠好好审题。一般来说，数据集的描述里会写的很清楚，这些缺失都代表着什么。当然，如果实在没有的话，也只能靠自己的『想当然』。。

在这里，我们用平均值来填满这些空缺。

In [85]:
mean_cols = all_dummy_df.mean()
mean_cols.head(10)
Out[85]:
LotFrontage 69.305795
LotArea 10168.114080
OverallQual 6.089072
OverallCond 5.564577
YearBuilt 1971.312778
YearRemodAdd 1984.264474
MasVnrArea 102.201312
BsmtFinSF1 441.423235
BsmtFinSF2 49.582248
BsmtUnfSF 560.772104
dtype: float64
In [86]:
all_dummy_df = all_dummy_df.fillna(mean_cols)

看看是不是没有空缺了？

In [87]:
all_dummy_df.isnull().sum().sum()
Out[87]:
0

标准化numerical数据

这一步并不是必要，但是得看你想要用的分类器是什么。一般来说，regression的分类器都比较傲娇，最好是把源数据给放在一个标准分布内。不要让数据间的差距太大。

这里，我们当然不需要把One-Hot的那些0/1数据给标准化。我们的目标应该是那些本来就是numerical的数据：

先来看看哪些是numerical的：

In [88]:
numeric_cols = all_df.columns[all_df.dtypes != ‘object’]
numeric_cols
Out[88]:
Index([‘LotFrontage’, ‘LotArea’, ‘OverallQual’, ‘OverallCond’, ‘YearBuilt’,
‘YearRemodAdd’, ‘MasVnrArea’, ‘BsmtFinSF1’, ‘BsmtFinSF2’, ‘BsmtUnfSF’,
‘TotalBsmtSF’, ‘1stFlrSF’, ‘2ndFlrSF’, ‘LowQualFinSF’, ‘GrLivArea’,
‘BsmtFullBath’, ‘BsmtHalfBath’, ‘FullBath’, ‘HalfBath’, ‘BedroomAbvGr’,
‘KitchenAbvGr’, ‘TotRmsAbvGrd’, ‘Fireplaces’, ‘GarageYrBlt’,
‘GarageCars’, ‘GarageArea’, ‘WoodDeckSF’, ‘OpenPorchSF’,
‘EnclosedPorch’, ‘3SsnPorch’, ‘ScreenPorch’, ‘PoolArea’, ‘MiscVal’,
‘MoSold’, ‘YrSold’],
dtype=‘object’)

计算标准分布：(X-X’)/s

让我们的数据点更平滑，更便于计算。

注意：我们这里也是可以继续使用Log的，我只是给大家展示一下多种“使数据平滑”的办法。

In [89]:
numeric_col_means = all_dummy_df.loc[:, numeric_cols].mean()
numeric_col_std = all_dummy_df.loc[:, numeric_cols].std()
all_dummy_df.loc[:, numeric_cols] = (all_dummy_df.loc[:, numeric_cols] - numeric_col_means) / numeric_col_std

Step 4: 建立模型

把数据集分回训练/测试集

In [90]:
dummy_train_df = all_dummy_df.loc[train_df.index]
dummy_test_df = all_dummy_df.loc[test_df.index]
In [91]:
dummy_train_df.shape, dummy_test_df.shape
Out[91]:
((1460, 303), (1459, 303))
In [92]:
X_train = dummy_train_df.values
X_test = dummy_test_df.values

做一点高级的Ensemble

一般来说，单个分类器的效果真的是很有限。我们会倾向于把N多的分类器合在一起，做一个“综合分类器”以达到最好的效果。

我们从刚刚的试验中得知，Ridge(alpha=15)给了我们最好的结果

In [93]:
from sklearn.linear_model import Ridge
ridge = Ridge(15)
Bagging

Bagging把很多的小分类器放在一起，每个train随机的一部分数据，然后把它们的最终结果综合起来（多数投票制）。

Sklearn已经直接提供了这套构架，我们直接调用就行：

In [94]:
from sklearn.ensemble import BaggingRegressor
from sklearn.model_selection import cross_val_score

在这里，我们用CV结果来测试不同的分类器个数对最后结果的影响。

注意，我们在部署Bagging的时候，要把它的函数base_estimator里填上你的小分类器

（ridge）
In [95]:
params = [1, 10, 15, 20, 25, 30, 40]
test_scores = []
for param in params:
clf = BaggingRegressor(n_estimators=param, base_estimator=ridge)
test_score = np.sqrt(-cross_val_score(clf, X_train, y_train, cv=10, scoring=‘neg_mean_squared_error’))
test_scores.append(np.mean(test_score))
In [96]:
import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(params, test_scores)
plt.title(“n_estimator vs CV Error”);

可见，前一个版本中，ridge最优结果也就是0.135；而这里，我们使用25个小ridge分类器的bagging，达到了低于0.132的结果。

当然了，你如果并没有提前测试过ridge模型，你也可以用Bagging自带的DecisionTree模型：

代码是一样的，把base_estimator给删去即可

In [106]:
params = [10, 15, 20, 25, 30, 40, 50, 60, 70, 100]
test_scores = []
for param in params:
clf = BaggingRegressor(n_estimators=param)
test_score = np.sqrt(-cross_val_score(clf, X_train, y_train, cv=10, scoring=‘neg_mean_squared_error’))
test_scores.append(np.mean(test_score))
In [107]:
import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(params, test_scores)
plt.title(“n_estimator vs CV Error”);

咦，看来单纯用DT不太灵光的。最好的结果也就0.140

Boosting

Boosting比Bagging理论上更高级点，它也是揽来一把的分类器。但是把他们线性排列。下一个分类器把上一个分类器分类得不好的地方加上更高的权重，这样下一个分类器就能在这个部分学得更加“深刻”。

In [97]:
from sklearn.ensemble import AdaBoostRegressor
In [98]:
params = [10, 15, 20, 25, 30, 35, 40, 45, 50]
test_scores = []
for param in params:
clf = BaggingRegressor(n_estimators=param, base_estimator=ridge)
test_score = np.sqrt(-cross_val_score(clf, X_train, y_train, cv=10, scoring=‘neg_mean_squared_error’))
test_scores.append(np.mean(test_score))
In [99]:
plt.plot(params, test_scores)
plt.title(“n_estimator vs CV Error”);

Adaboost+Ridge在这里，25个小分类器的情况下，也是达到了接近0.132的效果。

同理，这里，你也可以不必输入Base_estimator，使用Adaboost自带的DT。

In [108]:
params = [10, 15, 20, 25, 30, 35, 40, 45, 50]
test_scores = []
for param in params:
clf = BaggingRegressor(n_estimators=param)
test_score = np.sqrt(-cross_val_score(clf, X_train, y_train, cv=10, scoring=‘neg_mean_squared_error’))
test_scores.append(np.mean(test_score))
In [109]:
plt.plot(params, test_scores)
plt.title(“n_estimator vs CV Error”);

看来我们也许要先tune一下我们的DT模型，再做这个实验。。😛

XGBoost

最后，我们来看看巨牛逼的XGBoost，外号：Kaggle神器

这依旧是一款Boosting框架的模型，但是却做了很多的改进。

In [100]:
from xgboost import XGBRegressor

用Sklearn自带的cross validation方法来测试模型

In [101]:
params = [1,2,3,4,5,6]
test_scores = []
for param in params:
clf = XGBRegressor(max_depth=param)
test_score = np.sqrt(-cross_val_score(clf, X_train, y_train, cv=10, scoring=‘neg_mean_squared_error’))
test_scores.append(np.mean(test_score))

存下所有的CV值，看看哪个alpha值更好（也就是『调参数』）

In [102]:
import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(params, test_scores)
plt.title(“max_depth vs CV Error”);

惊了，深度为5的时候，错误率缩小到0.127

这就是为什么，浮躁的竞赛圈，人人都在用XGBoost 😃

Kaggle实战之房价预测案例

热门文章

最新文章

相关课程

相关电子书

相关实验场景