机器学习笔记 十九：由浅入深的随机森林模型之分类

1. 集成学习

  集成学习 （ensemble learning） 是时下非常流行的机器学习算法，它本身不是一个单独的机器学习算法，而是通过在数据上构建多个模型，集成所有模型的建模结果。基本上所有的机器学习领域都可以看到集成学习的身影，在现实中集成学习也有相当大的作用，它可以用来做市场营销模拟的建模，统计客户来源，保留和流失，也可用来预测疾病的风险和病患者的易感性。在现在的各种算法竞赛中，随机森林、梯度提升（GBDT）、Xgboost等集成算法的身影也随处可见，可见其效果之好，应用之广。

集成算法目标： 集成算法会考虑多个评估器的建模结果，汇总之后得到一个综合的结果，以此来获取比单个模型更好的回归或分类表现。

  多个模型集成成为的模型叫做集成评估器（ensemble estimator），组成集成评估器的每个模型都叫做基评估器（base estimator）。通常来说，有三类集成算法：装袋法（Bagging），提升法（Boosting）和stacking。

2.sklearn中的集成算法

2.1 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 ：用于不合适估算器的软投票/多数规则分类器

决策树结构：

决策树的核心问题：

• 如何找出正确的特征来进行提问，即如何分枝： 我们定义了用来衡量分枝质量的指标不纯度，分类树的不纯度用基尼系数（gini）或信息熵（entropy）来衡量，回归树的不纯度用MSE均方误差来衡量。每次分枝时，决策树对所有的特征进行不纯度计算，选取不纯度最低的特征进行分枝。分枝后，又再对被分枝的不同取值下，计算每个特征的不纯度，继续选取不纯度最低的特征进行分枝。
  每分枝一层，树整体的不纯度会越来越小，决策树追求的是最小不纯度。因此，决策树会一直分枝，直到没有更多的特征可用，或整体的不纯度指标已经最优，决策树就会停止生长。
• 树什么时候应该停下： 决策树非常容易过拟合，也就是说，它很容易在训练集上表现优秀，却在测试集上表现很糟糕。为了防止决策树的过拟合，所以我们要对决策树进行剪枝，sklearn中提供了大量的剪枝参数。

2.2 RandomForestClassifier

   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)

  随机森林是非常具有代表性的Bagging集成算法，它的所有基评估器都是决策树，分类树组成的森林就叫做随机森林分类器，回归树所集成的森林就叫做随机森林回归器。

2.2.1 参数

• criterion：不纯度的衡量指标，有基尼系数和信息熵两种选择
• max_depth： 树的最大深度，超过最大深度的树枝都会被剪掉
• min_samples_leaf ：一个节点在分枝后的每个子节点都必须包含至少min_samples_leaf个训练样本，否则分枝就不会发生
• min_samples_split ：一个节点必须要包含至少min_samples_split个训练样本，这个节点才允许被分枝，否则分枝就不会发生
• max_features max_features：限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃，默认值为总特征个数开平方取整
• min_impurity_decrease ：限制信息增益的大小，信息增益小于设定数值的分枝不会发生

2.2.2 n_estimators

  这是森林中树木的数量，即基评估器的数量。这个参数对随机森林模型的精确性影响是单调的，n_estimators越大，模型的效果往往越好。但是相应的，任何模型都有决策边界，n_estimators达到一定的程度之后，随机森林的精确性往往不在上升或开始波动，并且，n_estimators越大，需要的计算量和内存也越大，训练的时间也会越来越长。对于这个参数，我们是渴望在训练难度和模型效果之间取得平衡，即时间和精度之间的平衡
  n_estimators的默认值在现有版本的sklearn中是10，但是在即将更新的0.22版本中，这个默认值会被修正为100。这个修正显示出了使用者的调参倾向：要更大的n_estimators。

红酒数据集训练：

%matplotlib inline
# from sklearn.tree import DecisonTreeClassifier # 最新版本删除了这个功能
from sklearn import tree
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_wine

from sklearn.model_selection import train_test_split

import numpy as np
from scipy.special import comb


wine = load_wine()
Xtrain,Xtest,Ytrain,Ytest = train_test_split(wine.data, wine.target, test_size=0.3)

clf = tree.DecisionTreeClassifier(random_state=0)
rfc = RandomForestClassifier(random_state=0)

clf = clf.fit(Xtrain, Ytrain)
rfc = rfc.fit(Xtrain, Ytrain)

score_c = clf.score(Xtest, Ytest)
score_r = rfc.score(Xtest, Ytest)

print("single tree:{}".format(score_c),"random forest:{}".format(score_r))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

single tree:0.9629629629629629 random forest:1.0

随机森林和决策树的交叉验证：

# 1组交叉验证CV比较
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt


rfc = RandomForestClassifier(n_estimators=25)
rfc_s = cross_val_score(rfc, wine.data, wine.target, cv=10)

clf = tree.DecisionTreeClassifier()
clf_s = cross_val_score(clf, wine.data, wine.target, cv=10)

plt.plot(range(1,11), rfc_s, label = "RandomForest")
plt.plot(range(1,11), clf_s, label = "Decision tree")
plt.legend()
plt.show()


# label = "RandomForest"
# for model in [RandomForestClassifier(n_estimators=25), tree.DecisionTreeClassifier()]:
#     score = cross_val_score(model, wine.data, wine.target, cv=10)
#     print("{}".format(label)),print(score.mean())
#     plt.plot(range(1,11),score,label = label)
#     plt.legend()
#     label = "Decision Tree"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

np.random.seed(10)
import time
start = time.time()

# 10组交叉验证效果对比
rfc_1=[]
clf_1=[]

for i in range(10):
    rfc = RandomForestClassifier(n_estimators=25)
    rfc_s = cross_val_score(rfc, wine.data, wine.target, cv=10).mean()
    rfc_1.append(rfc_s)
    clf= tree.DecisionTreeClassifier()
    clf_s=cross_val_score(clf, wine.data, wine.target, cv=10).mean()
    clf_1.append(clf_s)
    
plt.plot(range(1,11), rfc_1, label = "Random Forest")
plt.plot(range(1,11), clf_1, label = "Decison Tree")
plt.legend()
plt.show()

end = time.time()
print(end - start)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

n_estimators的学习曲线：

np.random.seed(10)
import time
start = time.time()

superpa=[]
for i in range(50):
    rfc = RandomForestClassifier(n_estimators=i+1, n_jobs=-1) # n_jobs=-1并行运算，调用所有CPU
    rfc_s = cross_val_score(rfc, wine.data, wine.target, cv=10).mean()
    superpa.append(rfc_s)
print(max(superpa), superpa.index(max(superpa)))
plt.figure(figsize=[20,5])
plt.plot(range(1,51), superpa)
plt.show()

end = time.time()
print(end - start)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.2.3 random_state

  随机森林的本质是一种 装袋集成算法（bagging），装袋集成算法是对基评估器的预测结果进行平均或用多数表决原则来决定集成评估器的结果。在刚才的红酒例子中，我们建立了25棵树，对任何一个样本而言，平均或多数表决原则下，当且仅当有13棵以上的树判断错误的时候，随机森林才会判断错误。单独一棵决策树对红酒数据集的分类准确率在0.85上下浮动，假设一棵树判断错误的可能性为0.2(ε)，那20棵树以上都判断错误的可能性是：

import numpy as np
from scipy.special import comb

np.array([comb(25,i)*(0.2**i)*((1-0.2)**(25-i)) for i in range(13,26)]).sum()
1
2
3
4

0.00036904803455582827

  可见，判断错误的几率非常小，这让随机森林在红酒数据集上的表现远远好于单棵决策树。
  那现在就有一个问题了：我们说袋装法服从多数表决原则或对基分类器结果求平均，这即是说，我们默认森林中的每棵树应该是不同的，并且会返回不同的结果。设想一下，如果随机森林里所有的树的判断结果都一致（全判断对或全判断错），那随机森林无论应用何种集成原则来求结果，都应该无法比单棵决策树取得更好的效果才对。但我们使用了一样的类DecisionTreeClassifier，一样的参数，一样的训练集和测试集，为什么随机森林里的众多树会有不同的判断结果？
  问到这个问题，可能就会想到sklearn中的分类树DecisionTreeClassifier自带随机性，所以随机森林中的树天生就都是不一样的。决策树从最重要的特征中随机选择出一个特征来进行分枝，因此每次生成的决策树都不一样，这个功能由参数random_state控制。
  随机森林中其实也有random_state，用法和分类树中相似，只不过在分类树中，一个random_state只控制生成一棵树，而随机森林中的random_state控制的是生成森林的模式，而非让一个森林中只有一棵树。

rfc = RandomForestClassifier(n_estimators=20,random_state=2)
rfc = rfc.fit(Xtrain, Ytrain)
#随机森林的重要属性之一：estimators，查看森林中树的状况
rfc.estimators_[0].random_state

for i in range(len(rfc.estimators_)):
    print(rfc.estimators_[i].random_state)
1
2
3
4
5
6
7

1872583848
794921487
111352301
1853453896
213298710
1922988331
1869695442
2081981515
1805465960
1376693511
1418777250
663257521
878959199
854108747
512264917
515183663
1287007039
2083814687
1146014426
570104212

2.2.4 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_
1
2
3
4
5
6

0.9606741573033708

2.3 随机森林的重要接口

  随机森林的接口与决策树完全一致，因此依然有四个常用接口：apply, fit, predict和score。除此之外，还需要注意随机森林的predict_proba接口，这个接口返回每个测试样本对应的被分到每一类标签的概率，标签有几个分类就返回几个概率。如果是二分类问题，则predict_proba返回的数值大于0.5的，被分为1，小于0.5的，被分为0。
  传统的随机森林是利用袋装法中的规则，平均或少数服从多数来决定集成的结果；
  sklearn中的随机森林是平均每个样本对应的predict_proba返回的概率，得到一个平均概率，从而决定测试样本的分类。

rfc = RandomForestClassifier(n_estimators=50,random_state=42)
rfc = rfc.fit(Xtrain, Ytrain)
rfc.score(Xtest,Ytest)
# rfc.feature_importances_
# rfc.apply(Xtest)
# rfc.predict(Xtest)
# rfc.predict_proba(Xtest)
1
2
3
4
5
6
7

0.9814814814814815

2.4 Bonus（装袋法的必要条件）

  在使用袋装法时要求基评估器要尽量独立。袋装法还有另一个必要条件：基分类器的判断准确率至少要超过随机分类器，即基分类器的判断准确率至少要超过50%：

import numpy as np
import matplotlib.pyplot as plt
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()
1
2
3
4
5
6
7
8
9
10
11
12
13

  可以从图像上看出，当基分类器的误差率小于0.5，即准确率大于0.5时，集成的效果是比基分类器要好的。相反，当基分类器的误差率大于0.5，袋装的集成算法就失效了。所以在使用随机森林之前，一定要检查，用来组成随机森林的分类树们是否都有至少50%的预测正确率。