综述

“余既滋兰之九畹兮，又树蕙之百亩”

本文采用编译器：jupyter

集成学习 (ensemble learning)通过构建并结合多个学习器来完成学习任务。下图显示出集成学习的一般结构，先产生一组"个体学习器"，然后再通过某种方式将他们结合起来解决一个问题。

在日常生活中也充满着集成学习的例子：比如“买东西找人推荐”“专家会诊确定病情”等。

个体学习器由常见的机器学习模型构成，采用投票方式决定最终结果，为了达到“集成”的目的，个体学习器应具有差异性。

01 集成学习

import numpy as np
import matplotlib.pyplot as plt

from sklearn import datasets

X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=42)

plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

# 使用逻辑回归分类
from sklearn.linear_model import LogisticRegression

log_clf = LogisticRegression()
log_clf.fit(X_train, y_train)
log_clf.score(X_test, y_test)
# Out[5]:
# 0.86399999999999999

# 使用SVM方式分类
from sklearn.svm import SVC

svm_clf = SVC()
svm_clf.fit(X_train, y_train)
svm_clf.score(X_test, y_test)
# Out[6]:
# 0.88800000000000001

# 使用决策树进行预测
from sklearn.tree import DecisionTreeClassifier

dt_clf = DecisionTreeClassifier()
dt_clf.fit(X_train, y_train)
dt_clf.score(X_test, y_test)
# Out[7]:
# 0.872

# 集成学习，少数服从多数过程
y_predict1 = log_clf.predict(X_test)
y_predict2 = svm_clf.predict(X_test)
y_predict3 = dt_clf.predict(X_test)

y_predict = np.array((y_predict1 + y_predict2 + y_predict3) >= 2, dtype='int')

y_predict[:10]
# Out[10]:
# array([1, 0, 0, 1, 1, 1, 0, 0, 0, 0])

from sklearn.metrics import accuracy_score

accuracy_score(y_test, y_predict)
# 可以看出分类准确率比三种单独的方法要高
# Out[11]:
# 0.90400000000000003

使用Voting Classifier

from sklearn.ensemble import VotingClassifier

# 创建对象时，传入估计器
voting_clf = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()),
    ('svm_clf', SVC()),
    ('dt_clf', DecisionTreeClassifier())
], voting='hard')

voting_clf.fit(X_train, y_train)
"""
Out[13]:
VotingClassifier(estimators=[('log_clf', LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
          verbose=0, warm_start=False)), ('svm_clf...      min_weight_fraction_leaf=0.0, presort=False, random_state=None,
            splitter='best'))],
         flatten_transform=None, n_jobs=1, voting='hard', weights=None)
"""

voting_clf.score(X_test, y_test)
# Out[14]:
# 0.90400000000000003

02 Soft Voting

由于不同的学习机器确定结果所对应的概率不同，更合理的投票应当考虑权值，称为Soft Voting

对于下面的例子，如果不考虑权值，分类结果为B，但更直观的来看我们更愿意将其归入A类。

如果要设置集合的每一个模型都可以估计概率，满足scikit-learn的写法是加入predict_proba函数。

回顾之前介绍过的方法，看看都有哪些可以计算出预测概率：

1. 逻辑回归

逻辑回归模型本身就是基于概率模型的

2. k近邻

kNN也是可以估计概率的，下图的估计概率 = 2/3 = 66.7%

3. 决策树

决策树也是可以估计概率的（叶子节点中标记数量较多的点 / 叶子节点中总数据点个数）

4. 支持向量机

SVM可以通过一些特殊的方式计算出概率

import numpy as np
import matplotlib.pyplot as plt

from sklearn import datasets

X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=42)

plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y,random_state=42)

Hard Voting Classifier

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import VotingClassifier

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)
voting_clf.score(X_test, y_test)
# Out[9]:
# 0.89600000000000002

Soft Voting Classifier

# 需要设置SVM可以计算概率
voting_clf2 = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()),
    ('svm_clf', SVC(probability=True)),
    ('dt_clf', DecisionTreeClassifier(random_state=666))],
                             voting='soft')

voting_clf2.fit(X_train, y_train)
voting_clf2.score(X_test, y_test)
# Out[11]:
# 0.91200000000000003

虽然我们有很多机器学习方法，但是从集成的角度来看，仍然不够多！

所以我们需要对每一种机器学习方法创建更多的子模型，为了满足子模型之间必须存在的差异性，我们让每个子模型只看样本数据的一部分。

比如：一共有500个样本，每个子模型只看100个样本数据，每个模型不需要太高的准确率。

假设每个子模型只有51%的准确率：

如果只有1个子模型，整体准确率：51%

如果有3个子模型，整体准确率： $0.51^3+C_{3}^{2}\cdot 0.51^2\cdot 0.49 = 51.5\%$

如果有500个子模型，整体准确率： $\sum_{i=251}^{500}C_{500}^{i}\cdot 0.51^i\cdot 0.49^{500-i} = 65.6\%$

如果每个模型的准确率是60%： $\sum_{i=251}^{500}C_{500}^{i}\cdot 0.6^i\cdot 0.4^{500-i} = 99.99\%$

03 Bagging和Pasting

接上一节，有两种方式只看样本数据的一部分：

取样：放回取样 Bagging 不放回取样 Pasting

其中Bagging更常用（在统计学中放回取样叫做 bootstrap）

import numpy as np
import matplotlib.pyplot as plt

from sklearn import datasets

X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=42)

plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y)

使用Bagging

# 如果想要集成成百上千个子模型，首选方法是决策树。因为这种非参数学习模型更能产生差异较大的子模型
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

# 设置500个子模型，每个子模型看100个数据，放回取样
bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=50, max_samples=100,
                               bootstrap=True)

bagging_clf.fit(X_train, y_train)
bagging_clf.score(X_test, y_test)
# Out[6]:
# 0.92000000000000004

bagging_clf2 = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=5000, max_samples=100,
                               bootstrap=True)
bagging_clf2.fit(X_train, y_train)
bagging_clf2.score(X_test, y_test)
# 理论上，子模型数量越多，分类效果越好
# Out[7]:
# 0.93600000000000005

关于Bagging的更多讨论

1. 放回取样导致一部分样本很有可能没有取到，经过实验，平均大约有37%的样本没有取到，我们就可以使用这些样本来做测试 / 验证。在scikit-learn中需要设置oob_score_参数。

2. Bagging的设计思路使得它极易进行并行化处理。参数 n_jobs

3. 当数据样本特征过多时（图像识别领域），可以对特征进行随机采样称为Random Subspaces

4. 即针对样本，有针对特征进行随机采样称为Random Patches。

04 oob和更多Bagging相关

import numpy as np
import matplotlib.pyplot as plt

from sklearn import datasets

X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=42)

plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()

使用oob

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

# 指定记录oob_score，使用没有取到的数据做测试
bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=100,
                               bootstrap=True, oob_score=True)
bagging_clf.fit(X, y)
"""
Out[6]:
BaggingClassifier(base_estimator=DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
            max_features=None, max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=None,
            min_samples_leaf=1, min_samples_split=2,
            min_weight_fraction_leaf=0.0, presort=False, random_state=None,
            splitter='best'),
         bootstrap=True, bootstrap_features=False, max_features=1.0,
         max_samples=100, n_estimators=500, n_jobs=1, oob_score=True,
         random_state=None, verbose=0, warm_start=False)
"""

bagging_clf.oob_score_
# Out[7]:
# 0.91600000000000004

n_jobs

%%time
bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=100,
                               bootstrap=True, oob_score=True)
bagging_clf.fit(X, y)

"""
CPU times: user 608 ms, sys: 4.58 ms, total: 612 ms
Wall time: 611 ms
"""

%%time
# 传入n_jobs使用计算机所有的核
bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=100,
                               bootstrap=True, oob_score=True, n_jobs=-1)
bagging_clf.fit(X, y)

"""
CPU times: user 203 ms, sys: 35.5 ms, total: 239 ms
Wall time: 699 ms
"""

bootstrap_features

# 对特征进行随机取样，指定最大取样特征数(由于只有两个特征，每次只取一个是不太合理的)
# 把max_samples与n_estimators设置成相等的即实现了不对样本随机采样
random_subspaces_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=500,
                               bootstrap=True, oob_score=True, 
                               n_jobs=-1,
                               max_features=1, bootstrap_features=True)
random_subspaces_clf.fit(X, y)
random_subspaces_clf.oob_score_
# Out[11]:
# 0.84999999999999998

# 既对样本进行放回采样，又对特征进行放回采样
# 由多棵树组成的决策模型就叫做随机森林
random_patches_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=100,
                               bootstrap=True, oob_score=True, 
                               n_jobs=-1,
                               max_features=1, bootstrap_features=True)
random_patches_clf.fit(X, y)
random_patches_clf.oob_score_
# Out[12]:
# 0.85199999999999998

05 随机森林和Extra-Trees

随机森林定义：

使用Bagging取样方法，子模型为决策树，并且决策树在节点划分上使用随机的特征与阈值。

由于提供了额外的随机性，所以抑制了过拟合即抑制了方差，但增加了偏差。实际使用中可能需要一定的实验与判断来选择模型。因为节点的划分只用随机的特征与阈值，所以训练速度较快。

import numpy as np
import matplotlib.pyplot as plt

from sklearn import datasets

X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=42)

plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()

随机森林

from sklearn.ensemble import RandomForestClassifier
# 500棵树的随机森林
rf_clf = RandomForestClassifier(n_estimators=500, random_state=666, oob_score=True, n_jobs=-1)
rf_clf.fit(X, y)
"""
Out[5]:
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
            max_depth=None, max_features='auto', max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=None,
            min_samples_leaf=1, min_samples_split=2,
            min_weight_fraction_leaf=0.0, n_estimators=500, n_jobs=-1,
            oob_score=True, random_state=666, verbose=0, warm_start=False)
"""
rf_clf.oob_score_
# Out[6]:
# 0.89600000000000002

# 设置每棵决策树最多有几个叶节点
rf_clf2 = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, random_state=666, oob_score=True, n_jobs=-1)
rf_clf2.fit(X, y)
rf_clf2.oob_score_
# Out[8]:
# 0.92000000000000004

使用Extra-Trees

from sklearn.ensemble import ExtraTreesClassifier

et_clf = ExtraTreesClassifier(n_estimators=500, bootstrap=True, oob_score=True, random_state=666)
et_clf.fit(X, y)
"""
Out[10]:
ExtraTreesClassifier(bootstrap=True, class_weight=None, criterion='gini',
           max_depth=None, max_features='auto', max_leaf_nodes=None,
           min_impurity_decrease=0.0, min_impurity_split=None,
           min_samples_leaf=1, min_samples_split=2,
           min_weight_fraction_leaf=0.0, n_estimators=500, n_jobs=1,
           oob_score=True, random_state=666, verbose=0, warm_start=False)
"""
et_clf.oob_score_
# Out[11]:
# 0.89200000000000002

使用集成学习解决回归问题

# 使用方法和classifier相同，返回的是回归结果
from sklearn.ensemble import BaggingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import ExtraTreesRegressor

06 另一种集成学习思路：Boosting

基本思路：集成多个子模型，每个子模型都在尝试增强（Boosting）整体的效果。

每一个子模型都在尽力弥补上一个子模型所没划分出来的点，每个子模型对于每个点的权重也不相同。

Ada Boosting:

Gradient Boosting:

训练一个模型m1，产生错误e1；

针对e1训练第二个模型m2，产生错误e2；

针对e2训练第二个模型m3，产生错误e3；

最终预测结果是：m1+m2+m3+...

Stacking

将多个模型的输出作为输入再由另一个模型做出决定。

scikit-learn中没有对应的接口

最后，如果有什么疑问，欢迎和我微信交流。

Python遇见机器学习 ---- 集成学习 Ensemble Learning

综述