[机器学习与scikit-learn-17]：算法-随机森林分类与集成算法概述

作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客

本文网址：https://blog.csdn.net/HiWangWenBing/article/details/123389398

---

目录

前言：

第1章 集成算法概述

1.1 概述

1.2 集成算法的目标

1.3 sklearn中的集成算法：ensemble库

1.4 基评估器/基分类器

1.5 随机森林中的“随机”

1.6 随机森林运作的条件

第2章 RandomForestClassifier的使用

2.1 RandomForestClassifier类参数详解

2.2 代码示例

第3章 随机森林好于决策树的原理

3.1 random_state

3.2 样本的随机性

 第4章 其他关键性属性与接口

---

前言：

随机森林实际上是多个独立的决策树进行联合预测，多种算法的联合预测，又称为集成算法。

第1章 集成算法概述

1.1 概述

集成学习（ensemble learning）是时下非常流行的机器学习算法，它本身不是一个单独的机器学习算法，而是通过在数据上构建多个模型，综合/集成所有模型的建模结果。

基本上所有的机器学习领域都可以看到集成学习的身影，在现实中集成学习也有相当大的作用，它可以用来做市场营销模拟的建模，统计客户来源，保留和流失，也可用来预测疾病的风险和病患者的易感性。在现在的各种算法竞赛中，随机森林，梯度提升树（GBDT），Xgboost等集成算法的身影也随处可见，可见其效果之好，应用之广。

1.2 集成算法的目标

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

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

装袋法bagging的核心思想是构建多个相互独立、并行的评估器，然后对其预测进行平均或多数表决原则来决定集成评估器的结果。装袋法的代表模型就是随机森林。

提升算法boosting：基评估器是相关的，是按顺序/串行一一构建的。其核心思想是结合弱评估器的力量一次次对难以评估的样本进行预测，从而构成一个强评估器。提升法的代表模型有Adaboost和梯度提升树。

1.3 sklearn中的集成算法：ensemble库

集成算法中，有一半以上都是决策树的集成模型，可以看出：决策树在集成中必定是有很好的效果。其中就包括了用于分类的随机森林和用于回归的随机森林。

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

1.4 基评估器/基分类器

随机森林是有多个单个决策树组成，这里的单个决策树就称为基评估器。

1.5 随机森林中的“随机”

为什么“随机”森林呢？

随机性体现在如下：

（1）随机森林中的每个树的随机种子不同

（2）随机森林中每个树选择的特征是随机的

（3）随机森林中每个树的样本是随机的

每棵树的随机性越好，每个树之间的独立性就越高，袋装法的效果越高。

1.6 随机森林运作的条件

（1）独立性：在使用袋装法时要求基评估器要尽量独立。

（2）准确率：基分类器的判断准确率至少要超过随机分类器，即时说，基分类器的判断准确率至少要超过50%，如果基分类器的判断准确率小于50%，则随机森林的准确率小于单棵树的预测的准确率。如下演示：

import numpy as np
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()

第2章 RandomForestClassifier的使用

2.1 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)

n_estimators：

指定随机森林中决策树的数量，这是森林中树木的数量，即基评估器的数量。这个参数对随机森林模型的精确性影响是单调的，n_estimators越大，模型的效果往往越好。但是相应的，任何模型都有决策边界，n_estimators达到一定的程度之后，随机森林的精确性往往不在上升或开始波动，并且，n_estimators越大，需要的计算量和内存也越大，训练的时间也会越来越长。对于这个参数，我们是渴望在训练难度和模型效果之间取得平衡。

n_estimators的默认值，在不同的版本中有不同的值，有10或100等。

其他的决策树相关的参数（与决策树类似）

2.2 代码示例

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

（1）导入我们需要的包

# 1. 导入我们需要的包
%matplotlib inline
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_wine

（2）导入需要的数据集

# 2. 导入需要的数据集
wine = load_wine()
wine.data
wine.target

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

（3）建立决策树与随机森林普通模型

# 3. 建立决策树与随机森林普通模型
from sklearn.model_selection import train_test_split

# 构建数据集
Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)


# 构建决策树并进行训练
tree = DecisionTreeClassifier(random_state=1)
tree = tree.fit(Xtrain,Ytrain)
score_tree = tree.score(Xtest,Ytest)

#构建随机森林并进行训练
forest = RandomForestClassifier(random_state=1)
forest = forest.fit(Xtrain,Ytrain)
score_forest = forest.score(Xtest,Ytest)

print("决策树分数  ：", score_tree)
print("随机森林分数：",score_forest)

决策树分数  ： 0.8888888888888888
随机森林分数： 0.9814814814814815

（4）建立决策树与随机森林的交叉验证模型

# 4. 建立决策树与随机森林的交叉验证模型
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

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

forest = RandomForestClassifier(n_estimators=25)
forest_cross = cross_val_score(forest, wine.data,wine.target,cv=10)

print("\n决策树分数  ：\n", tree_cross)
print("\n随机森林分数：\n", forest_cross)

# 显示决策树和随机森林各自的交叉训练的分数
# A) 随机森林的平均分数远高于决策树：随机森林的分数在上方
# B) 随机森林的走势与决策树的走势相似
plt.plot(range(1,11),tree_cross,label = "Decision Tree")
plt.plot(range(1,11),forest_cross, label = "RandomForest")

plt.legend()
plt.show()

决策树分数  ：
 [0.88888889 0.88888889 0.77777778 0.88888889 0.83333333 0.83333333
 1.         0.88888889 0.94117647 0.76470588]

随机森林分数：
 [0.94444444 1.         0.88888889 0.94444444 1.         1.
 1.         1.         1.         1.        ]

 （5）画出随机森林和决策树在十次交叉验证下的效果对比

# 5. 画出随机森林和决策树在十次交叉验证下的效果对比
tree_log = []
forest_log = []
for i in range(10):
    # 决策树
    tree = DecisionTreeClassifier()
    tree_cross = cross_val_score(tree, wine.data,wine.target,cv=10).mean()
    tree_log.append(tree_cross)
    
    # 随机森林
    forest = RandomForestClassifier(n_estimators=25)
    forest_cross = cross_val_score(forest, wine.data,wine.target,cv=10).mean()
    forest_log.append(forest_cross)

# A) 随机森林的分数在决策树分数上方，效果更好
plt.plot(range(1,11),tree_log,label = "Decision Tree")
plt.plot(range(1, 11),forest_log,label = "Random Forest")

plt.legend()
plt.show()

随机森林的分数在决策树分数上方，效果更好

（6）n_estimators的学习曲线：森林中树木的个数对结果的影响

# 6. n_estimators的学习曲线
# 验证森林中树的个数对效果的影响：
# 决策树越多，分数越高，消耗的资源越多，训练的时间越长
#####【TIME WARNING: 2mins 30 seconds】#####
scores_log = []
for i in range(50):
    forest = RandomForestClassifier(n_estimators=i+1,n_jobs=-1)
    forest_cross = cross_val_score(forest, wine.data,wine.target,cv=10).mean()
    scores_log.append(forest_cross)

# 显示最大分数以及打印对应的森林中决策树的个数
print(max(scores_log), scores_log.index(max(scores_log)))

#画图
plt.figure(figsize=[20,5])
plt.plot(range(1,51),scores_log)
plt.show()

第3章 随机森林好于决策树的原理

3.1 random_state

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

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

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()

0.00036904803455582827 =》远远小于单个节点的错误率。

可见，判断错误的几率非常小，这让随机森林在红酒数据集上的表现远远好于单棵决策树。

那现在就有一个问题了：我们说袋装法服从多数表决原则或对基分类器结果求平均，这即是说，我们默认森林中的每棵树应该是不同的，并且会返回不同的结果。设想一下，如果随机森林里所有的树的判断结果都一致（全判断对或全判断错），那随机森林无论应用何种集成原则来求结果，都应该无法比单棵决策树取得更好的效果才对。但我们使用了一样的类DecisionTreeClassifier，一样的参数，一样的训练集和测试集，为什么随机森林里的众多树会有不同的判断结果？

这是因为sklearn中的分类树DecisionTreeClassifier自带随机性，所以随机森林中的树天生就都是不一样的。

我们在讲解分类树时曾提到，决策树从最重要的特征中随机选择出一个特征来进行
分枝，因此每次生成的决策树都不一样，这个功能由参数random_state控制。
随机森林中其实也有random_state，用法和分类树中相似。

只不过在决策树分类树中，一个random_state只控制生成一棵树，

而随机森林中的random_state控制的是生成森林的模式，而非让一个森林中只有一棵树。即使我们锁定random_state，森林中的每个决策数的random_state还是没有锁定，这就是随机森林中随机的最本质的含义。

如下列代码所示，随机森林的random_state=2，但其每棵树的random_state却不是固定的，也不相同。

forest = RandomForestClassifier(n_estimators=20,random_state=2)
forest = forest.fit(Xtrain, Ytrain)

#随机森林的重要属性之一：estimators，查看森林中树的状况
for i in range(len(forest.estimators_)):
    print(forest.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。我们还需要其他的随机性。

3.2 样本的随机性

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

 第4章 其他关键性属性与接口

# 创建随机森林
forest = RandomForestClassifier(n_estimators=25)

# 进行模型训练
forest = rfc.fit(Xtrain, Ytrain)

#评估模型在测试集上的分数
forest.score(Xtest,Ytest)

（1）每个特征的重要性

forest.feature_importances_

array([0.15351851, 0.04619176, 0.01648699, 0.03156205, 0.0173969 ,
       0.04205027, 0.15766258, 0.01431709, 0.01851271, 0.15047049,
       0.0226312 , 0.16380493, 0.16539452])

（2）预测，获取在决策树中的位置

# 在测试集上进行预测，获取在树中的位置
forest.apply(Xtest)

array([[14,  5,  4, ..., 14,  4,  6],
       [ 5, 16,  2, ...,  6,  2, 11],
       [20, 20, 13, ..., 14, 16,  9],
       ...,
       [ 5, 10,  7, ...,  6, 11,  9],
       [20, 17,  9, ..., 14, 13,  9],
       [20, 15,  9, ..., 14, 13,  9]], dtype=int64)

（3）对测试集进行预测，获取每个分类

# 对测试集进行预测，获取每个分类
forest.predict(Xtest)

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

（4）在测试集上进行预测，获取每个样本的每个分类的可能性

# 在测试集上进行预测，获取每个样本的每个分类的可能性
forest.predict_proba(Xtest)

array([[0.28, 0.2 , 0.52],
       [0.  , 0.88, 0.12],
       [1.  , 0.  , 0.  ],
       [0.88, 0.08, 0.04],
       [0.  , 0.08, 0.92],
       [0.  , 0.28, 0.72],
       [0.12, 0.  , 0.88],
       [0.6 , 0.28, 0.12],
       [0.  , 0.96, 0.04],
       [1.  , 0.  , 0.  ],
       [0.  , 0.96, 0.04],
       [0.  , 0.96, 0.04],

---

作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客

本文网址：https://blog.csdn.net/HiWangWenBing/article/details/123389398