1．概念

集成学习将多个训练的基础学习器进行结合，优化为更先进的学习器。集成学习模型的方式大致为以下几个：bagging、boosting、voting、stacking。它的特点是：

初始化，对m个训练样本的数据集(不同颜色代表不同数据集)，给每个样本分配初始权重(圆点越大，权重越大)；
使用带权重的数据集训练处一个弱学习器；
对弱学习器训练的错误样本增加权重；
新的带权重的数据集训练处下一个弱学习器；
如此重复，直到训练处的弱学习器达到事先指定的N，最终将N个弱学习器加权融合。

在sklearn中通过sklearn.ensemble包中实现。

2. 提升算法

提升算法是将一组弱学习器提升为强学习器的算法，也叫正向激励算法，最著名的是AdaBosst(adaptive boosting)算法。

在sklearn中通过sklearn.ensemble.AdaBoostClassifier和sklearn.ensemble.AdaBoostRegressor来实现。

#AdaBoost提升算法
from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import make_classification
def my_AdaBoost():
    x,y =  make_classification(n_samples=100000,n_features=50,n_informative=30,n_clusters_per_class=3,random_state=11)
     x_train,x_test,y_train,y_test = train_test_split(x, y,  random_state=11)
    clf =  AdaBoostClassifier(n_estimators=50,random_state=11)
    clf.fit(x_train,y_train)
     plt.rcParams['font.family'] = ['sans-serif']
     plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.title(u"集成精确率")
    plt.ylabel(u"准确率")
    plt.xlabel(u"集成学习中学习器的数量")
     plt.plot(range(1,51),[accuracy for accuracy in  clf.staged_score(x_test,y_test)])
    plt.show()

可以看出随着学习器中及学习器数量增加，准确率随之增加。

现在我们来装在红酒数据，来看一下sklearn.ensemble.AdaBoostClassifier和sklearn.ensemble.AdaBoostRegressor的表现。

AdaBoostClassifier：

def my_AdaBoostClassifier():
        wine_dataset =  datasets.load_wine()
        X =  wine_dataset['data']
        y =  wine_dataset['target']
         X_train,X_test,y_train,y_test = train_test_split(X, y, random_state=0)
        clf =  AdaBoostClassifier(n_estimators=50,random_state=11)
         clf.fit(X_train,y_train)
        print('训练数据集的得分：{:.2%}'.format(clf.score(X_train,y_train)))
        print('测试数据集的得分：{:.2%}'.format(clf.score(X_test,y_test)))

输出

训练数据集的得分：94.74%
测试数据集的得分：86.67%

AdaBoostRegressor：

def my_AdaBoostRegressor():
        wine_dataset =  datasets.load_wine()
        X =  wine_dataset['data']
        y =  wine_dataset['target']
         X_train,X_test,y_train,y_test = train_test_split(X, y, random_state=0)
        clf = AdaBoostRegressor(n_estimators=50,random_state=11)
         clf.fit(X_train,y_train)
        print('训练数据集的得分：{:.2%}:'.format(clf.score(X_train,y_train)))
        print('测试数据集的得分：{:.2%}:'.format(clf.score(X_test,y_test)))

输出

训练数据集的得分：100.00%
测试数据集的得分：95.56%

3. 装袋算法

Bagging算法 (英语：Bootstrap aggregating，引导聚集算法)，又称装袋算法，是机器学习领域的一种团体学习算法。最初由Leo Breiman于1994年提出。Bagging算法可与其他分类、回归算法结合，提高其准确率、稳定性的同时，通过降低结果的方差，避免过拟合的发生。m个样本原始数据进行n次抽样(n<=m)

形成一个构成n个样本的新的训练数据集的训练模型
重复T次，得到T个模型
有新样本进行预测，采用投票方式(分类问题)或求平均值方式(回归问题)得到新样本的预测结果

特点

平行合奏：每个模型独立构建
旨在减少方差，而不是偏差
适用于高方差低偏差模型(复杂模型)
基于树的方法的示例是随机森林，其开发完全生长的树(注意，RF修改生长的过程以减少树之间的相关性)

Sklearn中通过BaggingClassifier和BaggingRegressor实现装袋算法

from sklearn.svm import SVC
from sklearn.ensemble import BaggingClassifier
from sklearn.datasets import make_classification
def my_BaggingClassifier():
        iris =  datasets.load_iris()
        X = iris.data
        y = iris.target
         X_train,X_test,y_train,y_test = train_test_split(X, y, test_size=0.3)
        clf =  BaggingClassifier(base_estimator=SVC(),n_estimators=10, random_state=4)
         clf.fit(X_train,y_train)
        print('训练数据集的得分：{:.2%}'.format(clf.score(X_train,y_train)))
        print('测试数据集的得分：{:.2%}'.format(clf.score(X_test,y_test)))
         plt.plot(X_test,y_test)
        plt.show()

输出

训练数据集的得分：96.19%
测试数据集的得分：91.11%

输出

def my_BaggingRegressor():
        iris =  datasets.load_iris()
        X = iris.data
        y = iris.target
         X_train,X_test,y_train,y_test = train_test_split(X, y, test_size=0.3)
        clf =  BaggingRegressor(base_estimator=SVC(),n_estimators=10, random_state=4)
         clf.fit(X_train,y_train)
        print('训练数据集的得分：{:.2%}'.format(clf.score(X_train,y_train)))
        print('测试数据集的得分：{:.2%}'.format(clf.score(X_test,y_test)))
         plt.plot(X_test,y_test)
        plt.show()

训练数据集的得分：96.55%
测试数据集的得分：95.55%

4. 随机森林

随机森林是一种特殊的装袋算法，参见随机森林部分

5. 投票分类

投票分类分为Hard Voting与Soft Voting

Hard Voting
模型	A得分	B得分	获胜者
1	99%	1%	A
2	49%	51%	B
3	40%	60%	B
4	90%	10%	A
5	30%	70%	B
A:两票、B三票，B获胜

Soft Voting
模型	A得分	B得分
1	99%	1%
2	49%	51%
3	40%	60%
4	90%	10%
5	30%	70%
A：(99%+49%+40%+90%+30%)/5=61.6% B：(1%+51%+60%+10%+70%)/5=38.4% A获胜

Sklearn中通过sklearn.ensemble.VotingClassifier实现投票分类算法

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import VotingClassifier
def my_Voting():
    X, y =  datasets.make_moons(n_samples=500, noise=0.3, random_state=42)
    X_train, X_test,  y_train, y_test = train_test_split(X, y, random_state=42)
    voting_clf =  VotingClassifier(estimators=[('log_clf', LogisticRegression()),('svm_clf',  SVC()),('dt_clf', DecisionTreeClassifier(random_state=666))], voting='hard')
    voting_clf.fit(X_train,  y_train)
    print(' hard Voting训练数据集的得分：{:.2%}'.format(voting_clf.score(X_train,  y_train)))
    print(' hard Voting测试数据集的得分：{:.2%}'.format(voting_clf.score(X_test,  y_test)))
    voting_clf =  VotingClassifier(estimators=[('log_clf', LogisticRegression()),('svm_clf',  SVC(probability=True)),('dt_clf', DecisionTreeClassifier(random_state=666))],  voting='soft')
    voting_clf.fit(X_train,  y_train)
    print('soft Voting训练数据集的得分：{:.2%}'.format(voting_clf.score(X_train,  y_train)))
    print('soft Voting测试数据集的得分：{:.2%}'.format(voting_clf.score(X_test,  y_test)))

输出

hard Voting训练数据集的得分：93.60%
hard Voting测试数据集的得分：90.40%
soft Voting训练数据集的得分：96.53%
soft Voting测试数据集的得分：90.40%

6. 堆叠分类

stacking严格来说并不是一种算法，而是精美而又复杂的，对模型集成的一种策略。

首先我们会得到两组数据：训练集和测试集。将训练集分成5份：train1,train2,train3,train4,train5。
选定基模型。这里假定我们选择了xgboost, lightgbm 和 randomforest 这三种作为基模型。比如xgboost模型部分：依次用train1,train2,train3,train4,train5作为验证集，其余4份作为训练集，进行5折交叉验证进行模型训练；再在测试集上进行预测。这样会得到在训练集上由xgboost模型训练出来的5份predictions，和在测试集上的1份预测值B1。将这五份纵向重叠合并起来得到A1。lightgbm和randomforest模型部分同理。
三个基模型训练完毕后，将三个模型在训练集上的预测值作为分别作为3个"特征"A1,A2,A3，使用LR模型进行训练，建立LR模型。
使用训练好的LR模型，在三个基模型之前在测试集上的预测值所构建的三个"特征"的值(B1,B2,B3)上，进行预测，得出最终的预测类别或概率。

做stacking,首先需要安装mlxtend库。安装方法：进入Anaconda Prompt，输入命令 pip install mlxtend 即可。

通过mlxtend.classifier.StackingClassifier实现投票分类算法

from mlxtend.classifier import StackingClassifier
from mlxtend.feature_selection import ColumnSelector
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
def my_StackingClassifier_1():
    iris = load_iris()
    X = iris.data
    y = iris.target
    X_train, X_test,  y_train, y_test = train_test_split(X, y, random_state=42)
#基分类器1：xgboost
    pipe1 =  make_pipeline(ColumnSelector(cols=(0, 2)),AdaBoostClassifier())
#基分类器2：RandomForest
    pipe2 =  make_pipeline(ColumnSelector(cols=(1, 2, 3)),RandomForestClassifier()) 
    sclf =  StackingClassifier(classifiers=[pipe1, pipe2],  meta_classifier=LogisticRegression())
    sclf.fit(X_train,  y_train)
    print('StackingClassifier训练数据集的得分：{:.2%}'.format(sclf.score(X_train,  y_train)))
     print('StackingClassifier测试数据集的得分：{:.2%}'.format(sclf.score(X_test, y_test)))

输出

StackingClassifier训练数据集的得分：100.00%
StackingClassifier测试数据集的得分：100.00%

再来看一个

from mlxtend.classifier import StackingClassifier
from mlxtend.feature_selection import ColumnSelector
from sklearn.pipeline import make_pipeline
from sklearn.ensemble import RandomForestClassifier
def my_StackingClassifier_1():
        iris =  datasets.load_iris()
        X = iris.data
        y = iris.target
        X_train, X_test,  y_train, y_test = train_test_split(X, y, random_state=42)
#基分类器1：AdaBoostClassifier
        pipe1 =  make_pipeline(ColumnSelector(cols=(0, 2)),AdaBoostClassifier())
#基分类器2：RandomForest
        pipe2 =  make_pipeline(ColumnSelector(cols=(1, 2, 3)),RandomForestClassifier()) 
        sclf =  StackingClassifier(classifiers=[pipe1, pipe2],  meta_classifier=LogisticRegression())
        sclf.fit(X_train,  y_train)
        print('StackingClassifier训练数据集的得分：{:.2%}'.format(sclf.score(X_train,  y_train)))
         print('StackingClassifier测试数据集的得分：{:.2%}'.format(sclf.score(X_test, y_test)))

输出

5-fold cross validation:
Accuracy: 0.86 (+/- 0.10) [adaboost]
Accuracy: 0.95 (+/- 0.03) [lightgbm]
Accuracy: 0.94 (+/- 0.04) [Random Forest]
Accuracy: 0.94 (+/- 0.04) [StackingClassifier]