机器学习：基于决策树的 XX联盟游戏胜负预测

from collections import Counter
RANDOM_SEED = 2020 # 固定随机种子

import pandas as pd
csv_data = './data/high_diamond_ranked_10min.csv' # 数据路径
data_df = pd.read_csv(csv_data, sep=',') # 读入csv文件为pandas的DataFrame
data_df = data_df.drop(columns='gameId') # 舍去对局标号列

print(data_df.iloc[0]) # 输出第一行数据
data_df.describe() # 每列特征的简单统计信息

blueWins                            0.0
blueWardsPlaced                    28.0
blueWardsDestroyed                  2.0
blueFirstBlood                      1.0
blueKills                           9.0
blueDeaths                          6.0
blueAssists                        11.0
blueEliteMonsters                   0.0
blueDragons                         0.0
blueHeralds                         0.0
blueTowersDestroyed                 0.0
blueTotalGold                   17210.0
blueAvgLevel                        6.6
blueTotalExperience             17039.0
blueTotalMinionsKilled            195.0
blueTotalJungleMinionsKilled       36.0
blueGoldDiff                      643.0
blueExperienceDiff                 -8.0
blueCSPerMin                       19.5
blueGoldPerMin                   1721.0
redWardsPlaced                     15.0
redWardsDestroyed                   6.0
redFirstBlood                       0.0
redKills                            6.0
redDeaths                           9.0
redAssists                          8.0
redEliteMonsters                    0.0
redDragons                          0.0
redHeralds                          0.0
redTowersDestroyed                  0.0
redTotalGold                    16567.0
redAvgLevel                         6.8
redTotalExperience              17047.0
redTotalMinionsKilled             197.0
redTotalJungleMinionsKilled        55.0
redGoldDiff                      -643.0
redExperienceDiff                   8.0
redCSPerMin                        19.7
redGoldPerMin                    1656.7
Name: 0, dtype: float64

drop_features = ['blueGoldDiff', 'redGoldDiff', 
                 'blueExperienceDiff', 'redExperienceDiff', 
                 'blueCSPerMin', 'redCSPerMin', 
                 'blueGoldPerMin', 'redGoldPerMin'] # 需要舍去的特征列
df = data_df.drop(columns=drop_features) # 舍去特征列
info_names = [c[3:] for c in df.columns if c.startswith('red')] # 取出要作差值的特征名字（除去red前缀）
for info in info_names: # 对于每个特征名字
    df['br' + info] = df['blue' + info] - df['red' + info] # 构造一个新的特征，由蓝色特征减去红色特征，前缀为br
# 其中FirstBlood为首次击杀最多有一只队伍能获得，brFirstBlood=1为蓝，0为没有产生，-1为红
df = df.drop(columns=['blueFirstBlood', 'redFirstBlood']) # 原有的FirstBlood可删除
df

discrete_df = df.copy() # 先复制一份数据
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import pylab
def barchart_ax(discrete_df, title='各个特征取值数量统计', xlabel='特征名称', ylabel='特征的不同取值量', background_color= "#EAEAF2", Batch1_color = "#25AFF3"):
    feature_values = []
    x_text = []
    for c in discrete_df.columns[1:]:
        x_text.append(c)
        ct = discrete_df[c].duplicated(keep ='first')
        feature_values.append(len(ct[ct==False]))
    batch1=feature_values
    pylab.rcParams['figure.figsize'] = (19.0, 10.0)
    plt.rcParams['font.sans-serif'] = ['KaiTi']
    matplotlib.rcParams['axes.unicode_minus'] = False
    x = np.arange(len(x_text))
    width = 0.66
    fig, ax = plt.subplots()
    rects = ax.bar(x - width/2, batch1, width, color = Batch1_color)                               
    ax.patch.set_facecolor(background_color)  
    ax.set_title(title, fontsize=26)     
    ax.set_xlabel(xlabel, fontsize=22)   
    ax.set_ylabel(ylabel, fontsize=22)  
    ax.set_xticks(x)    
    ax.set_xticklabels(x_text, fontsize=22)   
    for rect in rects:
        height = rect.get_height()
        ax.annotate('{}'.format(height),      
            xy=(rect.get_x() + rect.get_width() / 2, height),
            xytext=(0,3),      
            textcoords="offset points",
            ha='center', va='bottom')
        plt.grid(linestyle = "dotted",color = "g")
    plt.xticks(rotation=89)
    fig.tight_layout()
    plt.show()
barchart_ax(discrete_df)

import pandas as pd
import numpy as np
import pandas as pd
import numpy as np
class discretization(object):
    """
    离散化类：提供几种可供选择的离散化方法。
    离散化就是将特征中多个不同的特征值用相对少的取值表示。
    每种离散化方法一次工作中对特定的列（特征）进行离散化操作，返回被离散的列的离散化结果
    如果最终需要获取完成所有特征离散化的DataFrame，则使用该类实例的DF属性（discretization.DF）即可
    """
    def __init__(self,DataF):
        """
        初始化：拷贝一份传入的DataFrame。
        仅当各备选的离散化方法中，submit = True 时，将改变 self.DF 中该列特征的数据。
        """
        self.DF = DataF.copy()
    def scaling(self,feature,scale,submit=True):
        """
        离散化备选方法1:
        数据尺度缩小法离散化——该方法法通过将数值除以特定的数来进行离散化。
        Parameters
        -------
         - feature: str，特征名，将用作从DF中索引该列特征的有序所有取值
         - scale: 该列特征数值的放缩尺度。
         - submit: bool，离散化后直接提交更改到self.DF中的该特征
        """
        dis_feature = self.DF[feature].copy()
        dis_feature = np.array(np.floor(np.array(self.DF[feature]/scale)))
        if submit:
            self.DF[feature] = dis_feature
        return dis_feature
    def pd_cut(self,feature,bins,submit=True):
        """
        离散化备选方法2:
        按数值区间分割数据离散化——先按照数据取值将数据分割成n组。
        Parameters
        -------
         - feature: str，特征名，将用作从DF中索引该列特征的有序所有取值
         - bins: 若为Series，则序列中数据元素各为分割点；
                 若为int，则特征值定义范围内的等宽bin数。x的范围在每一侧
                 都扩展了0.1％，以包括x的最小值和最大值。
         - submit: bool，离散化后直接提交更改到self.DF中的该特征
        """
        dis_feature = self.DF[feature].copy()
        dis_feature = pd.cut(dis_feature ,bins)
        if submit:
            self.DF[feature] = dis_feature 
        return dis_feature 
    def pd_qcut(self,feature,q,submit=True,**kw):
        """
        离散化备选方法3：
        等元素个数分割数据离散化——分割后每个存储组有相同元素个数。
        Parameters
        -------
         - feature: str，特征名，将用作从DF中索引该列特征的有序所有取值
         - q: 频数，int，也就是分割后的组数
         - q_label: serial，分割后，必须用新的标签代表旧的数据，标签数目必
                    须和分割的频数对应一致
         - submit: bool，离散化后直接提交更改到self.DF中的该特征
        """
        if kw.get('q_label') != None:
            q_label = kw.get('q_label')
        else:
            q_label = list(range(q))
        dis_feature = self.DF[feature].copy()
        dis_feature = pd.qcut(dis_feature,q,q_label,duplicates="drop") # duplicates="drop"表示如果bin边缘(每组的分位点处)不是唯一则丢弃非唯一变量
        if submit:
            self.DF[feature] = dis_feature
        return dis_feature
# Discretization = discretization(discrete_df)
# Discretization.scaling('brTotalGold',scale=100)   # 采用数值尺度缩小进行离散化
# Discretization.pd_cut('brTotalGold',[-10830,-5845,0,6135,11467]) # 划分为[(-10830, -5845] < (-5845, 0] < (0, 6135] < (6135, 11467]]
# Discretization.pd_qcut('brTotalGold',10)           # 采用等频（元素个数）分割进行离散化
# barchart_ax(Discretization.DF)

Discretization = discretization(discrete_df)
for c in df.columns[1:]: # 遍历每一列特征，跳过标签列
    '''
    请离散化每一列特征，即discrete_df[c] = ...
    提示：
    对于有些特征本身取值就很少，可以跳过即 if ... : continue
    对于其他特征，可以使用等区间离散化、等密度离散化或一些其他离散化方法
    可参考使用pandas.cut或qcut
    '''
    if len(set(discrete_df[c]))>10:    # 当不同特征取值数量超过 10 时进行离散化
        Discretization.pd_qcut(c,5)
barchart_ax(Discretization.DF)

from sklearn.model_selection import train_test_split, cross_validate # 划分数据集函数
discrete_df = Discretization.DF
all_y = discrete_df['blueWins'].values                # 所有标签数据
features = np.array(discrete_df.columns )[1:]        # 所有特征的名称
all_x = discrete_df[features].values  # 所有原始特征值，pandas的DataFrame.values取出为numpy的array矩阵
# 划分训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(all_x, all_y, test_size=0.2, random_state=RANDOM_SEED)
all_y.shape, all_x.shape, x_train.shape, x_test.shape, y_train.shape, y_test.shape # 输出数据行列信息
y_train[0:10]

array([1, 0, 0, 1, 0, 0, 1, 0, 0, 1], dtype=int64)

from math import log
import numpy as np
import random
from collections import Counter
RANDOM_SEED = 2021 # 固定随机种子
random.seed(random)
class Selector(object):
    """
    选择器
    【我的博客地址】:https://blog.csdn.net/qq_28550263/article/details/114867848
    """
    def __init__(self,labels):
        """
        Parameters
        ----------
        labels:    an Array-like object
        """
        self.labels = labels
    def majorityLabel(self):
        """
        选择出现次数最多的元素
        Return
        ------
        result:    labels中出现次数最多的那个成员
        """
        return Counter(list(self.labels)).most_common()[0][0]
    def maxProbability_elem(self):
        """
        有元素权重随机选择（元素随机）
        Return
        ------
        result:    labels 中的某个成员
        """
        return self.labels[int(random.random()* len(self.labels))]
    def maxProbability_class(self):
        """
        无元素权重随机选择（元素类随机）
        Return
        ------
        result:    labels 中的某个成员
        """
        return list(set(self.labels))[int(random.random()* len(self.labels))]
class ClassificationTree(object):
    """分类树"""
    def __init__(self, features, max_depth=10, min_samples_split=10, impurity_t='entropy',selector_t = 'majority_label',test=False):
        """
        Parameters
        ----------
        impurity_t：  str，表示混杂度的度量方式，只能是{"entropy","gini"}中的一个。
        """
        self.tree = None
        self.impurity_t = impurity_t
        self.features = features
        self.max_depth = max_depth
        self.min_samples_split = min_samples_split
        self.selector_t = selector_t
        self.test = test
    def get_lable(self,labels):
        """
        剪枝叶节点标签集选择标签
        Parameters
        ----------
        labels：    an Array-like object，某个节点处的标签集
        """
        Slor = Selector(labels)
        if self.selector_t == "majority_label": # 直接选取出现最多的标签返回
            return Slor.majorityLabel()
        elif self.selector_t == "random":       # 按权重随机选一个标签返回
            return Slor.maxProbability_elem()
    def impurity(self, anArray):
        """
        计算混杂度
        【我的博客地址】:https://blog.csdn.net/qq_28550263/article/details/114883862
        Parameters
        ----------
        anArray：     an Array like object，由某特征依次对应每条数据下的取值构成。
        Return
        result: float，
                表示计算得到的不纯度impurity的数值。
        """
        cnt = Counter(anArray)
        data_length = len(anArray)
        pis = [cnt[i]/data_length for i in cnt]
        if self.impurity_t == "entropy":         # 信息熵：Entropy = -∑(i=1,n)|(pi·logpi)
            return -np.sum([pi * np.log2(pi) for pi in pis if pi > 0])
        elif self.impurity_t == "gini":          # 基尼系数：Gini = 1-∑(k=1,n)|(Pk)^2
            return 1 - np.sum([Pi**2 for Pi in pis])
        else:
            raise ValueError("impurity_t can only be one of {'entropy','gini'}")
    def dividing_data_set(self, data_set,node_feature,node_feature_value):
        """
        划分数据集
        【我的博客地址】:https://blog.csdn.net/qq_28550263/article/details/114892718
        整个划分方法的思想是"记录索引-重索引"。简而言之就是先记住特征取值为指定取值的索引号，然
        后依据记录索引号保对其它特征下同索引号的元素进行保留。最终实现留下当前划分数据条的目的。
        Parameters
        ----------
        data_set： "dict"结构的数据集，其中键为”labels“的键值对对应为标签集（源于x_train），其余
                   的对应为特征取值键值对（源于y_train）。
        node_feature：可以是num、str等类型，但是必须和data_set中的键的类型保持一致。表示需要划分
                   数据集的节点处对应的特征名。
        node_feature_value：是对应与 node_feature 的一个特定取值。
        Returns
        -------
        result : dict
            返回子数据集字典，其形式与data_set保持一致。其中键`labels`对应的值类似是子标签集数组。
        """
        # 先获取对应特征 node_feature 在数据集中所有条数据的有序取值数组
        feature_in_sets = data_set[node_feature]
        # 记录所有取值为 node_feature_value 数据编号
        reserved_group = [i for i in range(len(feature_in_sets)) if feature_in_sets[i]==node_feature_value]
        # 接着依据 reserved_group 中的组号保留属于当前分支的数据
        sub_data_set = {}
        for the_key in data_set:
            sub_data_set[the_key] = np.array([data_set[the_key][i] for i in reserved_group])
        # 最后，删除用过的特征列
        del(sub_data_set[node_feature])
        return sub_data_set
    def gain(self, impurity_before_divide, data_set, probable_feature):
        """
        计算信息增益
        【我的博客地址】:https://blog.csdn.net/qq_28550263/article/details/114891368
        需要传入数据集划分前的不纯度、划分数据集所依赖特征对应的取值数组。考虑到在同一个节点测试不同子特征增益时都有用
        到划分前的不纯度，为了提升运行效率故在gain()外计算好该节点分裂前的不纯度后再传入gain()函数。其中数据集划分前的
        熵就是划分前的标签集labels的熵。其中按某特征划分后的不确定度，为依该特征各个取值划分的子数据集的中的标签集（即
        该特征划分完后所有的子标签集）的不确定度总和。
        Parameters
        ----------
        impurity_before_divide:  float，表示数据集划分前的不纯度。            
        data_set：               dict，划分前的数据集。
        probable_feature:        str，用于划分数据集的特征。
        Return
        ------
        result:      float，表征信息增益值。
        """
        impurity_after_divide = 0                             # 初始化数据集划分后的不存度为0
        for value in set(data_set[probable_feature]):         # 获取该特征所有的取值并使用集合去重，遍历之
            one_sublabel_array = self.dividing_data_set(           # 获取该子数据集中的标签集数组
                data_set = data_set, 
                node_feature = probable_feature,
                node_feature_value = value
            )['labels']
            impurity_after_divide = self.impurity(one_sublabel_array) # 累加每个子数据标签集的不存度
        return impurity_before_divide - impurity_after_divide               # 做差得到这个特征的增益并返回
    def gain_rate(self, impurity_before_divide, data_set, probable_feature):
        """
        计算信息增益率
        【我的博客地址】:https://blog.csdn.net/qq_28550263/article/details/114891368
        相对于信息增益的计算，信息增益率还要求解出由于该特征的不同取值带来的不确度。
         - 若由于特征取值带来的不确定度为0，说明无特征取值连续化影响，直接返回信息增益；
         - 若特征取值带来的不确定度不是0，则使用信息增益除以特征取证带来的不确定度。
        Parameters
        ----------
        impurity_before_divide:  float，表示数据集划分前的不纯度。            
        data_set：               dict，划分前的数据集。
        probable_feature:        str，用于划分数据集的特征。
        Return
        ------
        result:      float，表征信息增益值。
        """
        impurity_after_divide = 0                             # 初始化数据集划分后的不存度为0
        for value in set(data_set[probable_feature]):         # 获取该特征所有的取值并使用集合去重，遍历之
            one_sublabel_array = self.dividing_data_set(           # 获取该子数据集中的标签集数组
                data_set = data_set, 
                node_feature = probable_feature,
                node_feature_value = value
            )['labels']
        impurity_after_divide = self.impurity(one_sublabel_array)     # 累加每个子数据标签集的不存度
        gain = impurity_before_divide - impurity_after_divide               # 做差得到这个特征的增益
        feature_impurity = self.impurity(data_set[probable_feature])
        return gain/feature_impurity if feature_impurity > 0 else gain
    def best_feature(self, data_set):
        """
        求取节点处的最佳特征
        【我的博客地址】:https://blog.csdn.net/qq_28550263/article/details/114891368
        Parameters
        ----------
        data_set:    dict，与某个节点处的对应的数据集
        Return
        ------
        result：     str，数据集data_set所属节点处可用于分裂的最佳特征
        """
        features = [i for i in data_set if i != "labels"]                       # 获取数据集中当前节点处所有特征
        impurity_before_divide = self.impurity(data_set["labels"])    # 数据集划分前labels的混杂度
        max_gain_rate = -1          # 不会小于0，因此随便给个负数初始值
        the_best_feature = ""
        for probable_feature in features:
            rate = self.gain_rate(impurity_before_divide, data_set, probable_feature)
            if rate > max_gain_rate:
                max_gain_rate = rate
                the_best_feature = probable_feature
        return the_best_feature
    def expand_node(self, data_set, depth, branch):
        """
        递归拓展节点
        【我的博客地址】：https://blog.csdn.net/qq_28550263/article/details/114967776
        Parameters
        ----------
        data_set:   dict，该节点的数据集。键为特征名，值为该特征名对应的训练集数据。
        labels:     an Array-like object，当前标签集。根节点的标签集即原始训练集的标签集。
        depth:      int，上一节点的深度。根节点进来时从0开始。
        branch:     str or a num object，表示节点来时的路。
                         - 除了``根节点``外，其它的节点由于是由分裂而来，都有“来时的路”
                         - 根节点没有来处，只剩归途（分支）。
        Return
        ------
        result:    dict， 表征当前节点（及其预期的子节点）的字典。
                          如果是``非叶子节点``在递归调用拓展节点后必须返回该非叶子节点给
                          其父节点。
                          这也就是说，这类字典是依次连接一个个从``根节点``到所有``非叶子
                          节点``的纽带。
        """
        node = {}                                # 初始化节点
        if depth == 0:                           # 仅根节点不属于任何分支，不需要记录来时的路
            if self.test == False:
                print('正在训练决策树，请稍后...')
        else:
            node['branch'] = branch              # 对于非根节点，都需要记住来时的路
        nodedepth = depth + 1                    # 每递归一次节点的深度就在父节点基础上加1
        the_best_feature = self.best_feature(data_set)
        labels = data_set["labels"]              # 当前数据集的标签集
        bestfeature_values = list(set(data_set[the_best_feature]))  # 最佳特征的多有取值
        samples = len(data_set)                  # 当前节点的样本数，也就是节点数据集中标签集的元素个数
        node_label = self.get_lable(labels)      # 节点标签。非叶子节点也给一个标签，因为测试集的数据不一定是训练集见过的！
        # 记录当前节点处的相关数据
        node['depth'] = nodedepth                         # 记录当前节点的深度
        node['the_best_feature'] = the_best_feature       # 记录当前节点最佳特征
        node['bestfeature_values'] = bestfeature_values   # 记录当前节点的最佳特征取值，也就是节点分支名称们
        node['samples'] = len(labels)                     # 记录当前节点处的样本数量
        # 停止递归：所有特征的类别标签labels完全相同，这包含两种情况
        # 一种是还有很多样本时已经被完美地分类
        # 另外一种是，之前一直没有完成分类，直到现在都已经最后一个样本了
        if len(set(labels)) == 1: # 如果只有一种类别了，无需分裂，已经是叶节点
            node['label'] = list(labels)[0]
            return node
        # 停止递归：没有要求的足够样本数了
        elif node['samples'] < self.min_samples_split:
            node['label'] = node_label
            return node
        # 停止递归：到达最大分裂深度
        elif node['depth'] >= self.max_depth:
            node['label'] = node_label
            return node
        else:                                   # 递归扩展节点
            branchs = []                        # 是该非叶子节点的branch容器
            node['label'] = node_label          # 非叶子节点的标签可以预防测试集中遇到未学习过的数据
            for value in node['bestfeature_values']:
                subdata_set = self.dividing_data_set(                                # 划分子数据集
                                    data_set=data_set, 
                                    node_feature=node['the_best_feature'], 
                                    node_feature_value=value
                                )
                child_node = self.expand_node(subdata_set, nodedepth, branch=value)   # 递归调用
                branchs.append(child_node)
            node['branchs'] = branchs   # 每个node的分支们装在一个列表里，列表中装一个node字典就有一个分支
            return node
    def fit(self, x_train, y_train):
        """
        训练模型
         - x_train ：  an Array-like object，为最初的训练数据集；
         - y_train ：  an Array-like object，为最初的标签集。
        """
        assert len(self.features) == len(x_train[0])        # 输入数据的特征数目应该和模型定义时的特征数目相同    
        data_set = dict(zip(self.features,x_train.T))       # 转换为数据集字典
        data_set.update({"labels":y_train})                 # 将标签集（labels，也就是输出y们）也加入数据集
        # 拓展节点：初始深度为0，到第一个节点自动先变1，递归拓展
        self.tree = self.expand_node(data_set=data_set, depth=0, branch=None)
        if self.test == False:
            print('训练完成，可以使用show()方法展示决策树。')
    def predict_one(self,tree, one_features_data):
        """
        预测测试集中的一条数据
        这个过程实际上就是基于节点的递归查询过程，在某个节点:
        是否有分支：
            - 有分支：必为非叶子节点：
                          使用测试集该节点对应的特征名索引出测试特征值，决定接下来查询的分支：
                                如测试数据的特征值在分支列表中，进入特征值决定的分支，递归以上过程。
                                如测试数据的特征值不在分支列表中，说明是训练时没有遇到过的新情况：
                                      可以用投票器投出一个标签：即可以按照该节点数据集的标签集各标签占比投票一个，
                                                                也可以直接选该节点标签集中出现次数最多的标签作为投票结果。
            - 无分支：必为叶子节点：
                          返回叶子节点处的标签值为预测结果。
         - tree：递归过程中的树（除了根节点是原决策树，其它的节点都是其子树）；
         - one_features_data：单条数据各个特征的取值。
        """
        # 先将测试的这单条数据与原始的特征名依次组合成字典以待查询
        onetestdata_dict = dict(zip(self.features,list(one_features_data)))
        the_best_feature = tree.get('the_best_feature')   # 当前的节点（特征名）
        branchs = tree.get('branchs')                     # 当前特征节点下树的所有分支，是一个包含分支的列表
        if branchs == None:           # 没有分支时，时叶子节点
            return tree.get('label')  # 返回叶子节点处的标签
        else:                         # 否则是非叶子节点
            node_values = tree['bestfeature_values']                # 获取该非叶子节点所有分支值
            feature_value = onetestdata_dict.get(the_best_feature)  # 这条数据中当前特征对应的标签值
            if feature_value not in node_values:   # 这条来自测试集的特征值没有在训练时出现过（未学习到的样本）
                return tree.get('label')           # 不得不终止递归预测，返回本节点处的预测标签
            else:                                  # 仍然在学习到的分支中
                for i in range(len(branchs)):
                    if branchs[i].get('branch') == feature_value:
                        subtree = branchs[i]                                  # 进入该分支（获取子节点）
                        return self.predict_one(subtree, one_features_data)   # 递归预测之
    def predict(self, features):
        assert len(features.shape) == 1 or len(features.shape) == 2 # 只能是1维或2维
        '''
        预测测试集中数据标签
        使用它调用self.predict_one()对训练集中的每一条数据一次预测获取预测结果
        '''
        if len(features.shape) == 1: 
            features = np.array([features])
        tree = self.tree                      # 准备决策树
        predict_list = []                     # 训练结果容器
        # 对每一条数据依次调用predict_one()方法预测并以及将结果装入训练结果容器
        for one_features_data in features:
            one_pre_value = self.predict_one(tree, one_features_data)   # 计算出一条数据的预测标签
            predict_list.append(one_pre_value)                          # 将这一条数据的预测标签插入预测标签列表predict_list中
        return np.array(predict_list)                                   # 以np.array的形式返回预测标签数组
    def show(self, stype="text"):
        """可视化决策树"""
        if stype=="text":     # 打印文本
            print(self.tree)
        elif  stype=="draw":  # 绘制图像
            pass

clt = ClassificationTree(features=features, max_depth=4, min_samples_split=40, impurity_t='entropy',selector_t = 'majority_label')
clt.fit(x_train, y_train)

正在训练决策树，请稍后...
训练完成，可以使用show()方法展示决策树。

from sklearn.metrics import accuracy_score # 准确率函数
p_test = clt.predict(x_test)
test_acc = accuracy_score(p_test, y_test) # 将测试预测值与测试集标签对比获得准确率
print('accuracy: {:.4f}'.format(test_acc)) # 输出准确率

accuracy: 0.7060

parameters = {
    'impurity_t':['entropy', 'gini'], 
    'max_depth': range(2, 6), 
    'min_samples_split': [100, 200, 400, 500, 800],
    #"selector_t" : ["majority_label","random"],
    #"RANDOM_SEED":[100,500,1000,2000,4000,8000]   # 当 selector_t = random 时还可以测试随机种子对分类的影响
}
from multiprocessing import Process
max_acc = 0
max_acc_parameters = None
def one_test(features,max_depth,min_samples_split,impurity_t,selector_t,x_train,y_train,x_test,y_test):
    global max_acc
    global max_acc_parameters
    clt = ClassificationTree(features, max_depth, min_samples_split, impurity_t, selector_t,test=True)
    clt.fit(x_train, y_train)
    p_test = clt.predict(x_test)
    test_acc = accuracy_score(p_test, y_test)
    print("max_depth:",max_depth, "min_samples_split:",min_samples_split, "impurity_t:",impurity_t, "selector_t:",selector_t,"test_acc:",test_acc)
    if test_acc > max_acc:
        max_acc = test_acc
        print("\n>[更新latest_max_acc]：latest_max_acc=",max_acc)
        max_acc_parameters = {"max_depth":max_depth, "min_samples_split":min_samples_split, "impurity_t":impurity_t, "selector_t":selector_t,"test_acc":test_acc}
        print("[更新max_acc_parameters]：",max_acc_parameters)
for impurity_t in parameters["impurity_t"]:
    for max_depth in parameters["max_depth"]:
        for min_samples_split in parameters["min_samples_split"]:
            one_test(features,max_depth,min_samples_split,impurity_t,selector_t=selector_t,x_train=x_train,y_train=y_train,x_test=x_test,y_test=y_test)
            #for selector_t in parameters["selector_t"]:
                #if selector_t == "random":
                    #for RANDOM_SEED in parameters["RANDOM_SEED"]:
                        #one_test(features,max_depth,min_samples_split,impurity_t,selector_t,x_train,y_train,x_test,y_test)
                #else:
                    #one_test(features,max_depth,min_samples_split,impurity_t,selector_t,x_train,y_train,x_test,y_test)
print("\n【最终测试到】：\nMax_Acc=",max_acc,"\nMax_Acc_Parameters=",max_acc_parameters)

max_depth: 2 min_samples_split: 100 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
>[更新latest_max_acc]：latest_max_acc= 0.5167004048582996
[更新max_acc_parameters]： {'max_depth': 2, 'min_samples_split': 100, 'impurity_t': 'entropy', 'selector_t': 'majority_label', 'test_acc': 0.5167004048582996}
max_depth: 2 min_samples_split: 200 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 2 min_samples_split: 400 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 2 min_samples_split: 500 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 2 min_samples_split: 800 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 100 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 200 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 400 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 500 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 800 impurity_t: entropy selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 4 min_samples_split: 100 impurity_t: entropy selector_t: majority_label test_acc: 0.7059716599190283
>[更新latest_max_acc]：latest_max_acc= 0.7059716599190283
[更新max_acc_parameters]： {'max_depth': 4, 'min_samples_split': 100, 'impurity_t': 'entropy', 'selector_t': 'majority_label', 'test_acc': 0.7059716599190283}
max_depth: 4 min_samples_split: 200 impurity_t: entropy selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 4 min_samples_split: 400 impurity_t: entropy selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 4 min_samples_split: 500 impurity_t: entropy selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 4 min_samples_split: 800 impurity_t: entropy selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 5 min_samples_split: 100 impurity_t: entropy selector_t: majority_label test_acc: 0.7201417004048583
>[更新latest_max_acc]：latest_max_acc= 0.7201417004048583
[更新max_acc_parameters]： {'max_depth': 5, 'min_samples_split': 100, 'impurity_t': 'entropy', 'selector_t': 'majority_label', 'test_acc': 0.7201417004048583}
max_depth: 5 min_samples_split: 200 impurity_t: entropy selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 5 min_samples_split: 400 impurity_t: entropy selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 5 min_samples_split: 500 impurity_t: entropy selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 5 min_samples_split: 800 impurity_t: entropy selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 2 min_samples_split: 100 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 2 min_samples_split: 200 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 2 min_samples_split: 400 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 2 min_samples_split: 500 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 2 min_samples_split: 800 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 100 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 200 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 400 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 500 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 3 min_samples_split: 800 impurity_t: gini selector_t: majority_label test_acc: 0.5167004048582996
max_depth: 4 min_samples_split: 100 impurity_t: gini selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 4 min_samples_split: 200 impurity_t: gini selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 4 min_samples_split: 400 impurity_t: gini selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 4 min_samples_split: 500 impurity_t: gini selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 4 min_samples_split: 800 impurity_t: gini selector_t: majority_label test_acc: 0.7059716599190283
max_depth: 5 min_samples_split: 100 impurity_t: gini selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 5 min_samples_split: 200 impurity_t: gini selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 5 min_samples_split: 400 impurity_t: gini selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 5 min_samples_split: 500 impurity_t: gini selector_t: majority_label test_acc: 0.7201417004048583
max_depth: 5 min_samples_split: 800 impurity_t: gini selector_t: majority_label test_acc: 0.7201417004048583
【最终测试到】：
Max_Acc= 0.7201417004048583 
Max_Acc_Parameters= {'max_depth': 5, 'min_samples_split': 100, 'impurity_t': 'entropy', 'selector_t': 'majority_label', 'test_acc': 0.7201417004048583}