集成学习（Ensemble Learning）和模型融合
文章目录
- 1 集成学习概述
- 2 Boosting
- 2.1 AdaBoost[Freund and Schapire,1997]
- 2.2 boosting tree（提升树）
- 2.3 Gradient Tree Boosting （GB\(R\)T，梯度提升树）
- 2.4 XGBoost
- 2.5 LightGBM
- 3 Bagging
- 3.1 Bagging
- 3.2 随机森林（Random Forest）
- 4 学习法（Stacking）
- 5 ensemble
- 6 sklearn.ensemble实现集成学习
1 集成学习概述
Ensemble Learning 是指将多个不同的 Base Model 组合成一个 Ensemble Model 的方法。它可以同时降低最终模型的 Bias 和 Variance，从而在提高分数的同时又降低 Overfitting 的风险。在现在的 Kaggle 比赛中要不用 Ensemble 就拿到奖金几乎是不可能的。
集成学习的两大问题：每一轮如何改变训练数据的权值？如何将弱分类器组合成一个强分类器？
从理论上讲，Ensemble 要成功，有两个要素：
- Base Model 之间的相关性要尽可能的小。Ensemble 的 Diversity 越大，最终 Model 的 Bias 就越低。
- Base Model 之间的性能表现不能差距太大，最好个体学习器的性能都是比较好的。这其实是一个 Trade-off，在实际中很有可能表现相近的 Model 只有寥寥几个而且它们之间相关性还不低。但是实践告诉我们即使在这种情况下 Ensemble 还是能大幅提高成绩。
2 Boosting
能够降低模型的bias，迭代地训练 Base Model，每次根据上一个迭代中预测错误的情况修改训练样本的权重。也即 Gradient Boosting 的原理。比 Bagging 效果好，但更容易 Overfit。
2.1 AdaBoost[Freund and Schapire,1997]
提高前一轮弱分类器错误分类样本的权值，降低被正确分类样本的权值。
加权投票法组合分类器
AdaBoost算法：
输入：训练数据集 T = ( x 1 , y 1 ) , . . . , ( x m , y m ) T={(x_1,y_1),...,(x_m,y_m)} T=(x1,y1),...,(xm,ym)，其中 x i ∈ R n , y i ∈ { − 1 , + 1 } x_i\in \mathbb{R}^n,y_i\in \{-1,+1\} xi∈Rn,yi∈{−1,+1}；弱学习器算法。
输出：最终分类器 G ( x ) G(x) G(x)。
（1）初始化训练数据的权值
D 1 = ( w 11 , . . . , w 1 m ) , w 1 i = 1 m , i = 1 , 2 , . . . , m D_1=(w_{11},...,w_{1m}),w_{1i}=\frac{1}{m},i=1,2,...,m D1=(w11,...,w1m),w1i=m1,i=1,2,...,m
（2）依次对K个弱学习器进行学习， k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K
\quad （a）使用相同权值分布 D k D_k Dk的训练数据集学习，得到基本分类器
G k ( x ) → { − 1 , + 1 } G_k(x)\to\{-1,+1\} Gk(x)→{−1,+1}
\quad （b）计算 G k ( x ) G_k(x) Gk(x)在训练数据集上的分类误差率，删除 e k ≥ 1 2 e_k\ge \frac{1}{2} ek≥21的基学习器，说明基学习器比随机猜测还差。
e k = P ( G k ( x i ) = ̸ y i ) = ∑ i = 1 m w k i I ( G k ( x i ) = ̸ y i ) \displaystyle e_k=P(G_k(x_i)=\not y_i)=\sum_{i=1}^mw_{ki}I(G_k(x_i)=\not y_i) ek=P(Gk(xi)=yi)=i=1∑mwkiI(Gk(xi)=yi)
\quad （c）计算 G k ( x ) G_k(x) Gk(x)的系数
α k = 1 2 l n 1 − e k e k \alpha_k=\frac{1}{2}ln\frac{1-e_k}{e_k} αk=21lnek1−ek
\quad （d）更新训练数据的权值
D k + 1 = ( w k + 1 , 1 , . . . , w k + 1 , m ) , w k + 1 , i = w k i Z k e α k y i G k ( x i ) , i = 1 , 2 , . . . , m D_{k+1}=(w_{k+1,1},...,w_{k+1,m}),w_{k+1,i}=\frac{w_{ki}}{Z_k}e^{\alpha_ky_iG_k(x_i)},i=1,2,...,m Dk+1=(wk+1,1,...,wk+1,m),wk+1,i=ZkwkieαkyiGk(xi),i=1,2,...,m
这里， Z k Z_k Zk是规范化因子 Z k = ∑ i = 1 m w k i e α k y i G k ( x i ) \displaystyle Z_k=\sum^m_{i=1}w_{ki}e^{\alpha_ky_iG_k(x_i)} Zk=i=1∑mwkieαkyiGk(xi)，它使 D k + 1 D_{k+1} Dk+1成为一个概率分布。
（3）构建基本分类器的线性组合
f ( x ) = ∑ k = 1 K α k G k ( x ) \displaystyle f(x)=\sum_{k=1}^K\alpha_kG_k(x) f(x)=k=1∑KαkGk(x)
得到最终分类器：
G ( x ) = s i g n ( f ( x ) ) G(x)=sign(f(x)) G(x)=sign(f(x))
参考：《统计学习方法》李航
2.2 boosting tree（提升树）
提升树算法（向前分布算法，逐渐减少残差）
注：提升树算法仅在损失函数为平方误差损失函数时适用。
输入：训练数据集 T = ( x 1 , y 1 ) , . . . , ( x m , y m ) T={(x_1,y_1),...,(x_m,y_m)} T=(x1,y1),...,(xm,ym)，其中 x i ∈ R n , y i ∈ { − 1 , + 1 } x_i\in \mathbb{R}^n,y_i\in \{-1,+1\} xi∈Rn,yi∈{−1,+1}。
输出：提升树 f K ( x ) f_K(x) fK(x)。
（1）初始化 f 0 ( x ) = 0 f_0(x)=0 f0(x)=0
（2）对K棵决策树， k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K
\quad （a）计算残差： r k i = y i − f k − 1 ( x i ) , i = 1 , 2 , . . . , m r_{ki}=y_i-f_{k-1}(x_i),i=1,2,...,m rki=yi−fk−1(xi),i=1,2,...,m
\quad （b）拟合残差学习一个回归树： T ( x ; Θ k ) T(x;\Theta_k) T(x;Θk)
\quad （c）更新： f k ( x ) = f k − 1 ( x ) + T ( x ; Θ k ) f_k(x)=f_{k-1}(x)+T(x;\Theta_k) fk(x)=fk−1(x)+T(x;Θk)
（3）得到回归问题的提升树（分类问题即对回归问题的提升树进行符号函数变换）：
f K ( x ) = ∑ k = 1 K T ( x ; Θ k ) f_K(x)=\sum_{k=1}^KT(x;\Theta_k) fK(x)=k=1∑KT(x;Θk)
参考：《统计学习方法》李航
2.3 Gradient Tree Boosting （GB(R)T，梯度提升树）
梯度提升树算法（一般化的提升树算法）
输入：训练数据集 T = ( x 1 , y 1 ) , . . . , ( x m , y m ) T={(x_1,y_1),...,(x_m,y_m)} T=(x1,y1),...,(xm,ym)，其中 x i ∈ R n , y i ∈ { − 1 , + 1 } x_i\in \mathbb{R}^n,y_i\in \{-1,+1\} xi∈Rn,yi∈{−1,+1}；损失函数 L ( y , f ( x ) ) L(y,f(x)) L(y,f(x))。
输出：提升树 f ^ ( x ) \hat f(x) f^(x)。
（1）初始化 f 0 ( x ) = a r g m i n c ∑ i = 1 m L ( y i , c ) f_0(x)=arg min_c\sum^m_{i=1}L(y_i,c) f0(x)=argminc∑i=1mL(yi,c)
（2）对K棵决策树， k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K
\quad （a）计算损失函数的负梯度： r k i = − ∂ L ( y i , f k − 1 ( x i ) ) ∂ f k − 1 ( x i ) , i = 1 , 2 , . . . , m r_{ki}=-\frac{\partial L(y_i,f_{k-1}(x_i))}{\partial f_{k-1}(x_i)},i=1,2,...,m rki=−∂fk−1(xi)∂L(yi,fk−1(xi)),i=1,2,...,m
\quad （b）对 r k i r_{ki} rki拟合一个回归树，得到第K棵树的叶结点区域： R k j , j = 1 , 2 , . . . J R_{kj},j=1,2,...J Rkj,j=1,2,...J
\quad （c）对 j = 1 , 2 , . . . , J j=1,2,...,J j=1,2,...,J，计算 c k j = a r g m i n c ∑ x i ∈ R k j L ( y i , f k − 1 ( x i ) + c ) \displaystyle c_{kj}=argmin_c\sum_{x_i\in R_{kj}}L(y_i,f_{k-1}(x_i)+c) ckj=argmincxi∈Rkj∑L(yi,fk−1(xi)+c)
\quad （d）更新： f k ( x ) = f k − 1 ( x ) + ∑ j = 1 J c k j I ( x ∈ R k j ) f_k(x)=f_{k-1}(x)+\sum_{j=1}^Jc_{kj}I(x\in R_{kj}) fk(x)=fk−1(x)+∑j=1JckjI(x∈Rkj)
（3）得到回归问题的提升树（分类问题即对回归问题的提升树进行符号函数变换）：
f ^ ( x ) = f K ( x ) = ∑ k = 1 K ∑ j = 1 J c k j I ( x ∈ R k j ) \displaystyle \hat f(x)=f_K(x)=\sum_{k=1}^K\sum_{j=1}^Jc_{kj}I(x\in R_{kj}) f^(x)=fK(x)=k=1∑Kj=1∑JckjI(x∈Rkj)
2.4 XGBoost
XGBoost详解
2.5 LightGBM
LGB详解
3 Bagging
独立的训练一些基学习器(一般倾向于强大而复杂的模型比如完全生长的决策树)，然后综合他们的预测结果。
3.1 Bagging
通常为了获得差异性较大的基学习器，我们对不同的基学习器给不同的训练数据集。根据采样方式有以下变体：
Pasting:直接从样本集里随机抽取的到训练样本子集
Bagging:自助采样(有放回的抽样)得到训练子集
Random Subspaces:列采样,按照特征进行样本子集的切分
Random Patches:同时进行行采样、列采样得到样本子集
当训练了许多基学习器后，将他们简单平均（连续）或投票法（离散）得到最终学习器。
这里给出投票法的几种类型：
绝对多数投票法：如果标记投票超过半数则预测标记，否则拒绝预测。
相对多数投票法：预测为得票最多的标记，若有多个得票相同，则随机选取一个。
加权投票法：以学习器的准确率为权重加权投票，并选择最多的票数标记。
时间复杂度：O(m)
3.2 随机森林（Random Forest）
随机森林在基学习器较少的时候表现不太好，但随着基学习器数目的增加，随机森林通常会收敛到更低的方差。
和决策树算法类似，先从候选划分属性中随机选取 k = l o g 2 d k=log_2d k=log2d（推荐）个属性，接着用划分算法选择最优的属性，构建基决策树们。然后做法和bagging相同，用简单平均（连续）或投票法（离散）得到最终学习器。
极端随机森林即k=1
4 学习法（Stacking）
Stacking：这里会详细介绍。
5 ensemble
ensemble就是加权平均多个模型的结果，如
ensemble = stacked_pred*0.70 + xgb_pred*0.15 + lgb_pred*0.15
6 sklearn.ensemble实现集成学习
.AdaBoostRegressor(base_estimator=None, n_estimators=50, learning_rate=1.0, loss=’linear’, random_state=None)
n_estimators：基学习器数量
base_estimator：基学习器类型，默认.tree.DecisionTreeRegressor(max_depth=3)
.AdaBoostClassifier(base_estimator=None, n_estimators=50, learning_rate=1.0, algorithm=’SAMME.R’, random_state=None).BaggingClassifier(base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None, random_state=None, verbose=0).BaggingRegressor(base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None, random_state=None, verbose=0).RandomForestClassifier(n_estimators=’warn’, criterion=’gini’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None).RandomForestRegressor(n_estimators=’warn’, criterion=’mse’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False).ExtraTreesClassifier(n_estimators=’warn’, criterion=’gini’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=False, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None).ExtraTreesRegressor(n_estimators=’warn’, criterion=’mse’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=False, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False).VotingClassifier(estimators, voting=’hard’, weights=None, n_jobs=None, flatten_transform=True)
voting：默认hard表示绝对多数投票法，即选择超过半数的票数；若为soft表示相对多数投票法，即选择最多票数。
.VotingRegressor(estimators, weights=None, n_jobs=None)[source].GradientBoostingClassifier(loss=’deviance’, learning_rate=0.1, n_estimators=100, subsample=1.0, criterion=’friedman_mse’, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_decrease=0.0, min_impurity_split=None, init=None, random_state=None, max_features=None, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’, validation_fraction=0.1, n_iter_no_change=None, tol=0.0001).GradientBoostingRegressor(loss=’ls’, learning_rate=0.1, n_estimators=100, subsample=1.0, criterion=’friedman_mse’, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_decrease=0.0, min_impurity_split=None, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’, validation_fraction=0.1, n_iter_no_change=None, tol=0.0001).HistGradientBoostingClassifier(loss=’auto’, learning_rate=0.1, max_iter=100, max_leaf_nodes=31, max_depth=None, min_samples_leaf=20, l2_regularization=0.0, max_bins=256, scoring=None, validation_fraction=0.1, n_iter_no_change=None, tol=1e-07, verbose=0, random_state=None)：数据量较大时效果比GradientBoostingClassifier好得多。.HistGradientBoostingRegressor(loss=’least_squares’, learning_rate=0.1, max_iter=100, max_leaf_nodes=31, max_depth=None, min_samples_leaf=20, l2_regularization=0.0, max_bins=256, scoring=None, validation_fraction=0.1, n_iter_no_change=None, tol=1e-07, verbose=0, random_state=None)
