随机森林 random forest

分手后的思念是犯贱 2023-06-27 08:38 17阅读 0赞

# 随机森林 random forest #

*  [数据集地址][Link 1]

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

## 原理： ##

*  数据的随机化：使得随机森林中的决策树更普遍化一点，适合更多的场景。
    
    （有放回的准确率在：70% 以上， 无放回的准确率在：60% 以上）
    
    1.  采取有放回的抽样方式 构造子数据集，保证不同子集之间的数量级一样（不同子集／同一子集 之间的元素可以重复）
    2.  利用子数据集来构建子决策树，将这个数据放到每个子决策树中，每个子决策树输出一个结果。
    3.  然后统计子决策树的投票结果，得到最终的分类 就是 随机森林的输出结果。
    4.  如下图，假设随机森林中有3棵子决策树，2棵子树的分类结果是A类，1棵子树的分类结果是B类，那么随机森林的分类结果就是A类
    
    ![image][]
 *  待选择特征的随机化:
    
    1.  子树从所有的待选特征中随机选取一定的特征。
    2.  在选取的特征中选取最优的特征。

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

![image][image 1]

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

## 开发： ##

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

*  优缺点：
    
        优点：几乎不需要输入准备、可实现隐式特征选择、训练速度非常快、其他模型很难超越、很难建立一个糟糕的随机森林模型、大量优秀、免费以及开源的实现。
        缺点：劣势在于模型大小、是个很难去解释的黑盒子。
        适用数据范围：数值型和标称型
 *  导入样本集:
    
        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)\]][img-EogzlJD0-1578200707562_home_ach_.config_Typora_typora-user-images_image-20200105130239560.png]

[Link 1]: https://github.com/apachecn/AiLearning
[image]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9jYW1vLmdpdGh1YnVzZXJjb250ZW50LmNvbS84MWE5MTc3MjM5OGQ4ZmY5ZDU0ZDA2OTYyMDY0ZmZmMGE5NzMwODk2LzY4NzQ3NDcwM2EyZjJmNjQ2MTc0NjEyZTYxNzA2MTYzNjg2NTYzNmUyZTZmNzI2NzJmNjk2ZDY3MmY0MTY5NGM2NTYxNzI2ZTY5NmU2NzJmNmQ2YzJmMzcyZTUyNjE2ZTY0NmY2ZDQ2NmY3MjY1NzM3NDJmMjU0NTM2MjUzOTM1MjU0MjMwMjU0NTM2MjUzODQ0MjU0MTQ1MjU0NTM5MjUzODM3MjUzODQ0MjU0NTM2MjUzODQxMjU0MjQ0MjU0NTM2MjU0MTMwMjU0MjM3MmU2YTcwNjc?x-oss-process=image/format,png
[image 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9jYW1vLmdpdGh1YnVzZXJjb250ZW50LmNvbS8zMTY4YWE5NmNmNjBkOWUyMjRmNmFjODJjZTU1ZjAxYWNjMTNlZDNiLzY4NzQ3NDcwM2EyZjJmNjQ2MTc0NjEyZTYxNzA2MTYzNjg2NTYzNmUyZTZmNzI2NzJmNjk2ZDY3MmY0MTY5NGM2NTYxNzI2ZTY5NmU2NzJmNmQ2YzJmMzcyZTUyNjE2ZTY0NmY2ZDQ2NmY3MjY1NzM3NDJmMjU0NTM3MjUzODM5MjU0MjM5MjU0NTM1MjU0MjQ1MjUzODMxMjU0NTM5MjUzODM3MjUzODQ0MjU0NTM2MjUzODQxMjU0MjQ0MjU0NTM2MjU0MTMwMjU0MjM3MmU2YTcwNjc?x-oss-process=image/format,png
[img-EogzlJD0-1578200707562_home_ach_.config_Typora_typora-user-images_image-20200105130239560.png]: https://img-blog.csdnimg.cn/20200105130528193.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ3OTE1NQ==,size_16,color_FFFFFF,t_70