手写决策树算法——基于决策树的XX联盟游戏胜负预测

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}