比如说五虎将，武力平均值就是呼延灼，其下是秦明，董平；其上是林冲，关胜。
  
假设武力值是 秦明 95，董平 96，呼延灼 97，关胜 98，林冲 99

针对这个样本，其方差就是秦明，董平，林冲，关胜这四人的武力值和呼延灼差距多少。
如果都和呼延灼需要大战八百回合才能分出胜负，那么说明方差小。如果大战三百合就能分出胜负，那说明方差大。

假设马军八骠骑的武力值如下：徐宁 92、索超 90、张清 86、朱仝 90、史进 88、穆弘 85，花荣 90、杨志 95。

如果有一个模型，用八骠骑来拟合五虎将。这个模型是：任意选取一个八骠骑来拟合。（ 实际工作中偏置应该是取八骠骑平均值，这里偏置是任选一个，是为了说明方便 ）

如果用杨志来拟合五虎将，则最能逼近五虎将，这时候偏置小。如果选出的是穆弘，则偏置最大。
对于没遮拦穆弘，大家估计都是只知其名不知其事，可见其武力值最低。

当然穆弘的故事可能是在古本《水浒》有，但是后来世代相传中从今本《水浒》中被删除，所以被低视。

水浒故事有系统的文字记录首见《宣和遗事》。该书讲述先后落草太行山梁山、后来《水浒》说成是入伙鲁西梁山泊的人物共三十八名。其中的没遮拦穆横无疑就是《水浒》中的穆弘。
《宣和遗事》中的穆横是押运花石纲的十二指使之一。这十二人因公务而结义，后又因营救杨志而同往太行山落草，遂成为开创山寨的基本成员。《水浒传》处理这十二指使，有八人是和穆横完全一样待遇的(林冲、花荣、张清、徐宁、李应、关胜、孙立、杨志)。
这八人全都在《水浒》里成了独当一面的人物。如果一切顺应传统去发展，穆弘总不致变成一个有名无实的空白人物。

梁山要打某座州府，究竟用什么办法呢？

听吴学究的嘛？
吴学究在生辰纲的表现实在不行，漏洞太多。打大名府等也基本就是一招：事先混进城里，然后里应外合。
所以还是应该集思广益，采用集成学习。

可以采用两个办法
  
办法1
神机军师朱武，混江龙李俊，智多星吴用，入云龙公孙胜，混世魔王樊瑞五个人都分别出一个主意，然后投票选出一个综合方案。
  
方法2
吴用先出一个主意，然后朱武针对这个主意做些调整补漏，给出了一个新主意。李俊再针对朱武的主意进行修补，给出了第三个主意...... 最后给出一个最终主意。
  
办法1 就是bagging方式的近似模拟
办法2 就是boosting方式的近似模拟

（1）采用重复抽样的方法每次从n个原始样本中抽取m个样本（m自己设定）
（2）对于m个样本计算统计量
（3）重复步骤（1）（2）N次（N一般大于1000），这样就可以算出N个统计量
（4）计算这N个统计量的方差

比如说，我现在要对一些未知样本做分类，分类算法选取一种，比如SVM。我要估计的总体参数是准确率（accuracy）。对于n个原始样本，从步骤（1）开始，每次对抽取出的样本用SVM训练出一个模型，然后用这个模型对未知样本做分类，得到一个准确率。重复N次，可以得到N个准确率，然后对计算出的N个准确率做方差。

为什么要计算这N个统计量的方差而不是期望或者均值。方差表示的是一组数据与其平均水平的偏离程度，如果计算的方差值在一定范围之内，则表示这些数据的波动不是很大，那么他们的均值就可以用来估计总体的参数，而如果方差很大，这些样本统计量波动很大，那么总体的参数估计就不太准确？

如果采用了bagging方法。样本有放回，而且投票可以并行。

每次抽取 5 个人投票是否接受。

第一次抽出 徐宁 、索超 、朱仝 、花荣、杨志。则 5 票都是 接受招安

第二次抽出 鲁智深，武松，朱贵，刘唐，李逵。则 5 票都是 反对招安

第三次抽出 徐宁 、索超，鲁智深，武松，阮小二。则 2 票接受，3 票反对，则这次样本是 反对招安。
  
最后综合三次的结果是：反对招安。
  
现在情况已经对招安不利了，如果再并行进行投票，那么对结果就更无法估计。
这样的话，对于是否招安就真的是梁山群体民主评议，公明哥哥和吴学究没办法后台黑箱操控了。

"Boosting"的基本思想是通过某种方式使得每一轮基学习器在训练过程中更加关注上一轮学习错误的样本
  
所以我们有两套方案。
方案一：每次每次剔除异常数值
方案二：每次调整异常数值权重
  
-----------------------------------------------------------------
  
方案一：每次剔除异常数值，这种适合宋江的样本全部无法控制的情况  
  
迭代1 
样本：鲁智深，武松，朱贵，刘唐，李逵。则 5 票都是 反对招安
宋江说：出家人与世无争，就不要参与投票了，改换为徐宁，索超两位兄弟。
宋江跟踪错误率，因为本次弱分类器误差太大，所以本次权重降低。
  
迭代2
样本：徐宁，索超，朱贵，刘唐，李逵。则 2 票接受，3 票反对，则这次样本是 反对招安
宋江说：铁牛兄弟不懂事，乱投票，来人乱棒打出去，换成杨志兄弟。
宋江跟踪错误率，因为本次弱分类器误差太大，所以本次权重降低。
  
迭代3
样本：徐宁，索超，朱贵，刘唐，杨志。则 3 票接受，2 票反对，则这次样本是 接受招安
宋江说：朱贵兄弟平时总是打点酒店，对于时政缺少认知，换成关胜兄弟。
宋江跟踪错误率，因为本次弱分类器误差较小，所以本次权重增加。
  
迭代4
样本：徐宁，索超，关胜，刘唐，杨志。则 4 票接受，1 票反对，则这次样本是 接受招安
宋江说：刘唐兄弟头发染色了，不利用梁山形象，换成花荣兄弟。
宋江跟踪错误率，因为本次弱分类器误差较小，所以本次权重增加。
  
迭代5
样本：徐宁，索超，关胜，花荣，杨志。则 5 票接受，则这次样本是 接受招安。
宋江跟踪错误率，因为本次弱分类器没有误差，所以本次权重增加。
即误差率小的分类器，在最终分类器中的重要程度大。
  
最后综合 5 次选举结果，梁山最后决定接受招安。
  
-----------------------------------------------------------------  
  
方案二：每次降低异常数值权重，这种适合样本中有宋江可以控制的头领
  
迭代1 
样本：武松，花荣，朱贵，杨志，李逵。则 2 票接受，3 票反对，则本次结论是 反对招安
宋江说：出家人与世无争，降低武松权重为 1/2 。
宋江跟踪错误率，因为本次弱分类器误差太大，所以本次权重降低。
  
迭代2
样本：武松(权重1/2)，花荣，朱贵，杨志，李逵。则 2 票接受，2又1/2 票反对，则这次结论是 反对招安
宋江说：铁牛兄弟不懂事，乱投票，降低李逵权重为 1/2。
宋江跟踪错误率，因为本次弱分类器误差太大，所以本次权重降低。
  
迭代3
样本：武松(权重1/2)，花荣，朱贵，杨志，李逵(权重1/2)。则 2 票接受，2 票反对，则这次结论是 无结论
宋江说：朱贵兄弟平时打点酒店，对于时政缺少认知，降低朱贵权重为 1/2。
宋江跟踪错误率，因为本次弱分类器无结论，所以本次权重为零。
  
迭代4
样本：武松(权重1/2)，花荣，朱贵(权重1/2)，杨志，李逵(权重1/2)。则 2 票接受，1又1/2 票反对，则这次结论是 接受招安
宋江说：这次好，花荣做过知寨，有见地，增加花荣权重。继续投票。
宋江跟踪错误率，因为本次弱分类器误差较小，所以本次权重增加。
  
迭代5
样本：武松(权重1/2)，花荣(权重2)，朱贵(权重1/2)，杨志，李逵(权重1/2)。则 3 票接受，1又1/2 票反对，则这次结论是 接受招安
宋江说：这次好，杨志做过制使，有见地，增加杨志权重。继续投票。  
宋江跟踪错误率，因为本次弱分类器误差较小，所以本次权重增加。
  
迭代6
样本：武松(权重1/2)，花荣(权重2)，朱贵(权重1/2)，杨志(权重2)，李逵(权重1/2)。则 4 票接受，1又1/2 票反对，则这次结论是 接受招安
宋江跟踪错误率，因为本次弱分类器误差较小，所以本次权重增加。  
  
最后综合 6 次选举结果，梁山最后决定接受招安。 
  
-----------------------------------------------------------------    
 
这里能看出来，Boosting算法对于样本的异常值十分敏感，因为Boosting算法中每个分类器的输入都依赖于前一个分类器的分类结果，会导致误差呈指数级累积。

宋江每一次选择的训练集都依赖于上一次学习的结果。每次剔除异常数值 或者 调整异常数值权重。(在实际boosting算法中是增加异常数值的权重)。
  
宋江也根据每一次训练的训练误差得到该次预测函数的权重。

从我们例子能看出来。

1. Bagging
bagging没有针对性的对分类器进行调整，只是单纯的增加样本数量和采样次数，以此来让平均值逼近结果。
所以bagging的基模型应该本身就是强模型（偏差低方差高）。
  
所以，bagging应该是对许多强（甚至过强）的分类器求平均。在这里，每个单独的分类器的bias都是低的，平均之后bias依然低；而每个单独的分类器都强到可能产生overfitting的程度，也就是variance高，求平均的操作起到的作用就是降低这个variance。

2. Boosting
boosting就是为了让每一次分类器的结果逐渐接近期望目标。即宋江期望一步一步的boosting到最终接受招安这个结果。这样才能在样本上最好拟合“招安”这个期望结果，从最初的“拒绝招安”这个high bias过渡到“接受招安”这个期望结果。
  
boosting是把许多弱的分类器组合成一个强的分类器。弱的分类器bias高，而强的分类器bias低，所以说boosting起到了降低bias的作用。variance不是boosting的主要考虑因素。
  
Boosting 是迭代算法，每一次迭代都根据上一次迭代的预测结果对样本进行加权，所以随着迭代不断进行，误差会越来越小，所以模型的 bias 会不断降低。这种算法无法并行，例子比如Adaptive Boosting。

# -*- coding: utf-8 -*-
"""
Created on Thu Jul 26 16:38:18 2018
@author: aoanng
"""

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


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

# 除了标签列，其他列都转换为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())

# 将数据集随机分成N块，方便交叉验证，其中一块是测试集，其他四块是训练集
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 get_subsample(dataSet, ratio):
    subdataSet = []
    lenSubdata = round(len(dataSet) * ratio)#返回浮点数
    while len(subdataSet) < lenSubdata:
        index = randrange(len(dataSet) - 1)
        subdataSet.append(dataSet[index])
    # print len(subdataSet)
    return subdataSet

# 分割数据集
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

# 计算分割代价
def spilt_loss(left, right, class_values):
    loss = 0.0
    for class_value in class_values:
        left_size = len(left)
        if left_size != 0:  # 防止除数为零
            prop = [row[-1] for row in left].count(class_value) / float(left_size)
            loss += (prop * (1.0 - prop))
        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

# 选取任意的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)
    # print 'features:',features
    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
    # print b_loss
    # print type(b_index)
    return {'index': b_index, 'value': b_value, 'left': b_left, 'right': b_right}

# 决定输出标签
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']
    # print left
    right = root['right']
    del (root['left'])
    del (root['right'])
    # print depth
    if not left or not right:
        root['left'] = root['right'] = decide_label(left + right)
        # print 'testing'
        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)
        # print 'testing_left'
        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)
        # print 'testing_right'
        sub_spilt(root['right'], n_features, max_depth, min_size, depth + 1)

# 构造决策树
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
  
# 预测测试集结果
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']
            # predictions=set(predictions)

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)
        # print 'tree %d: '%i,tree
        trees.append(tree)
    # predict_values = [predict(trees,row) for row in test]
    predict_values = [bagging_predict(trees, row) for row in test]
    return predict_values
  
# 计算准确率
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))


if __name__ == '__main__':
    seed(1) 
    dataSet = loadCSV('sonar-all-data.csv')
    column_to_float(dataSet)#dataSet
    n_folds = 5
    max_depth = 15
    min_size = 1
    ratio = 1.0
    # n_features=sqrt(len(dataSet)-1)
    n_features = 15
    n_trees = 10
    folds = spiltDataSet(dataSet, n_folds)#先是切割数据集
    scores = []
    for fold in folds:
        train_set = folds[
                    :]  # 此处不能简单地用train_set=folds，这样用属于引用,那么当train_set的值改变的时候，folds的值也会改变，所以要用复制的形式。（L[:]）能够复制序列，D.copy() 能够复制字典，list能够生成拷贝 list(L)
        train_set.remove(fold)#选好训练集
        # print len(folds)
        train_set = sum(train_set, [])  # 将多个fold列表组合成一个train_set列表
        # print len(train_set)
        test_set = []
        for row in fold:
            row_copy = list(row)
            row_copy[-1] = None
            test_set.append(row_copy)
            # for row in test_set:
            # print row[-1]
        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))))

# -*- coding: utf-8 -*-
"""
@Env: Python2.7
@Time: 2019/10/24 13:31
@Author: zhaoxingfeng
@Function：Random Forest（RF），随机森林二分类
@Version: V1.2
参考文献：
[1] UCI. wine[DB/OL].https://archive.ics.uci.edu/ml/machine-learning-databases/wine.
"""
import pandas as pd
import numpy as np
import random
import math
import collections
from sklearn.externals.joblib import Parallel, delayed

class Tree(object):
    """定义一棵决策树"""
    def __init__(self):
        self.split_feature = None
        self.split_value = None
        self.leaf_value = None
        self.tree_left = None
        self.tree_right = None

    def calc_predict_value(self, dataset):
        """通过递归决策树找到样本所属叶子节点"""
        if self.leaf_value is not None:
            return self.leaf_value
        elif dataset[self.split_feature] <= self.split_value:
            return self.tree_left.calc_predict_value(dataset)
        else:
            return self.tree_right.calc_predict_value(dataset)

    def describe_tree(self):
        """以json形式打印决策树，方便查看树结构"""
        if not self.tree_left and not self.tree_right:
            leaf_info = "{leaf_value:" + str(self.leaf_value) + "}"
            return leaf_info
        left_info = self.tree_left.describe_tree()
        right_info = self.tree_right.describe_tree()
        tree_structure = "{split_feature:" + str(self.split_feature) + 
                         ",split_value:" + str(self.split_value) + 
                         ",left_tree:" + left_info + 
                         ",right_tree:" + right_info + "}"
        return tree_structure

class RandomForestClassifier(object):
    def __init__(self, n_estimators=10, max_depth=-1, min_samples_split=2, min_samples_leaf=1,
                 min_split_gain=0.0, colsample_bytree=None, subsample=0.8, random_state=None):
        """
        随机森林参数
        ----------
        n_estimators:      树数量
        max_depth:         树深度，-1表示不限制深度
        min_samples_split: 节点分裂所需的最小样本数量，小于该值节点终止分裂
        min_samples_leaf:  叶子节点最少样本数量，小于该值叶子被合并
        min_split_gain:    分裂所需的最小增益，小于该值节点终止分裂
        colsample_bytree:  列采样设置，可取[sqrt、log2]。sqrt表示随机选择sqrt(n_features)个特征，
                           log2表示随机选择log(n_features)个特征，设置为其他则不进行列采样
        subsample:         行采样比例
        random_state:      随机种子，设置之后每次生成的n_estimators个样本集不会变，确保实验可重复
        """
        self.n_estimators = n_estimators
        self.max_depth = max_depth if max_depth != -1 else float('inf')
        self.min_samples_split = min_samples_split
        self.min_samples_leaf = min_samples_leaf
        self.min_split_gain = min_split_gain
        self.colsample_bytree = colsample_bytree
        self.subsample = subsample
        self.random_state = random_state
        self.trees = None
        self.feature_importances_ = dict()

    def fit(self, dataset, targets):
        """模型训练入口"""
        assert targets.unique().__len__() == 2, "There must be two class for targets!"
        targets = targets.to_frame(name='label')

        if self.random_state:
            random.seed(self.random_state)
        random_state_stages = random.sample(range(self.n_estimators), self.n_estimators)

        # 两种列采样方式
        if self.colsample_bytree == "sqrt":
            self.colsample_bytree = int(len(dataset.columns) ** 0.5)
        elif self.colsample_bytree == "log2":
            self.colsample_bytree = int(math.log(len(dataset.columns)))
        else:
            self.colsample_bytree = len(dataset.columns)

        # 并行建立多棵决策树
        self.trees = Parallel(n_jobs=-1, verbose=0, backend="threading")(
            delayed(self._parallel_build_trees)(dataset, targets, random_state)
                for random_state in random_state_stages)
        
    def _parallel_build_trees(self, dataset, targets, random_state):
        """bootstrap有放回抽样生成训练样本集，建立决策树"""
        subcol_index = random.sample(dataset.columns.tolist(), self.colsample_bytree)
        dataset_stage = dataset.sample(n=int(self.subsample * len(dataset)), replace=True, 
                                        random_state=random_state).reset_index(drop=True)
        dataset_stage = dataset_stage.loc[:, subcol_index]
        targets_stage = targets.sample(n=int(self.subsample * len(dataset)), replace=True, 
                                        random_state=random_state).reset_index(drop=True)

        tree = self._build_single_tree(dataset_stage, targets_stage, depth=0)
        print(tree.describe_tree())
        return tree

    def _build_single_tree(self, dataset, targets, depth):
        """递归建立决策树"""
        # 如果该节点的类别全都一样/样本小于分裂所需最小样本数量，则选取出现次数最多的类别。终止分裂
        if len(targets['label'].unique()) <= 1 or dataset.__len__() <= self.min_samples_split:
            tree = Tree()
            tree.leaf_value = self.calc_leaf_value(targets['label'])
            return tree

        if depth < self.max_depth:
            best_split_feature, best_split_value, best_split_gain = self.choose_best_feature(dataset, targets)
            left_dataset, right_dataset, left_targets, right_targets = 
                self.split_dataset(dataset, targets, best_split_feature, best_split_value)

            tree = Tree()
            # 如果父节点分裂后，左叶子节点/右叶子节点样本小于设置的叶子节点最小样本数量，则该父节点终止分裂
            if left_dataset.__len__() <= self.min_samples_leaf or 
                    right_dataset.__len__() <= self.min_samples_leaf or 
                    best_split_gain <= self.min_split_gain:
                tree.leaf_value = self.calc_leaf_value(targets['label'])
                return tree
            else:
                # 如果分裂的时候用到该特征，则该特征的importance加1
                self.feature_importances_[best_split_feature] = 
                    self.feature_importances_.get(best_split_feature, 0) + 1

                tree.split_feature = best_split_feature
                tree.split_value = best_split_value
                tree.tree_left = self._build_single_tree(left_dataset, left_targets, depth+1)
                tree.tree_right = self._build_single_tree(right_dataset, right_targets, depth+1)
                return tree
        # 如果树的深度超过预设值，则终止分裂
        else:
            tree = Tree()
            tree.leaf_value = self.calc_leaf_value(targets['label'])
            return tree

    def choose_best_feature(self, dataset, targets):
        """寻找最好的数据集划分方式，找到最优分裂特征、分裂阈值、分裂增益"""
        best_split_gain = 1
        best_split_feature = None
        best_split_value = None

        for feature in dataset.columns:
            if dataset[feature].unique().__len__() <= 100:
                unique_values = sorted(dataset[feature].unique().tolist())
            # 如果该维度特征取值太多，则选择100个百分位值作为待选分裂阈值
            else:
                unique_values = np.unique([np.percentile(dataset[feature], x)
                                           for x in np.linspace(0, 100, 100)])

            # 对可能的分裂阈值求分裂增益，选取增益最大的阈值
            for split_value in unique_values:
                left_targets = targets[dataset[feature] <= split_value]
                right_targets = targets[dataset[feature] > split_value]
                split_gain = self.calc_gini(left_targets['label'], right_targets['label'])

                if split_gain < best_split_gain:
                    best_split_feature = feature
                    best_split_value = split_value
                    best_split_gain = split_gain
        return best_split_feature, best_split_value, best_split_gain

    @staticmethod
    def calc_leaf_value(targets):
        """选择样本中出现次数最多的类别作为叶子节点取值"""
        label_counts = collections.Counter(targets)
        major_label = max(zip(label_counts.values(), label_counts.keys()))
        return major_label[1]

    @staticmethod
    def calc_gini(left_targets, right_targets):
        """分类树采用基尼指数作为指标来选择最优分裂点"""
        split_gain = 0
        for targets in [left_targets, right_targets]:
            gini = 1
            # 统计每个类别有多少样本，然后计算gini
            label_counts = collections.Counter(targets)
            for key in label_counts:
                prob = label_counts[key] * 1.0 / len(targets)
                gini -= prob ** 2
            split_gain += len(targets) * 1.0 / (len(left_targets) + len(right_targets)) * gini
        return split_gain

    @staticmethod
    def split_dataset(dataset, targets, split_feature, split_value):
        """根据特征和阈值将样本划分成左右两份，左边小于等于阈值，右边大于阈值"""
        left_dataset = dataset[dataset[split_feature] <= split_value]
        left_targets = targets[dataset[split_feature] <= split_value]
        right_dataset = dataset[dataset[split_feature] > split_value]
        right_targets = targets[dataset[split_feature] > split_value]
        return left_dataset, right_dataset, left_targets, right_targets

    def predict(self, dataset):
        """输入样本，预测所属类别"""
        res = []
        for _, row in dataset.iterrows():
            pred_list = []
            # 统计每棵树的预测结果，选取出现次数最多的结果作为最终类别
            for tree in self.trees:
                pred_list.append(tree.calc_predict_value(row))

            pred_label_counts = collections.Counter(pred_list)
            pred_label = max(zip(pred_label_counts.values(), pred_label_counts.keys()))
            res.append(pred_label[1])
        return np.array(res)


if __name__ == '__main__':
    df = pd.read_csv("source/wine.txt")
    df = df[df['label'].isin([1, 2])].sample(frac=1, random_state=66).reset_index(drop=True)
    clf = RandomForestClassifier(n_estimators=5,
                                 max_depth=5,
                                 min_samples_split=6,
                                 min_samples_leaf=2,
                                 min_split_gain=0.0,
                                 colsample_bytree="sqrt",
                                 subsample=0.8,
                                 random_state=66)
    train_count = int(0.7 * len(df))
    feature_list = ["Alcohol", "Malic acid", "Ash", "Alcalinity of ash", "Magnesium", "Total phenols", 
                    "Flavanoids", "Nonflavanoid phenols", "Proanthocyanins", "Color intensity", "Hue", 
                    "OD280/OD315 of diluted wines", "Proline"]
    clf.fit(df.loc[:train_count, feature_list], df.loc[:train_count, 'label'])

    from sklearn import metrics
    print(metrics.accuracy_score(df.loc[:train_count, 'label'], clf.predict(df.loc[:train_count, feature_list])))
    print(metrics.accuracy_score(df.loc[train_count:, 'label'], clf.predict(df.loc[train_count:, feature_list])))