devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

决策树_信息熵(information entropy)的计算头歌

作者：繁依Fanyi0 | 2024-05-29 18:28:05

赞

踩

信息熵(information entropy)的计算头歌

第1关：什么是决策树

任务描述

本关任务：根据本节课所学知识完成本关所设置的选择题。

相关知识

为了完成本关任务，你需要掌握决策树的相关基础知识。

引例

在炎热的夏天，没有什么比冰镇后的西瓜更能令人感到心旷神怡的了。现在我要去水果店买西瓜，但什么样的西瓜能入我法眼呢？那根据我的个人习惯，在挑西瓜时可能就有这样的脑回路。

假设现在水果店里有3个西瓜，它们的属性如下：

编号瓤是否够红够不够冰是否便宜是否有籽
1是否是否
2是是否是
3否是是否

那么根据我的脑回路我会买1和2号西瓜。

其实我的脑回路可以看成一棵树，并且这棵树能够帮助我对买不买西瓜这件事做决策，所以它就是一棵决策树。

决策树的相关概念

决策树是一种可以用于分类与回归的机器学习算法，但主要用于分类。用于分类的决策树是一种描述对实例进行分类的树形结构。决策树由结点和边组成，其中结点分为内部结点和叶子结点，内部结点表示一个特征或者属性，叶子结点表示标签（脑回路图中黄色的是内部结点，蓝色的是叶子结点）。

从代码角度来看，决策树其实可以看成是一堆if-else语句的集合，例如引例中的决策树完全可以看成是如下代码：

 

  1. if isRed:
  2. if isCold:
  3. if hasSeed:
  4. print("buy")
  5. else:
  6. print("don't buy")
  7. else:
  8. if isCheap:
  9. print("buy")
  10. else:
  11. print("don't buy")
  12. else:
  13. print("don't buy")
 

因此决策树的一个非常大的优势就是模型的可理解性非常高，甚至可以用来挖掘数据中比较重要的信息。
 

那么如何构造出一棵好的决策树呢？其实构造决策树时会遵循一个指标，有的是按照信息增益来构建，如ID3算法；有的是信息增益率来构建，如C4.5算法；有的是按照基尼系数来构建的，如CART算法。但不管是使用哪种构建算法，决策树的构建过程通常都是一个递归选择最优特征，并根据特征对训练集进行分割，使得对各个子数据集有一个最好的分类的过程。
 

这一过程对应着对特征空间的划分，也对应着决策树的构建。一开始，构建决策树的根结点，将所有训练数据都放在根结点。选择一个最优特征，并按照这一特征将训练数据集分割成子集，使得各个子集有一个在当前条件下最好的分类。如果这些子集已经能够被基本正确分类，那么构建叶子结点，并将这些子集分到所对应的叶结点中去；如果还有子集不能被基本正确分类，那么就对这些子集选择新的最优特征，继续对其进行分割，并构建相应的结点。如此递归进行下去，直至所有训练数据子集被基本正确分类，或者没有合适的特征为止。最后每个子集都被分到叶子结点上，即都有了明确的类别。这就构建出了一棵决策树。
 

编程要求
 

根据本关所学习到的知识，完成所有选择题。
 

测试说明
 

平台会对你的选项进行判断，如果实际输出结果与预期结果相同，则通关；反之，则 GameOver。
 

  1. 1、下列说法正确的是？（A、B)
  2.  
  3. A、训练决策树的过程就是构建决策树的过程
  4.  
  5. B、ID3算法是根据信息增益来构建决策树
  6.  
  7. C、C4.5算法是根据基尼系数来构建决策树
  8.  
  9. D、决策树模型的可理解性不高
  10.  
  11.  
  12. 2、下列说法错误的是？(A)
  13.  
  14. A、从树的根节点开始，根据特征的值一步一步走到叶子节点的过程是决策树做决策的过程
  15.  
  16. B、决策树只能是一棵二叉树
  17.  
  18. C、根节点所代表的特征是最优特征
 

 

第2关：信息熵与信息增益
 

任务描述
 

本关任务：掌握什么是信息增益，完成计算信息增益的程序设计。
 

相关知识
 

为了完成本关任务，你需要掌握：
 

  •  
    信息熵；
     
  •  
    条件熵；
     
  •  
    信息增益。
     
 

信息熵
 

信息是个很抽象的概念。人们常常说信息很多，或者信息较少，但却很难说清楚信息到底有多少。比如一本五十万字的中文书到底有多少信息量。
 

直到1948年，香农提出了“信息熵”的概念，才解决了对信息的量化度量问题。信息熵这个词是香农从热力学中借用过来的。热力学中的热熵是表示分子状态混乱程度的物理量。香农用信息熵的概念来描述信源的不确定度。信源的不确定性越大，信息熵也越大。
 

从机器学习的角度来看，信息熵表示的是信息量的期望值。如果数据集中的数据需要被分成多个类别，则信息量I(xi​)的定义如下(其中xi​表示多个类别中的第i个类别，p(xi​)数据集中类别为xi​的数据在数据集中出现的概率表示)：
 

I(Xi​)=−log2​p(xi​)
 

由于信息熵是信息量的期望值，所以信息熵H(X)的定义如下(其中n为数据集中类别的数量)：
 

H(X)=−sumi=1n​p(xi​)log2​p(xi​)
 

从这个公式也可以看出，如果概率是0或者是1的时候，熵就是0（因为这种情况下随机变量的不确定性是最低的）。那如果概率是0.5，也就是五五开的时候，此时熵达到最大，也就是1。（就像扔硬币，你永远都猜不透你下次扔到的是正面还是反面，所以它的不确定性非常高）。所以呢，熵越大，不确定性就越高。
 

条件熵
 

在实际的场景中，我们可能需要研究数据集中某个特征等于某个值时的信息熵等于多少，这个时候就需要用到条件熵。条件熵H(Y|X)表示特征X为某个值的条件下，类别为Y的熵。条件熵的计算公式如下：
 

H(Y∣X)=sumi=1n​pi​H(Y∣X=xi​)
 

当然条件熵的性质也和熵的性质一样，概率越确定，条件熵就越小，概率越五五开，条件熵就越大。
 

信息增益
 

现在已经知道了什么是熵，什么是条件熵。接下来就可以看看什么是信息增益了。所谓的信息增益就是表示我已知条件X后能得到信息Y的不确定性的减少程度。
 

就好比，我在玩读心术。你心里想一件东西，我来猜。我已开始什么都没问你，我要猜的话，肯定是瞎猜。这个时候我的熵就非常高。然后我接下来我会去试着问你是非题，当我问了是非题之后，我就能减小猜测你心中想到的东西的范围，这样其实就是减小了我的熵。那么我熵的减小程度就是我的信息增益。
 

所以信息增益如果套上机器学习的话就是，如果把特征A对训练集D的信息增益记为g(D, A)的话，那么g(D, A)的计算公式就是：
 

g(D,A)=H(D)−H(D,A)
 

为了更好的解释熵，条件熵，信息增益的计算过程，下面通过示例来描述。假设我现在有这一个数据集，第一列是编号，第二列是性别，第三列是活跃度，第四列是客户是否流失的标签（0表示未流失，1表示流失）。
 

编号性别活跃度是否流失
1男高0
2女中0
3男低1
4女高0
5男高0
6男中0
7男中1
8女中0
9女低1
10女中0
11女高0
12男低1
13女低1
14男高0
15男高0
 

假如要算性别和活跃度这两个特征的信息增益的话，首先要先算总的熵和条件熵。总的熵其实非常好算，就是把标签作为随机变量X。上表中标签只有两种（0和1）因此随机变量X的取值只有0或者1。所以要计算熵就需要先分别计算标签为0的概率和标签为1的概率。从表中能看出标签为0的数据有10条，所以标签为0的概率等于2/3。标签为1的概率为1/3。所以熵为：
 

−(1/3)∗log(1/3)−(2/3)∗log(2/3)=0.9182
 

接下来就是条件熵的计算，以性别为男的熵为例。表格中性别为男的数据有8条，这8条数据中有3条数据的标签为1，有5条数据的标签为0。所以根据条件熵的计算公式能够得出该条件熵为：
 

−(3/8)∗log(3/8)−(5/8)∗log(5/8)=0.9543
 

根据上述的计算方法可知，总熵为：
 

−(5/15)∗log(5/15)−(10/15)∗log(10/15)=0.9182
 

性别为男的熵为：
 

−(3/8)∗log(3/8)−(5/8)∗log(5/8)=0.9543
 

性别为女的熵为：
 

−(2/7)∗log(2/7)−(5/7)∗log(5/7)=0.8631
 

活跃度为低的熵为：
 

−(4/4)∗log(4/4)−0=0
 

活跃度为中的熵为：
 

−(1/5)∗log(1/5)−(4/5)∗log(4/5)=0.7219
 

活跃度为高的熵为：
 

−0−(6/6)∗log(6/6)=0
 

现在有了总的熵和条件熵之后就能算出性别和活跃度这两个特征的信息增益了。
 

**性别的信息增益=总的熵-(8/15)性别为男的熵-(7/15)性别为女的熵=0.0064
 

**活跃度的信息增益=总的熵-(6/15)*活跃度为高的熵-(5/15)活跃度为中的熵-(4/15)活跃度为低的熵=0.6776
 

那信息增益算出来之后有什么意义呢？回到读心术的问题，为了我能更加准确的猜出你心中所想，我肯定是问的问题越好就能猜得越准！换句话来说我肯定是要想出一个信息增益最大（减少不确定性程度最高）的问题来问你。其实ID3算法也是这么想的。ID3算法的思想是从训练集D中计算每个特征的信息增益，然后看哪个最大就选哪个作为当前结点。然后继续重复刚刚的步骤来构建决策树。
 

编程要求
 

根据提示，在右侧编辑器补充代码，完成calcInfoGain函数实现计算信息增益。
 

calcInfoGain函数中的参数:
 

  •  
    feature：测试用例中字典里的feature，类型为ndarray；
     
  •  
    label：测试用例中字典里的label，类型为ndarray；
     
  •  
    index：测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益。
     
 

测试说明
 

平台会对你编写的代码进行测试，期望您的代码根据输入来输出正确的信息增益，以下为其中一个测试用例：
 

测试输入： {'feature':[[0, 1], [1, 0], [1, 2], [0, 0], [1, 1]], 'label':[0, 1, 0, 0, 1], 'index': 0}
 

预期输出： 0.419973
 

提示： 计算log可以使用NumPy中的log2函数
 

  1. import numpy as np
  2.  
  3.  
  4. def calcInfoGain(feature, label, index):
  5.     '''
  6.     计算信息增益
  7.     :param feature:测试用例中字典里的feature，类型为ndarray
  8.     :param label:测试用例中字典里的label，类型为ndarray
  9.     :param index:测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益。
  10.     :return:信息增益，类型float
  11.     ''' 
  12.  
  13.     #*********** Begin ***********#
  14.  
  15.     # 计算熵
  16.     def calcInfoEntropy(feature, label):
  17.         '''
  18.         计算信息熵
  19.         :param feature:数据集中的特征，类型为ndarray
  20.         :param label:数据集中的标签，类型为ndarray
  21.         :return:信息熵，类型float
  22.         '''
  23.  
  24.         label_set = set(label)
  25.         result = 0
  26.         for l in label_set:
  27.             count = 0
  28.             for j in range(len(label)):
  29.                 if label[j] == l:
  30.                     count += 1
  31.             # 计算标签在数据集中出现的概率
  32.             p = count / len(label)
  33.             # 计算熵
  34.             result -= p * np.log2(p)
  35.         return result
  36.  
  37.     # 计算条件熵
  38.     def calcHDA(feature, label, index, value):
  39.         '''
  40.         计算信息熵
  41.         :param feature:数据集中的特征，类型为ndarray
  42.         :param label:数据集中的标签，类型为ndarray
  43.         :param index:需要使用的特征列索引，类型为int
  44.         :param value:index所表示的特征列中需要考察的特征值，类型为int
  45.         :return:信息熵，类型float
  46.         '''
  47.         count = 0
  48.         # sub_feature和sub_label表示根据特征列和特征值分割出的子数据集中的特征和标签
  49.         sub_feature = []
  50.         sub_label = []
  51.         for i in range(len(feature)):
  52.             if feature[i][index] == value:
  53.                 count += 1
  54.                 sub_feature.append(feature[i])
  55.                 sub_label.append(label[i])
  56.         pHA = count / len(feature)
  57.         e = calcInfoEntropy(sub_feature, sub_label)
  58.         return pHA * e
  59.  
  60.     base_e = calcInfoEntropy(feature, label)
  61.     f = np.array(feature)
  62.     # 得到指定特征列的值的集合
  63.     f_set = set(f[:, index])
  64.     sum_HDA = 0
  65.     # 计算条件熵
  66.     for value in f_set:
  67.         sum_HDA += calcHDA(feature, label, index, value)
  68.     # 计算信息增益
  69.     return base_e - sum_HDA
  70.     #*********** End *************#
  71.  
 

第3关：使用ID3算法构建决策树
 

任务描述
 

本关任务：补充python代码，完成DecisionTree类中的fit和predict函数。
 

相关知识
 

为了完成本关任务，你需要掌握：
 

  •  
    ID3算法构造决策树的流程；
     
  •  
    如何使用构造好的决策树进行预测。
     
 

ID3算法
 

ID3算法其实就是依据特征的信息增益来构建树的。其大致步骤就是从根结点开始，对结点计算所有可能的特征的信息增益，然后选择信息增益最大的特征作为结点的特征，由该特征的不同取值建立子结点，然后对子结点递归执行上述的步骤直到信息增益很小或者没有特征可以继续选择为止。
 

因此，ID3算法伪代码如下：
 

 

  1. #假设数据集为D，标签集为A，需要构造的决策树为tree
  2. def ID3(D, A):
  3. if D中所有的标签都相同:
  4. return 标签
  5. if 样本中只有一个特征或者所有样本的特征都一样:
  6. 对D中所有的标签进行计数
  7. return 计数最高的标签
  9. 计算所有特征的信息增益
  10. 选出增益最大的特征作为最佳特征(best_feature)
  11. 将best_feature作为tree的根结点
  12. 得到best_feature在数据集中所有出现过的值的集合(value_set)
  13. for value in value_set:
  14. 从D中筛选出best_feature=value的子数据集(sub_feature)
  15. 从A中筛选出best_feature=value的子标签集(sub_label)
  16. #递归构造tree
  17. tree[best_feature][value] = ID3(sub_feature, sub_label)
  18. return tree
 

使用决策树进行预测
 

决策树的预测思想非常简单，假设现在已经构建出了一棵用来决策是否买西瓜的决策树。
 

 

并假设现在在水果店里有这样一个西瓜，其属性如下：
 

瓤是否够红够不够冰是否便宜是否有籽
是否是否
 

那买不买这个西瓜呢？只需把西瓜的属性代入决策树即可。决策树的根结点是瓤是否够红，所以就看西瓜的属性，经查看发现够红，因此接下来就看够不够冰。而西瓜不够冰，那么看是否便宜。发现西瓜是便宜的，所以这个西瓜是可以买的。
 

因此使用决策树进行预测的伪代码也比较简单，伪代码如下：
 

 

  1. #tree表示决策树，feature表示测试数据
  2. def predict(tree, feature):
  3. if tree是叶子结点:
  4. return tree
  5. 根据feature中的特征值走入tree中对应的分支
  6. if 分支依然是课树:
  7. result = predict(分支, feature)
  8. return result
 

编程要求
 

填写fit(self, feature, label)函数，实现ID3算法，要求决策树保存在self.tree中。其中：
 

  •  
    feature：训练集数据，类型为ndarray，数值全为整数；
     
  •  
    label：训练集标签，类型为ndarray，数值全为整数。
     
 

填写predict(self, feature)函数，实现预测功能，并将标签返回，其中：
 

  • feature：测试集数据，类型为ndarray，数值全为整数。（PS：feature中有多条数据）
 

测试说明
 

只需完成fit与predict函数即可，程序内部会调用您所完成的fit函数构建模型并调用predict函数来对数据进行预测。预测的准确率高于0.92视为过关。(PS:若self.tree is None则会打印决策树构建失败)
 

  1. import numpy as np
  2.  
  3. class DecisionTree(object):
  4.     def __init__(self):
  5.         #决策树模型
  6.         self.tree = {}
  7.  
  8.     def calcInfoGain(self, feature, label, index):
  9.         '''
  10.         计算信息增益
  11.         :param feature:测试用例中字典里的feature，类型为ndarray
  12.         :param label:测试用例中字典里的label，类型为ndarray
  13.         :param index:测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益。
  14.         :return:信息增益，类型float
  15.         '''
  16.  
  17.         # 计算熵
  18.         def calcInfoEntropy(label):
  19.             '''
  20.             计算信息熵
  21.             :param label:数据集中的标签，类型为ndarray
  22.             :return:信息熵，类型float
  23.             '''
  24.  
  25.             label_set = set(label)
  26.             result = 0
  27.             for l in label_set:
  28.                 count = 0
  29.                 for j in range(len(label)):
  30.                     if label[j] == l:
  31.                         count += 1
  32.                 # 计算标签在数据集中出现的概率
  33.                 p = count / len(label)
  34.                 # 计算熵
  35.                 result -= p * np.log2(p)
  36.             return result
  37.  
  38.         # 计算条件熵
  39.         def calcHDA(feature, label, index, value):
  40.             '''
  41.             计算信息熵
  42.             :param feature:数据集中的特征，类型为ndarray
  43.             :param label:数据集中的标签，类型为ndarray
  44.             :param index:需要使用的特征列索引，类型为int
  45.             :param value:index所表示的特征列中需要考察的特征值，类型为int
  46.             :return:信息熵，类型float
  47.             '''
  48.             count = 0
  49.             # sub_feature和sub_label表示根据特征列和特征值分割出的子数据集中的特征和标签
  50.             sub_feature = []
  51.             sub_label = []
  52.             for i in range(len(feature)):
  53.                 if feature[i][index] == value:
  54.                     count += 1
  55.                     sub_feature.append(feature[i])
  56.                     sub_label.append(label[i])
  57.             pHA = count / len(feature)
  58.             e = calcInfoEntropy(sub_label)
  59.             return pHA * e
  60.  
  61.         base_e = calcInfoEntropy(label)
  62.         f = np.array(feature)
  63.         # 得到指定特征列的值的集合
  64.         f_set = set(f[:, index])
  65.         sum_HDA = 0
  66.         # 计算条件熵
  67.         for value in f_set:
  68.             sum_HDA += calcHDA(feature, label, index, value)
  69.         # 计算信息增益
  70.         return base_e - sum_HDA
  71.  
  72.     # 获得信息增益最高的特征
  73.     def getBestFeature(self, feature, label):
  74.         max_infogain = 0
  75.         best_feature = 0
  76.         for i in range(len(feature[0])):
  77.             infogain = self.calcInfoGain(feature, label, i)
  78.             if infogain > max_infogain:
  79.                 max_infogain = infogain
  80.                 best_feature = i
  81.         return best_feature
  82.  
  83.     def createTree(self, feature, label):
  84.         # 样本里都是同一个label没必要继续分叉了
  85.         if len(set(label)) == 1:
  86.             return label[0]
  87.         # 样本中只有一个特征或者所有样本的特征都一样的话就看哪个label的票数高
  88.         if len(feature[0]) == 1 or len(np.unique(feature, axis=0)) == 1:
  89.             vote = {}
  90.             for l in label:
  91.                 if l in vote.keys():
  92.                     vote[l] += 1
  93.                 else:
  94.                     vote[l] = 1
  95.             max_count = 0
  96.             vote_label = None
  97.             for k, v in vote.items():
  98.                 if v > max_count:
  99.                     max_count = v
  100.                     vote_label = k
  101.             return vote_label
  102.  
  103.         # 根据信息增益拿到特征的索引
  104.         best_feature = self.getBestFeature(feature, label)
  105.         tree = {best_feature: {}}
  106.         f = np.array(feature)
  107.         # 拿到bestfeature的所有特征值
  108.         f_set = set(f[:, best_feature])
  109.         # 构建对应特征值的子样本集sub_feature, sub_label
  110.         for v in f_set:
  111.             sub_feature = []
  112.             sub_label = []
  113.             for i in range(len(feature)):
  114.                 if feature[i][best_feature] == v:
  115.                     sub_feature.append(feature[i])
  116.                     sub_label.append(label[i])
  117.             # 递归构建决策树
  118.             tree[best_feature][v] = self.createTree(sub_feature, sub_label)
  119.         return tree
  120.  
  121.     def fit(self, feature, label):
  122.         '''
  123.         :param feature: 训练集数据，类型为ndarray
  124.         :param label:训练集标签，类型为ndarray
  125.         :return: None
  126.         '''
  127.  
  128.         #************* Begin ************#
  129.         self.tree = self.createTree(feature, label)
  130.         #************* End **************#
  131.  
  132.     def predict(self, feature):
  133.         '''
  134.         :param feature:测试集数据，类型为ndarray
  135.         :return:预测结果，如np.array([0, 1, 2, 2, 1, 0])
  136.         '''
  137.  
  138.         #************* Begin ************#
  139.         result = []
  140.  
  141.         def classify(tree, feature):
  142.             if not isinstance(tree, dict):
  143.                 return tree
  144.             t_index, t_value = list(tree.items())[0]
  145.             f_value = feature[t_index]
  146.             if isinstance(t_value, dict):
  147.                 classLabel = classify(tree[t_index][f_value], feature)
  148.                 return classLabel
  149.             else:
  150.                 return t_value
  151.  
  152.         for f in feature:
  153.             result.append(classify(self.tree, f))
  154.  
  155.         return np.array(result)
  156.         #************* End **************#
  157.  
 

 

第4关：信息增益率
 

任务描述
 

本关任务：根据本关所学知识，完成calcInfoGainRatio函数。
 

相关知识
 

为了完成本关任务，你需要掌握：信息增益率
 

信息增益率
 

由于在使用信息增益这一指标进行划分时，更喜欢可取值数量较多的特征。为了减少这种偏好可能带来的不利影响，Ross Quinlan使用了信息增益率这一指标来选择最优划分属性。
 

信息增益率的数学定义为如下，其中D表示数据集，a表示数据集中的某一列，Gain(D,a)表示D中a的信息增益，V表示a这一列中取值的集合，v表示V中的某种取值，∣D∣表示D中样本的数量，∣Dv∣表示D中a这一列中值等于v的数量。
 

Gain_ratio(D,a)=−v=1∑V​∣D∣∣Dv∣​log2​∣D∣∣Dv∣​Gain(D,a)​
 

从公式可以看出，信息增益率很好算，只是用信息增益除以另一个分母，该分母通常称为固有值。举个例子，还是使用第二关中提到过的数据集，第一列是编号，第二列是性别，第三列是活跃度，第四列是客户是否流失的标签（0表示未流失，1表示流失）。
 

编号性别活跃度是否流失
1男高0
2女中0
3男低1
4女高0
5男高0
6男中0
7男中1
8女中0
9女低1
10女中0
11女高0
12男低1
13女低1
14男高0
15男高0
 

根据第二关已经知道性别的信息增益为0.0064，设a为性别，则有Gain(D,a)=0.0064。由根据数据可知，V=2，假设当v=1时表示性别为男，v=2时表示性别为女，则有∣D∣=15，∣D1∣=8，∣D2∣=7。因此根据信息增益率的计算公式可知Gainr​atio(D,a)=0.0642。同理可以算出活跃度的信息增益率为0.4328。
 

编程要求
 

根据提示，在右侧编辑器补充代码，完成calcInfoGainRatio函数实现计算信息增益。
 

calcInfoGainRatio函数中的参数:
 

  •  
    feature：测试用例中字典里的feature，类型为ndarray；
     
  •  
    label：测试用例中字典里的label，类型为ndarray；
     
  •  
    index：测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益率。
     
 

测试说明
 

平台会对你编写的代码进行测试，期望您的代码根据输入来输出正确的信息增益，以下为其中一个测试用例：
 

测试输入： {'feature':[[0, 1], [1, 0], [1, 2], [0, 0], [1, 1]], 'label':[0, 1, 0, 0, 1], 'index': 0}
 

预期输出： 0.432538
 

提示： 计算log可以使用NumPy中的log2函数.
 

  1. import numpy as np
  2.  
  3. def calcInfoGain(feature, label, index):
  4.     '''
  5.     计算信息增益
  6.     :param feature:测试用例中字典里的feature，类型为ndarray
  7.     :param label:测试用例中字典里的label，类型为ndarray
  8.     :param index:测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益。
  9.     :return:信息增益，类型float
  10.     '''
  11.     # 计算熵
  12.     def calcInfoEntropy(label):
  13.         '''
  14.         计算信息熵
  15.         :param label:数据集中的标签，类型为ndarray
  16.         :return:信息熵，类型float
  17.         '''
  18.  
  19.         label_set = set(label)
  20.         result = 0
  21.         for l in label_set:
  22.             count = 0
  23.             for j in range(len(label)):
  24.                 if label[j] == l:
  25.                     count += 1
  26.             # 计算标签在数据集中出现的概率
  27.             p = count / len(label)
  28.             # 计算熵
  29.             result -= p * np.log2(p)
  30.         return result
  31.  
  32.     # 计算条件熵
  33.     def calcHDA(feature, label, index, value):
  34.         '''
  35.         计算信息熵
  36.         :param feature:数据集中的特征，类型为ndarray
  37.         :param label:数据集中的标签，类型为ndarray
  38.         :param index:需要使用的特征列索引，类型为int
  39.         :param value:index所表示的特征列中需要考察的特征值，类型为int
  40.         :return:信息熵，类型float
  41.         '''
  42.         count = 0
  43.         # sub_feature和sub_label表示根据特征列和特征值分割出的子数据集中的特征和标签
  44.         sub_feature = []
  45.         sub_label = []
  46.         for i in range(len(feature)):
  47.             if feature[i][index] == value:
  48.                 count += 1
  49.                 sub_feature.append(feature[i])
  50.                 sub_label.append(label[i])
  51.         pHA = count / len(feature)
  52.         e = calcInfoEntropy(sub_label)
  53.         return pHA * e
  54.  
  55.     base_e = calcInfoEntropy(label)
  56.     f = np.array(feature)
  57.     # 得到指定特征列的值的集合
  58.     f_set = set(f[:, index])
  59.     sum_HDA = 0
  60.     # 计算条件熵
  61.     for value in f_set:
  62.         sum_HDA += calcHDA(feature, label, index, value)
  63.     # 计算信息增益
  64.     return base_e - sum_HDA
  65.  
  66.  
  67.  
  68. def calcInfoGainRatio(feature, label, index):
  69.     '''
  70.     计算信息增益率
  71.     :param feature:测试用例中字典里的feature，类型为ndarray
  72.     :param label:测试用例中字典里的label，类型为ndarray
  73.     :param index:测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益。
  74.     :return:信息增益率，类型float
  75.     '''
  76.  
  77.     #********* Begin *********#
  78.     info_gain = calcInfoGain(feature, label, index)
  79.     unique_value = list(set(feature[:, index]))
  80.     IV = 0
  81.     for value in unique_value:
  82.         len_v = np.sum(feature[:, index] == value)
  83.         IV -= (len_v/len(feature))*np.log2((len_v/len(feature)))
  84.     return info_gain/IV
  85.     #********* End *********#
  86.  
 

第5关：基尼系数
 

 

任务描述
 

本关任务：根据本关所学知识，完成calcGini函数。
 

相关知识
 

为了完成本关任务，你需要掌握：基尼系数。
 

基尼系数
 

在ID3算法中我们使用了信息增益来选择特征，信息增益大的优先选择。在C4.5算法中，采用了信息增益率来选择特征，以减少信息增益容易选择特征值多的特征的问题。但是无论是ID3还是C4.5,都是基于信息论的熵模型的，这里面会涉及大量的对数运算。能不能简化模型同时也不至于完全丢失熵模型的优点呢？当然有！那就是基尼系数！
 

CART算法使用基尼系数来代替信息增益率，基尼系数代表了模型的不纯度，基尼系数越小，则不纯度越低，特征越好。这和信息增益与信息增益率是相反的(它们都是越大越好)。
 

基尼系数的数学定义为如下，其中D表示数据集，pk​表示D中第k个类别在D中所占比例。
 

Gini(D)=1−sumk=1∣y∣​pk2​
 

从公式可以看出，相比于信息增益和信息增益率，计算起来更加简单。举个例子，还是使用第二关中提到过的数据集，第一列是编号，第二列是性别，第三列是活跃度，第四列是客户是否流失的标签（0表示未流失，1表示流失）。
 

编号性别活跃度是否流失
1男高0
2女中0
3男低1
4女高0
5男高0
6男中0
7男中1
8女中0
9女低1
10女中0
11女高0
12男低1
13女低1
14男高0
15男高0
 

从表格可以看出，D中总共有2个类别，设类别为0的比例为p1​，则有p1​=1510​。设类别为1的比例为p2​，则有p2​=155​。根据基尼系数的公式可知Gini(D)=1−(p12​+p22​)=0.4444。
 

上面是基于数据集D的基尼系数的计算方法，那么基于数据集D与特征a的基尼系数怎样计算呢？其实和信息增益率的套路差不多。计算公式如下：
 

Gini(D,a)=sumv=1V​∣D∣∣Dv∣​Gini(Dv)
 

还是以用户流失的数据为例，现在算一算性别的基尼系数。设性别男为v=1，性别女为v=2则有∣D∣=15，∣D1∣=8，∣D2∣=7，Gini(D1)=0.46875，Gini(D2)=0.40816。所以Gini(D,a)=0.44048。
 

编程要求
 

根据提示，在右侧编辑器补充代码，完成calcGini函数实现计算信息增益。
 

calcGini函数中的参数:
 

  •  
    feature：测试用例中字典里的feature，类型为ndarray；
     
  •  
    label：测试用例中字典里的label，类型为ndarray；
     
  •  
    index：测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算基尼系数。
     
 

测试说明
 

平台会对你编写的代码进行测试，期望您的代码根据输入来输出正确的信息增益，以下为其中一个测试用例：
 

测试输入： {'feature':[[0, 1], [1, 0], [1, 2], [0, 0], [1, 1]], 'label':[0, 1, 0, 0, 1], 'index': 0}
 

预期输出： 0.266667
 

  1. import numpy as np
  2.  
  3. def calcGini(feature, label, index):
  4.     '''
  5.     计算基尼系数
  6.     :param feature:测试用例中字典里的feature，类型为ndarray
  7.     :param label:测试用例中字典里的label，类型为ndarray
  8.     :param index:测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益。
  9.     :return:基尼系数，类型float
  10.     '''
  11.  
  12.     #********* Begin *********#
  13.     def _gini(label):
  14.         unique_label = list(set(label))
  15.         gini = 1
  16.         for l in unique_label:
  17.             p = np.sum(label == l)/len(label)
  18.             gini -= p**2
  19.         return gini
  20.     unique_value = list(set(feature[:, index]))
  21.     gini = 0
  22.     for value in unique_value:
  23.         len_v = np.sum(feature[:, index] == value)
  24.         gini += (len_v/len(feature))*_gini(label[feature[:, index] == value])
  25.     return gini
  26.     #********* End *********#
  27.  
 

第6关：预剪枝与后剪枝
 

任务描述
 

本关任务：补充python代码，完成DecisionTree类中的fit和predict函数。
 

相关知识
 

为了完成本关任务，你需要掌握：
 

  •  
    为什么需要剪枝；
     
  •  
    预剪枝；
     
  •  
    后剪枝。
     
 

为什么需要剪枝
 

决策树的生成是递归地去构建决策树，直到不能继续下去为止。这样产生的树往往对训练数据有很高的分类准确率，但对未知的测试数据进行预测就没有那么准确了，也就是所谓的过拟合。
 

决策树容易过拟合的原因是在构建决策树的过程时会过多地考虑如何提高对训练集中的数据的分类准确率，从而会构建出非常复杂的决策树（树的宽度和深度都比较大）。在之前的实训中已经提到过，模型的复杂度越高，模型就越容易出现过拟合的现象。所以简化决策树的复杂度能够有效地缓解过拟合现象，而简化决策树最常用的方法就是剪枝。剪枝分为预剪枝与后剪枝。
 

预剪枝
 

预剪枝的核心思想是在决策树生成过程中，对每个结点在划分前先进行一个评估，若当前结点的划分不能带来决策树泛化性能提升，则停止划分并将当前结点标记为叶结点。
 

想要评估决策树算法的泛化性能如何，方法很简单。可以将训练数据集中随机取出一部分作为验证数据集，然后在用训练数据集对每个结点进行划分之前用当前状态的决策树计算出在验证数据集上的正确率。正确率越高说明决策树的泛化性能越好，如果在划分结点的时候发现泛化性能有所下降或者没有提升时，说明应该停止划分，并用投票计数的方式将当前结点标记成叶子结点。
 

举个例子，假如上一关中所提到的用来决定是否买西瓜的决策树模型已经出现过拟合的情况，模型如下：
 

 

假设当模型在划分是否便宜这个结点前，模型在验证数据集上的正确率为0.81。但在划分后，模型在验证数据集上的正确率降为0.67。此时就不应该划分是否便宜这个结点。所以预剪枝后的模型如下：
 

 

 

从上图可以看出，预剪枝能够降低决策树的复杂度。这种预剪枝处理属于贪心思想，但是贪心有一定的缺陷，就是可能当前划分会降低泛化性能，但在其基础上进行的后续划分却有可能导致性能显著提高。所以有可能会导致决策树出现欠拟合的情况。
 

后剪枝
 

后剪枝是先从训练集生成一棵完整的决策树，然后自底向上地对非叶结点进行考察，若将该结点对应的子树替换为叶结点能够带来决策树泛化性能提升，则将该子树替换为叶结点。
 

后剪枝的思路很直接，对于决策树中的每一个非叶子结点的子树，我们尝试着把它替换成一个叶子结点，该叶子结点的类别我们用子树所覆盖训练样本中存在最多的那个类来代替，这样就产生了一个简化决策树，然后比较这两个决策树在测试数据集中的表现，如果简化决策树在验证数据集中的准确率有所提高，那么该子树就可以替换成叶子结点。该算法以bottom-up的方式遍历所有的子树，直至没有任何子树可以替换使得测试数据集的表现得以改进时，算法就可以终止。
 

从后剪枝的流程可以看出，后剪枝是从全局的角度来看待要不要剪枝，所以造成欠拟合现象的可能性比较小。但由于后剪枝需要先生成完整的决策树，然后再剪枝，所以后剪枝的训练时间开销更高。
 

编程要求
 

填写fit(self, train_feature, train_label, val_featrue, val_label)函数，实现带后剪枝的ID3算法，要求决策树保存在self.tree中。其中：
 

  •  
    train_feature：训练集数据，类型为ndarray，数值全为整数；
     
  •  
    train_label：训练集标签，类型为ndarray，数值全为整数；
     
  •  
    val_feature：验证集数据，类型为ndarray，数值全为整数；
     
  •  
    val_label：验证集标签，类型为ndarray，数值全为整数。
     
 

填写predict(self, feature)函数，实现预测功能，并将标签返回，其中：
 

  • feature：测试集数据，类型为ndarray，数值全为整数。（PS：feature中有多条数据）
 

测试说明
 

只需完成fit与predict函数即可，程序内部会调用您所完成的fit函数构建模型并调用predict函数来对数据进行预测。预测的准确率高于0.935视为过关。(PS:若self.tree is None则会打印决策树构建失败)
 

  1. import numpy as np
  2. from copy import deepcopy
  3.  
  4. class DecisionTree(object):
  5.     def __init__(self):
  6.         #决策树模型
  7.         self.tree = {}
  8.  
  9.     def calcInfoGain(self, feature, label, index):
  10.         '''
  11.         计算信息增益
  12.         :param feature:测试用例中字典里的feature，类型为ndarray
  13.         :param label:测试用例中字典里的label，类型为ndarray
  14.         :param index:测试用例中字典里的index，即feature部分特征列的索引。该索引指的是feature中第几个特征，如index:0表示使用第一个特征来计算信息增益。
  15.         :return:信息增益，类型float
  16.         '''
  17.  
  18.         # 计算熵
  19.         def calcInfoEntropy(feature, label):
  20.             '''
  21.             计算信息熵
  22.             :param feature:数据集中的特征，类型为ndarray
  23.             :param label:数据集中的标签，类型为ndarray
  24.             :return:信息熵，类型float
  25.             '''
  26.  
  27.             label_set = set(label)
  28.             result = 0
  29.             for l in label_set:
  30.                 count = 0
  31.                 for j in range(len(label)):
  32.                     if label[j] == l:
  33.                         count += 1
  34.                 # 计算标签在数据集中出现的概率
  35.                 p = count / len(label)
  36.                 # 计算熵
  37.                 result -= p * np.log2(p)
  38.             return result
  39.  
  40.         # 计算条件熵
  41.         def calcHDA(feature, label, index, value):
  42.             '''
  43.             计算信息熵
  44.             :param feature:数据集中的特征，类型为ndarray
  45.             :param label:数据集中的标签，类型为ndarray
  46.             :param index:需要使用的特征列索引，类型为int
  47.             :param value:index所表示的特征列中需要考察的特征值，类型为int
  48.             :return:信息熵，类型float
  49.             '''
  50.             count = 0
  51.             # sub_feature和sub_label表示根据特征列和特征值分割出的子数据集中的特征和标签
  52.             sub_feature = []
  53.             sub_label = []
  54.             for i in range(len(feature)):
  55.                 if feature[i][index] == value:
  56.                     count += 1
  57.                     sub_feature.append(feature[i])
  58.                     sub_label.append(label[i])
  59.             pHA = count / len(feature)
  60.             e = calcInfoEntropy(sub_feature, sub_label)
  61.             return pHA * e
  62.  
  63.         base_e = calcInfoEntropy(feature, label)
  64.         f = np.array(feature)
  65.         # 得到指定特征列的值的集合
  66.         f_set = set(f[:, index])
  67.         sum_HDA = 0
  68.         # 计算条件熵
  69.         for value in f_set:
  70.             sum_HDA += calcHDA(feature, label, index, value)
  71.         # 计算信息增益
  72.         return base_e - sum_HDA
  73.  
  74.     # 获得信息增益最高的特征
  75.     def getBestFeature(self, feature, label):
  76.         max_infogain = 0
  77.         best_feature = 0
  78.         for i in range(len(feature[0])):
  79.             infogain = self.calcInfoGain(feature, label, i)
  80.             if infogain > max_infogain:
  81.                 max_infogain = infogain
  82.                 best_feature = i
  83.         return best_feature
  84.  
  85.     # 计算验证集准确率
  86.     def calc_acc_val(self, the_tree, val_feature, val_label):
  87.         result = []
  88.  
  89.         def classify(tree, feature):
  90.             if not isinstance(tree, dict):
  91.                 return tree
  92.             t_index, t_value = list(tree.items())[0]
  93.             f_value = feature[t_index]
  94.             if isinstance(t_value, dict):
  95.                 classLabel = classify(tree[t_index][f_value], feature)
  96.                 return classLabel
  97.             else:
  98.                 return t_value
  99.  
  100.         for f in val_feature:
  101.             result.append(classify(the_tree, f))
  102.  
  103.         result = np.array(result)
  104.         return np.mean(result == val_label)
  105.  
  106.     def createTree(self, train_feature, train_label):
  107.         # 样本里都是同一个label没必要继续分叉了
  108.         if len(set(train_label)) == 1:
  109.             return train_label[0]
  110.         # 样本中只有一个特征或者所有样本的特征都一样的话就看哪个label的票数高
  111.         if len(train_feature[0]) == 1 or len(np.unique(train_feature, axis=0)) == 1:
  112.             vote = {}
  113.             for l in train_label:
  114.                 if l in vote.keys():
  115.                     vote[l] += 1
  116.                 else:
  117.                     vote[l] = 1
  118.             max_count = 0
  119.             vote_label = None
  120.             for k, v in vote.items():
  121.                 if v > max_count:
  122.                     max_count = v
  123.                     vote_label = k
  124.             return vote_label
  125.  
  126.         # 根据信息增益拿到特征的索引
  127.         best_feature = self.getBestFeature(train_feature, train_label)
  128.         tree = {best_feature: {}}
  129.         f = np.array(train_feature)
  130.         # 拿到bestfeature的所有特征值
  131.         f_set = set(f[:, best_feature])
  132.         # 构建对应特征值的子样本集sub_feature, sub_label
  133.         for v in f_set:
  134.             sub_feature = []
  135.             sub_label = []
  136.             for i in range(len(train_feature)):
  137.                 if train_feature[i][best_feature] == v:
  138.                     sub_feature.append(train_feature[i])
  139.                     sub_label.append(train_label[i])
  140.  
  141.             # 递归构建决策树
  142.             tree[best_feature][v] = self.createTree(sub_feature, sub_label)
  143.  
  144.         return tree
  145.  
  146.     # 后剪枝
  147.     def post_cut(self, val_feature, val_label):
  148.         # 拿到非叶子节点的数量
  149.         def get_non_leaf_node_count(tree):
  150.             non_leaf_node_path = []
  151.  
  152.             def dfs(tree, path, all_path):
  153.                 for k in tree.keys():
  154.                     if isinstance(tree[k], dict):
  155.                         path.append(k)
  156.                         dfs(tree[k], path, all_path)
  157.                         if len(path) > 0:
  158.                             path.pop()
  159.                     else:
  160.                         all_path.append(path[:])
  161.  
  162.             dfs(tree, [], non_leaf_node_path)
  163.  
  164.             unique_non_leaf_node = []
  165.             for path in non_leaf_node_path:
  166.                 isFind = False
  167.                 for p in unique_non_leaf_node:
  168.                     if path == p:
  169.                         isFind = True
  170.                         break
  171.                 if not isFind:
  172.                     unique_non_leaf_node.append(path)
  173.             return len(unique_non_leaf_node)
  174.  
  175.         # 拿到树中深度最深的从根节点到非叶子节点的路径
  176.         def get_the_most_deep_path(tree):
  177.             non_leaf_node_path = []
  178.  
  179.             def dfs(tree, path, all_path):
  180.                 for k in tree.keys():
  181.                     if isinstance(tree[k], dict):
  182.                         path.append(k)
  183.                         dfs(tree[k], path, all_path)
  184.                         if len(path) > 0:
  185.                             path.pop()
  186.                     else:
  187.                         all_path.append(path[:])
  188.  
  189.             dfs(tree, [], non_leaf_node_path)
  190.  
  191.             max_depth = 0
  192.             result = None
  193.             for path in non_leaf_node_path:
  194.                 if len(path) > max_depth:
  195.                     max_depth = len(path)
  196.                     result = path
  197.             return result
  198.  
  199.         # 剪枝
  200.         def set_vote_label(tree, path, label):
  201.             for i in range(len(path)-1):
  202.                 tree = tree[path[i]]
  203.             tree[path[len(path)-1]] = vote_label
  204.  
  205.         acc_before_cut = self.calc_acc_val(self.tree, val_feature, val_label)
  206.         # 遍历所有非叶子节点
  207.         for _ in range(get_non_leaf_node_count(self.tree)):
  208.             path = get_the_most_deep_path(self.tree)
  209.  
  210.             # 备份树
  211.             tree = deepcopy(self.tree)
  212.             step = deepcopy(tree)
  213.  
  214.             # 跟着路径走
  215.             for k in path:
  216.                 step = step[k]
  217.  
  218.             # 叶子节点中票数最多的标签
  219.             vote_label = sorted(step.items(), key=lambda item: item[1], reverse=True)[0][0]
  220.  
  221.             # 在备份的树上剪枝
  222.             set_vote_label(tree, path, vote_label)
  223.  
  224.             acc_after_cut = self.calc_acc_val(tree, val_feature, val_label)
  225.  
  226.             # 验证集准确率高于0.9才剪枝
  227.             if acc_after_cut > acc_before_cut:
  228.                 set_vote_label(self.tree, path, vote_label)
  229.                 acc_before_cut = acc_after_cut
  230.  
  231.  
  232.  
  233.     def fit(self, train_feature, train_label, val_feature, val_label):
  234.         '''
  235.         :param train_feature:训练集数据，类型为ndarray
  236.         :param train_label:训练集标签，类型为ndarray
  237.         :param val_feature:验证集数据，类型为ndarray
  238.         :param val_label:验证集标签，类型为ndarray
  239.         :return: None
  240.         '''
  241.  
  242.         #************* Begin ************#
  243.         self.tree = self.createTree(train_feature, train_label)
  244.         # 后剪枝
  245.         self.post_cut(val_feature, val_label)
  246.         #************* End **************#
  247.  
  248.     def predict(self, feature):
  249.         '''
  250.         :param feature:测试集数据，类型为ndarray
  251.         :return:预测结果，如np.array([0, 1, 2, 2, 1, 0])
  252.         '''
  253.  
  254.         #************* Begin ************#
  255.         result = []
  256.  
  257.         # 单个样本分类
  258.         def classify(tree, feature):
  259.             if not isinstance(tree, dict):
  260.                 return tree
  261.             t_index, t_value = list(tree.items())[0]
  262.             f_value = feature[t_index]
  263.             if isinstance(t_value, dict):
  264.                 classLabel = classify(tree[t_index][f_value], feature)
  265.                 return classLabel
  266.             else:
  267.                 return t_value
  268.  
  269.         for f in feature:
  270.             result.append(classify(self.tree, f))
  271.  
  272.         return np.array(result)
  273.         #************* End **************#
  274.  
 

第7关：鸢尾花识别
 

 

任务描述
 

本关任务：使用sklearn完成鸢尾花分类任务。
 

相关知识
 

为了完成本关任务，你需要掌握如何使用sklearn提供的DecisionTreeClassifier。
 

数据简介
 

 

 

鸢尾花数据集是一类多重变量分析的数据集。通过花萼长度，花萼宽度，花瓣长度，花瓣宽度4个属性预测鸢尾花卉属于(Setosa，Versicolour，Virginica)三个种类中的哪一类(其中分别用0，1，2代替)。
 

数据集中部分数据与标签如下图所示：
 

 

 

 

 

DecisionTreeClassifier
 

DecisionTreeClassifier的构造函数中有两个常用的参数可以设置：
 

  • criterion:划分节点时用到的指标。有gini（基尼系数）,entropy(信息增益)。若不设置，默认为gini
  • max_depth:决策树的最大深度，如果发现模型已经出现过拟合，可以尝试将该参数调小。若不设置，默认为None
 

和sklearn中其他分类器一样，DecisionTreeClassifier类中的fit函数用于训练模型，fit函数有两个向量输入：
 

  •  
    X：大小为[样本数量,特征数量]的ndarray，存放训练样本；
     
  •  
    Y：值为整型，大小为[样本数量]的ndarray，存放训练样本的分类标签。
     
 

DecisionTreeClassifier类中的predict函数用于预测，返回预测标签，predict函数有一个向量输入：
 

  • X：大小为[样本数量,特征数量]的ndarray，存放预测样本。
 

DecisionTreeClassifier的使用代码如下：
 

 

  1. from sklearn.tree import DecisionTreeClassifier
  3. clf = tree.DecisionTreeClassifier()
  4. clf.fit(X_train, Y_train)
  5. result = clf.predict(X_test)
 

编程要求
 

补充python代码，实现鸢尾花数据的分类任务，其中训练集数据保存在./step7/train_data.csv中，训练集标签保存在。./step7/train_label.csv中，测试集数据保存在。./step7/test_data.csv中。请将对测试集的预测结果保存至。./step7/predict.csv中。这些csv文件可以使用pandas读取与写入。
 

注意：当使用pandas读取完csv文件后，请将读取到的DataFrame转换成ndarray类型。这样才能正常的使用fit和predict。
 

示例代码：
 

 

  1. import pandas as pd
  3. # as_matrix()可以将DataFrame转换成ndarray
  4. # 此时train_df的类型为ndarray而不是DataFrame
  5. train_df = pd.read_csv('train_data.csv').as_matrix()
 

数据文件格式如下图所示:
 

 

 

标签文件格式如下图所示:
 

 

 

PS：predict.csv文件的格式必须与标签文件格式一致。
 

测试说明
 

只需将结果保存至./step7/predict.csv即可，程序内部会检测您的代码，预测准确率高于0.95视为过关。
 

  1. #********* Begin *********#
  2. import pandas as pd
  3. from sklearn.tree import DecisionTreeClassifier
  4.  
  5. train_df = pd.read_csv('./step7/train_data.csv').as_matrix()
  6. train_label = pd.read_csv('./step7/train_label.csv').as_matrix()
  7. test_df = pd.read_csv('./step7/test_data.csv').as_matrix()
  8.  
  9. dt = DecisionTreeClassifier()
  10. dt.fit(train_df, train_label)
  11. result = dt.predict(test_df)
  12.  
  13. result = pd.DataFrame({'target':result})
  14. result.to_csv('./step7/predict.csv', index=False)
  15.  
  16. #********* End *********#
  17.  
 


                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/643505
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号