随机森林 random forest

最新推荐文章于 2023-02-25 14:57:34 发布
最新推荐文章于 2023-02-25 14:57:34 发布
阅读量399 收藏
点赞数
分类专栏： 机器学习 学生 python 文章标签： 算法 机器学习 随机森林
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42479155/article/details/103842096
版权
学生 同时被 3 个专栏收录
112 篇文章 0 订阅
订阅专栏
python
74 篇文章 2 订阅
订阅专栏
机器学习
53 篇文章 0 订阅
订阅专栏

随机森林 random forest

概述：随机森林是指多棵树对样本进行训练并且预测的一种分类器，决策树相当于大师，通过自己在数据集中学习到的只是用于新数据的分类，三个臭皮匠，顶个诸葛亮

原理：

  • 数据的随机化：使得随机森林中的决策树更普遍化一点，适合更多的场景。

    （有放回的准确率在：70% 以上， 无放回的准确率在：60% 以上）

    1. 采取有放回的抽样方式 构造子数据集，保证不同子集之间的数量级一样（不同子集／同一子集 之间的元素可以重复）
    2. 利用子数据集来构建子决策树，将这个数据放到每个子决策树中，每个子决策树输出一个结果。
    3. 然后统计子决策树的投票结果，得到最终的分类 就是 随机森林的输出结果。
    4. 如下图，假设随机森林中有3棵子决策树，2棵子树的分类结果是A类，1棵子树的分类结果是B类，那么随机森林的分类结果就是A类

    image

  • 待选择特征的随机化:

    1. 子树从所有的待选特征中随机选取一定的特征。
    2. 在选取的特征中选取最优的特征。

下图中，蓝色的方块代表所有可以被选择的特征，也就是目前的待选特征；黄色的方块是分裂特征。
左边是一棵决策树的特征选取过程，通过在待选特征中选取最优的分裂特征（别忘了前文提到的ID3算法，C4.5算法，CART算法等等），完成分裂。右边是一个随机森林中的子树的特征选取过程。

image

随机森林中的决策树彼此不同，提升系统的多样性，提升分类性能

开发：

收集数据：任何方法
准备数据：转换样本集
分析数据：任何方法
训练算法：通过数据随机化和特征随机化，进行多实例的分类评估
测试算法：计算错误率
使用算法：输入样本数据，然后运行 随机森林 算法判断输入数据分类属于哪个分类，最后对计算出的分类执行后续处理

  • 优缺点：

    优点：几乎不需要输入准备、可实现隐式特征选择、训练速度非常快、其他模型很难超越、很难建立一个糟糕的随机森林模型、大量优秀、免费以及开源的实现。
缺点：劣势在于模型大小、是个很难去解释的黑盒子。
适用数据范围：数值型和标称型

  • 导入样本集:

    def loadDataSet(filename:str):
    dataset = []
    with open(filename,'r') as f:
        for line in f.readlines():
            if not line:
                continue
            lineArr = []
            # le = len(line.split(','))
            for featrue in line.split(','):
                #strip()返回左右去除空格
                str_f = featrue.strip()
                # if str_f.isdigit():# 判断是否可以转化为数字
                #     # 将这一行数据的某一列可以转化为数字的转化为float
                #     lineArr.append(float(str_f))
                # else:
                #     #添加label
                #     lineArr.append(str_f)
                try:
                    lineArr.append(float(str_f))
                except:
                    lineArr.append(str_f)
            dataset.append(lineArr)
    return dataset

  • 交叉验证,将样本集合划分成几个集合

    #交叉验证,给数据集合划分不是给数据划分
def cross_validation_split(dataset, n_folds):
    """cross_validation_split(将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的)
    Args:
        dataset     原始数据集
        n_folds     数据集dataset分成n_flods份
    Returns:
        dataset_split    list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的
    """
    dataset_split = list()
    dataset_copy = list(dataset)       # 复制一份 dataset,防止 dataset 的内容改变
    fold_size = len(dataset) / n_folds
    for i in range(n_folds):
        fold = list()                  # 每次循环 fold 清零，防止重复导入 dataset_split
        while len(fold) < fold_size:   # 这里不能用 if，if 只是在第一次判断时起作用，while 执行循环，直到条件不成立
            # 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此则自助采样法。从而保证每棵决策树训练集的差异性
            index = randrange(len(dataset_copy))
            # 将对应索引 index 的内容从 dataset_copy 中导出，并将该内容从 dataset_copy 中删除。
            # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
            # fold.append(dataset_copy.pop(index))  # 无放回的方式
            fold.append(dataset_copy[index])  # 有放回的方式
        dataset_split.append(fold)
    # 由dataset分割出的n_folds个数据构成的列表，为了用于交叉验证
    return dataset_split

  • 通过指定值进行分割数据,可以理解为树的两个孩子节点

    # Split a dataset based on an attribute and an attribute value # 根据特征和特征值分割数据集
def test_split(index, value, dataset):
    left, right = list(), list()
    for row in dataset:
        if float(row[index]) < float(value):
            left.append(row)
        else:
            right.append(row)
    return left, right

  • 基尼不纯系数的计算

    # Calculate the Gini index for a split dataset
def gini_index(groups, class_values):    # 个人理解：计算代价，分类越准确，则 gini 越小
    gini = 0.0
    for class_value in class_values:     # class_values = [0, 1]就是label的值
        for group in groups:             # groups = (left, right)
            size = len(group)
            if size == 0:
                continue
            proportion = [row[-1] for row in group].count(class_value) / float(size)
            gini += (proportion * (1.0 - proportion))    # 个人理解：计算代价，分类越准确，则 gini 越小
    return gini

  • 分割数据的最优特征

    # 找出分割数据集的最优特征，得到最优的特征 index，特征值 row[index]，以及分割完的数据 groups（left, right）
def get_split(dataset, n_features):
    class_values = list(set(row[-1] for row in dataset))  # class_values =[0, 1]
    b_index, b_value, b_score, b_groups = 999, 999, 999, None
    features = list()
    while len(features) < n_features:
        index = randrange(len(dataset[0])-1)  # 往 features 添加 n_features 个特征（ n_feature 等于特征数的根号），特征索引从 dataset 中随机取
        if index not in features:
            features.append(index)
    for index in features:                    # 在 n_features 个特征中选出最优的特征索引，并没有遍历所有特征，从而保证了每课决策树的差异性
        for row in dataset:
            groups = test_split(index, row[index], dataset)  # groups=(left, right), row[index] 遍历每一行 index 索引下的特征值作为分类值 value, 找出最优的分类特征和特征值
            gini = gini_index(groups, class_values)
            # 左右两边的数量越一样，说明数据区分度不高，gini系数越大
            if gini < b_score:
                b_index, b_value, b_score, b_groups = index, row[index], gini, groups  # 最后得到最优的分类特征 b_index,分类特征值 b_value,分类结果 b_groups。b_value 为分错的代价成本
    # print(b_score)
    return {'index': b_index, 'value': b_value, 'groups': b_groups}

  • 统计结果中最好的特征

    # Create a terminal node value # 输出group中出现次数较多的标签
def to_terminal(group):
    outcomes = [row[-1] for row in group]           # max() 函数中，当 key 参数不为空时，就以 key 的函数对象为判断的标准
    return max(set(outcomes), key=outcomes.count)   # 输出 group 中出现次数较多的标签

  • 创建一个决策树

    # Create child splits for a node or make terminal  # 创建子分割器，递归分类，直到分类结束
def split(node, max_depth, min_size, n_features, depth):  # max_depth = 10, min_size = 1, n_features = int(sqrt((dataset[0])-1))
    left, right = node['groups']
    del(node['groups'])
# check for a no split
    if not left or not right:
        node['left'] = node['right'] = to_terminal(left + right)
        return
# check for max depth
    if depth >= max_depth:   # max_depth=10 表示递归十次，若分类还未结束，则选取数据中分类标签较多的作为结果，使分类提前结束，防止过拟合
        node['left'], node['right'] = to_terminal(left), to_terminal(right)
        return
# process left child
    if len(left) <= min_size:
        node['left'] = to_terminal(left)
    else:
        node['left'] = get_split(left, n_features)  # node['left']是一个字典，形式为{'index':b_index, 'value':b_value, 'groups':b_groups}，所以node是一个多层字典
        split(node['left'], max_depth, min_size, n_features, depth+1)  # 递归，depth+1计算递归层数
# process right child
    if len(right) <= min_size:
        node['right'] = to_terminal(right)
    else:
        node['right'] = get_split(right, n_features)
        split(node['right'], max_depth, min_size, n_features, depth+1)


# Build a decision tree
def build_tree(train, max_depth, min_size, n_features):
    """build_tree(创建一个决策树)
    Args:
        train           训练数据集
        max_depth       决策树深度不能太深，不然容易导致过拟合
        min_size        叶子节点的大小
        n_features      选取的特征的个数
    Returns:
        root            返回决策树
    """

    # 返回最优列和相关的信息
    root = get_split(train, n_features)

    # 对左右2边的数据 进行递归的调用，由于最优特征使用过，所以在后面进行使用的时候，就没有意义了
    # 例如： 性别-男女，对男使用这一特征就没任何意义了
    split(root, max_depth, min_size, n_features, 1)
    return root

  • 通过决策树来进行预测

    # Make a prediction with a decision tree
def predict(node, row):   # 预测模型分类结果
    if float(row[node['index']]) < float(node['value']):
        if isinstance(node['left'], dict):       # isinstance 是 Python 中的一个内建函数。是用来判断一个对象是否是一个已知的类型。
            return predict(node['left'], row)
        else:
            return node['left']
    else:
        if isinstance(node['right'], dict):
            return predict(node['right'], row)
        else:
            return node['right']

  • 随机森林预测

    # Make a prediction with a list of bagged trees
def bagging_predict(trees, row):
    """bagging_predict(bagging预测)
    Args:
        trees           决策树的集合
        row             测试数据集的每一行数据
    Returns:
        返回随机森林中，决策树结果出现次数做大的
    """

    # 使用多个决策树trees对测试集test的第row行进行预测，再使用简单投票法判断出该行所属分类
    predictions = [predict(tree, row) for tree in trees]
    return max(set(predictions), key=predictions.count)

  • 数据随机样本

    # 创建数据集合中的随机子样本
# Create a random subsample from the dataset with replacement
def subsample(dataset, ratio):   # 创建数据集的随机子样本
    """random_forest(评估算法性能，返回模型得分)
    Args:
        dataset         训练数据集
        ratio           训练数据集的样本比例
    Returns:
        sample          随机抽样的训练样本
    """

    sample = list()
    # 训练样本的按比例抽样。
    # round() 方法返回浮点数x的四舍五入值。
    n_sample = round(len(dataset) * ratio)
    while len(sample) < n_sample:
        # 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此则自助采样法。从而保证每棵决策树训练集的差异性
        index = randrange(len(dataset))
        sample.append(dataset[index])
    return sample

  • 随机森林预测算法,对所有测试集合

    # Random Forest Algorithm
def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features):
    """random_forest(评估算法性能，返回模型得分)
    Args:
        train           训练数据集
        test            测试数据集
        max_depth       决策树深度不能太深，不然容易导致过拟合
        min_size        叶子节点的大小
        sample_size     训练数据集的样本比例
        n_trees         决策树的个数
        n_features      选取的特征的个数
    Returns:
        predictions     每一行的预测结果，bagging 预测最后的分类结果
    """

    trees = list()
    # n_trees 表示决策树的数量
    for i in range(n_trees):
        # 随机抽样的训练样本， 随机采样保证了每棵决策树训练集的差异性
        sample = subsample(train, sample_size)
        # 创建一个决策树
        tree = build_tree(sample, max_depth, min_size, n_features)
        trees.append(tree)

    # 每一行的预测结果，bagging 预测最后的分类结果
    predictions = [bagging_predict(trees, row) for row in test]
    return predictions

  • 通过预测值和真实值求出准确率

    # Calculate accuracy percentage
def accuracy_metric(actual, predicted):  # 导入实际值和预测值，计算精确度
    correct = 0
    for i in range(len(actual)):
        if actual[i] == predicted[i]:
            correct += 1
    return correct / float(len(actual)) * 100.0

  • rerank函数:对一系列交叉验证的结果

    # 评估算法性能，返回模型得分
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
    """evaluate_algorithm(评估算法性能，返回模型得分)
    Args:
        dataset     原始数据集
        algorithm   使用的算法
        n_folds     数据的份数
        *args       其他的参数
    Returns:
        scores      模型得分
    """

    # 将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次 list 的元素是无重复的
    folds = cross_validation_split(dataset, n_folds)
    scores = list()
    # 每次循环从 folds 从取出一个 fold 作为测试集，其余作为训练集，遍历整个 folds ，实现交叉验证
    for fold in folds:
        train_set = list(folds)
        train_set.remove(fold)
        # 将多个 fold 列表组合成一个 train_set 列表, 类似 union all
        """
        In [20]: l1=[[1, 2, 'a'], [11, 22, 'b']]
        In [21]: l2=[[3, 4, 'c'], [33, 44, 'd']]
        In [22]: l=[]
        In [23]: l.append(l1)
        In [24]: l.append(l2)
        In [25]: l
        Out[25]: [[[1, 2, 'a'], [11, 22, 'b']], [[3, 4, 'c'], [33, 44, 'd']]]
        In [26]: sum(l, [])
        Out[26]: [[1, 2, 'a'], [11, 22, 'b'], [3, 4, 'c'], [33, 44, 'd']]
        """
        train_set = sum(train_set, [])
        test_set = list()
        # fold 表示从原始数据集 dataset 提取出来的测试集
        for row in fold:
            row_copy = list(row)
            row_copy[-1] = None
            test_set.append(row_copy)
        predicted = algorithm(train_set, test_set, *args)
        actual = [row[-1] for row in fold]

        # 计算随机森林的预测结果的正确率
        accuracy = accuracy_metric(actual, predicted)
        scores.append(accuracy)
    return scores

  • 总体代码

    # 随机森林 randomforest
# 收集数据：提供的文本文件
# 准备数据：转换样本集
# 分析数据：手工检查数据
# 训练算法：在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果
# 测试算法：在采用自定义 n_folds 份随机重抽样 进行测试评估，得出综合的预测评分
# 使用算法：若你感兴趣可以构建完整的应用程序，从案例进行封装，也可以参考我们的代码
from random import seed,randrange,random
def loadDataSet(filename:str):
    dataset = []
    with open(filename,'r') as f:
        for line in f.readlines():
            if not line:
                continue
            lineArr = []
            # le = len(line.split(','))
            for featrue in line.split(','):
                #strip()返回左右去除空格
                str_f = featrue.strip()
                # if str_f.isdigit():# 判断是否可以转化为数字
                #     # 将这一行数据的某一列可以转化为数字的转化为float
                #     lineArr.append(float(str_f))
                # else:
                #     #添加label
                #     lineArr.append(str_f)
                try:
                    lineArr.append(float(str_f))
                except:
                    lineArr.append(str_f)
            dataset.append(lineArr)
    return dataset
#交叉验证,给数据集合划分不是给数据划分
def cross_validation_split(dataset, n_folds):
    """cross_validation_split(将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的)
    Args:
        dataset     原始数据集
        n_folds     数据集dataset分成n_flods份
    Returns:
        dataset_split    list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的
    """
    dataset_split = list()
    dataset_copy = list(dataset)       # 复制一份 dataset,防止 dataset 的内容改变
    fold_size = len(dataset) / n_folds
    for i in range(n_folds):
        fold = list()                  # 每次循环 fold 清零，防止重复导入 dataset_split
        while len(fold) < fold_size:   # 这里不能用 if，if 只是在第一次判断时起作用，while 执行循环，直到条件不成立
            # 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此则自助采样法。从而保证每棵决策树训练集的差异性
            index = randrange(len(dataset_copy))
            # 将对应索引 index 的内容从 dataset_copy 中导出，并将该内容从 dataset_copy 中删除。
            # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
            # fold.append(dataset_copy.pop(index))  # 无放回的方式
            fold.append(dataset_copy[index])  # 有放回的方式
        dataset_split.append(fold)
    # 由dataset分割出的n_folds个数据构成的列表，为了用于交叉验证
    return dataset_split


# Split a dataset based on an attribute and an attribute value # 根据特征和特征值分割数据集
def test_split(index, value, dataset):
    left, right = list(), list()
    for row in dataset:
        if float(row[index]) < float(value):
            left.append(row)
        else:
            right.append(row)
    return left, right


# Calculate the Gini index for a split dataset
def gini_index(groups, class_values):    # 个人理解：计算代价，分类越准确，则 gini 越小
    gini = 0.0
    for class_value in class_values:     # class_values = [0, 1]就是label的值
        for group in groups:             # groups = (left, right)
            size = len(group)
            if size == 0:
                continue
            proportion = [row[-1] for row in group].count(class_value) / float(size)
            gini += (proportion * (1.0 - proportion))    # 个人理解：计算代价，分类越准确，则 gini 越小
    return gini


# 找出分割数据集的最优特征，得到最优的特征 index，特征值 row[index]，以及分割完的数据 groups（left, right）
def get_split(dataset, n_features):
    class_values = list(set(row[-1] for row in dataset))  # class_values =[0, 1]
    b_index, b_value, b_score, b_groups = 999, 999, 999, None
    features = list()
    while len(features) < n_features:
        index = randrange(len(dataset[0])-1)  # 往 features 添加 n_features 个特征（ n_feature 等于特征数的根号），特征索引从 dataset 中随机取
        if index not in features:
            features.append(index)
    for index in features:                    # 在 n_features 个特征中选出最优的特征索引，并没有遍历所有特征，从而保证了每课决策树的差异性
        for row in dataset:
            groups = test_split(index, row[index], dataset)  # groups=(left, right), row[index] 遍历每一行 index 索引下的特征值作为分类值 value, 找出最优的分类特征和特征值
            gini = gini_index(groups, class_values)
            # 左右两边的数量越一样，说明数据区分度不高，gini系数越大
            if gini < b_score:
                b_index, b_value, b_score, b_groups = index, row[index], gini, groups  # 最后得到最优的分类特征 b_index,分类特征值 b_value,分类结果 b_groups。b_value 为分错的代价成本
    # print(b_score)
    return {'index': b_index, 'value': b_value, 'groups': b_groups}


# Create a terminal node value # 输出group中出现次数较多的标签
def to_terminal(group):
    outcomes = [row[-1] for row in group]           # max() 函数中，当 key 参数不为空时，就以 key 的函数对象为判断的标准
    return max(set(outcomes), key=outcomes.count)   # 输出 group 中出现次数较多的标签


# Create child splits for a node or make terminal  # 创建子分割器，递归分类，直到分类结束
def split(node, max_depth, min_size, n_features, depth):  # max_depth = 10, min_size = 1, n_features = int(sqrt((dataset[0])-1))
    left, right = node['groups']
    del(node['groups'])
# check for a no split
    if not left or not right:
        node['left'] = node['right'] = to_terminal(left + right)
        return
# check for max depth
    if depth >= max_depth:   # max_depth=10 表示递归十次，若分类还未结束，则选取数据中分类标签较多的作为结果，使分类提前结束，防止过拟合
        node['left'], node['right'] = to_terminal(left), to_terminal(right)
        return
# process left child
    if len(left) <= min_size:
        node['left'] = to_terminal(left)
    else:
        node['left'] = get_split(left, n_features)  # node['left']是一个字典，形式为{'index':b_index, 'value':b_value, 'groups':b_groups}，所以node是一个多层字典
        split(node['left'], max_depth, min_size, n_features, depth+1)  # 递归，depth+1计算递归层数
# process right child
    if len(right) <= min_size:
        node['right'] = to_terminal(right)
    else:
        node['right'] = get_split(right, n_features)
        split(node['right'], max_depth, min_size, n_features, depth+1)


# Build a decision tree
def build_tree(train, max_depth, min_size, n_features):
    """build_tree(创建一个决策树)
    Args:
        train           训练数据集
        max_depth       决策树深度不能太深，不然容易导致过拟合
        min_size        叶子节点的大小
        n_features      选取的特征的个数
    Returns:
        root            返回决策树
    """

    # 返回最优列和相关的信息
    root = get_split(train, n_features)

    # 对左右2边的数据 进行递归的调用，由于最优特征使用过，所以在后面进行使用的时候，就没有意义了
    # 例如： 性别-男女，对男使用这一特征就没任何意义了
    split(root, max_depth, min_size, n_features, 1)
    return root


# Make a prediction with a decision tree
def predict(node, row):   # 预测模型分类结果
    if float(row[node['index']]) < float(node['value']):
        if isinstance(node['left'], dict):       # isinstance 是 Python 中的一个内建函数。是用来判断一个对象是否是一个已知的类型。
            return predict(node['left'], row)
        else:
            return node['left']
    else:
        if isinstance(node['right'], dict):
            return predict(node['right'], row)
        else:
            return node['right']


# Make a prediction with a list of bagged trees
def bagging_predict(trees, row):
    """bagging_predict(bagging预测)
    Args:
        trees           决策树的集合
        row             测试数据集的每一行数据
    Returns:
        返回随机森林中，决策树结果出现次数做大的
    """

    # 使用多个决策树trees对测试集test的第row行进行预测，再使用简单投票法判断出该行所属分类
    predictions = [predict(tree, row) for tree in trees]
    return max(set(predictions), key=predictions.count)

# 创建数据集合中的随机子样本
# Create a random subsample from the dataset with replacement
def subsample(dataset, ratio):   # 创建数据集的随机子样本
    """random_forest(评估算法性能，返回模型得分)
    Args:
        dataset         训练数据集
        ratio           训练数据集的样本比例
    Returns:
        sample          随机抽样的训练样本
    """

    sample = list()
    # 训练样本的按比例抽样。
    # round() 方法返回浮点数x的四舍五入值。
    n_sample = round(len(dataset) * ratio)
    while len(sample) < n_sample:
        # 有放回的随机采样，有一些样本被重复采样，从而在训练集中多次出现，有的则从未在训练集中出现，此则自助采样法。从而保证每棵决策树训练集的差异性
        index = randrange(len(dataset))
        sample.append(dataset[index])
    return sample


# Random Forest Algorithm
def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features):
    """random_forest(评估算法性能，返回模型得分)
    Args:
        train           训练数据集
        test            测试数据集
        max_depth       决策树深度不能太深，不然容易导致过拟合
        min_size        叶子节点的大小
        sample_size     训练数据集的样本比例
        n_trees         决策树的个数
        n_features      选取的特征的个数
    Returns:
        predictions     每一行的预测结果，bagging 预测最后的分类结果
    """

    trees = list()
    # n_trees 表示决策树的数量
    for i in range(n_trees):
        # 随机抽样的训练样本， 随机采样保证了每棵决策树训练集的差异性
        sample = subsample(train, sample_size)
        # 创建一个决策树
        tree = build_tree(sample, max_depth, min_size, n_features)
        trees.append(tree)

    # 每一行的预测结果，bagging 预测最后的分类结果
    predictions = [bagging_predict(trees, row) for row in test]
    return predictions


# Calculate accuracy percentage
def accuracy_metric(actual, predicted):  # 导入实际值和预测值，计算精确度
    correct = 0
    for i in range(len(actual)):
        if actual[i] == predicted[i]:
            correct += 1
    return correct / float(len(actual)) * 100.0


# 评估算法性能，返回模型得分
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
    """evaluate_algorithm(评估算法性能，返回模型得分)
    Args:
        dataset     原始数据集
        algorithm   使用的算法
        n_folds     数据的份数
        *args       其他的参数
    Returns:
        scores      模型得分
    """

    # 将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次 list 的元素是无重复的
    folds = cross_validation_split(dataset, n_folds)
    scores = list()
    # 每次循环从 folds 从取出一个 fold 作为测试集，其余作为训练集，遍历整个 folds ，实现交叉验证
    for fold in folds:
        train_set = list(folds)
        train_set.remove(fold)
        # 将多个 fold 列表组合成一个 train_set 列表, 类似 union all
        """
        In [20]: l1=[[1, 2, 'a'], [11, 22, 'b']]
        In [21]: l2=[[3, 4, 'c'], [33, 44, 'd']]
        In [22]: l=[]
        In [23]: l.append(l1)
        In [24]: l.append(l2)
        In [25]: l
        Out[25]: [[[1, 2, 'a'], [11, 22, 'b']], [[3, 4, 'c'], [33, 44, 'd']]]
        In [26]: sum(l, [])
        Out[26]: [[1, 2, 'a'], [11, 22, 'b'], [3, 4, 'c'], [33, 44, 'd']]
        """
        train_set = sum(train_set, [])
        test_set = list()
        # fold 表示从原始数据集 dataset 提取出来的测试集
        for row in fold:
            row_copy = list(row)
            row_copy[-1] = None
            test_set.append(row_copy)
        predicted = algorithm(train_set, test_set, *args)
        actual = [row[-1] for row in fold]

        # 计算随机森林的预测结果的正确率
        accuracy = accuracy_metric(actual, predicted)
        scores.append(accuracy)
    return scores


if __name__ == '__main__':

    # 加载数据
    dataset = loadDataSet('/home/ach/桌面/machine-learning/ai/randomforest/7.RandomForest/sonar-all-data.txt')
    # print(dataset)

    n_folds = 10        # 分成5份数据，进行交叉验证
    max_depth = 20     # 调参（自己修改） #决策树深度不能太深，不然容易导致过拟合
    min_size = 1       # 决策树的叶子节点最少的元素数量
    sample_size = 1.0  # 做决策树时候的样本的比例
    # n_features = int((len(dataset[0])-1))
    n_features = 15     # 调参（自己修改） #准确性与多样性之间的权衡
    for n_trees in [1, 10, 20]:  # 理论上树是越多越好
        scores = evaluate_algorithm(dataset, random_forest, n_folds, max_depth, min_size, sample_size, n_trees, n_features)
        # 每一次执行本文件时都能产生同一个随机数
        seed(1)
        print('random=', random())
        print('Trees: %d' % n_trees)
        print('Scores: %s' % scores)
        print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))

SK 实现随机森林

# 导入需要的包
import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import  RandomForestClassifier
from sklearn.model_selection import cross_val_score
def loadDataSet(filename:str):
    dataset = []
    datalabel = []
    with open(filename,'r') as f:
        for line in f.readlines():
            if not line:
                continue
            lineArr = []
            # le = len(line.split(','))
            for featrue in line.split(','):
                #strip()返回左右去除空格
                str_f = featrue.strip()
                # if str_f.isdigit():# 判断是否可以转化为数字
                #     # 将这一行数据的某一列可以转化为数字的转化为float
                #     lineArr.append(float(str_f))
                # else:
                #     #添加label
                #     # lineArr.append(str_f)
                #     datalabel.append(str_f)
                try:
                    lineArr.append(float(str_f))
                except:
                    datalabel.append(str_f)
            dataset.append(lineArr)
    return dataset,datalabel
if __name__ == '__main__':
    # 加载数据
    dataset,datalabel = loadDataSet('/home/ach/桌面/machine-learning/ai/randomforest/7.RandomForest/sonar-all-data.txt')
    rfc = RandomForestClassifier(random_state=1,n_estimators=11,oob_score=True,max_features=15)
    # print(np.mat(dataset).shape)
    # print(np.mat(datalabel).reshape())
    # print(cross_val_score(rfc,np.mat(dataset),np.mat(datalabel).T,cv=10).mean())
    score = cross_val_score(rfc,np.mat(dataset),np.mat(datalabel).T,cv = 5)
    plt.plot(range(1,6),score,label = "Random Forest")
    plt.legend()
    plt.show()

  • 运行结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EogzlJD0-1578200707562)(/home/ach/.config/Typora/typora-user-images/image-20200105130239560.png)]

胖虎艾春辉
关注
专栏目录
机器学习-随机森林(Random Forest)
Santorinisu Blogs
02-20 370
Section I: Brief Introduction on Random Forest Random forests have gained huge popularity om applications of machine learning during the last decade due to their good classification performance,scalab...
java实现随机森林RandomForest的示例代码
08-29
public class RandomForest { List<Sample> mSamples; List<Cart> mCarts; double mFeatureRate; int mMaxDepth; int mMinLeaf; Random mRandom; public void loadData(String path, String regex) throws ...
tree.fm - listen to a random forest-crx插件
04-03
语言:English (United States) 调入来自世界各地的森林。 逃生，放松和保存。 世界各地的人们都在录制森林的声音，… 调入来自世界各地的森林。 逃生，放松和保存。 世界各地的人们都记录了他们森林的声音，因此您可以在禁闭或无法旅行的情况下逃脱进入大自然。 使用此扩展程序可以放松，冥想或做一些数字化的shinrin-yoku。
随机森林
qq_42832437的博客
09-03 234
在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定。利用相同的训练数搭建多个独立的分类模型，然后通过投票的方式，以少数服从多数的原则作出最终的分类决策。 例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个数的结果是False, 那么最终结果会是True. 在前面的决策当中我们提到，一个标准的决策树会根据每维特征对预测结果的影响程度进行排序，进而决定不同的特征从上至下构建分裂节点的顺序，如此以来，所有在随机森林中的决策树都会受这一策略影响而构
随机森林Random Forest（RF）回归预测-MATLAB源代码实现-附带使用教程及注意事项
09-23
随机森林Random Forest（RF）回归预测-MATLAB源代码实现 附带使用教程及注意事项，代码有使用教程及注意事项，可保证运行，运行失败或报错免费解决。 随机森林（Random Forest，RF）是一种机器学习方法，常用于回归...
随机森林Random Forest(RF)分类模型-二分类及多分类模型-分类预测-MATLAB源代码-附带使用教程及注意事项
最新发布
10-02
随机森林Random Forest(RF)分类模型-二分类及多分类模型-分类预测-MATLAB源代码-附带使用教程及注意事项 本代码详细图文介绍，请点击博客主页查找对应文章查看。 代码有使用教程及注意事项，可保证运行，运行失败或...
集成学习之随机森林（RandomForest）
tunghao的博客
02-02 839
标题
随机森林RandomForest——看我以弱搏强
weiji123_的博客
03-29 1358
随机森林RandomForest——看我以弱搏强 原来机器学习就是这个意思~
随机森林的直观理解
syh666233的博客
01-09 797
随机森林 森林：许多决策树的集合 随机： 假如我们的数据集有1000行，30列 随机森林的随机性体现在两个方面 1.行：森林里面的每一棵决策树都会训练一批随机的训练样本。比如说，每一棵决策树都会从1000行数据里面，随机选择100行进行训练。这样他们训练出来的结果也就有随机性。 2.列：也不是所有的列都会传入决策树，而是从所有的列中，随机的挑选。和行情形类似，每一棵决策树从30列数据里面，挑3例来进行训练。 最后，每一棵决策树都会给出一个预测结果，我们这里假设有5棵决策树，他们的目标是预测泰坦
随机森林(RandomForest)算法
张欣的博客
12-18 4767
随机森林是bagging方法的一种具体实现。它会训练多棵决策树，然后将这些结果融合在一起就是最终的结果。随机森林可以用于分裂，也可以用于回归。主要在于决策树类型的选取，根据具体的任务选择具体类别的决策树。 对于分类问题，一个测试样本会送到每一颗决策树中进行预测，然后投票，得票最多的类为最终的分类结果； 对与回归问题，随机森林的预测结果是所有决策树输出的均值。 随机森林的随机性主要体现在两个地...
通俗解读随机森林Random Forest
夏之微风的博客
08-12 2348
通俗解读随机森林Random Forest1. 什么是集成学习2. 什么是Bagging3 随机森林 1. 什么是集成学习 集成学习(ensemble learning)通过构建并结合多个学习器来完成学习任务，有时也被成为多分类器系统(multi-classifier system)、基于委员会的学习(committee-based learning)。 简单来说，就是对于一个分类问题，我同时训练三个分类器。假如我用简单的“投票法”来产生结果的话，那么当分类器1分类结果为1，分类器2分类结果也为1，而分类器
机器学习-集成学习：随机森林（Random Forest）
数据客
12-27 2529
内容参考：https://github.com/NLP-LOVE/ML-NLP/tree/master/Machine%20Learning/3.1%20Random%20Forest​​​​​ 略做修改 0.集成学习 如果你随机向几千专家询问一个复杂的问题，然后汇总他们的回答，在许多情况下，你会发现，这个汇总的答案比最好的那个专家回答得要好。同样，如果你聚合一组预测器（比如分类器或者回归器）的预测，得到的预测结果也比最好的单个预测器要好，这种聚合一组预测器来进行预测的方法，称为集成学习。 例如..
随机森林算法
rocking_struggling的博客
03-27 1686
一句话：随机森林=决策树+bagging+随机属性选择 原文链接：https://blog.csdn.net/qq_34106574/article/details/82016442 1 什么是随机森林？ 　　作为新兴起的、高度灵活的一种机器学习算法，随机森林（Random Forest，简称RF）拥有广泛的应用前景，从市场营销到医疗保健保险，既可以用来做市场营销模拟的建模，统计客户来源，保留和流...
R语言机器学习篇——随机森林
m0_73275932的博客
02-12 1万+
一种集成学习的方法。
【实践】随机森林算法参数解释及调优（含Python代码）
热门推荐
wzk4869的博客
08-09 2万+
【实践】随机森林算法参数解释及调优（含Python代码）
随机森林算法（Random Forest）R语言实现
amyniez的博客，欢迎交流讨论
02-25 1万+
随机森林是以决策树为基学习器的集成学习算法。随机森林非常简单，易于实现，计算开销也很小，更令人惊奇的是它在分类和回归上表现出了十分惊人的性能，因此，随机森林也被誉为“代表集成学习技术水平的方法”。
随机森林Random Forest深度解析与Python实现
"这篇文章除了介绍随机森林的基本概念，还强调了其在Python中的实现，特别是如何利用随机森林来进行特征选择和预测。文章涵盖了随机森林作为集成学习方法的分类，与Boosting和Bagging的关系，以及随机森林在决策树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值