ML02随机森林

---

title: 随机森林–机器学习经典算法
date: 2021-04-11
tags:

• ML
• 基础
  categories:
• dataAnalysis
  typora-copy-images-to: ./img
  typora-root-url: ./img

---

随机森林算法

​ 虽然决策树算法比较简单，也不需要对数据进行转换，但是容易出现过拟合问题，使用随机森林算法可以避免这个问题。

​ 随机森林算法是一种集成学习方法，基本思想是把几棵不同参数的决策树打包到一起，每科决策树单独进行预测，然后计算所有决策树预测结果的平均值（适用于回归分析），或所有决策树投票，得到最终结果（适用于分类）。在随机森林算法中，不会让每棵树都生成最佳的节点，而是在每个节点上随机选择一个特征进行分裂。

​ 通常来说，有三类集成算法，装袋法Bagging，提升法Boosting，和stacking。随机森林是装袋法的代表模型，他的所有基评估器都是决策树。分类器组成的森林叫做随机森林分类器。回归树集成的森林叫做随机森林回归器。

​ 由于随机森林是按照决策树的基评估，所以决策树的准确率越高。随机森林的准确率就越高。

随机森林分类重要参数

1. 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
  from sklearn.model_selection import cross_val_score
  import matplotlib.pyplot as plt
  

• 导入需要的数据集

  wine = load_wine()
  

• sklearn建模的基本流程

  # 实例化
  # 训练集带入实例化后的模型去进行训练，使用的接口是fit
  # 使用其他接口将测试集导入我们训练好的模型，去获取我们希望获取的结果（score,Ytest)
  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)
  

• 查看随机森林和决策树在一次交叉验证的对比

  # 查看一次交叉验证的效果对比
  rfc = RandomForestClassifier(n_estimators=25)
  rfc_s = cross_val_score(rfc, wine.data, wine.target, cv=10)
  
  clf = RandomForestClassifier()
  clf_s = cross_val_score(rfc, wine.data, wine.target, cv=10)
  

• 10次交叉验证

  # 我们认为一次具有偶然性。所以想要查看10次
  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(rfc, 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()
  

• 下面我们看看树的个数对随机森林的影响

  superpa = []
  for i in range(200):
      rfc = RandomForestClassifier(n_estimators=i + 1, n_jobs=-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()
  

2. Random_state

​ sklearn中的分类树DecisionTreeClassififier自带随机性，所以随机森林中的树天生就都是不一样的。我们在讲解分类树时曾提到，决策树从最重要的特征中随机选择出一个特征来进行分枝，因此每次生成的决策树都不一样，这个功能由参数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)

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

​ 因此，除了random_state。我们还需要其他的随机性。

3. bootstrap & oob_score

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

​ bootstrap参数默认为True，代表采用这种有返回的随机抽样技术，通常我们也不会设置为False

​ 没有参与建模的数据，这些数据被称为袋外数据(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)
print(rfc.oob_score_)

4. predice_proba

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

5. Bouns:Bagging的另一个必要条件

还有个必要条件：基分类器的判断准确率至少要超过随机分类器，即时说，基分类器的判断准确率至少要超过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()

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

随机森林回归重要参数

1. criterion

回归树衡量分枝质量的指标，支持的标准有三种：

1）输入"mse"使用均方误差mean squared error(MSE)，父节点和叶子节点之间的均方误差的差额将被用来作为

特征选择的标准，这种方法通过使用叶子节点的均值来最小化L2损失

2）输入“friedman_mse”使用费尔德曼均方误差，这种指标使用弗里德曼针对潜在分枝中的问题改进后的均方误差

3）输入"mae"使用绝对平均误差MAE（mean absolute error），这种指标使用叶节点的中值来最小化L1损失。

2. 重要属性和接口

​ 最重要的属性和接口，都与随机森林的分类器相一致，还是apply, fifit, predict和score最为核心。值得一提的是，随机森林回归并没有predict_proba这个接口，因为对于回归来说，并不存在一个样本要被分到某个类别的概率问题，因此没有predict_proba这个接口。

• 随机森林回归的用法

  from sklearn.datasets import load_boston
  from sklearn.model_selection import cross_val_score
  from sklearn.ensemble import RandomForestRegressor
  import sklearn
  
  boston = load_boston()
  # print(boston)
  
  regressor = RandomForestRegressor(n_estimators=100, random_state=0)
  cvs = cross_val_score(regressor, boston.data, boston.target, cv=10, scoring='neg_mean_squared_error')
  print(cvs)
  print(sorted(sklearn.metrics.SCORERS.keys()))
  

  和决策树完全一致。只是多了参数n_estimators。在上述代码中，返回十次交叉验证的结果，注意在这里，如果不填写scoring = “neg_mean_squared_error”，交叉验证默认的模型衡量指标是R平方，因此交叉验证的结果可能有正也可能有负。而如果写上scoring，则衡量标准是负MSE，交叉验证的结果只可能为负。

3. 用随机森林回归填补缺失值

​ 我们从现实中收集的数据，几乎不可能是完美无缺的，往往都会有一些缺失值。面对缺失值，很多人选择的方式是直接将含有缺失值的样本删除，这是一种有效的方法，但是有时候填补缺失值会比直接丢弃样本效果更好，即便我们其实并不知道缺失值的真实样貌。sklearn中，我们可以使用sklearn.impute.SimpleImputer来轻松地将均值，中值，或者其他最常用的数值填补到数据中，在这个案例中，我们将使用均值，0，和随机森林回归来填补缺失值，并验证四种状况下的拟合状况，找出对使用的数据集来说最佳的缺失值填补方法。

• 导入要使用的包

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_boston
from sklearn.impute import SimpleImputer
# 用来填补缺失值。
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score

• 导入数据集

# 波士顿房价数据集是连续型标签。是用回归
dataset = load_boston()
# print(dataset.data.shape)   #(506, 13)
# 对于标签是连续型变量的。我们要使用回归模型
# print(dataset.target)
# 完整的数据集
X_full, Y_full = dataset.data, dataset.target

• 制造空的数据集

##=================接下来都是表示人为怎么选择缺失数据值
n_samples = X_full.shape[0]
n_features = X_full.shape[1]

# 首先我们要确定希望放入缺失数据的比例，在这里我们假设是50%，
# 那总共有3289个数据缺失
rng = np.random.RandomState(0)
missing_rate = 0.5
# np.floor表示向下取整，返回.0格式的浮点数。然后用int进行取整
n_missing_samples = int(np.floor(n_samples * n_features * missing_rate))
# print(n_missing_samples)
# randint(下限，上限，n)请在下限和上限之间取出n个整数
missing_features = rng.randint(0, n_features, n_missing_samples)
missing_samples = rng.randint(0, n_samples, n_missing_samples)

# 所有的数为 #(506, 13)
# print(missing_features)  # 都在0到13这个范围内
# print(len(missing_features))
# print(missing_samples)  # 都在0到506这个范围内
# print(len(missing_samples))

# 我们现在采样了3289个数据，远远超过我们的样本量506，所以我们使用随机抽取的函数randint。
# 但是如果我们需要的数据量小于我们的样本量506，那我们可以采用np.random.choice来抽样。
# choice会随机抽取不重复的随机数。
# 因此可以帮我们让数据更加分散，确保数据不会集成在一起
X_missing = X_full.copy()
Y_missing = Y_full.copy()
X_missing[missing_samples, missing_features] = np.nan
# print(X_missing)
# 有空的数据集已经弄好了
X_missing = pd.DataFrame(X_missing)
# print(X_missing)

• 用均值或者用0进行填补

# 告诉他。需要被填补的是np.nan，策略是用mean均值填充
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')  # 实例化
X_missing_mean = imp_mean.fit_transform(X_missing)  # 训练fit+导出predict=fit_transform
# 判断是否所有的数已经被填补完毕。
print(pd.DataFrame(X_missing_mean).isnull().sum())

# 使用0进行填补
imp_0 = SimpleImputer(missing_values=np.nan, strategy="constant", fill_value=0)
X_missing_0 = imp_0.fit_transform(X_missing)
print(X_missing_0)

• 随机森林填补

# 利用随机森林填充
X_missing_reg = X_missing.copy()

# 我们要从特征值缺失最少的特征，所以要找到缺失值从小到大的顺序
# sum(axis=0)默认就是axis=0.表示按列加和
# print(X_missing_reg.isnull().sum(axis=0))
# np.sort会损失索引。np.argsort不会损失索引

# 缺失值从小到大特征值的顺序
sortindex = np.argsort((X_missing_reg.isnull().sum(axis=0)).values)
# [ 6 12  8  7  9  0  2  决策树  5  4  3 10 11] 表示第6个特征(第6列）缺失值最小
# print(sortindex)

# 构建我们新的特征矩阵（没有被选中去填充的特征+原始的标签）和新的标签(被选中去填充的特征）
df = X_missing_reg
fillc = df.iloc[:, 6]
# 新特征矩阵

# 没有被选中的去填充的特征。没有第6列
# print(df.iloc[:, df.columns != 6])
# 原始的标签
# print(pd.DataFrame(Y_full))

# 新的特征矩阵
# print(pd.concat([df.iloc[:, df.columns != 6], pd.DataFrame(Y_full)], axis=1决策树))
# 填补0后的特征矩阵
df_0 = SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=0).fit_transform(df)
# print(df_0)

# 找出我们的训练集。测试集。
# 是被选中要填充的特征中（现在是我们的标签）存在的那些值，非空值
Ytrain = fillc[fillc.notnull()]
# print(Ytrain)
# 是被选中要填充的特征中（现在是我们的标签）存在的那些值，空值
# 我们需要的不是Ytest的值，而是空值的索引
Ytest = fillc[fillc.isnull()]
# print(Ytest)

# 在新特征矩阵上，被选出来的要填充的特征的非空值所对应的记录
Xtrain = df_0[Ytrain.index, :]

# 在新特征矩阵上，被选出来的要填充的特征的空值所对应的记录
Xtest = df_0[Ytest.index, :]

# 用随机森林填充
rfc = RandomForestRegressor(n_estimators=100)  # 实例化
rfc = rfc.fit(Xtrain, Ytrain)  # 导入训练集进行训练
Ypredict = rfc.predict(Xtest)  # 用predict接口将Xtest导入，得到我们的预测结果，就是我们要用来填充空值的这些值

print(pd.DataFrame(Ypredict))  # [185 rows x 1决策树 columns]

# 将得到的预测结果。填补好
X_missing_reg.loc[X_missing_reg.iloc[:, 6].isnull(), 6] = Ypredict
# print(X_missing_reg.loc[X_missing_reg.iloc[:, 6].isnull(), 6])
# ==========完成了第6列的填补

• 随机森林循环填充

# 循环填充
for i in sortindex:
    # 构建我们的新特征矩阵和新标签
    df = X_missing_reg
    # 取出需要预测的这一列标签
    fillc = df.iloc[:, i]
    # 把之前的和最初的连接起来组成新的特征矩阵
    df = pd.concat([df.iloc[:, df.columns != i], pd.DataFrame(Y_full)], axis=1)
    # 在新特征矩阵中。对含有缺失值的列进行0的填补
    df_0 = SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=0).fit_transform(df)
    Ytrain = fillc[fillc.notnull()]
    Ytest = fillc[fillc.isnull()]
    Xtrain = df_0[Ytrain.index, :]
    Xtest = df_0[Ytest.index, :]
    # 用随机森林回归填充缺失值
    rfc = RandomForestRegressor(n_estimators=100)
    rfc = rfc.fit(Xtrain, Ytrain)
    Ypredict = rfc.predict(Xtest)
    # 将填补好的特征返回到我们的原始的特征矩阵中
    X_missing_reg.loc[X_missing_reg.iloc[:, i].isnull(), i] = Ypredict

• 利用填补好的数据进行建模

X = [X_full, X_missing_reg]
mse = []
std = []
for x in X:
    estimator = RandomForestRegressor(random_state=0, n_estimators=100)
    scores = cross_val_score(estimator, x, Y_full, scoring='neg_mean_squared_error',
                             cv=5).mean()
    mse.append(scores * -1)
print(mse)

• 绘图

# 根据所得到的结果画出条形图
X_labels = ['X_full', 'X_missing_reg']
colors = ['r', 'g']
plt.figure(figsize=(12, 6))  # 画出画布
ax = plt.subplot(111)  # plt.subplot添加子图，添加了子图所有的命令在子图中执行
for i in np.arange(len(mse)):  # len(mse)=4
    # alpha = 0.6表示透明度
    ax.barh(i, mse[i], color=colors[i], alpha=0.6, align="center")  # 表示y轴
    # mse[i]一个条
ax.set_title('Imputation Techniques with Boston Data')  # 标题
ax.set_xlim(left=np.min(mse) * 0.9, right=np.max(mse) * 1.1)  # x轴的取值
ax.set_yticks(np.arange(len(mse)))  # y轴的刻度
ax.set_xlabel('MSE')  # x轴的名字
# ax.invert_yaxis()  # 你要把y上面这个轴命名好
ax.set_yticklabels(X_labels)
plt.show()

另外关于机器学习调参的方法，是一步步进行细化，进而达到满意值。

参考

菜菜的sklearn课堂直播间： https://live.bilibili.com/12582510

python数据分析挖掘与可视化