In [71]:
import numpy as np
import pandas as pd
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]:
这时候大概心里可以有数，哪些地方需要人为的处理一下，以做到源数据更加好被process。
In [74]:
%matplotlib inline
prices = pd.DataFrame({"price":train_df["SalePrice"], "log(price + 1)":np.log1p(train_df["SalePrice"])})
prices.hist()
Out[74]:
可见，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]:
而y_train则是SalePrice那一列
In [78]:
y_train.head()
Out[78]:
In [79]:
all_df['MSSubClass'].dtypes
Out[79]:
In [80]:
all_df['MSSubClass'] = all_df['MSSubClass'].astype(str)
变成str以后，做个统计，就很清楚了
In [81]:
all_df['MSSubClass'].value_counts()
Out[81]:
In [82]:
pd.get_dummies(all_df['MSSubClass'], prefix='MSSubClass').head()
Out[82]:
此刻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]:
In [84]:
all_dummy_df.isnull().sum().sort_values(ascending=False).head(10)
Out[84]:
可以看到，缺失最多的column是LotFrontage
处理这些缺失的信息，得靠好好审题。一般来说，数据集的描述里会写的很清楚，这些缺失都代表着什么。当然，如果实在没有的话，也只能靠自己的『想当然』。。
在这里，我们用平均值来填满这些空缺。
In [85]:
mean_cols = all_dummy_df.mean()
mean_cols.head(10)
Out[85]:
In [86]:
all_dummy_df = all_dummy_df.fillna(mean_cols)
看看是不是没有空缺了？
In [87]:
all_dummy_df.isnull().sum().sum()
Out[87]:
In [88]:
numeric_cols = all_df.columns[all_df.dtypes != 'object']
numeric_cols
Out[88]:
计算标准分布：(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
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]:
In [92]:
X_train = dummy_train_df.values
X_test = dummy_test_df.values
In [93]:
from sklearn.linear_model import Ridge
ridge = Ridge(15)
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
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模型，再做这个实验。。:P
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 :)
In [ ]: