sklearn机器学习：随机森林分类器RandomForestClassifier

以下以随机森林为例讨论集成算法。

sklearn随机森林分类器

随机森林是非常具有代表性的Bagging集成算法，它的所有基评估器都是决策树，分类树组成的森林就叫做随机森林分类器，回归树所集成的森林就叫做随机森林回归器。我们先来看
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)

重要参数

控制基评估器的参数

criterion 不纯度的衡量指标，有基尼系数和信息熵两种选择
max_depth 树的最大深度，超过最大深度的树枝都会被剪掉
min_samples_leaf
一个节点在分枝后的每个子节点都必须包含至少min_samples_leaf个训练样本，否则分枝就不会发生
min_samples_split
一个节点必须要包含至少min_samples_split个训练样本，这个节点才允许被分枝，否则分枝就不会发生
max_features
限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃，默认值为总特征个数开平方取整
min_impurity_decrease 限制信息增益的大小，信息增益小于设定值的分枝不会发生
这些参数在随机森林中的含义，和我们在上决策树时说明的内容一模一样，单个决策树的准确率越高，随机森林的准确率也会越高，因为装袋法是依赖于平均值或者少数服从多数原则来决定集成的结果的。

n_estimators

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

sklearn建立随机森林分类器

树模型的优点是简单易懂，可视化之后的树人人都能够看懂，可惜随机森林是无法被可视化的。为了更加直观地让大家体会随机森林的效果，来进行一个随机森林和单个决策树效益的对比。
依然使用红酒数据集。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
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
wine.data
wine.target
#切分训练集和测试集
Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)
#建立模型
clf = 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:",score_c)
print("Random Forest:",score_r)

Single Tree: 0.8888888888888888
Random Forest: 0.9444444444444444

#画出随机森林和决策树在一组交叉验证下的效果对比
#交叉验证：是数据集划分为n分，依次取每一份做测试集，每n-1份做训练集，多次训练模型以观测模型稳定性的方法
from sklearn.model_selection import cross_val_score
rfc = RandomForestClassifier(n_estimators=25)
rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10)
clf = 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 = "DecisionTree")
plt.legend()
plt.show()

#一种更加有趣也更简单的写法
label = "RandomForest"
for model in [RandomForestClassifier(n_estimators=25),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 = "DecisionTree"

RandomForest:
0.955813553491572
DecisionTree:
0.88359133126935

#画出随机森林和决策树在十组交叉验证下的效果对比
rfc_l = []
clf_l = []
for i in range(10):
    rfc = RandomForestClassifier(n_estimators=25)
    rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
    rfc_l.append(rfc_s)
    clf = DecisionTreeClassifier()
    clf_s = cross_val_score(clf,wine.data,wine.target,cv=10).mean()
    clf_l.append(clf_s)
#绘制结果曲线
plt.plot(range(1,11),rfc_l,label = "RandomForest")
plt.plot(range(1,11),clf_l,label = "DecisionTree")
plt.legend()
plt.show()

#n_estimators的学习曲线
#======【TIME WARNING: 2mins 30 seconds】==========#
superpa = []
for i in range(200):
    rfc = RandomForestClassifier(n_estimators=i+1)
    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,201),superpa)
plt.show()

0.9891812865497076 33

random_state

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

其中，i是判断错误的次数，也是判错的树的数量，ε是一棵树判断错误的概率，（1-ε）是判断正确的概率，共判对25-i次。采用组合，是因为25棵树中，有任意i棵都判断错误。

#bagging判断错误的可能性（概率组合预测）
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()
#sum([comb(25,i)*(0.2**i)*((1-0.2)**(25-i)) for i in range(13,26)])

0.00036904803455582827

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

1872583848

#打印出森林中所有树的随机模式
for i in range(len(rfc.estimators_)):
	print(rfc.estimators_[i].random_state)

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

当random_state固定时，随机森林中生成是一组固定的树，但每棵树依然是不一致的，这是用”随机挑选特征进行分枝“的方法得到的随机性。并且可以证明，当这种随机性越大的时候，袋装法的效果一般会越来越好。用袋装法集成时，基分类器应当是相互独立的，是不相同的。
但这种做法的局限性是很强的，当需要成千上万棵树的时候，数据不一定能够提供成千上万的特征来构筑尽量多尽量不同的树。因此，除了random_state，还需要其他的随机性。

bootstrap & oob_score

要让基分类器尽量都不一样，一种很容易理解的方法是使用不同的训练集来进行训练，而袋装法正是通过有放回的随机抽样技术来形成不同的训练数据，bootstrap就是用来控制抽样技术的参数。
在一个含有n个样本的原始训练集中，随机采样，每次采样一个样本，并在抽取下一个样本之前将该样本放回原始训练集，也就是说下次采样时这个样本依然可能被采集到，这样采集n次，最终得到一个和原始训练集一样大的，n个样本组成的自助集。由于是随机采样，这样每次的自助集和原始
数据集不同，和其他的采样集也是不同的。这样就可以自由创造取之不尽用之不竭，并且互不相同的自助集，用这些自助集来训练基分类器，我们的基分类器自然也就各不相同了。
bootstrap参数默认True，代表采用这种有放回的随机抽样技术。通常，这个参数不会被我们设置为False。

然而有放回抽样也会有自己的问题。由于是有放回，一些样本可能在同一个自助集中出现多次，而其他一些却可能被忽略，一般来说，自助集大约平均会包含63%的原始数据。因为每一个样本被抽到某个自助集中的概率为：
$$1-(1-\frac{1}{n}{)}^n$$
这里的数学公式如何理解呢？要从一个n个样本的数据集中有放回抽样出另一个n个样本的数据集，也就是总共需要进行n次抽样。一个样本在一次抽样中被抽到的概率为1/n，则在一次抽样中没有被抽到的概率是1-1/n，n次都没有抽中的概率就是(1-1/n)ⁿ，所以被抽中的概率就是1减去n次都没有抽中的概率。

当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_#使用oob评估获得的训练集得分

0.9719101123595506

重要属性和接口

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

#分别尝试以下属性和接口
rfc = RandomForestClassifier(n_estimators=25)
rfc = rfc.fit(Xtrain, Ytrain)
rfc.score(Xtest,Ytest)

0.9629629629629629

rfc.feature_importances_

array([0.17294472, 0.03080132, 0.0169717 , 0.00817673, 0.03415142,
       0.04871774, 0.14288035, 0.03357762, 0.02965377, 0.20877748,
       0.06008938, 0.08454388, 0.1287139 ])

rfc.apply(Xtest)#返回叶节点索引值

array([[19, 20, 15, ..., 15, 15,  8],
       [ 4,  3,  4, ...,  4,  2,  3],
       [10,  6,  7, ...,  9,  2,  1],
       ...,
       [19, 20, 17, ..., 16, 15,  8],
       [19, 20, 15, ..., 16, 15,  8],
       [ 8,  3,  4, ...,  5,  4,  3]], dtype=int64)

rfc.predict(Xtest)

array([0, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 0, 1, 0, 0, 2, 0, 2,
       1, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 1, 1, 0, 2, 0, 1, 0, 1, 0, 2, 1,
       1, 1, 0, 2, 2, 2, 1, 0, 0, 2])

rfc.predict_proba(Xtest)

array([[0.96, 0.04, 0.  ],
       [0.  , 0.28, 0.72],
       [0.  , 0.96, 0.04],
       [0.  , 1.  , 0.  ],
       ...
       [0.32, 0.64, 0.04],
       [0.88, 0.04, 0.08],
       [0.84, 0.12, 0.04],
       [0.  , 0.  , 1.  ]])

Bagging的另一个必要条件

使用袋装法时要求基评估器要尽量独立。其实，袋装法还有另一个必要条件：基分类器的判断准确率至少要超过随机分类器，就是说，基分类器的判断准确率至少要超过50%。基于随机森林的准确率公式画出基分类器的误差率ε和随机森林的误差率之间的图像如下：

#基分类器的误差率ε和随机森林的误差率对比
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()