Python实现及可视化决策树

一，背景及理论

1.1 前言

1. 本文将针对ID3算法进行决策树的构建
2. 因数据全是离散变量，因此本文不考虑连续变量离散化的思路，其实非常简单，有兴趣可以去百度。
3. 本文所使用数据集规模较小，因此不考虑划分训练与测试集。
4. 本文仅介绍最基本的算法实现以及基本理论，关于其他优化树结构的奇淫巧计在此不深挖。
5. 关于所有第三方库的安装配置与使用问题可以直接私聊博主。
6. 若发现本文中出现任何错误请在评论区及时支持，感谢！

以下为本项目所有用到的开发资源：
开发环境: python3.7, pycharm
数据处理库：pandas，numpy
可视化库：graphviz
项目代码与数据集: 项目代码与数据集

文章写于2020疫情期间，现在才发，懒狗实锤。

1.2 算法简介

决策树(Decision Tree)是一种机器学习方法。是一种树形结构，其中每个内部节点表示一种分类特征，每个分支表示该特征的判断情况。每个叶子节点表示一种分类结果。

决策树是一种非常常用的分类方法，是一种监督学习方法，通过给定一堆训练样本(每个样本包含一组特征和一个结果)，通过决策树算法的学习就可以得到一个决策树模型，这个模型就可以针对之后用户给出的数据进行正确的分类。

1.3 算法理论依据(建议配合示例学习)

1.3.1 ID3算法

核心思想是利用信息熵原理选择信息增益最大的特征作为分类属性，递归拓展决策树分支，从而完成决策树的构造。

1.3.2 信息熵

熵(entropy)表示随机变量不确定性，熵越大，变量的不确定性就越大：

举个不是特别恰当但通俗的例子：一把烟在烟盒中它们位置的熵就很小，因为他们位置确定性高，但是当这一盒烟掉在地上，烟掉的到处都是的时候，它的熵就变大了，也就代表他们位置的不确定性增加了。

熵的计算公式如下：

$$Entropy=-\sum _{i=1}^n{p}_i\ast \log (p_i)$$
其中$p_i$表示类$i$的数量占比(本项目中总共分两类:好瓜和坏瓜)。通过公式结合之前提到过熵的意义。不难想到，当好瓜和坏瓜各占一半时，此时的熵最大，而当所有瓜都是好瓜或者坏瓜的时候，熵最小。

1.3.3信息增益

用信息增益表示当前节点分裂前后根的数据复杂度和分裂节点数据复杂度的变化值。

信息增益计算公式如下:

$$InfoGain=Entropy(D)-\sum _{i=1}^n\frac{|D_i|}{|D|}Entropy(D_i)$$

公式中$D$代表父节点,$D_i$表示叶子节点。公式看起来比较抽象，我用我的理解来解释一下：

要明确信息增益这个概念，首先我们要明确分类问题的目的:即通过一组特征从而判断对象的类别。
那么在我们刚拿到这一组特征的时候，是否可以把他看成不确定性很大，即熵很高的数据呢。答案是肯定的，而决策树的过程其实就是通过不断降低熵值，使结果越来越确定的过程。

那么，如何使每一次算法执行都能最大化的降低熵，增加确定性呢？

信息增益的概念就诞生了，从公式上看：信息熵等于父节点的熵值减去所有子节点的条件熵(即对于父样本的条件下子节点的熵值，这里建议配合下文示例一起理解)，也就可以理解为这一次的节点分裂使熵值降低了多少。总的来说
信息增益是衡量每一次节点分裂所带来的确定性提高的量化指标。
我们每次计算的信息增益是针对于某一个特征而言的，但一个物体肯定不止一个特征，于是在构造决策树的过程中，我们每一次都将计算所有特征的信息增益，然后找到信息增益最大的特征进行分裂，这样也使得每一次构造决策树节点的收益是最大的。

1.4 算法示例

从以上表格我们可以看出一个西瓜的好坏可以通过$色泽,根蒂,敲声,纹理,脐部,触感$进行判断。

根据算法流程，构造决策树我们就要先计算信息每个特征的信息增益，以色泽为例，计算方法如下：

首先对于其根节点，总共17个样本，其中好样本8个，坏样本9个，则父节点的熵值:

$$\begin{array}{r}Entropy(D)=-\sum _{i=1}^n{p}_i\ast \log (p_i)=-(\frac{8}{17}\ast log(\frac{8}{17})+\frac{9}{17}\ast log(\frac{9}{17}))=0.9967\end{array}$$

接着统计其三个子节点的样本及对应结果个数：

青绿：好样本3个，坏样本3个，$D_{青绿}：6$
乌黑：好样本4个，坏样本2个，$D_{乌黑}：6$
浅白：好样本1个，坏样本4个，$D_{浅白}：5$

接下来计算子节点的条件熵值(以青绿为例):
$$\begin{gathered} Entropy(D_{青绿})=-\frac{|D_{青绿}|}{|D|}\ast \sum _{i=1}^n{p}_i\ast \log (p_i)=-\frac{6}{17}\ast (\frac{3}{6}\ast \log (\frac{3}{6})+\frac{3}{6}\ast \log (\frac{3}{6}))=0.352 \\ Entropy(D_{乌黑})=0.324 \\ Entropy(D_{浅白})=0.212 \end{gathered}$$

最后可通过信息增益计算公式计算出信息增益:
$$InfoGai{n}_{色泽}=Entropy(D)-Entropy(D_{青绿})-Entropy(D_{乌黑})-Entropy(D_{浅白})=0.1087$$
假设当前以色泽特征作为节点进行分裂，即色泽的信息增益是当前所有特征中最高的（实际是纹理特征）。

节点分裂图如下：

![色泽节点分裂图][3]
色泽特征包含三种属性$青绿,乌黑,浅白$，所以将出现三个分支继续分裂，而下一次分裂的特征是哪一个需要根据拆分后的数据集进行下一次的信息增益计算，用这样的方式进行循环，直到所有的属性被使用完毕得到分类结果后停止循环。

最终生成的决策树如下:

二，代码详解

2.1 类的成员变量介绍

    # 读取Excel数据文件的位置
    data_path = ""

    # 不带序号和标题的所有数据
    data = []

    # 训练数据，只有特征（暂时没使用，后期数据量大后可扩展）
    train_data = []

    # 训练数据的标签集合
    train_label = []

    # 特征及特征可能出现的情况
    feature_map = {}

    # 所有可能出现的标签值
    label_map = []

    # 所有标签名，对应Excel表头
    feature_name = {}

    # 绘制决策树所需节点颜色
    feature_color = {}

data_path: 读取的数据集文件位置，暂时只支持Excel文件，且规定数据集第一列为序号，最后一列为标签。

data: 不带标题(色泽，根蒂…)以及序号的所有数据，也是本文主要使用的数据集。

train_data: 不包含标签的纯特征数据，本意是在划分训练和测试集时使用，本文中因数据量较小暂时无用。

train_label: 对应训练集的标签，本文暂时无用

// 存储所有特征及其包含的属性种类
{
  0:["青绿", "乌黑", "浅白"],
  1:["蜷缩", "稍蜷", "硬挺"],
  2:["浊响", "沉闷"],
  3:["清晰", "稍糊", "模糊"],
  4:["凹陷", "稍凹", "平坦"],
  6:["硬滑", "软黏"]
}

# 所有可能出现的标签值
label_map = ["是", "否"]

# 所有特征索引对应的特征名
{
  0:"色泽",
  1:"根蒂",
  2:"敲声",
  3:"纹理",
  4:"脐部",
  6:"触感"
}

# 特征所对应的颜色(在后期可视化时，用于绘制节点)
{
  0:"red",
  1:"blue",
  2:"yellow",
  3:"orange",
  4:"yellow",
  6:"pink"
}

2.2 类的方法

2.2.1 构造方法

构造器加载了所有可能用到的数据，为成员变量提供了初始化数据，在创建类时只需要提供数据集所在的Excel表格路径即可。值得一提的是，在构造器中提供了决策树self.tree的初始化，这里是为了方便直接通过类的实例进行调用，其实也可以在外部自己通过createTree创建决策树。tree在前面的成员变量中并没有进行介绍，因此将在后面详细讨论tree的结构。

    def __init__(self, data_path):
        self.data_path = data_path
        self.data = self.load_dataset()
        self.train_data = self.data[:, :-1]
        self.train_label = self.data[:, -1]
        color = ["red", "blue", "yellow", "orange", "black", "pink", "green"]
        self.feature_color = dict(zip([i for i in range(len(self.train_data[0]))],
                                      [color[i] for i in range(len(self.train_data[0]))]))
        self.feature_map = self.load_feature_map()
        self.label_map = self.load_label_map()
        self.feature_name = self.load_feature_name()

        self.tree = self.createTree(self.data, [i for i in self.feature_map.keys()])

2.2.2 数据加载方法

这里都是关于pandas以及numpy的一些基本操作，没有特别重要的点，因此不再赘述。

      # 加载除编号外所有数据
        def load_dataset(self):
            df = pd.read_excel(self.data_path)
            return df.to_numpy()[:, 1:]
    
        # 加载特征名
        def load_feature_name(self):
            name = list(pd.read_excel(self.data_path).keys()[1:-1])
            re = dict(zip([i for i in range(len(name))], name))
            return re
    
        # 加载特征，以及所有可能出现的特征
        def load_feature_map(self):
            feature = list(pd.read_excel(self.data_path).keys())[1:-1]
            feature_map = dict(zip([i for i in range(len(feature))],
                           [[] for i in range(len(feature))]))
    
            for i in range(len(feature)):
                for j in self.data[:, i]:
                    if j not in feature_map[i]:
                        feature_map[i].append(j)
    
            return feature_map
    
        # 加载所有标签种类
        def load_label_map(self):
            label_map = []
            for i in self.train_label:
                if i not in label_map:
                    label_map.append(i)
            return label_map

2.2.3 创建树(核心)

createTree方法是本项目最核心的部分，其最主要的思想就是通过递归，每一次递归根据当前的子数据集(subDataset)以及剩余未使用的特征值(restFeatures)来计算每个特征的信息增益，并比较出信息增益最大的特征作为下一个节点进行分裂。而currentFeatureType以及currentFeatureName两个属性可以表示当前处于哪一个节点(特征)下的哪一个分支(属性)，以此来防止当子数据集为空时找不到当前位置的问题。

算法主要步骤：

1，判断是否可以直接输出叶子节点(结果)

• 当子数据集为空时，则在总数据集中找到当前对应属性下的所有标签值，返回出现的最多的标签(例:当前处于色泽[“浅白”]，可是在之前层层的拆分下，子数据集中已经不存在[“浅白”]属性的样本，那么就对于总数据集来说，色泽为浅白的样本个数为5，其中1个为好瓜，4个为坏瓜，所以这时直接输出叶子节点判断它为坏瓜)
• 当某一属性所对应的样本标签全都一样的时候，直接返回叶子节点(例:当前处于纹理[“模糊”]，纹理为模糊的所有样本都是坏瓜，我们就可以直接判断，只要纹理是模糊的都是坏瓜，这样大大降低了决策树结构的复杂性，也提高了分类的泛化能力，从某种意义上降低了过拟合所带来的风险。)
• 当处于只剩下一个特征，而其他特征都分裂完成的情况时，直接返回这最后一个特征所对应最多的标签值即可。

2, 因为通过以上判断仍未输出结果，于是可断言需要继续创建子树

• 循环计算所有剩余特征的信息增益。
• 找出最大信息增益的特征，将它移出restFeatures。
• 通过循环，遍历该特征下的所有分支，并且拆分父数据集。
• 针对分支继续创建子树。

   """
   @:param subDataset (ndarray类型) 子决策树所包含的样本
   @:param restFeatures (List类型) 剩下未划分的特征
   @:param currentFeatureType (int类型) 当前划分的特征类型
   @:param currentFeatureName (string类型) 当前划分的特征类型名
   
   @:return tempTree (dict类型) 决策树
   """
   def createTree(self, subDataset, restFeatures, currentFeatureType=None, currentFeatureName=None):
   
       dataset = subDataset
       featureList = restFeatures.copy()
   
       # 当前节点无数据时，直接通过整体数据集判断最有可能出现的标签值
       if len(subDataset) == 0:
           result = dict(zip(self.label_map, [0 for i in range(len(self.label_map))]))
           for item in self.data:
               if item[currentFeatureType] == currentFeatureName:
                   result[item[-1]] += 1
           maxValue = max(result.values())
           for item in result:
               if result[item] == maxValue:
                   return item
   
       # 当某一属性对应的标签值全部相同时，直接返回标签值，可以以此方法剪枝，降低决策树的复杂度
       if np.sum(subDataset[:, -1] == subDataset[:,-1][0]) == len(subDataset):
           return subDataset[:,-1][0]
   
       # 当只剩下最后一个特征，返回单节点树
       if len(featureList) == 0:
           resultList = []
           for i in self.label_map:
               resultList.append(np.sum(dataset[:, -1] == i))
           resultList = np.array(resultList)
           maxPos = resultList.argmax()
           return self.label_map[maxPos]
   
       # 计算当前所剩余的所有特征的信息增益
       gainList = []
       for i in featureList:
           gainList.append(self.calInfoGain(dataset, i))
       print(gainList)
   
       # 找到最大信息增益特征，并且更新剩余特征表
       gainList = np.array(gainList)
       maxGainPos = gainList.argmax()
       maxFeatureType = featureList[maxGainPos]
       del featureList[maxGainPos]
   
       tempTree = {}
       tempTree["feature"] = maxFeatureType
   
       # 以最大信息增益特征为下一节点，对当前特征所有选项递归创建子树
       for i in self.feature_map[maxFeatureType]:
           tempTree[i] = self.createTree(self.splitDataset(dataset, i, maxFeatureType), featureList, maxFeatureType, i)
   
       return tempTree

其中返回值tempTree是字典类型，本文中决策树的数据类型是由字典嵌套来实现的，tempTree结构如下：

    {
      'feature': 3, 
      '清晰': 
      {
        'feature': 1, 
        '蜷缩': '是', 
        '稍蜷': 
        {
          'feature': 0, 
          '青绿': '是', 
          '乌黑': 
          {
            'feature': 5, 
            '硬滑': '是', 
            '软黏': '否',
          }, 
          '浅白': '是',
        }, 
        '硬挺': '否',
      }, 
      '稍糊': 
      {
        'feature': 5, 
        '硬滑': '否', 
        '软黏': '是',
      }, 
      '模糊': '否',
    }

每一层包含一个"feature"字段表示当前节点特征的索引值，然后包含该特征的所有分支所连接的下一节点。
若下一节点类型仍然是字典类型，则说明将继续分裂。
若下一节点类型是string类型，说明找到了分类结果。

2.2.4 计算信息增益

以下是计算信息增益所使用的方法，具体信息增益计算公式方法与原理都在上文出现，在此不赘述，其他一些相关信息可看代码注释。

    """
    @:param subDataset (ndarray类型) 将要划分的数据集
    @:param featureType (int类型) 当前将要计算的特征类型
    
    @:return 计算的信息增益结果
    """
    # 计算信息增益
    def calInfoGain(self, subDataset, featureType):
        result = 0
        labelCount = self.featureCount(subDataset, featureType)

        for i in labelCount.keys():
            result += self.calEntropy("Child",subDataset, labelCount[i])

        return self.calEntropy("Parent", subDataset) - result

    # 计算信息熵
    """
    @:param calType (string类型) 计算模式:"Parent":计算父节点的熵, "Child":计算子节点的熵
    @:param subDataset (ndarray类型) 当前数据集
    @:param labelCount (dict类型) 记录当前类型所对应标签的出现次数。key:标签名(string), value:标签出现次数(int)
    
    @:return result 熵值(float类型)
    """
    def calEntropy(self, calType, subDataset, labelCount=None):
        result = 0
        itemSize = 0

        if calType == "Parent":
            labelCount = dict(zip(self.label_map,
                                  [0 for i in range(len(self.label_map))]))

            for item in subDataset:
                labelCount[item[-1]] += 1

        for i in self.label_map:
            itemSize += labelCount[i]
        for i in self.label_map:
            if labelCount[i] == 0:
                continue
            else:
                pi = labelCount[i] / itemSize
            result = result - (pi * log(pi, 2))
        return itemSize / len(subDataset) * result

    # 计算特征对应种类数
    """
    @:param subDataset (ndarray类型) 当前数据集
    @:param featureType (int类型) 当前统计的数据类型
    
    @:return featureCount(dict类型) 该类型特征下所有属性名对应的标签出现次数
    """
    def featureCount(self, subDataset, featureType):
        currentType = self.feature_map[featureType]
        featureCount = {}
        for i in currentType:
            featureCount[i] = dict(zip(self.label_map,
                                    [0 for i in range(len(self.label_map))]))
        for item in subDataset:
            featureCount[item[featureType]][item[-1]] += 1
        return featureCount

这里解释一下几个参数结构，首先是featureCount方法，输入参数是子数据集以及当前所统计的特征，而返回的是该类型特征下所有属性名对应的标签出现次数，具体结构如下:

    // 以色泽为例
    {
      '青绿': {
        '是': 3, 
        '否': 3
      }, 
      '乌黑': {
        '是': 4, 
        '否': 2
      }, 
      '浅白': {
      '是': 1, 
      '否': 4
      }
    }

而在calInfoGain方法中获取到featureCount后，循环遍历所有属性，将labelCount传给calEntropy进行计算，也就是这里的：

    //以色泽["青绿"]为例
    {
       '是': 3, 
       '否': 3
    }

2.2.5 工具方法

一些辅助方法，其中划分子集的方法在每一次递归调用时使用，预测结果方法可以用当前tree模型对输入特征进行预测得到结果。而计算树的叶子节点与深度暂时并未用上。

 # 划分子集
 """
 @:param subDataset (ndarray类型) 将要划分的数据集
 @:param subFeatureName (string类型) 将要划分的特征名
 @:param maxFeatureType (int类型) 将要划分的特征类型，由最大信息增益得到
 
 @:return tempDataset (ndarray类型) 划分后的数据集
 """
 
 def splitDataset(self, subDataset, subFeatureName, maxFeatureType):
     tempDataset = []
     for i in range(len(subDataset)):
         if subDataset[i][maxFeatureType] == subFeatureName:
             tempDataset.append(subDataset[i])
     tempDataset = np.array(tempDataset)
     return tempDataset

 # 预测结果
 """
 @:param feature (list类型) 用户输入的待测特征
 @:param tree (dict类型) 决策树模型
 
 @:return result(string类型) 预测结果
 """
 def classify(self, feature, tree):
     # 对决策树进行搜索，若当前特征对应的是结果则直接返回，若当前特征对应的是子树继续遍历
     if type(tree[feature[tree["feature"]]]) == type({}):
         result = self.classify(feature, tree[feature[tree["feature"]]])
     else:
         return tree[feature[tree["feature"]]]
     return result

 # 获取树的叶子节点个数（暂时未用上）
 def getNumberLeafs(self, tree):
     number = 0
     currentFeatureType = tree["feature"]
     for i in self.feature_map[currentFeatureType]:
         if type(tree[i]) == type({}):
             number += self.getNumberLeafs(tree[i])
         else:
             number = number + 1
     return number

 # 获取树的深度（暂时未用上）
 def getTreeDepth(self, tree):
     depth = 1
     maxDepth = 0
     currentFeatureType = tree["feature"]
     for i in self.feature_map[currentFeatureType]:
         if type(tree[i]) == type({}):
             depth += self.getTreeDepth(tree[i])
         else:
             depth = 1
         if depth >= maxDepth:
             maxDepth = depth

     return maxDepth
     ```
#### 2.2.6 决策树可视化
关于这里可视化部分的代码，更多的是对于graphviz函数库的使用，该知识点与本文主要内容无关，所以我就直接贴代码了，关于函数库的安装，配置，使用或者说源码部分有不理解的位置欢迎私聊。
```python
 # 绘制决策树图像
 def showTree(self, tree):
     g = Digraph("DecisionTree")
     fileName = "DecisionTree.gv"
     self.createNode(tree, g, 0, "1")
     g.view(fileName)

 # 创建决策树节点，用于绘制图像
 """
 @:param tree (dict类型) 决策树模型
 @:param graph (Digraph类型) 用于存放当前的图
 @:param depth (int类型) 当前绘制的深度
 @:param id (int类型) 当前深度下的节点唯一标识符
 
 Tips:不会在外部直接调用，由类自己调用
 """
 def createNode(self, tree, graph, depth, id):
     currentFeatureType = tree["feature"]
     currentFeatureName = self.feature_name[currentFeatureType]
     if depth == 0:
         graph.node(name=currentFeatureName + str(depth) + id,
                    color=self.feature_color[currentFeatureType],
                    fontname="Microsoft YaHei",
                    label=currentFeatureName)

     count = 1
     for i in self.feature_map[currentFeatureType]:
         if type(tree[i]) == type({}):
             nextFeature = tree[i]["feature"]
             graph.node(name=self.feature_name[nextFeature] + str(depth + 1) + str(count),
                        color=self.feature_color[nextFeature],
                        fontname="Microsoft YaHei",
                        label=self.feature_name[nextFeature]
                        )
             graph.edge(currentFeatureName + str(depth) + id,
                        self.feature_name[nextFeature] + str(depth + 1) + str(count),
                        color="green",
                        label=i,
                        fontname="Microsoft YaHei")
             self.createNode(tree[i], graph, depth + 1, str(count))
         else:
             graph.node(name=tree[i] + str(depth + 1) + str(count),
                        color="purple",
                        fontname="Microsoft YaHei",
                        label=tree[i]
                        )
             graph.edge(currentFeatureName + str(depth) + id,
                        tree[i] + str(depth + 1) + str(count),
                        color="green",
                        label=i,
                        fontname="Microsoft YaHei"
                        )
         count += 1

可视化结构如下:

三,总结

本文只是给出了关于决策树最基本的构建方法，并未涉及过多的优化策略。现如今有很多更好的节点选取方案，而且根据不同的环境，也应当选取不一样方法。但是万变不离其宗，学会学好最基本的部分，之后怎么改变问题都不大。然后就是因为数据量的问题，没机会建立一个完整的训练-测试的分类器结构，但其实也很简单，只不过是多使用点数据工程的技巧，本质上还是不会有太多变换。

遗憾的是因为考研这段时间项目代码写的都比较急，更多注重于功能的实现，有些架构方面的问题并未过多考虑，所以可能存在一定的代码冗余以及过度耦合的情况，将来有时间的话，我应该会继续优化。

我看了看这篇文章，我已经尽可能的把每个我认为不好理解的点用最白的话讲出来了，而且在学习中踩过的坑我也尽量解释(函数库调用除外)，但造成的结果就是感觉篇幅太长，应该不会有人静下心来看看，之后还是得好好权衡一下。