机器学习（Machine Learning）——第4章 决策树

4.1 基本流程

  决策树是基于树模型做决策。一般的，一棵决策树包含一个根结点、若干个内部结点和若干个叶结点；叶结点对应于决策结果，其他每个结点则对应于一个属性测试；每个结点包含的样本集合根据属性测试的结果被划分到子结点中；根结点包含样本全集。
  从根结点到每个叶结点的路径对应了一个判定测试序列。决策树学习的目的是为了产生一棵泛化能力强，即处理未见示例能力强的决策树。
  根据表4-1可生成如图4-1所示的决策树。

表4-1 西瓜数据集

图4-1 决策树样例

  如上所述，图4-1决策树每一个通往叶子结点的路径就是一条判断序列。例如对于表4-1中的第1个样本，从决策树根结点出发，判断“纹理”特征，1号样本纹理为“清晰”，进入纹理结点最左侧的子结点中，接着判断“根蒂”，1号样本根蒂为“蜷缩”，进入根蒂结点最左侧的子结点中，该子结点为叶子结点，因此得到1号样本的预测结果为“好瓜”。
  根据训练集样本生成一棵决策树的算法，如图4-2所示。

图4-2 决策树学习基本算法

  决策树的生成是一个递归过程。简单得说，生成决策树主要分为两个部分。
  ① 特征选择： 特征选择是指从当前结点所拥有的特征中选择一个特征$a$作为当前结点的划分标准，一般特征选择的策略将直接影响决策树算法的性能。此步骤对应图4-2中TreeGenerate过程的第8步。
  ② 生成子结点： 按照当前结点所包含的训练样本数据在属性$a$上的取值将训练样本分成若干类，每一类作为当前结点的子结点所具有的数据样本。然后对未划分的结点进行考察，递归地进行属性选择和数据样本划分。
  例如，对于表4-1中的17个样本，我们选择“纹理”属性对数据集进行划分，得到三个数据子集，分别是：清晰（1,2,3,4,5,6,8,10,15），稍糊（7,9,13,14,17），模糊（11,12,16）。生成三个子结点，将这三个子集分别分到对应的子结点中，就形成了图4-3所示的二层决策树。然后递归处理，对新生成的三个子结点执行同样的操作（注意：新生成的三个子结点不包含属性“纹理”）。

图4-3 基于“纹理”属性对根结点划分

  
  在图4-2所示的算法流程中，有三种情形会导致递归返回。
  （1）当前结点所包含的样本全属于同一类别，无需划分；
  （2）当前属性集为空，或是所有样本在所有属性上取值相同，无法划分；
  （3）当前结点包含的样本集合为空，不能划分。
  对于情况（1），很好理解，当前结点所包含的样本全部属于同一类别，即使进行划分生成子树，该结点的子树所有叶结点也只能属于同一类别，这样做是没有意义的。
  对于情况（2），属性集为空，则没有特征可供选择，划分没有依据；所有样本在所有属性上取值相同，则划分出的集合只有一个（它本身，相当于没有划分）。对于此种情况，直接把当前结点标记为叶结点，并将其类别设定为该结点所含样本最多的类别。
  对于情况（3），直接把当前结点标记为叶结点，其类别为父结点所含样本最多的类别。

4.2 划分选择

  此小节主要介绍特征选择部分选择特征的原则（“特征”和“属性”是一个意思）。一般而言，随着划分过程不断进行，我们希望决策树的分支结点所包含的样本尽可能属于同一类别，即结点的“纯度”越来越高。
  常用三种指标来作为选择特征进行划分的依据。

4.2.1 信息增益

  信息熵： 度量样本集合纯度最常用的一种指标。假定当前样本集合$D$中第$k$类样本所占的比例为$p_k(k=1,2,...,|y|)$，则$D$的信息熵定义为
$$\begin{array}{r}Ent(D)=-\sum _{k=1}^{|y|}{p}_k\ast lo{g}_2{p}_k\end{array}$$
$Ent(D)$值越小，则$D$的纯度越高。
  信息增益： 假定离散属性$a$有$V$个可能的取值 { a 1 , a 2 , . . . , a V } \{a^1,a^2,...,a^V\} {a1,a2,...,aV}（例如表4-1中“纹理”属性有：清晰、稍糊、模糊，三个取值） ，若使用$a$来对样本集$D$进行划分，则会产生$V$个分支结点，其中第$v$个分支结点包含了$D$中所有在属性$a$上取值为$a^v$的样本，记为$D^v$（例如图4-3）。$|D^v|$表示集合$D^v$包含样本的数量，则数据集$D$在属性$a$上的信息增益定义为
$$\begin{array}{r}Gain(D,a)=Ent(D)-\sum _{v=1}^V\frac{|D^v|}{|D|}Ent(D^v)\end{array}$$
  以表4-1的西瓜数据集为例，数据集记为D。D中样本分为两类，则$|y|=2$，好瓜占$\frac{8}{17}$，坏瓜占$\frac{9}{17}$。因此$D$的信息熵为
$$\begin{array}{r}Ent(D)=-\sum _{k=1}^2{p}_k\ast lo{g}_2{p}_k=-(\frac{8}{17}\ast lo{g}_2\frac{8}{17}+\frac{9}{17}\ast lo{g}_2\frac{9}{17})=0.998\end{array}$$
  以属性“色泽”为例，使用色泽属性对$D$进行划分，则得到3个子集：$D^1(色泽=青绿)$，$D^2(色泽=乌黑)$，$D^3(色泽=浅白)$。
  分别计算$D^1,D^2,D^3$的信息熵
$$\begin{array}{r}Ent(D^1)=-(\frac{3}{6}\ast lo{g}_2\frac{3}{6}+\frac{3}{6}\ast lo{g}_2\frac{3}{6})=1.000\end{array}$$
$$\begin{array}{r}Ent(D^2)=-(\frac{4}{6}\ast lo{g}_2\frac{4}{6}+\frac{2}{6}\ast lo{g}_2\frac{2}{6})=0.918\end{array}$$
$$\begin{array}{r}Ent(D^3)=-(\frac{1}{5}\ast lo{g}_2\frac{1}{5}+\frac{4}{5}\ast lo{g}_2\frac{4}{5})=0.722\end{array}$$
  计算属性“色泽”在数据集$D$上的信息增益为：
$$\begin{array}{r}Gain(D,色泽)=Ent(D)-\sum _{v=1}^3\frac{|D^v|}{|D|}Ent(D^v)=0.998-(\frac{6}{17}\ast 1.000+\frac{6}{17}\ast 0.918+\frac{5}{17}\ast 0.722)=0.109\end{array}$$
  同理，计算出其他属性（根蒂、敲声、纹理、脐部、触感）的信息增益，从中选出信息增益最大的属性$a$划分数据集$D$。信息增益越大，意味着使用属性$a$来进行划分所获得的“纯度提升”越大。
  信息增益准则对可取值数目较多的属性有所偏好。

4.2.2 增益率

  定义属性$a$在数据集$D$上的“增益率”为
$$\begin{array}{r}Gain\_ratio(D,a)=\frac{Gain(D,a)}{IV(a)}\end{array}$$
其中
$$\begin{array}{r}IV(a)=-\sum _{v=1}^V\frac{|D^v|}{|D|}\ast lo{g}_2\frac{|D^v|}{|D|}\end{array}$$
  属性$a$的可能取值数目越多（即$V$越大），$IV(a)$的值通常越大。
  增益率准则对可取值数目较少的属性有所偏好。因此，增益率常与信息增益结合使用：先从候选划分属性中找出信息增益高于平均水平的属性，再从中选择增益率最高的。

4.2.3 基尼指数

  定义数据集$D$的基尼值为
$$\begin{array}{r}Gini(D)=\sum _{k=1}^{|y|}\sum _{k^{\prime }\ne k}{p}_k{p}_{k^{\prime }}=1-\sum _{k=1}^{|y|}{p}_k^2\end{array}$$
  $Gini(D)$反映了从数据集$D$中随机抽取两个样本，其类别标记不一致的概率。$Gini(D)$越小，数据集$D$纯度越高。
  定义属性$a$在数据集$D$上的基尼指数为
$$\begin{array}{r}Gini\_index(D,a)=\sum _{v=1}^V\frac{|D^v|}{|D|}Gini(D^v)\end{array}$$
  选择基尼指数最小的属性作为最优划分属性。

4.2.4 小结

表4-2 信息增益，增益率及基尼指数总结

指标	确定最优划分属性	偏好	经典决策树算法
信息增益	取最大值对应属性	偏好可取值数目较多的属性	ID3
增益率	取最大值对应属性	偏好可取值数目较少的属性	C4.5
基尼指数	取最小值对应属性	——	CART

4.2.5 决策树代码实现

  使用Python语言从底层实现决策树的学习算法、预测新样本等功能。未使用机器学习库，以便能帮助自己更好的理解算法细节。使用信息增益作为选择最优划分属性的依据。

# -*- coding: utf-8 -*-
"""
Created on Sat Nov 21 19:22:06 2020

@author: qiqi
"""

import math
import random
from collections import Counter

class TreeNode(object):
    
    def __init__(self):
        '''
        IsLeaf:当前结点是否为叶子结点
        C:当前结点标签类别，仅当IsLeaf为True时才有意义
        a:当前结点判断的属性
        Sons:当前结点子结点字典，通过a的取值作为key访问
        
        Returns
        -------
        None.

        '''
        self.IsLeaf = False
        self.C = None
        self.a = None
        self.Sons = dict()
        
class DecisionTree(object):
    
    def __init__(self, AValue=dict(), Attribute=[]):
        '''
        Parameters
        ----------
        AValue : TYPE, optional
            记录每个属性的可以取哪些值. The default is dict().
        Attribute : TYPE, optional
            数据集属性/特征列表. The default is [].

        Returns
        -------
        None.

        '''
        self.AValue = AValue
        self.Attribute = Attribute
    
    def __CalClassNum(self, D):
        #计算数据集D中的样本类别数，其中D为二维列表，最后一列是类别标签
        s = set()
        D = list(D)
        for d in D:
            s.add(d[-1])
        return len(s)
    
    def __Same(self, D, A):
        #判断D中样本在A属性上取值是否相同。A为属性列表，A中某个属性在A的下标i，与D中第i列数据对应
        for a in A:
            s = set()
            for d in D:
                s.add(d[self.Attribute.index(a)])
            if len(s) > 1:
                return False
        return True
    
    def __CalMax(self, D):
        #计算数据集D中样本数最多的类别
        C = [d[-1] for d in D] #从D中的每一行取最后一个元素，得到每个样本的类别
        dic = Counter(C) #统计C中每个元素出现的次数，返回一个字典
        _, result = max(zip(dic.values(), dic.keys()))
        return result
    
    def __Ent(self, D):
        #计算信息熵
        C = [d[-1] for d in D] #从D中的每一行取最后一个元素，得到每个样本的类别
        dic = Counter(C) #统计C中每个元素出现的次数，返回一个字典
        rate = list(dic.values())
        Sum = 0
        for r in rate:
            Sum += (r/len(D)) * math.log2(r/len(D))
        return -Sum
    
    def __Gain(self, D, A, a):
        #计算属性a在数据集D上的信息增益
        EntD = self.__Ent(D)
        Gain = 0
        for a_v in self.AValue[a]:
            #将数据集D按照属性a的取值分为若干部分
            D_v = self.__GetSubset(D, A, a, a_v)
            Gain += (len(D_v)/len(D)) * self.__Ent(D_v)
        Gain = EntD - Gain
        return Gain
    
    def __SplitA(self, D, A):
        #计算数据集D对A中每个属性的信息增益或增益率或基尼指数作为评价值，选择最大评价值对应的属性
        Max = 0
        result = A[0]
        for a in A:
            e = self.__Gain(D, A, a)
            if e > Max:
                Max = e
                result = a
        return result
    
    def __GetSubset(self, D, A, a, a_v):
        #计算数据集D中在某一属性a上取值为a_v的样本子集，记为D_v
        D_v = []
        for d in D:
            if d[self.Attribute.index(a)] == a_v:
                D_v.append(d)
        return D_v
    
    def CalAValue(self, D, A):
        #计算属性集A中每个属性在数据集D中的取值，返回一个字典，字典key为属性，value为取值集合
        AValue = dict()
        for a in A:
            s = set()
            for d in D:
                s.add(d[A.index(a)])
            AValue[a] = s
        return AValue
        
    def TreeGenerate(self, D=None, A=None):
        node = TreeNode()  #生成结点node
        if self.__CalClassNum(D) == 1:
            #D中样本全属于同一类别C，将node标记为C类叶结点
            C = D[0][-1]
            node.IsLeaf = True
            node.C = C
            return node
        elif A is None or len(A)==0 or self.__Same(D, A):
            #当前属性集A为空,或者D中样本在A上取值相同，将node标记为叶结点，
            #其类别标记为D中样本数最多的类别
            node.IsLeaf = True
            node.C = self.__CalMax(D)
            return node
        else:
            #从A中选择最优划分属性a
            #对a的每一个值a_v为node生成一个分支，令D_v表示D中在a上取值为a_v的样本子集
            #如果D_v为空，将分支结点标记为叶结点，其类别标记为D中样本最多的类别，return
            #如果D_v不为空，以TreeGenerate(D_v, A\{a})为分支结点
            a = self.__SplitA(D, A)
            for a_v in self.AValue[a]:
                D_v = self.__GetSubset(D, A, a, a_v)
                if len(D_v) == 0:
                    son = TreeNode()
                    son.IsLeaf = True
                    son.C = self.__CalMax(D)
                    node.Sons[a_v] = son
                else:
                    A_a = A.copy()
                    A_a.remove(a)
                    son =  self.TreeGenerate(D_v, A_a)
                    node.IsLeaf = False
                    node.a = a
                    node.Sons[a_v] = son
            return node
        
    def Predict(self, root, A, d):
        #预测单个样本d
        if root is not None:
            if root.IsLeaf:
                return root.C
            else:
                return self.Predict(root.Sons[d[A.index(root.a)]], A, d)
        else:
            return None
    
    def Evaluate(self, root, A, D):
        #计算决策树在数据集D上的精度，保留两位小数
        right = 0
        for d in D:
            if self.Predict(root, A, d) == d[-1]:
                right += 1
        return round(right/len(D), 2)
    
    def Dfs(self, root, p, Path):
        #以深度优先遍历方式得到通往每个叶结点的路径
        if root.IsLeaf:
            p += '--' + root.C
            Path.append(p)
        else:
            for a_v in self.AValue[root.a]:
                tp = p
                p += root.a + '?' + '--' + '(' + a_v + ')' + '--'
                self.Dfs(root.Sons[a_v], p, Path)
                p = tp
            
#定义数据集
D = [['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '好瓜'],
     ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', '好瓜'],
     ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '好瓜'],
     ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', '好瓜'],
     ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '好瓜'],
     ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘', '好瓜'],
     ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘', '好瓜'],
     ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑', '好瓜'],
     ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑', '坏瓜'],
     ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘', '坏瓜'],
     ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑', '坏瓜'],
     ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘', '坏瓜'],
     ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑', '坏瓜'],
     ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑', '坏瓜'],
     ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘', '坏瓜'],
     ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑', '坏瓜'],
     ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑', '坏瓜']]

#定义属性集，属性集每个属性的顺序需要与D中取值对应
A = ['色泽', '根蒂', '敲声', '纹理', '脐部', '触感']
random.shuffle(D)  #打乱数据集
train = D[0:10]  #训练集取前10个样本
test = D[10:]  #验证集取剩余样本
Dec = DecisionTree(AValue=dict(), Attribute=A)
Dec.AValue = Dec.CalAValue(D, A)  #计算数据集D中每个属性可以取到什么值
root = Dec.TreeGenerate(train, A)  #使用训练数据训练决策树
print('测试集精度:', Dec.Evaluate(root, A, test))
Path = []
Dec.Dfs(root, '', Path)
print('决策树通向每个叶结点的判断路径如下')
edge = ''
for _ in range(max(len(p) for p in Path)*2): edge += '*'
print(edge)
for i in range(len(Path)): print('路径%d:' % (i), Path[i])
print(edge)

  代码运行结果如图4-4所示。由于训练集和测试集是随机划分的，并且样本数量很少，因此代码运行多次，可能得到的结果相差很大。若使用$D$中全部17个样本训练，则可得到如上面图4-1所示的决策树。图4-4中每条路径对应了决策树由根结点通往每个叶结点的判定序列。

图4-4 代码运行结果

4.3 剪枝处理

  剪枝是决策树学习算法对付“过拟合”的主要手段。决策树剪枝的基本策略有“预剪枝”和“后剪枝”。

4.3.1 预剪枝

  预剪枝是指在决策树生成过程中，对每个结点在划分前先进行估计，若当前结点的划分不能带来决策树泛化性能提升，则停止划分并将当前结点标记为叶结点。
  简单来说，就是在每次对当前结点划分前，计算划分前验证集的精度$a_1$（也可以是其他评价指标），再试探性地对当前结点进行划分，计算试探性划分后验证集精度$a_2$。若$a_1<a_2$，则进行这次划分；若$a_1>a_2$，则不进行此次划分，此试探性划分作废，将当前节点标记为叶结点；若$a_1=a_2$，则划分与不划分两者均可，一般不进行划分，因为这样做可降低生成的决策树的规模，减少预测新样本时的时间开销。划分步骤属性的选择和叶结点类别标记设置的策略与上面讲到的图4-2所示的决策树学习算法一致。
  图4-5所示决策树基于表4-3数据集生成的未剪枝决策树，图4-6所示决策树基于表4-3生成的预剪枝决策树。

表4-3 西瓜数据集划分出的训练集（双线上部）与验证集（双线下部）

图4-5 基于表4-3生成的未剪枝决策树

图4-6 基于表4-3生成的预剪枝决策树

4.3.2 后剪枝

  后剪枝先从训练集生成一棵完整的决策树，然后自底向上地对非叶结点进行考察，若将该结点对应的子树替换为叶结点能够带来决策树泛化性能提升，则将该子树替换为叶结点，叶结点类别标记取当前考察非叶结点包含样本数最多的类别，若有多个类别满足条件，则可从其中任取一个。
  简单来说，就是自底向上依次考察每个非叶结点，计算当前决策树下验证集的精度$a_1$（也可以是其他评价指标），再试探性地把当前结点修改为叶结点，计算试探性修改后整棵决策树验证集精度$a_2$。若$a_1<a_2$，则保存这次试探性修改；若$a_1>a_2$，则撤销此次试探性修改；若$a_1=a_2$，则两者均可，一般保存修改，因为这样做可降低生成的决策树的规模，减少预测新样本时的时间开销，此种情形下验证集精度虽无提高，但根据奥卡姆剃刀准则，剪枝后的模型更好。

图4-7 基于表4-3生成的后剪枝决策树

4.3.3 小结

  预剪枝可以在生成决策树时裁剪掉众多分支，这不仅降低了过拟合风险，还能显著减少决策树训练时间和测试时间开销。但有些分支的当前划分虽不能提升泛化性能、甚至导致泛化性能下降，但在其基础上进行的后续划分却有可能导致性能显著提高。预剪枝基于“贪心”本质禁止某些分支展开，容易造成欠拟合。
  后剪枝 通常比预剪枝保留了更多的分支，后剪枝决策树欠拟合风险很小，泛化性能往往优于预剪枝。但后剪枝在训练决策树时开销远大于预剪枝。一般情况下，如果条件允许的话，还是建议使用后剪枝。

4.4 连续与缺失值

4.4.1 连续值处理

  由于连续属性的可取值数目不再有限，因此，不能直接根据连续属性的可取值来对结点进行划分。此时，需要使用连续属性离散化技术，最简单的策略是采用二分法。
  给定样本集$D$和连续属性$a$，假定$a$在$D$上出现了$n$个不同的取值，将这些值从小到大进行排序，记为 { a 1 , a 2 , … , a n } \{a^1,a^2,…,a^n \} {a1,a2,…,an}。基于划分点$t$可将$D$分为子集$D_t^{-}$和$D_t^{+}$，其中$D_t^{-}$包含那些在属性$a$上取值不大于$t$的样本，而$D_t^{+}$则包含那些在属性$a$上取值大于$t$的样本。
  对连续属性$a$，可考察包含$n-1$个元素的候选划分点集合
T a = { a i + a i + 1 2 ∣ 1 ≤ i ≤ n − 1 } \begin{aligned} T_a=\{\frac{a^i+a^{i+1}}{2} |1 \le i \le n-1\} \end{aligned} Ta​={2ai+ai+1​∣1≤i≤n−1}​
即把区间$[a^i,a^{i+1})$的中位点$\frac{a^i+a^{i+1}}{2}$作为候选划分点，然后使用每个中位点$t$将$a$的属性值划分为两个集合，并计算此种划分后的信息增益$Gain(D,a,t)$，从中选择最大信息增益所对应的划分点对属性$a$进行划分，生成当前结点的子结点。
G a i n ( D , a ) = max ⁡ t ∈ T a G a i n ( D , a , t ) = max ⁡ t ∈ T a E n t ( D ) − ∑ λ ∈ { − , + } ∣ D t λ ∣ ∣ D ∣ E n t ( D t λ ) \begin{aligned} Gain(D,a)=\max_{t\in T_a}Gain(D,a,t)=\max_{t\in T_a}Ent(D)-\sum_{\lambda \in \{-,+\}}\frac{|D_t^\lambda|}{|D|}Ent(D_t^\lambda) \end{aligned} Gain(D,a)=t∈Ta​max​Gain(D,a,t)=t∈Ta​max​Ent(D)−λ∈{−,+}∑​∣D∣∣Dtλ​∣​Ent(Dtλ​)​
其中$Gain(D,a,t)$是数据集$D$基于划分点$t$二分后的信息增益，选择是$Gain(D,a,t)$最大化的划分点。
  例如，对于一组数据共$6$个样本，某一个属性$a$取值有$6$种，分别为 { 1 , 2 , 3 , 4 , 5 , 6 } \{1,2,3,4,5,6\} {1,2,3,4,5,6}，其候选划分点集合为 T a = { 1.5 , 2.5 , 3.5 , 4.5 , 5.5 } T_a=\{1.5, 2.5, 3.5, 4.5, 5.5\} Ta​={1.5,2.5,3.5,4.5,5.5}，依次使用每个候选划分点将$6$个样本分为两部分，划分后其中一部分的所有样本的属性$a$的值均小于等于使用的划分点，另一部分大于划分点。
  假设取划分点为$2.5$，即$t=2.5$，则将得到两个划分集合 D t − = { 1 , 2 } D_t^−=\{1,2\} Dt−​={1,2}和 D t + = { 3 , 4 , 5 , 6 } D_t^+=\{3,4,5,6\} Dt+​={3,4,5,6}，进而计算出$Gain(D,a,t=2.5)$。依次考虑$T_a$中每个元素，假设使用$3.5$划分后$Gain(D,a,t)$最大，则当前节点的判定条件为“$a\le 3.5$”，当前节点生成两个子结点，并将$D_t^{-}$和$D_t^{+}$集合所对应的样本分别放入这两个子结点中。
  注意，与离散属性不同，若当前结点划分属性为连续属性，该属性还可作为其后代结点的划分属性。

4.4.2 缺失值处理

  现实任务中常会遇到不完整样本，即样本的某些属性值缺失。对于此类情况，一般在数据预处理步骤使用特征工程相关方法予以解决。但本小结主要介绍在决策树学习算法中如何应对这样的问题。
  面对缺失数据我们需要解决两个问题：
  （1）如何在属性值缺失的情况下进行划分属性选择，也就是如何计算每个属性$a$的信息增益$Gain(D,a)$；
  （2）给定划分属性，若样本在该属性上的值缺失，如何对样本进行划分。例如：西瓜的色泽属性有“乌黑”、“青绿”、“浅白”三种，根据每个样本的色泽属性取值将样本分成三类，但若存在某个样本$x$，$x$的色泽属性值缺失，那么样本$x$该分到哪一类？
  给定数据集$D$和属性$a$，令$\tilde{D}$表示$D$中在属性$a$上没有缺失值的样本子集。对问题（1），可根据$\tilde{D}$来判断属性$a$的优劣。假定属性$a$有$V$个可取值 { a 1 , a 2 , . . . , a V } \{a^1,a^2,...,a^V\} {a1,a2,...,aV}，令$\widetilde{D^v}$表示$\tilde{D}$中在属性$a$上取值为$a^v$的样本子集，$\widetilde{D_k}$表示$\tilde{D}$中属于第$k$类$(k=1,2,...,|y|)$的样本子集，则显然有$\tilde{D}={\cup }_{k=1}^{|y|}\widetilde{D_k}$，$\tilde{D}={\cup }_{v=1}^V\widetilde{D^v}$。假定为每个样本$x$赋予一个权重$w_x$，并定义
$$\begin{array}{r}\rho =\frac{{\sum }_{x\in \tilde{D}}{w}_x}{{\sum }_{x\in D}{w}_x}\end{array}$$
$$\begin{array}{r}\widetilde{p_k}=\frac{{\sum }_{x\in \widetilde{D_k}}{w}_x}{{\sum }_{x\in \tilde{D}}{w}_x}(1\le k\le |y|)\end{array}$$
$$\begin{array}{r}\widetilde{r_v}=\frac{{\sum }_{x\in \widetilde{D^v}}{w}_x}{{\sum }_{x\in \tilde{D}}{w}_x}(1\le v\le V)\end{array}$$
  对属性$a$，$\rho$表示无缺失值样本所占的比例，$\widetilde{p_k}$表示无缺失值样本中第$k$类所占的比例，$\widetilde{r_v}$表示无缺失值样本中在属性$a$上取值$a^v$的样本所占的比例。推广信息增益公式为
$$\begin{array}{r}Gain(D,a)=\rho \ast Gain(\tilde{D},a)=\rho \ast (Ent(\tilde{D})-\sum _{v=1}^V\widetilde{r_v}Ent(\widetilde{D^v}))\end{array}$$
其中，
$$\begin{array}{r}Ent(\tilde{D})=-\sum _{k=1}^{|y|}\widetilde{p_k}lo{g}_2\widetilde{p_k}\end{array}$$
  对于问题（2），若样本$x$在划分属性$a$上的取值已知，则将$x$划入与其取值对应的子结点，且样本权值在子结点中保持为$w_x$。若样本$x$在划分属性$a$上的取值未知，则将$x$同时划入所有子结点，且样本权值在与属性$a^v$对应的子结点中调整为$\widetilde{r_v}\ast w_x$；根结点中的样本权值全部初始化为$1$。直观感受，这是让同一个样本以不同概率划入到不同的子结点中。
  例如，在如表4-4所示的“西瓜数据集——缺失部分数据”中，假设对“纹理”进行根结点划分。划分结果是使编号 { 1 , 2 , 3 , 4 , 5 , 6 , 15 } \{1,2,3,4,5,6,15\} {1,2,3,4,5,6,15}的样本进行“纹理=清晰”分支，编号 { 7 , 9 , 13 , 14 , 17 } \{7,9,13,14,17\} {7,9,13,14,17}的样本进入“纹理=稍糊”分支，编号 { 11 , 12 , 16 } \{11,12,16\} {11,12,16}的样本进行“纹理=模糊”分支，且样本在各子结点中权值保持为$1$。对于样本$8$，将该样本放入全部三个子结点中，并分别将权值调整为$1\ast \frac{7}{15}$、$1\ast \frac{5}{15}$、$1\ast \frac{3}{15}$。注意，在对子结点进行划分时，子结点中样本$8$的权值不再是$1$。

表4-4 西瓜数据集——缺失部分数据

4.5 多变量决策树

  以上所叙述的决策树都是单变量决策树，即每个非叶结点都是对单个属性的判断。而除了单变量决策树之外，还有多变量决策树，即每个非叶结点是对多个属性组合的判断。这里多个属性组合的方式可以是简单的线性组合，也可以是复杂组合，如每个非叶结点设置一个神经网络对多个属性的复杂组合进行判断。
  图4-8展示了一棵采用线性组合方式的多变量决策树。

图4-8 多变量决策树

  我基于sklearn的线性回归模型实现了多变量决策树，详细内容可以关注我的另一篇博客。

4.6 sklearn机器学习库——决策树

  下面代码基于sklearn机器学习库实现了乳腺癌数据分类，sklearn中还包含了可用于回归任务的决策树。sklearn包含了众多经典的机器学习算法，并做了很多相关的优化工作。建议在实际工程中使用，但由于方法库屏蔽掉了很多算法细节，因此在学习阶段不建议过于依赖方法库。sklearn中文文档

# -*- coding: utf-8 -*-
"""
Created on Tue Nov 24 14:59:04 2020

@author: qiqi
"""

import pydot
from sklearn.tree import export_graphviz
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()  #加载乳腺癌数据集

#参数random_state是指随机生成器
X_train, X_test, y_train, y_test = train_test_split(cancer['data'],cancer['target'], random_state=42)

#设置深度为4，即产生4个问题就停止生长.这是一种预剪枝手段，防止过拟合。
tree = DecisionTreeClassifier(max_depth=4, random_state=0)

#训练决策树
tree.fit(X_train,y_train)
print('Train score:{:.3f}'.format(tree.score(X_train,y_train)))
print('Test score:{:.3f}'.format(tree.score(X_test,y_test)))

#生成可视化图,Windows下class_names使用中文会乱码
export_graphviz(tree, out_file='tree.dot',class_names=['serious','slight'],feature_names=cancer.feature_names,impurity=False,filled=True)
#展示可视化图
(graph,) = pydot.graph_from_dot_file('tree.dot')
graph.write_png('tree.png')

  上面代码使用了预剪枝策略（代码确实简短），生成的决策树训练集精度为$0.99$，测试集精度为$0.92$。图4-9是使用sklearn库方法绘制的决策树结构图，sklearn确实好用。

图4-9 决策树结构图

博客参考周志华教授《机器学习》（西瓜书）