（八）集成学习Bagging之随机森林知识点汇总与python实现

不定期持续更新ing~~~~~

目录

一、知识点总结不定期持续更新中：

Part1 ：集成算法，bagging，boosting

Part2：随机森林

Part3：相关知识点

Part4：一些疑惑

二、sklearn参数：

A.使模型预测更好的特征

B.使得模型训练更容易的特征

三、代码实现

1.采用工具包实现随机森林和单个决策树：

 2.详细代码实现随机森林（来自网友）

四、参考博客

一、知识点汇总：

Part1 ：集成算法，bagging，boosting

• 集成模型（Ensemble）的思想：为了解决单个模型所固有的缺陷，从而整合更多的模型，取长补短，避免局限性。
• 自助法（Bootstrap）：即从样本自身中再生成很多可用的同等规模的新样本，从自己中产生和自己类似的，所以叫做自助，即不借助其他样本数据。（有放回的抽样问题）
• bagging的名称来源于 （ Bootstrap AGGregatING ），意思是自助抽样集成，这种方法将训练集分成m个新的训练集，然后在每个新训练集上构建一个模型，各自不相干，最后预测时我们将这个m个模型的结果进行整合，得到最终结果
• bagging每轮随机采样中，训练集大约有36.8%的数据没被采样，被称为“袋外数据”
• 对于分类：通常使用简单投票法，得到最多票数的类别或者类别之一为最终的模型输出
• 对于回归：通常使用简单平均法，对T个弱学习器得到的回归结果进行算术平均得到最终的模型输出。（分类投票，回归均值）
• Bagging：有放回的重复抽样方法，各学习器之间没有依赖关系，可以并行生成，减少方差
• Boosting：各个学习器之间是串联的，每一轮训练集不变，改变的是样本的权重，减少偏差
• 为什么说bagging减少了variance，而boosting减少了bias
  • 偏差：预测值和真实值之间的差值，欠拟合
  • 方差：预测值之间的离散程度，过拟合，记住太多细节
  • boosting降低bias，即增加基模型的个数逼近目标，通常来说boosting是在优化loss function，在降低loss，那么很显然，这在很大程度上是减少bias，但同样我们也发现boosting的方差是随着基模型的个数逐渐增大的，所以当我们增大基模型个数提高准确率时，整体模型的方差也随之增大了。
  • baggingj降低方差，即基模型个数越大，可以降低模型的过拟合，但当m增大到一定程度时，降低模型过拟合的能力达到极限
• Bagging+决策树=随机森林
• AdaBoost+决策树=提升树
• Gradient+Boosting+决策树=GBDT

Part2：随机森林

• 随机森林是bagging的一个特化进阶版
  • 特化是指：随机森林的弱学习器都是决策树
  • 进阶是指：在bagging样本随机采样的基础上，又加上了特征的随机选择
• 随机森林的构造过程：行采样和列采样
  • 行采样：假设有N个样本，有放回的随机选择N个样本（自助法）
  • 列采样：每个样本有M个属性，随机选择m个属性，m<<M，然后从这m个属性中采用某种策略（信息增益）来选择1个属性作为该节点的分裂属性

•  特征选择的个数：减少特征选择个数，不仅会提升算法个数，也可能降低测试误差，通常使用的值为sqrt的数量或者

• m是决策树的重要参数，m越小，方差越小，拟合程度越差，偏倚越大，一般选择交叉验证法寻找最佳m
• OOB：袋外错误率。随机森林有一个重要的优点就是，没有必要对它进行交叉验证或者用一个独立的测试集来获得误差的一个无偏估计。它可以在内部进行评估，也就是说在生成的过程中就可以对误差建立一个无偏估计。在构建每棵树时，我们对训练集使用了不同的bootstrap sample（随机且有放回地抽取）。所以对于每棵树而言（假设对于第k棵树），大约有1/3的训练实例没有参与第k棵树的生成，它们称为第k棵树的oob样本。而这样的采样特点就允许我们进行oob估计
• 整个决策树形成过程中没有进行剪枝，因为特征和样本的随机性选择导致不容易陷入过拟合
• 随机森林具有很好的抗噪声能力
• 他能处理很高维（feature很多）的数据，并且不用做特征选择
• 可以度量样本之间的相似性
• 训练过程中能检测特征重要性，是常见的特征筛选方法。当某一特征在所有树种离树根的平均距离越近，这一特征就越重要
• 需要调整的参数有：决策树个数，递归次数（决策树深度），特征选择的个数
• 决策树个数：越多越稳定
• 决策树深度：深度越小，计算量越小，速度越快，常用的取值为10-100

Part3：相关知识点

• 相关知识点：ID3
  • 在ID3中，选择信息增益的指标来选择分裂特征，信息增益越大，说明选择的变量分裂后的分支下输出更纯
  • ID3有很多明显不足的地方：比如不能处理连续性变量；不能处理缺失值；选择分裂变量时会倾向于选择类别较多的变量；容易过拟合
• 相关知识点：C4.5
  • 解决ID3不能处理连续变量：在C4.5中，会先将连续变量离散化。如我们有一个连续变量A，共有m个不同的取值 ，算法首先将连续变量按照一定的顺序排列，排列后一共有m-1个切分点，切分点的值总是取相邻两个值的均值，即第t个切分点的值表示为(at+at+1)/2 ，然后根据切分点将变量一分为二
  • 解决ID3不能处理缺失值：C4.5可以处理缺失值，具体原因【待补充】
  • 解决ID3倾向于选择类别较多的变量：C4.5引入了信息增益率替换信息增益
  • 解决ID3过拟合问题：引入正则化系数进行了初步剪枝
  • 不足：生成的是多叉树，效率不如二叉树高；只能用于分类，不能用于回归；由于使用了熵模型，里面有大量耗时的对数运算，如果是连续值还有大量的排序运算，运算效率较低
• 绝大多数随机森林算法中用的都是Cart树
  • 在sklearn中的随机森林算法中用的就是cart树，在分类问题中，分裂方式不限于gini，也可以选entropy，在回归问题中，用的是mse和mae
• 相关知识点：Cart
  • cart树里面引入了gini系数，gini计算相比熵要简单的多，所以可以减少一定的运算量
  • cart树既可以做回归，也可以做分类
  • cart树就是多个二叉树组成，这种特点使得cart算法与C4.5算法在处理离散变量上有很大的不同
    • 如某个特征A被选取建立决策树节点，如果它有A1,A2,A3三种类别，我们会在决策树上一下建立一个三叉的节点。这样导致决策树是多叉树。但是cart分类树使用的方法不同，他采用的是不停的二分，CART分类树会考虑把A分成{A1}和{A2,A3} ，{A2} 和{A1,A3} ，{A3}和{A1,A2} ，若最终选择{A1}和{A2,A3} 作为分裂类，那么A2和A3在后续还是有可能会被再次分裂开。
  • 因为每次都是二分裂，所以cart也没有ID3中倾向于选择类别较多的变量的缺陷
  • cart树对连续变量的处理与C4.5类似
• 随机森林中类别数较多的变量会倾向于有较高的变量重要性，可以从dummy化去考虑，由于类别较多的变量横向dummy化的变量较多，其被选进m特征的概率会比其他变量更高
• 决策树数量多的时候，因为并行计算面临着训练空间会比较大的缺点？

Part4：一些疑惑

• 随机森林与多重线性相关
  • 答案是在一定程度可以，但建议剔除相关性较强的变量，降低这种影响
  • 在随机森林的步骤中，有一步是要求每次分裂都从随机的m个特征中选择一特征作为分裂特征，这种随机性就是为了使得树与树之间的相关性变低，或者说变得不一样。如果变量集里面出现了两个完全一致（相关性的极端）的变量，那该变量被选到m个变量的机会就会变高，那么构造出来的树就会变得越像，树与树之间的相关性就会变高，那么随机森林的泛化的能力就会变差。换句话说，这些相似的变量挤占了带有其他信息的变量入模的机会，从而使得模型变差。
• 为什么要随机抽样：
  • 如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的，这样的话完全没有bagging的必要；
• 为什么要有放回地抽样：
  • 如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是"有偏的"，都是绝对"片面的"，也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树(弱分类器)的投票表决，这种表决应该是"求同"，因此使用完全不同的训练集来训练每棵树这样对最终分类结果是没有帮助的，这样无异于是"盲人摸象"

 图片来源：机器学习-浅谈随机森林的几个tricks-20170917 - 知乎 

 图片来源：随机森林算法原理解析_华山拎壶冲的博客-CSDN博客_随机森林原理

 图片来源：随机森林（Random Forest）算法原理_江户川柯壮的博客-CSDN博客_随机森林

二、sklearn参数：

Random Forest算法参数解释及调优_nobody~的博客-CSDN博客_随机森林参数调优

A.使模型预测更好的特征

主要有3类特征可以被调整，以改善该模型的预测能力

1.max_features:允许单个决策树使用特征的最大数量，Python为最大特征数提供了多个可选项:

• Auto/None ：简单地选取所有特征，每颗树都可以利用他们
• sqrt ：此选项是每颗子树可以利用总特征数的平方根个。 例如，如果变量（特征）的总数是100，所以每颗子树只能取其中的10个
• 0.X：此选项允许每个随机森林的子树可以利用变量（特征）数的X0％

• 增加max_features一般能提高模型的性能，因为在每个节点上，我们有更多的选择可以考虑。 然而，这未必完全是对的，因为它降低了单个树的多样性，而这正是随机森林独特的优点。 但是，可以肯定，你通过增加max_features会降低算法的速度。 因此，你需要适当的平衡和选择最佳max_features

2.n_estimators:在利用最大投票数或平均值来预测之前，你想要建立子树的数量。

• 较多的子树可以让模型有更好的性能，但同时让你的代码变慢。 你应该选择尽可能高的值，只要你的处理器能够承受的住，因为这使你的预测更好更稳定。

3.min_sample_leaf:最小样本叶片大小。

• 叶是决策树的末端节点。 较小的叶子使模型更容易捕捉训练数据中的噪声。 一般来说，我更偏向于将最小叶子节点数目设置为大于50。在你自己的情况中，你应该尽量尝试多种叶子大小种类，以找到最优的那个

B.使得模型训练更容易的特征

1.n_jobs:这个参数告诉引擎有多少处理器是它可以使用。

• “-1”意味着没有限制，而“1”值意味着它只能使用一个处理器

2.random_state:此参数让结果容易复现。

三、代码实现

1.采用工具包实现随机森林和单个决策树：

数据集来源：打不开的可以点击百度网盘链接

链接: https://pan.baidu.com/s/1h_cq12b2op8-T7sM0YeQ7w 提取码: 83tt

https://archive.ics.uci.edu/ml/machine-learning-databases/undocumented/connectionist-bench/sonar/

import csv
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier # 决策树
from sklearn.ensemble import RandomForestClassifier # 随机森林

'''加载数据，一行行的存入列表'''
def loadCSV(filename):
    dataSet = []
    with open(filename, 'r') as file:
        csvReader = csv.reader(file)
        for line in csvReader:
            dataSet.append(line)
    return dataSet
dataSet = loadCSV('/Users/Downloads/sonar_all_data.csv')


'''处理数据，除了标签列，其他列都转换为float类型'''
def column_to_float(dataSet):
    featLen = len(dataSet[0]) - 1
    for data in dataSet:
        for column in range(featLen):
            data[column] = float(data[column].strip())
column_to_float(dataSet)


'''划分数据集7：3'''
X = []
Y = []
for i in dataSet:
    x= i[:-1]
    y = i[-1]
    Y.append(y)
    X.append(x)
X_train, X_test, y_train, y_test = train_test_split(X,Y, test_size=0.3)


'''计算准确率'''
def accuracy(predict_values, actual):
    correct = 0
    for i in range(len(actual)):
        if actual[i] == predict_values[i]:
            correct += 1
    return correct / float(len(actual))


'''工具包预测结果'''
rf=RandomForestClassifier(random_state=0)# 随机森林
clf = DecisionTreeClassifier(random_state=0)# 单个决策树
rf = rf.fit(X_train,y_train)
clf = clf.fit(X_train,y_train)
score_rf =rf.score(X_test,y_test)
score_clf =clf.score(X_test,y_test)
print("随机森林：",score_rf)
print("决策树：",score_clf)

实验结果：

随机森林： 0.8412698412698413
决策树： 0.6349206349206349

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

画出随机森林和决策树在十组交叉验证下的效果对比
rfc_l = []
clf_l = []
for i in range(10):
    rfc = RandomForestClassifier(n_estimators=25)
    rfc_s = cross_val_score(rfc,X,Y,cv=10).mean()
    rfc_l.append(rfc_s)
    clf = DecisionTreeClassifier()
    clf_s = cross_val_score(clf,X,Y,cv=10).mean()
    clf_l.append(clf_s)

plt.plot(range(1,11),rfc_l,label = "Random Forest")
plt.plot(range(1,11),clf_l,label = "Decision Tree")
plt.legend()
plt.show()

 2.详细代码实现随机森林（来自网友）

import csv
from random import seed
from random import randrange
from math import sqrt

'''决定输出标签'''
def decide_label(data):
    output = [row[-1] for row in data]
    # 简单投票法
    return max(set(output), key=output.count)


'''子分割，不断地构建叶节点的过程'''
def sub_spilt(root, n_features, max_depth, min_size, depth):
    left = root['left']
    right = root['right']
    del (root['left'])
    del (root['right'])
    if not left or not right:
        root['left'] = root['right'] = decide_label(left + right)
        return
    if depth > max_depth:
        root['left'] = decide_label(left)
        root['right'] = decide_label(right)
        return
    if len(left) < min_size:
        root['left'] = decide_label(left)
    else:
        root['left'] = get_best_spilt(left, n_features)
        sub_spilt(root['left'], n_features, max_depth, min_size, depth + 1)
    if len(right) < min_size:
        root['right'] = decide_label(right)
    else:
        root['right'] = get_best_spilt(right, n_features)
        sub_spilt(root['right'], n_features, max_depth, min_size, depth + 1)


'''计算分割代价'''
def spilt_loss(left, right, class_values):
    loss = 0.0
    for class_value in class_values:
        left_size = len(left)
        if left_size != 0:  # 防止除数为零
            # list.count(obj)返回元素在列表中出现的次数。
            prop = [row[-1] for row in left].count(class_value) / float(left_size)
            loss += (prop * (1.0 - prop))# GINI指数
        right_size = len(right)
        if right_size != 0:
            prop = [row[-1] for row in right].count(class_value) / float(right_size)
            loss += (prop * (1.0 - prop))
    return loss


'''分割数据集,左右分支'''
def data_spilt(dataSet, index, value):
    left = []
    right = []
    for row in dataSet:
        if row[index] < value:
            left.append(row)
        else:
            right.append(row)
    return left, right


'''选取任意的n个特征，在这n个特征中，选取分割时的最优特征'''
def get_best_spilt(dataSet, n_features):
    features = []
    class_values = list(set(row[-1] for row in dataSet))
    b_index, b_value, b_loss, b_left, b_right = 999, 999, 999, None, None
    # 列采样
    while len(features) < n_features:
        index = randrange(len(dataSet[0])-1)
        if index not in features:
            features.append(index)
    for index in features:#找到列的最适合做节点的索引，（损失最小）
        for row in dataSet:
            left, right = data_spilt(dataSet, index, row[index])#以它为节点的，左右分支
            loss = spilt_loss(left, right, class_values)# 计算分割代价
            if loss < b_loss:#寻找最小分割代价
                b_index, b_value, b_loss, b_left, b_right = index, row[index], loss, left, right
    return {'index': b_index, 'value': b_value, 'left': b_left, 'right': b_right}


'''构造决策树'''
def build_tree(dataSet, n_features, max_depth, min_size):
    root = get_best_spilt(dataSet, n_features)
    sub_spilt(root, n_features, max_depth, min_size, 1)
    return root


'''行采样，随机抽样选择N个样本'''
def get_subsample(dataSet, ratio):
    subdataSet = []
    lenSubdata = round(len(dataSet) * ratio)#四舍五入保留整数
    while len(subdataSet) < lenSubdata:
        index = randrange(len(dataSet))# 行采样，随机选择
        subdataSet.append(dataSet[index])
    return subdataSet


'''预测测试集结果'''
def predict(tree, row):
    predictions = []
    if row[tree['index']] < tree['value']:
        if isinstance(tree['left'], dict):
            return predict(tree['left'], row)
        else:
            return tree['left']
    else:
        if isinstance(tree['right'], dict):
            return predict(tree['right'], row)
        else:
            return tree['right']
def bagging_predict(trees, row):
    predictions = [predict(tree, row) for tree in trees]
    return max(set(predictions), key=predictions.count)


'''创建随机森林'''
def random_forest(train, test, ratio, n_feature, max_depth, min_size, n_trees):
    trees = []
    for i in range(n_trees):
        train = get_subsample(train, ratio)#从切割的训练集中选取子集
        tree = build_tree(train, n_features, max_depth, min_size)#构建 一个决策树
        # 随机森林
        trees.append(tree)
        
    predict_values = [bagging_predict(trees, row) for row in test]
    return predict_values


'''将数据集随机分成n_folds块，方便交叉验证，其中一块是测试集，其他四块是训练集'''
def spiltDataSet(dataSet, n_folds):
    fold_size = int(len(dataSet) / n_folds)
    dataSet_copy = list(dataSet)
    dataSet_spilt = []
    for i in range(n_folds):
        fold = []
        while len(fold) < fold_size:  # 这里不能用if，if只是在第一次判断时起作用，while执行循环，直到条件不成立
            index = randrange(len(dataSet_copy))
            fold.append(dataSet_copy.pop(index))  # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
        dataSet_spilt.append(fold)
    return dataSet_spilt


'''加载数据，一行行的存入列表'''
def loadCSV(filename):
    dataSet = []
    with open(filename, 'r') as file:
        csvReader = csv.reader(file)
        for line in csvReader:
            dataSet.append(line)
    return dataSet
dataSet = loadCSV('/Users/Downloads/sonar_all_data.csv')


'''除了标签列，其他列都转换为float类型'''
def column_to_float(dataSet):
    featLen = len(dataSet[0]) - 1
    for data in dataSet:
        for column in range(featLen):
            data[column] = float(data[column].strip())

            
'''计算准确率'''
def accuracy(predict_values, actual):
    correct = 0
    for i in range(len(actual)):
        if actual[i] == predict_values[i]:
            correct += 1
    return correct / float(len(actual))


n_folds = 5# 划分数据集数，用于后续交叉验证
n_features = 7# 选取特征数
n_trees = 20# 决策树数量
max_depth = 15
min_size = 1
ratio = 1.0
scores = []
folds = spiltDataSet(dataSet, n_folds)
# 该部分选取4个数据集作为训练集，1个数据集作为测试集，实现交叉验证
for fold in folds:
    train_set = folds[:]
    train_set.remove(fold)
    train_set = sum(train_set, [])
    test_set = []
    for row in fold:
        row_copy = list(row)
        row_copy[-1] = None
        test_set.append(row_copy)
    actual = [row[-1] for row in fold]
    predict_values = random_forest(train_set, test_set, ratio, n_features, max_depth, min_size, n_trees)
    accur = accuracy(predict_values, actual)
    scores.append(accur)
print ('Trees is %d' % n_trees)
print ('scores:%s' % scores)
print ('mean score:%s' % (sum(scores) / float(len(scores))))

 输出：

Trees is 20
scores:[0.7804878048780488, 0.6341463414634146, 0.4878048780487805, 0.7560975609756098, 0.8048780487804879]
mean score:0.6926829268292682

四、参考博客

随机森林原理详解 random forest 代码+参数讲解_统计分析分析的博客-CSDN博客_随机森林代码讲解事实上随机森林的基本单元决策树很早就被提出来了，只不过单个决策树效果不好。这个情况和神经网络差不多。到了2001年Breiman把分类树组合成随机森林（Breiman 2001a），即在变量（列）的使用和数据（行）的使用上进行随机化，生成很多分类树，再汇总分类树的结果。在运算没有增加的情况下，精度提高了不少。进入正题随机森林由两个部分组成随机 和 森林森林简单来说就是很多颗树，而这个树...https://blog.csdn.net/qq_36303521/article/details/88045247?spm=1001.2101.3001.6650.2&utm_medium=distribute.pc_relevant.none-task-blog-2~default~CTRLIST~Rate-2.pc_relevant_aa&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2~default~CTRLIST~Rate-2.pc_relevant_aa&utm_relevant_index=5python实现随机森林_随心1993的博客-CSDN博客_python 随机森林定义：随机森林指的是利用多棵决策树对样本进行训练并预测的一种分类器。可回归可分类。 所以随机森林是基于多颗决策树的一种集成学习算法，常见的决策树算法主要有以下几种： 1. ID3：使用信息增益g(D,A)进行特征选择 2. C4.5：信息增益率 =g(D,A)/H(A) 3. CART：基尼系数 一个特征的信息增益(或信息增益率，或基尼系数)越大，表明特征对样本的熵的减少能力更...https://blog.csdn.net/colourful_sky/article/details/82082854

机器学习：04. 随机森林之RandomForestClassifier - 简书https://www.jianshu.com/p/c1afbe4b9364

       机器学习-浅谈随机森林的几个tricks-20170917 - 知乎这篇文章不会涉及大量原理性的介绍，因为在其他地方，这种介绍已经非常多了，这里只介绍几个在随机森林中容易忽视的点。 1、随机森林每个分裂点都是随机选取m个特征 先假设我们有N个样本，M个特征，那么在这种情况…https://zhuanlan.zhihu.com/p/29408863

随机森林原理_随机森林-RF_weixin_39612057的博客-CSDN博客1、概念 随机森林(Random forest，RF)就是通过集成学习的思想将多棵树集成的一种算法，它的基本单元是决策树。 在机器学习中，随机森林是一个包含多个决策树的分类器， 并且其输出的类别是由个别树输出的类别的众数而定。 其实从直观角度来解释，每棵决策树都是一个分类器(假设现在针对的是分类问题)，那么对于一个输入样本，N棵树会有N个分类结果。而随机森林集成了所有的分类投票结果，将投票次数最多...https://blog.csdn.net/weixin_39612057/article/details/111390923