Task5 模型结果融合

Task5 模型结果融合

5.1 模型融合目标

• 对于多种调参完成的模型进行模型融合。
• 完成对于多种模型的融合，提交融合结果并打卡。

5.2 内容介绍

模型融合是比赛后期一个重要的环节，大体来说有如下的类型方式。

1. 简单加权融合:

   • 回归（分类概率）：算术平均融合（Arithmetic mean），几何平均融合（Geometric mean）；
   • 分类：投票（Voting)
   • 综合：排序融合(Rank averaging)，log融合

   2.stacking/blending:

• 构建多层模型，并利用预测结果再拟合预测。

​ boosting/bagging（在xgboost，Adaboost,GBDT中已经用到）:

• 多树的提升方法

5.3 代码实战

本次代码讲解结合的是天池比赛的二手车价格进行预测。

5.3.1 模型定义

首先我们在这里定义三种模型，机器学习中的线性回归模型、Xgboost模型、Lightgbm 模型和gbdt模型。

1. 定义线性回归模型

   def build_model_lr(x_train,y_train):
       reg_model = linear_model.LinearRegression()
       reg_model.fit(x_train,y_train)
       return reg_model
   

2. 定义Xgboost 模型

   def build_model_xgb(x_train,y_train):
       model = xgb.XGBRegressor(n_estimators=120, learning_rate=0.08, gamma=0, subsample=0.8,\
           colsample_bytree=0.9, max_depth=5) #, objective ='reg:squarederror'
       model.fit(x_train, y_train)
       return model
   

3. 定义Lightgbm模型

def build_model_lgb(x_train,y_train):
    estimator = lgb.LGBMRegressor(num_leaves=63,n_estimators = 100)
    param_grid = {
        'learning_rate': [0.01, 0.05, 0.1],
    }
    gbm = GridSearchCV(estimator, param_grid)
    gbm.fit(x_train, y_train)
    return gbm

4. 定义gbdt模型

   def build_model_gbdt(x_train,y_train):
       estimator =GradientBoostingRegressor(loss='ls',subsample= 0.85,max_depth= 5,n_estimators = 100)
       param_grid = { 
               'learning_rate': [0.05,0.08,0.1,0.2],
               }
       gbdt = GridSearchCV(estimator, param_grid,cv=3)
       gbdt.fit(x_train,y_train)
       print(gbdt.best_params_)
       # print(gbdt.best_estimator_ )
       return gbdt
   

5.3.2 划分数据集进行训练和预测

划分数据集

## Split data with val
x_train,x_val,y_train,y_val = train_test_split(X_data,Y_data,test_size=0.3)

用模型进行训练和预测

## Train and Predict
print('Predict LR...')
model_lr = build_model_lr(x_train,y_train)
val_lr = model_lr.predict(x_val)
subA_lr = model_lr.predict(X_test)

print('predict XGB...')
model_xgb = build_model_xgb(x_train,y_train)
val_xgb = model_xgb.predict(x_val)
subA_xgb = model_xgb.predict(X_test)

print('predict lgb...')
model_lgb = build_model_lgb(x_train,y_train)
val_lgb = model_lgb.predict(x_val)
subA_lgb = model_lgb.predict(X_test)

print('Predict GBDT...')
model_gbdt = build_model_gbdt(x_train,y_train)
val_gbdt = model_gbdt.predict(x_val)
subA_gbdt = model_gbdt.predict(X_test)

5.3.3 简单加权融和

所谓加权平均其实就是简单的算术平均，把几个模型的结果按照一定的算术比例重新生成一个新的结果。

def Weighted_method(test_pre1,test_pre2,test_pre3,w=[1/3,1/3,1/3]):
    Weighted_result = w[0]*pd.Series(test_pre1)+w[1]*pd.Series(test_pre2)+w[2]*pd.Series(test_pre3)
    return Weighted_result

## Init the Weight
w = [0.3,0.4,0.3]

## 测试验证集准确度
val_pre = Weighted_method(val_lgb,val_xgb,val_gbdt,w)
MAE_Weighted = mean_absolute_error(y_val,val_pre)
print('MAE of Weighted of val:',MAE_Weighted)

## 预测数据部分
subA = Weighted_method(subA_lgb,subA_xgb,subA_gbdt,w)

上面的w就是比例系数，然后把三个模型的结果按照系数平均融合成一个新的结果。这种思想还是用到数学里面一个比较简单的思想。

5.3.4 Stacking 融合

Staking融合的简单理解就是利用模型生成的训练集、验证集和测试集，然后利用在第二 层利用新的模型再跑一次第一层模型的训练集，然后进行预测。

1.利用第一层模型生成新的训练集、验证集和测试集

## 第一层
train_lgb_pred = model_lgb.predict(x_train)
train_xgb_pred = model_xgb.predict(x_train)
train_gbdt_pred = model_gbdt.predict(x_train)

Strak_X_train = pd.DataFrame()
Strak_X_train['Method_1'] = train_lgb_pred
Strak_X_train['Method_2'] = train_xgb_pred
Strak_X_train['Method_3'] = train_gbdt_pred

Strak_X_val = pd.DataFrame()
Strak_X_val['Method_1'] = val_lgb
Strak_X_val['Method_2'] = val_xgb
Strak_X_val['Method_3'] = val_gbdt

Strak_X_test = pd.DataFrame()
Strak_X_test['Method_1'] = subA_lgb
Strak_X_test['Method_2'] = subA_xgb
Strak_X_test['Method_3'] = subA_gbdt

2.第二层利用新的模型进行预测

## level2-method 
model_lr_Stacking = build_model_lr(Strak_X_train,y_train)
## 训练集
train_pre_Stacking = model_lr_Stacking.predict(Strak_X_train)
print('MAE of Stacking-LR:',mean_absolute_error(y_train,train_pre_Stacking))

## 验证集
val_pre_Stacking = model_lr_Stacking.predict(Strak_X_val)
print('MAE of Stacking-LR:',mean_absolute_error(y_val,val_pre_Stacking))

## 预测集
print('Predict Stacking-LR...')
subA_Stacking = model_lr_Stacking.predict(Strak_X_test)

5.4 经验总结

比赛的融合这个问题，个人的看法来说其实涉及多个层面，也是提分和提升模型鲁棒性的一种重要方法：

• 1）结果层面的融合，这种是最常见的融合方法，其可行的融合方法也有很多，比如根据结果的得分进行加权融合，还可以做Log，exp处理等。在做结果融合的时候，有一个很重要的条件是模型结果的得分要比较近似，然后结果的差异要比较大，这样的结果融合往往有比较好的效果提升。
• 2）特征层面的融合，这个层面其实感觉不叫融合，准确说可以叫分割，很多时候如果我们用同种模型训练，可以把特征进行切分给不同的模型，然后在后面进行模型或者结果融合有时也能产生比较好的效果。
  合方法也有很多，比如根据结果的得分进行加权融合，还可以做Log，exp处理等。在做结果融合的时候，有一个很重要的条件是模型结果的得分要比较近似，然后结果的差异要比较大，这样的结果融合往往有比较好的效果提升。
• 2）特征层面的融合，这个层面其实感觉不叫融合，准确说可以叫分割，很多时候如果我们用同种模型训练，可以把特征进行切分给不同的模型，然后在后面进行模型或者结果融合有时也能产生比较好的效果。
• 3）模型层面的融合，模型层面的融合可能就涉及模型的堆叠和设计，比如加Staking层，部分模型的结果作为特征输入等，这些就需要多实验和思考了，基于模型层面的融合最好不同模型类型要有一定的差异，用同种模型不同的参数的收益一般是比较小的。