【问题3】：Kaggle练习题《房价预测》----分别采用的岭回归，随机森林，bagging模型，AdaBoost，XgBoost等。

た入场券 2022-03-20 16:40 175阅读 0赞

### **第一步:**导入基本的模块， 并且加载数据。 ###

import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    
    # index_col=0  将第0列作为行索引
    train_df = pd.read_csv('data/home_price/train.csv', index_col=0)
    test_df = pd.read_csv('data/home_price/test.csv', index_col=0)
    # print(train_df.head())
    # print(train_df.shape)

下面是读取出来的数据       数据集下载地址:[https://www.kaggle.com/c/house-prices-advanced-regression-techniques][https_www.kaggle.com_c_house-prices-advanced-regression-techniques]

<table> 
 <thead> 
  <tr> 
   <th>MSSubClass</th> 
   <th>MSZoning</th> 
   <th>LotFrontage</th> 
   <th>LotArea</th> 
   <th>Street</th> 
   <th>Alley</th> 
   <th>LotShape</th> 
   <th>LandContour</th> 
   <th>Utilities</th> 
   <th>LotConfig</th> 
   <th>...</th> 
   <th>PoolArea</th> 
   <th>PoolQC</th> 
   <th>Fence</th> 
   <th>MiscFeature</th> 
   <th>MiscVal</th> 
   <th>MoSold</th> 
   <th>YrSold</th> 
   <th>SaleType</th> 
   <th>SaleCondition</th> 
   <th>SalePrice</th> 
  </tr> 
  <tr> 
   <th>Id</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
   <th>&nbsp;</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>1</th> 
   <td>60</td> 
   <td>RL</td> 
   <td>65.0</td> 
   <td>8450</td> 
   <td>Pave</td> 
   <td>NaN</td> 
   <td>Reg</td> 
   <td>Lvl</td> 
   <td>AllPub</td> 
   <td>Inside</td> 
   <td>...</td> 
   <td>0</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>0</td> 
   <td>2</td> 
   <td>2008</td> 
   <td>WD</td> 
   <td>Normal</td> 
   <td>208500</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>20</td> 
   <td>RL</td> 
   <td>80.0</td> 
   <td>9600</td> 
   <td>Pave</td> 
   <td>NaN</td> 
   <td>Reg</td> 
   <td>Lvl</td> 
   <td>AllPub</td> 
   <td>FR2</td> 
   <td>...</td> 
   <td>0</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>0</td> 
   <td>5</td> 
   <td>2007</td> 
   <td>WD</td> 
   <td>Normal</td> 
   <td>181500</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>60</td> 
   <td>RL</td> 
   <td>68.0</td> 
   <td>11250</td> 
   <td>Pave</td> 
   <td>NaN</td> 
   <td>IR1</td> 
   <td>Lvl</td> 
   <td>AllPub</td> 
   <td>Inside</td> 
   <td>...</td> 
   <td>0</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>0</td> 
   <td>9</td> 
   <td>2008</td> 
   <td>WD</td> 
   <td>Normal</td> 
   <td>223500</td> 
  </tr> 
  <tr> 
   <th>4</th> 
   <td>70</td> 
   <td>RL</td> 
   <td>60.0</td> 
   <td>9550</td> 
   <td>Pave</td> 
   <td>NaN</td> 
   <td>IR1</td> 
   <td>Lvl</td> 
   <td>AllPub</td> 
   <td>Corner</td> 
   <td>...</td> 
   <td>0</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>0</td> 
   <td>2</td> 
   <td>2006</td> 
   <td>WD</td> 
   <td>Abnorml</td> 
   <td>140000</td> 
  </tr> 
  <tr> 
   <th>5</th> 
   <td>60</td> 
   <td>RL</td> 
   <td>84.0</td> 
   <td>14260</td> 
   <td>Pave</td> 
   <td>NaN</td> 
   <td>IR1</td> 
   <td>Lvl</td> 
   <td>AllPub</td> 
   <td>FR2</td> 
   <td>...</td> 
   <td>0</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>NaN</td> 
   <td>0</td> 
   <td>12</td> 
   <td>2008</td> 
   <td>WD</td> 
   <td>Normal</td> 
   <td>250000</td> 
  </tr> 
 </tbody> 
</table>

5 rows × 80 columns

kaggle平台提供了两张表，一张是带标签的数据（训练数据）， 一张是不带标签的数据（测试数据）。接下来，我想做的就是将带有标签数据的标签列删除，它也就变成不带标签的数据。在将测试数据与其进行合并。这么做主要是为了统一进行数据预处理的时候更加方便。等所有的需要的预处理进行完之后，我们再把他们分隔开。

### 第二步：合并数据 ###

prices = pd.DataFrame({'price': train_df['SalePrice'], 'log(price+1)': np.log1p(train_df['SalePrice'])})
    prices.hist()   # 画图 看一下标签是否平滑
    plt.show()
    
    y_train = np.log1p(train_df.pop('SalePrice'))  # 将原来的标签删除 剩下log(price+1)列的数据
    all_df = pd.concat((train_df, test_df), axis=0) # 将train_df, test_df合并

我们这里除了将标签取下来，还构造了一个新列log(price+1) 这样主要是为了不让数据倾斜。  也就是让数据尽可能服从高斯分布。log1p(x) 就是log(x+1)。  这里我们将数据进行了平滑，那么按“怎么来的怎么去”原则，最后的预测结果就需要expm1()。 也就是将预测结果变为真实的房价数。   log1p反运算就是expm1()

### 第三步：特征工程（处理缺失值等） ###

# 有些数据的取值只有四五，或者可数个。这类数据我们转为one_hot编码
    
    # 发现MSSubClass值应该是分类值
    print(all_df['MSSubClass'].dtypes)  # int64
    all_df['MSSubClass'] = all_df['MSSubClass'].astype(str)
    print(all_df['MSSubClass'].value_counts())
    # 我们将category的变量转变为numerical表达形式
    # 当我们用numerical来表达categorical的时候，要注意，数字本身有大小。
    # 不能乱指定大小，我们采用one_hot编码
    # pandas自带的get_dummies方法可以一键做到one_hot
    print(pd.get_dummies(all_df['MSSubClass'], prefix='MSSubClass').head())
    # 此刻MSSubClass被我们分成了12个column，每一个代表一个category。是就是1，不是就是0。
    
    # 同理,我们把所有的category数据都转化为One_hot
    all_dummy_df = pd.get_dummies(all_df)
    
    
    # 缺失值处理
    
    # 统计每列缺失值情况
    print(all_dummy_df.isnull().sum().sort_values(ascending=False).head())
    # 可以看到，缺失最多的column是LotFrontage
    # 处理这些缺失的信息，得靠好好审题。一般来说，数据集的描述里会写的很清楚，这些缺失都代表着什么。当然，如果实在没有的话，也只能靠自己的『想当然』。。
    # 在这里，我们用平均值来填满这些空缺
    
    # 我们用均值填充
    mean_cols = all_dummy_df.mean()
    all_dummy_df = all_dummy_df.fillna(mean_cols)
    
    # 再检查一下是否有缺失值
    print(all_dummy_df.isnull().sum().sum())
    
    
    # 标准化数字型数据
    
    # 标准化numerical数据¶
    # 这一步并不是必要，但是得看你想要用的分类器是什么。一般来说，regression的分类器都比较傲娇，最好是把源数据给放在一个标准分布内。不要让数据间的差距太大。
    # 这里，我们当然不需要把One-Hot的那些0/1数据给标准化。我们的目标应该是那些本来就是numerical的数据：
    
    # 先找出数字型数据
    numeric_cols = all_df.columns[all_df.dtypes != 'object']
    # print(numeric_cols)
    # 对其标准化
    numeric_col_mean = 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_mean) / numeric_col_std
    
    # 将合并的数据此时进行拆分  分为训练数据和测试数据
    dummy_train_df = all_dummy_df.loc[train_df.index]
    dummy_test_df = all_dummy_df.loc[test_df.index]

这一步我们分别进行了：将训练数据和测试数据进行合并，主要是为了方便进行统一处理； 将category型的数据转化为one_hot编码； 对缺失值进行填充； 标准化数据； 将合并的数据又分开。

### 第四步：模型的建立，预测 ###

**模型1：岭回归**

from sklearn.linear_model import Ridge
    from sklearn.model_selection import cross_val_score
    
    X_train = dummy_train_df.values
    X_test = dummy_test_df.values
    
    alphas = np.logspace(-3, 2, 50)
    test_scores = []
    for alpha in alphas:
        clf = Ridge(alpha)
        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))
    
    # 看那个alpha下 模型预测的更好
    plt.plot(alphas, test_scores)
    plt.title('Alpha vs CV Error')
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70][]

根据图像发现alpha值为15左右的时候,模型最佳。 均方误差值为：0.135左右

**模型二：随机森林（基本模型我们设为岭回归。一般默认为回归树）**

from sklearn.ensemble import RandomForestRegressor
    
    max_features = [0.1, 0.3, 0.5, 0.7, 0.9, 0.99]
    test_scores = []
    for max_feat in max_features:
        clf = RandomForestRegressor(n_estimators=200, max_features=max_feat)
        test_score = np.sqrt(-cross_val_score(clf, X_train, y_train, cv=5, scoring='neg_mean_squared_error'))
        test_scores.append(np.mean(test_score))
    plt.plot(max_features, test_scores)
    plt.title('Max Features vs CV Error')
    plt.show()

max\_features 代表的划分是考虑的最大特征数，可以是大于1的具体数字， 代表考虑多少个特征。 如果是小于1的数字，代表的是特征的百分之多少。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 1][]

从上图中我们可以看到当max\_feature为0.3左右的时候，均方误差最小。大概也是0.135

**模型三：Stacking集成 （用stacking的思维来汲取两种或多种模型的优点）**

# 我们用一个Stacking的思维来汲取两种或多种模型的优点
    ridge = Ridge(alpha=15)
    rf = RandomForestRegressor(n_estimators=500, max_features=0.3)
    
    ridge.fit(X_train, y_train)
    rf.fit(X_train, y_train)
    
    # 上面提到了，因为最前面我们给label做了个log(1+x), 于是这里我们需要把predit的值给exp回去，并且减掉那个"1"
    # 所以就是我们的expm1()函数。
    
    y_ridge = np.expm1(ridge.predict(X_test))
    y_rf = np.expm1(rf.predict(X_test))
    
    y_final = (y_ridge + y_rf) / 2
    submission_df = pd.DataFrame(data={'ID': test_df.index, 'SalePrice': y_final})
    # print(submission_df)

submission\_df 就是我们这场比赛需要提交的结果。也就是测试样本的预测值。

**模型四： bagging模型**

from sklearn.ensemble import BaggingRegressor
    from sklearn.model_selection import cross_val_score
    
    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))
    plt.plot(params, test_scores)
    plt.title('n_estimator vs CV Error')
    plt.show()

bagging就是把多个小分类器放在一起，每个train随机选取一部分，然后把他们的最终结果综合起来（投票制）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 2][]

分类器个数为10个的时候  均方误差最小，大概为0.132。 比前面的几种模型好

** 模型五：Adaboost**

from sklearn.ensemble import AdaBoostRegressor
    
    params = [10, 15, 20, 25, 30, 35, 40, 45, 50]
    test_scores = []
    for param in params:
        clf = AdaBoostRegressor(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))
    
    plt.plot(params, test_scores)
    plt.title("n_estimator vs CV Error")

这里的基本分类器依旧是岭回归  ，我们找的还是基分类器个数与均方误差的关系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 3][]

Adaboos+Ridge, 用35个弱分类器的情况下，均方误差能降到0.141左右。。可以再增加基分类器个数 看图像的走势

**模型六：Kaggle神器：XgBoost  **

from xgboost import XGBRegressor
    
    # 用sklearn自带的cross validation方法来测试模型
    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))
    plt.plot(params, test_scores)
    plt.title('max_depth vs CV Error')
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 4][]

惊了，深度为5的时候，错误率缩小到0.127。。这就是为什么，浮躁的竞赛圈，人人都在用XGBoost

[https_www.kaggle.com_c_house-prices-advanced-regression-techniques]: https://www.kaggle.com/c/house-prices-advanced-regression-techniques
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70]: /images/20220320/fef9be22057342e4b9800daf57933bf6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 1]: /images/20220320/69d09041dffa4821807ecea7ff1e67dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 2]: /images/20220320/7b273d7a6a9248688eadf43e727ed7b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 3]: /images/20220320/022122b768b94f168235f85b527d1cc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 4]: /images/20220320/be2f00eaee1b4250871c33432cb09253.png