（八）集成学习Bagging之随机森林与python代码实现

 知识点：

• 集成模型（Ensemble）的思想：为了解决单个模型所固有的缺陷，从而整合更多的模型，取长补短，避免局限性。
• 自助法（Bootstrap）：即从样本自身中再生成很多可用的同等规模的新样本，从自己中产生和自己类似的，所以叫做自助，即不借助其他样本数据。（有放回的抽样问题）
• bagging的名称来源于 （ Bootstrap AGGregatING ），意思是自助抽样集成，这种方法将训练集分成m个新的训练集，然后在每个新训练集上构建一个模型，各自不相干，最后预测时我们将这个m个模型的结果进行整合，得到最终结果
• 对于分类：通常使用简单投票法，得到最多票数的类别或者类别之一为最终的模型输出
• 对于回归：通常使用简单平均法，对T个弱学习器得到的回归结果进行算术平均得到最终的模型输出。（分类投票，回归均值）
• 随机森林是bagging的一个特化进阶版
• 特化是指：随机森林的弱学习器都是决策树
• 进阶是指：在bagging样本随机采样的基础上，又加上了特征的随机选择
• Bagging是一种有放回的重复抽样方法，各学习器之间没有依赖关系，可以并行生成
• Boosting各个学习器之间是串联的关系，每一轮的训练集不变，改变的是样本的权重
• Bagging+决策树=随机森林
• AdaBoost+决策树=提升树
• Gradient+Boosting+决策树=GBDT
• 随机森林的构造过程：行采样和列采样
• 行采样：假设有N个样本，有放回的随机选择N个样本（自助法）
• 列采样：每个样本有M个属性，随机选择m个属性，m<，然后从这m个属性中采用某种策略（信息增益）来选择1个属性作为该节点的分裂属性
• bagging每轮随机采样中，训练集大约有36.8%的数据没被采样，被称为“袋外数据”
• m是决策树的重要参数，m越小，方差越小，拟合程度越差，偏倚越大，一般选择交叉验证法寻找最佳m
• 整个决策树形成过程中没有进行剪枝，因为特征和样本的随机性选择导致不容易陷入过拟合
• 随机森林具有很好的抗噪声能力
• 他能处理很高维（feature很多）的数据，并且不用做特征选择
• 可以度量样本之间的相似性
• 训练过程中能检测特征重要性，是常见的特征筛选方法。当某一特征在所有树种离树根的平均距离越近，这一特征就越重要
• 需要调整的参数有：决策树个数，递归次数（决策树深度），特征选择的个数
• 决策树个数：越多越稳定
• 决策树深度：深度越小，计算量越小，速度越快，常用的取值为10-100
• 特征选择的个数：减少特征选择个数，不仅会提升算法个数，也可能降低测试误差，通常使用的值为

 图片来源：随机森林算法原理解析_华山拎壶冲的博客-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:此参数让结果容易复现。

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

数据集来源：

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

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

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