根据菜菜的课程进行整理，方便记忆理解
代码位置如下：
集成学习
集成学习（ensemble learning）是时下非常流行的机器学习算法，它本身不是一个单独的机器学习算法，而是通过在数据上构建多个模型，集成所有模型的建模结果。基本上所有的机器学习领域都可以看到集成学习的身影，在现实中集成学习也有相当大的作用，它可以用来做市场营销模拟的建模，统计客户来源，保留和流失，也可用来预测疾病的风险和病患者的易感性。在现在的各种算法竞赛中，随机森林，梯度提升树（GBDT），Xgboost等集成算法的身影也随处可见，可见其效果之好，应用之广。
集成算法的目标
集成算法会考虑多个评估器的建模结果，汇总之后得到一个综合的结果，以此来获取比单个模型更好的回归或分类表现。
多个模型集成成为的模型叫做集成评估器（ensemble estimator），组成集成评估器的每个模型都叫做基评估器（base estimator）。通常来说，有三类集成算法：装袋法（Bagging），提升法（Boosting）和stacking。
装袋法
- 核心思想
- 构建多个相互独立的评估器，然后对其预测进行平均或多数表决原则来决定集成评估器的结果
- 代表模型
- 随机森林 提升法
- 基评估器是相关的，是按顺序一一构建的
- 核心思想
- 是结合弱评估器的力量一次次对难以评估的样本进行预测，从而构成一个强评估器。
- 代表模型
- Adaboost和梯度提升树。
sklearn中的集成算法
- sklearn中的集成算法模块ensemble
| 类 | 类的功能 |
|---|---|
| ensemble.AdaBoostClassifier | AdaBoost分类 |
| ensemble.AdaBoostRegressor | Adaboost回归 |
| ensemble.BaggingClassifier | 装袋分类器 |
| ensemble.BaggingRegressor | 装袋回归器 |
| ensemble.ExtraTreesClassifier | Extra-trees分类（超树，极端随机树） |
| ensemble.ExtraTreesRegressor | Extra-trees回归 |
| ensemble.GradientBoostingClassifier | 梯度提升分类 |
| ensemble.GradientBoostingRegressor | 梯度提升回归 |
| ensemble.IsolationForest | 隔离森林 |
| ensemble.RandomForestClassifier | 随机森林分类 |
| ensemble.RandomForestRegressor | 随机森林回归 |
| ensemble.RandomTreesEmbedding | 完全随机树的集成 |
| ensemble.VotingClassifier | 用于不合适估算器的软投票/多数规则分类器 |
集成算法中，有一半以上都是树的集成模型，可以想见决策树在集成中必定是有很好的效果。
RandomForestClassifier
随机森林是非常具有代表性的Bagging集成算法，它的所有基评估器都是决策树，分类树组成的森林就叫做随机森林分类器，回归树所集成的森林就叫做随机森林回归器。
class sklearn.ensemble.RandomForestClassifier (
n_estimators=’10’,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)
重要参数
控制基评估器的参数
我们的随机森林分类器中的很多的参数和决策树都是相同的
| 参数 | 含义 |
|---|---|
| criterion | 不纯度的衡量指标，有基尼系数和信息熵两种选择 |
| max_depth | 树的最大深度，超过最大深度的树枝都会被剪掉 |
| min_samples_leaf | 一个节点在分枝后的每个子节点都必须包含至少min_samples_leaf个训练样本，否则分枝就不会发生 |
| min_samples_split | 一个节点必须要包含至少min_samples_split个训练样本，这个节点才允许被分枝，否则分枝就不会发生 |
| max_features | max_features限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃，默认值为总特征个数开平方取整 |
| min_impurity_decrease | 限制信息增益的大小，信息增益小于设定数值的分枝不会发生 |
n_estimators
这是森林中树木的数量，即基评估器的数量。
- 渴望在训练难度和模型效果之间取得平衡
- 这个参数对随机森林模型的精确性影响是单调的，n_estimators越大，模型的效果往往越好。
- 任何模型都有决策边界，n_estimators达到一定的程度之后，随机森林的精确性往往不在上升或开始波动，n_estimators越大，需要的计算量和内存也越大，训练的时间也会越来越长。
n_estimators的默认值在现有版本的sklearn中是10，但是在即将更新的0.22版本中，这个默认值会被修正为100。这个修正显示出了使用者的调参倾向：要更大的n_estimators。
构建森林
- 导入我们需要的包
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
- 导入需要的数据集
wine = load_wine()
wine.data
wine.target
- 建模的基本流程
dtc = DecisionTreeClassifier(criterion="gini",random_state=20)
rfc = RandomForestClassifier(n_estimators=100,random_state=20)
Xtrain,Xtest,Ytrain,Ytest = train_test_split(wine.data,wine.target,test_size=0.3)
dtc.fit(Xtrain,Ytrain)
dtc_score = dtc.score(Xtest,Ytest)
rfc.fit(Xtrain,Ytrain)
rfc_score = rfc.score(Xtest,Ytest)
print("score of 决策树-{}".format(dtc_score))
print("score of 随机森林-{}".format(rfc_score))
# score of 决策树-0.8518518518518519
# score of 随机森林-0.9814814814814815
- 完成10次10折交叉验证的均值的决策树和随机森林的对比
import matplotlib.pyplot as plt
from sklearn.model_selection import cross_val_score
dtc_s_10 = []
rfc_s_10 = []
for i in range(10):
dtc = DecisionTreeClassifier(criterion="gini")
rfc = RandomForestClassifier(n_estimators=100)
dtc_c = cross_val_score(dtc,wine.data,wine.target,cv=10).mean()
rfc_c = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
dtc_s_10.append(dtc_c)
rfc_s_10.append(rfc_c)
plt.figure()
plt.plot(range(1,11),dtc_s_10,label="decisiontree",color="r")
plt.plot(range(1,11),rfc_s_10,label="randomforest",color="b")
plt.show()
- 一次10折交叉验证的曲线的绘制
dtc = DecisionTreeClassifier(criterion="gini")
rfc = RandomForestClassifier(n_estimators=100)
dtc_c = cross_val_score(dtc,wine.data,wine.target,cv=10)
rfc_c = cross_val_score(rfc,wine.data,wine.target,cv=10)
plt.figure()
plt.plot(range(1,11),dtc_c,label="decisiontree",color="r")
plt.plot(range(1,11),rfc_c,label="randomforest",color="b")
plt.show()
- n_estimators的学习曲线
n_score = []
for i in range(200):
rfc = RandomForestClassifier(n_estimators=i+1,random_state=20)
rfc.fit(Xtrain,Ytrain)
score = rfc.score(Xtest,Ytest)
n_score.append(score)
plt.figure()
plt.plot(range(1,201),n_score,label="randomforest",color="b")
plt.show()
随机森林用了什么方法，来保证集成的效果一定好于单个分类器?
随机森林的本质是一种装袋集成算法（bagging），装袋集成算法是对基评估器的预测结果进行平均或用多数表决原则来决定集成评估器的结果。在刚才的红酒例子中，我们建立了25棵树，对任何一个样本而言，平均或多数表决原则下，当且仅当有13棵以上的树判断错误的时候，随机森林才会判断错误。单独一棵决策树对红酒数据集的分类准确率在0.85上下浮动，假设一棵树判断错误的可能性为0.2(ε)，那20棵树以上都判断错误的可能性是：
其中，i是判断错误的次数，也是判错的树的数量，ε是一棵树判断错误的概率，（1-ε）是判断正确的概率，共判对25 - i次。采用组合，是因为25棵树中，有任意i棵都判断错误。
可见，判断错误的几率非常小，这让随机森林在红酒数据集上的表现远远好于单棵决策树。
random_state
我们说袋装法服从多数表决原则或对基分类器结果求平均，这即是说，我们默认森林中的每棵树应该是不同的，并且会返回不同的结果。设想一下，如果随机森林里所有的树的判断结果都一致（全判断对或全判断错），那随机森林无论应用何种集成原则来求结果，都应该无法比单棵决策树取得更好的效果才对。但我们使用了一样的类DecisionTreeClassifier，一样的参数，一样的训练集和测试集，为什么随机森林里的众多树会有不同的判断结果？
问到这个问题，很多小伙伴可能就会想到了：sklearn中的分类树DecisionTreeClassifier自带随机性，所以随机森林中的树天生就都是不一样的。我们在讲解分类树时曾提到，决策树从最重要的特征中随机选择出一个特征来进行分枝，因此每次生成的决策树都不一样，这个功能由参数random_state控制。
随机森林中其实也有random_state，用法和分类树中相似，只不过在分类树中，一个random_state只控制生成一棵树，而随机森林中的random_state控制的是生成森林的模式，而非让一个森林中只有一棵树。
- 重要属性
esmimators_可以查看森林中的树的情况
# 我们可以使用esmimators_进行查看森林中的书的情况
# 当random_state固定时，随机森林中生成是一组固定的树，但每棵树依然是不一致的，这是用”随机挑选特征进行分枝“的方法得到的随机性
rfc = RandomForestClassifier(n_estimators=20,random_state=20)
rfc.fit(Xtrain,Ytrain)
for i in range(len(rfc.estimators_)):
print(rfc.estimators_[i].random_state)
"""
378518883
1663920602
1708167439
1951685855
1681611676
1942519002
1356511625
521790868
154144587
602822422
823592519
1934675106
1626422240
742452342
79503912
176838101
678396378
1467049754
832580347
1359590355
"""
- 可以看到每一棵树的细节
# 可以看到每一棵树的细节
rfc = RandomForestClassifier(n_estimators=20,random_state=20)
rfc.fit(Xtrain,Ytrain)
for i in range(len(rfc.estimators_)):
print(rfc.estimators_[i])
"""
DecisionTreeClassifier(ccp_alpha=0.0, 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, presort='deprecated',
random_state=378518883, splitter='best')
"""
- 当random_state固定时，随机森林中生成是一组固定的树，但每棵树依然是不一致的，这是用”随机挑选特征进行分枝“的方法得到的随机性。并且我们可以证明，当这种随机性越大的时候，袋装法的效果一般会越来越好。用袋装法集成时，基分类器应当是相互独立的，是不相同的。
- 但这种做法的局限性是很强的，当我们需要成千上万棵树的时候，数据不一定能够提供成千上万的特征来让我们构筑尽量多尽量不同的树。因此，除了random_state。我们还需要其他的随机性。
bootstrap & oob_score
- 要让基分类器尽量都不一样，一种很容易理解的方法是使用不同的训练集来进行训练，而袋装法正是通过有放回的随机抽样技术来形成不同的训练数据，
bootstrap就是用来控制抽样技术的参数。 - 在一个含有n个样本的原始训练集中，我们进行随机采样，每次采样一个样本，并在抽取下一个样本之前将该样本放回原始训练集，也就是说下次采样时这个样本依然可能被采集到，这样采集n次，最终得到一个和原始训练集一样大的，n个样本组成的自助集。由于是随机采样，这样每次的自助集和原始数据集不同，和其他的采样集也是不同的。这样我们就可以自由创造取之不尽用之不竭，并且互不相同的自助集，用这些自助集来训练我们的基分类器，我们的基分类器自然也就各不相同了。
- bootstrap参数
- 默认True，代表采用这种有放回的随机抽样技术。
- 通常，这个参数不会被我们设置为False。
然而有放回抽样也会有自己的问题。由于是有放回，一些样本可能在同一个自助集中出现多次，而其他一些却可能被忽略，一般来说，自助集大约平均会包含63%的原始数据。因为每一个样本被抽到某个自助集中的概率为：
当n足够大时，这个概率收敛于1-(1/e)，约等于0.632。因此，会有约37%的训练数据被浪费掉，没有参与建模，这些数据被称为袋外数据(out of bag data，简写为oob)。除了我们最开始就划分好的测试集之外，这些数据也可以被用来作为集成算法的测试集。也就是说，在使用随机森林时，我们可以不划分测试集和训练集，只需要用袋外数据来测试我们的模型即可。当然，这也不是绝对的，当n和n_estimators都不够大的时候，很可能就没有数据掉落在袋外，自然也就无法使用oob数据来测试模型了。
如果希望用袋外数据来测试，则需要在实例化时就将oob_score这个参数调整为True，训练完毕之后，我们可以用随机森林的另一个重要属性：
- oob_score_来查看我们的在袋外数据上测试的结果
# 无需划分测试集合和训练集和
rfc = RandomForestClassifier(n_estimators=25,oob_score=True)
rfc = rfc.fit(wine.data,wine.target) #重要属性oob_score_
rfc.oob_score_
# 0.9662921348314607
重要属性和接口
- 重要属性
- emtimators_
- oob_socre_
- feature_importances_
- 重要接口
- apply
- fit
- score
- predict
- predict_proda 返回每个测试样本被分到每一类的概率，标签有几个分类就有几个概率
- sklearn中的随机森林是平均每个样本对应的predict_proba返回的概率，得到一个平均概率，从而决定测试样本的分类
- 如果是二分类问题，则predict_proba返回的数值大于0.5的，被分为1，小于0.5的，被分为0
- 在测试集上验证score
rfc = RandomForestClassifier(n_estimators=25)
rfc = rfc.fit(Xtrain, Ytrain)
rfc.score(Xtest,Ytest)
# 1.0
- 属性的重要性的打分
# 属性的重要性的打分
rfc.feature_importances_
# array([0.12243581, 0.03522112, 0.01390403, 0.02553358, 0.04562275,0.06105908, 0.16123971, 0.02699044, 0.01589102, 0.1025578 ,0.06549809, 0.1749309 , 0.14911568])
- 对于测试结果生成的数的叶子节点的下标
rfc.apply(Xtest)
"""
array([[12, 19, 14, ..., 21, 21, 14],
[ 2, 15, 5, ..., 21, 15, 4],
[21, 19, 14, ..., 21, 26, 14],
...,
[ 2, 15, 5, ..., 12, 15, 4],
[12, 15, 14, ..., 21, 15, 14],
[20, 6, 3, ..., 6, 10, 9]], dtype=int64)
"""
- 预测测试属于哪一个类
# 预测测试属于哪一个类
rfc.predict(Xtest)
# array([0, 1, 0, 1, 2, 0, 2, 1, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 1, 0, 2, 0,2, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 2, 2, 0, 0, 1, 1, 1, 2, 0, 0,1, 1, 0, 1, 1, 2, 1, 1, 0, 2])
- 分到每一个类的概率
# 返回被分到每一个类的概率
rfc.predict_proba(Xtest)
"""
部分展示
array([[1. , 0. , 0. ],
[0.16, 0.76, 0.08],
[0.92, 0.08, 0. ],
[0.32, 0.64, 0.04],
[0. , 0.24, 0.76],
[0.6 , 0.36, 0.04],
[0. , 0.12, 0.88],
[0.04, 0.88, 0.08]])
"""
Bagging的必要条件
基分类器的判断准确率至少要超过随机分类器，即时说，基分类器的判断准确率至少要超过50% 当基分类器的误差率小于0.5，即准确率大于0.5时，集成的效果是比基分类器要好的。相反，当基分类器的误差率大于0.5，袋装的集成算法就失效了
import numpy as np
from scipy.special import comb
x = np.linspace(0,1,20)
y = []
for epsilon in np.linspace(0,1,20):
E = np.array([comb(25,i)*(epsilon**i)*((1-epsilon)**(25-i)) for i in range(13,26)]).sum()
y.append(E)
plt.plot(x,y,"o-",label="when estimators are different")
plt.plot(x,x,"--",color="red",label="if all estimators are same")
plt.xlabel("individual estimator's error")
plt.ylabel("RandomForest's error")
plt.legend()
plt.show()
