【机器学习实战】学习笔记 | 决策树

我会带着你远行 2022-11-21 01:24 251阅读 0赞

分类决策树：  
由节点和有向边组成。结点有两种类型：内部结点和叶子结点。内部结点表示一个特征或者属性，叶结点表示一个类（也就是最终决定结果）

**构建决策树：**

*  **1 特征选择**
    
     *  特征选择的标准是信息增益（在划分数据集之后信息发生的变化）
     *  如何计算信息增益？：香农熵（集合信息的度量方式），表示的是随机变量不确定性的度量。如果待分类的事物可能划分在多个分类中，则符号xi的信息定义为：其中p是选择该类的概率  
        ![在这里插入图片描述][20201029195620489.png_pic_center]
     *  计算所有类别所有可能包含的信息期望值公式：其中n是分类数目。熵越大随机变量的不确定性越大。 ![在这里插入图片描述][20201029195753338.png_pic_center]
     *  当熵中的概率由数据估计（特别是最大似然估计）得到时，所对应的熵叫，**经验熵**。
     *  编写代码计算经验熵：

![在这里插入图片描述][20201029202018530.png_pic_center]

*  信息增益：我们要选信息增益最大，即选择对最终分类结果影响最大的特征作为分类特征。
 *  条件熵：H(Y|X)表示在已知随机变量x的条件下随机变量Y的不确定性；随机变量x给定的条件下随机变量y的条件熵H(Y|X)定义为：x给定条件下y的条件概率分布的熵对x的数学期望：  
    ![在这里插入图片描述][20201029202800920.png_pic_center]![在这里插入图片描述][20201029202810207.png_pic_center]
 *  当条件熵中的概率由数据估计（特别是极大似然估计）得到时，所对应的条件熵为条件经验熵。
 *  特征A对训练数据集D的信息增益g（D,A），定义为集合D的经验熵H（D）与特征A给定条件下D的经验条件熵H（D|A)之差：  
    ![在这里插入图片描述][20201029203100258.png_pic_center]
 *  一般的，熵H(D)与条件熵H(D|A之差成为**互信息**。决策树学习中的信息增益等价于训练数据集中类与特征的互信息。
 *  编写代码计算信息增益

""" 数据集标注： 年龄：0代表青年，1代表中年，2代表老年； 有工作：0代表否，1代表是； 有自己的房子：0代表否，1代表是； 信贷情况：0代表一般，1代表好，2代表非常好； 类别(是否给贷款)：no代表否，yes代表是。 """
    from math import log
    
    def createDataSet():
        dataSet = [[0, 0, 0, 0, 'no'],  # 数据集
                   [0, 0, 0, 1, 'no'],
                   [0, 1, 0, 1, 'yes'],
                   [0, 1, 1, 0, 'yes'],
                   [0, 0, 0, 0, 'no'],
                   [1, 0, 0, 0, 'no'],
                   [1, 0, 0, 1, 'no'],
                   [1, 1, 1, 1, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [2, 0, 1, 2, 'yes'],
                   [2, 0, 1, 1, 'yes'],
                   [2, 1, 0, 1, 'yes'],
                   [2, 1, 0, 2, 'yes'],
                   [2, 0, 0, 0, 'no']]
        labels = ['不放贷', '放贷']  # 分类属性
        return dataSet, labels  # 返回数据集和分类属性
    
    """ 函数说明：计算给定数据集的经验熵 parameters: dataSet 数据集 Return： shannonEnt-经验熵 """
    def calcShannonEnt(dataSet):
        numEntires=len(dataSet) #返回数据集行数
        labelCounts={ }#保存每个标签出现次数的字典
        for featVec in dataSet:#对每组特征向量进行统计
            currentLabel=featVec[-1]#提取标签信息
            if currentLabel not in labelCounts.keys():#如果标签没有放入统计字典，就加入
                labelCounts[currentLabel]=0
            labelCounts[currentLabel]+=1 #label计数
        shannonEnt=0.0   #经验熵
        for key in labelCounts:  #计算香农熵
            prob=float(labelCounts[key])/numEntires #选择该标签的概率
            shannonEnt -=prob*log(prob,2) #利用公式计算
        return shannonEnt
    
    """ 函数说明：按照给定特征划分数据集 parameter： dataSet -待划分的数据集 axis-划分数据集的特征 value-需要返回的特征的值 """
    def splitDataSet(dataSet,axis,valus):
        retDataSet=[]  #创建返回的数据集列表
        for featVec in dataSet:  #遍历数据集
            if featVec[axis]==dataSet:
                reducedFeatVec=featVec[:axis] #去掉axis特征
                reducedFeatVec.extend(featVec[axis+1:]) #将符合条件的添加到返回的数据集
                retDataSet.append(reducedFeatVec)
        return retDataSet   #返回划分后的数据集
    
    
    """ 函数说明：选择最优特征 Parameters: dataSet returns: bestFeature -信息增益最大的（最优）特征的索引值 """
    def chooseBestFeatureToSplit(dataSet):
        numFeatures=len(dataSet[0])-1  #特征数量
        baseEntropy=calcShannonEnt(dataSet) #计算数据集的香农熵
        bestInfoGain=0.0  #信息增益
        bestFeature=-1  #最优特征的索引值
        for i in range(numFeatures):  #遍历所有特征
            #获取dataSet的第i个所有特征值
            featList=[example[i] for example in dataSet]
            uniqueVals=set(featList)  #创建set集合{}，元素不可重复
            newEntropy=0.0   #经验条件熵
            for value in uniqueVals:  #计算信息增益
                subDataSet=splitDataSet(dataSet,i,value) #subDataSet划分后的子集
                prob=len(subDataSet)/float(len(dataSet))   #计算子集的概率
                newEntropy +=prob*calcShannonEnt(subDataSet)  #根据公式计算经验条件熵
            infoGain=baseEntropy-newEntropy      #信息增益
            print("第%d个特征的增益为%.3f"%(i,infoGain))  #打印每个特征的信息增益
            if(infoGain>bestInfoGain):    #计算信息增益
                bestInfoGain=infoGain  #更新信息增益，找到最大的信息增益
                bestFeature=i   #记录信息熵最大特征的索引值
        return bestFeature   #返回信息增益最大的特征的索引值
    
    
    
    if __name__=='__main__':
        dataSet,features=createDataSet()
        print("最优特征索引值："+str(chooseBestFeatureToSplit(dataSet)))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center]

*  **2 决策树生成**
    
     *  构建决策树的算法有：ID3、CART、C4.5
     *  ID3算法的核心是在决策树各个节点上对应信息增益准则选择特征，递归地构建决策树。相当于用极大似然法进行概率模型的选择。
     *  具体方法是：从根节点开始，对节点计算所有可能的特征的信息增益，选择信息增益最大的特征作为结点特征，由该结点的不同取值建立子节点；再对子节点递归上述方法，直到所有特征的信息增益均很小或没有特征可以选择为止。
     *  编写代码构建决策树

""" 数据集标注： 年龄：0代表青年，1代表中年，2代表老年； 有工作：0代表否，1代表是； 有自己的房子：0代表否，1代表是； 信贷情况：0代表一般，1代表好，2代表非常好； 类别(是否给贷款)：no代表否，yes代表是。 """
    from math import log
    import operator
    
    def createDataSet():
        dataSet = [[0, 0, 0, 0, 'no'],  # 数据集
                   [0, 0, 0, 1, 'no'],
                   [0, 1, 0, 1, 'yes'],
                   [0, 1, 1, 0, 'yes'],
                   [0, 0, 0, 0, 'no'],
                   [1, 0, 0, 0, 'no'],
                   [1, 0, 0, 1, 'no'],
                   [1, 1, 1, 1, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [2, 0, 1, 2, 'yes'],
                   [2, 0, 1, 1, 'yes'],
                   [2, 1, 0, 1, 'yes'],
                   [2, 1, 0, 2, 'yes'],
                   [2, 0, 0, 0, 'no']]
        labels = ['年龄', '有工作', '有自己的房子', '信贷情况']  # 分类属性
        return dataSet, labels  # 返回数据集和分类属性
    
    """ 函数说明：计算给定数据集的经验熵 parameters: dataSet 数据集 Return： shannonEnt-经验熵 """
    def calcShannonEnt(dataSet):
        numEntires=len(dataSet) #返回数据集行数
        labelCounts={ }#保存每个标签出现次数的字典
        for featVec in dataSet:#对每组特征向量进行统计
            currentLabel=featVec[-1]#提取标签信息
            if currentLabel not in labelCounts.keys():#如果标签没有放入统计字典，就加入
                labelCounts[currentLabel]=0
            labelCounts[currentLabel]+=1 #label计数
        shannonEnt=0.0   #经验熵
        for key in labelCounts:  #计算香农熵
            prob=float(labelCounts[key])/numEntires #选择该标签的概率
            shannonEnt -=prob*log(prob,2) #利用公式计算
        return shannonEnt
    
    """ 函数说明：按照给定特征划分数据集 parameter： dataSet -待划分的数据集 axis-划分数据集的特征 value-需要返回的特征的值 """
    def splitDataSet(dataSet,axis,value):
        retDataSet=[]  #创建返回的数据集列表
        for featVec in dataSet:  #遍历数据集
            if featVec[axis]==value:
                reducedFeatVec=featVec[:axis] #去掉axis特征
                reducedFeatVec.extend(featVec[axis+1:]) #将符合条件的添加到返回的数据集
                retDataSet.append(reducedFeatVec)
        return retDataSet   #返回划分后的数据集
    
    
    """ 函数说明：选择最优特征 Parameters: dataSet returns: bestFeature -信息增益最大的（最优）特征的索引值 """
    def chooseBestFeatureToSplit(dataSet):
        numFeatures=len(dataSet[0])-1  #特征数量
        baseEntropy=calcShannonEnt(dataSet) #计算数据集的香农熵
        bestInfoGain=0.0  #信息增益
        bestFeature=-1  #最优特征的索引值
        for i in range(numFeatures):  #遍历所有特征
            #获取dataSet的第i个所有特征值
            featList=[example[i] for example in dataSet]
            uniqueVals=set(featList)  #创建set集合{}，元素不可重复
            newEntropy=0.0   #经验条件熵
            for value in uniqueVals:  #计算信息增益
                subDataSet=splitDataSet(dataSet,i,value) #subDataSet划分后的子集
                prob=len(subDataSet)/float(len(dataSet))   #计算子集的概率
                newEntropy +=prob*calcShannonEnt(subDataSet)  #根据公式计算经验条件熵
            infoGain=baseEntropy-newEntropy      #信息增益
            print("第%d个特征的增益为%.3f"%(i,infoGain))  #打印每个特征的信息增益
            if(infoGain>bestInfoGain):    #计算信息增益
                bestInfoGain=infoGain  #更新信息增益，找到最大的信息增益
                bestFeature=i   #记录信息熵最大特征的索引值
        return bestFeature   #返回信息增益最大的特征的索引值
    
    """ 函数说明：统计classList中出现此处最多的元素（类标签） parameters: classList -类标签列表 returns: sortedClassCount[0][0]- 出现此处最多的元素（类标签） """
    def majorityCnt(classList):
        classCount={ }
        for vote in classList:   #统计classList中每个元素出现的次数
            if vote not in classCount.keys():classCount[vote]=0
            classCount[vote]+=1
        sortedClassCount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)#根据字典的值降序排序
        return sortedClassCount[0][0]  #返回classList中出现次数最多的元素
    
    """ 函数说明：创建决策树 parameters： dataSet -训练数据集 labels- 分类属性标签 featLabels -存储选择的是最优特征标签 returns myTree - 决策树 """
    def createTree(dataSet,labels,featLabels):
        classList=[example[-1] for example in dataSet]  #取分类标签（是否放贷：yes or no)
        if classList.count(classList[0])==len(classList):  #如果类别完全相同则停止继续划分
            return classList[0]
        if len(dataSet[0])==1 or len(labels)==0:  #遍历完所有特征时返回出现次数最多的类别标签
            return majorityCnt(classList)
        bestFeat=chooseBestFeatureToSplit(dataSet) #选择最优特征的标签
        bestFeatLabel=labels[bestFeat]
        featLabels.append(bestFeatLabel)
        myTree={ bestFeatLabel:{ }}  #根据最优特征的标签生成树
        del(labels[bestFeat]) #删除已经使用的特征标签
        featValues=[example[bestFeat] for example in dataSet]#得到训练集中所有最优特征的属性值
        uniqueVals=set(featValues)#去掉重复的属性值
        for value in uniqueVals: #遍历特征，创建决策树
            subLabels=labels[:]
            myTree[bestFeatLabel][value]=createTree(splitDataSet(dataSet,bestFeat,value),subLabels,featLabels)
        return myTree
    
    if __name__=='__main__':
        dataSet,labels=createDataSet()
        featLabels=[]
        myTree=createTree(dataSet,labels,featLabels)
        print(myTree)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 1]

*  **3 决策树可视化**

> Matplotlib绘制决策树需要的函数：  
> getNumLeafs：获取决策树叶子结点的数目  
> getTreeDepth：获取决策树的层数  
> plotNode：绘制结点  
> plotMidText：标注有向边属性值  
> plotTree：绘制决策树  
> createPlot：创建绘制面板

*  代码：

""" 数据集标注： 年龄：0代表青年，1代表中年，2代表老年； 有工作：0代表否，1代表是； 有自己的房子：0代表否，1代表是； 信贷情况：0代表一般，1代表好，2代表非常好； 类别(是否给贷款)：no代表否，yes代表是。 """
    from matplotlib.font_manager import  FontProperties
    import matplotlib.pyplot as plt
    from math import log
    import operator
    
    def createDataSet():
        dataSet = [[0, 0, 0, 0, 'no'],  # 数据集
                   [0, 0, 0, 1, 'no'],
                   [0, 1, 0, 1, 'yes'],
                   [0, 1, 1, 0, 'yes'],
                   [0, 0, 0, 0, 'no'],
                   [1, 0, 0, 0, 'no'],
                   [1, 0, 0, 1, 'no'],
                   [1, 1, 1, 1, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [2, 0, 1, 2, 'yes'],
                   [2, 0, 1, 1, 'yes'],
                   [2, 1, 0, 1, 'yes'],
                   [2, 1, 0, 2, 'yes'],
                   [2, 0, 0, 0, 'no']]
        labels = ['年龄', '有工作', '有自己的房子', '信贷情况']  # 分类属性
        return dataSet, labels  # 返回数据集和分类属性
    
    """ 函数说明：计算给定数据集的经验熵 parameters: dataSet 数据集 Return： shannonEnt-经验熵 """
    def calcShannonEnt(dataSet):
        numEntires=len(dataSet) #返回数据集行数
        labelCounts={ }#保存每个标签出现次数的字典
        for featVec in dataSet:#对每组特征向量进行统计
            currentLabel=featVec[-1]#提取标签信息
            if currentLabel not in labelCounts.keys():#如果标签没有放入统计字典，就加入
                labelCounts[currentLabel]=0
            labelCounts[currentLabel]+=1 #label计数
        shannonEnt=0.0   #经验熵
        for key in labelCounts:  #计算香农熵
            prob=float(labelCounts[key])/numEntires #选择该标签的概率
            shannonEnt -=prob*log(prob,2) #利用公式计算
        return shannonEnt
    
    """ 函数说明：按照给定特征划分数据集 parameter： dataSet -待划分的数据集 axis-划分数据集的特征 value-需要返回的特征的值 """
    def splitDataSet(dataSet,axis,value):
        retDataSet=[]  #创建返回的数据集列表
        for featVec in dataSet:  #遍历数据集
            if featVec[axis]==value:
                reducedFeatVec=featVec[:axis] #去掉axis特征
                reducedFeatVec.extend(featVec[axis+1:]) #将符合条件的添加到返回的数据集
                retDataSet.append(reducedFeatVec)
        return retDataSet   #返回划分后的数据集
    
    
    """ 函数说明：选择最优特征 Parameters: dataSet returns: bestFeature -信息增益最大的（最优）特征的索引值 """
    def chooseBestFeatureToSplit(dataSet):
        numFeatures=len(dataSet[0])-1  #特征数量
        baseEntropy=calcShannonEnt(dataSet) #计算数据集的香农熵
        bestInfoGain=0.0  #信息增益
        bestFeature=-1  #最优特征的索引值
        for i in range(numFeatures):  #遍历所有特征
            #获取dataSet的第i个所有特征值
            featList=[example[i] for example in dataSet]
            uniqueVals=set(featList)  #创建set集合{}，元素不可重复
            newEntropy=0.0   #经验条件熵
            for value in uniqueVals:  #计算信息增益
                subDataSet=splitDataSet(dataSet,i,value) #subDataSet划分后的子集
                prob=len(subDataSet)/float(len(dataSet))   #计算子集的概率
                newEntropy +=prob*calcShannonEnt(subDataSet)  #根据公式计算经验条件熵
            infoGain=baseEntropy-newEntropy      #信息增益
            print("第%d个特征的增益为%.3f"%(i,infoGain))  #打印每个特征的信息增益
            if(infoGain>bestInfoGain):    #计算信息增益
                bestInfoGain=infoGain  #更新信息增益，找到最大的信息增益
                bestFeature=i   #记录信息熵最大特征的索引值
        return bestFeature   #返回信息增益最大的特征的索引值
    
    """ 函数说明：统计classList中出现此处最多的元素（类标签） parameters: classList -类标签列表 returns: sortedClassCount[0][0]- 出现此处最多的元素（类标签） """
    def majorityCnt(classList):
        classCount={ }
        for vote in classList:   #统计classList中每个元素出现的次数
            if vote not in classCount.keys():classCount[vote]=0
            classCount[vote]+=1
        sortedClassCount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)#根据字典的值降序排序
        return sortedClassCount[0][0]  #返回classList中出现次数最多的元素
    
    """ 函数说明：创建决策树 parameters： dataSet -训练数据集 labels- 分类属性标签 featLabels -存储选择的是最优特征标签 returns myTree - 决策树 """
    def createTree(dataSet,labels,featLabels):
        classList=[example[-1] for example in dataSet]  #取分类标签（是否放贷：yes or no)
        if classList.count(classList[0])==len(classList):  #如果类别完全相同则停止继续划分
            return classList[0]
        if len(dataSet[0])==1 or len(labels)==0:  #遍历完所有特征时返回出现次数最多的类别标签
            return majorityCnt(classList)
        bestFeat=chooseBestFeatureToSplit(dataSet) #选择最优特征的标签
        bestFeatLabel=labels[bestFeat]
        featLabels.append(bestFeatLabel)
        myTree={ bestFeatLabel:{ }}  #根据最优特征的标签生成树
        del(labels[bestFeat]) #删除已经使用的特征标签
        featValues=[example[bestFeat] for example in dataSet]#得到训练集中所有最优特征的属性值
        uniqueVals=set(featValues)#去掉重复的属性值
        for value in uniqueVals: #遍历特征，创建决策树
            subLabels=labels[:]
            myTree[bestFeatLabel][value]=createTree(splitDataSet(dataSet,bestFeat,value),subLabels,featLabels)
        return myTree
    
    """ 获取决策树叶子结点数目 parameter： myTree -决策树 returns numLeafs -决策树的叶子结点的数据 """
    def getNumLeafs(myTree):
        numLeafs = 0                                                #初始化叶子
        firstStr = next(iter(myTree))                                #python3中myTree.keys()返回的是dict_keys,不在是list,所以不能使用myTree.keys()[0]的方法获取结点属性，可以使用list(myTree.keys())[0]
        secondDict = myTree[firstStr]                                #获取下一组字典
        for key in secondDict.keys():
            if type(secondDict[key]).__name__=='dict':                #测试该结点是否为字典，如果不是字典，代表此结点为叶子结点
                numLeafs += getNumLeafs(secondDict[key])
            else:   numLeafs +=1
        return numLeafs
    
    """ 获取决策树的层数 Parameters: myTree - 决策树 Returns: maxDepth - 决策树的层数 """
    def getTreeDepth(myTree):
        maxDepth = 0                                                #初始化决策树深度
        firstStr = next(iter(myTree))                                #python3中myTree.keys()返回的是dict_keys,不在是list,所以不能使用myTree.keys()[0]的方法获取结点属性，可以使用list(myTree.keys())[0]
        secondDict = myTree[firstStr]                                #获取下一个字典
        for key in secondDict.keys():
            if type(secondDict[key]).__name__=='dict':                #测试该结点是否为字典，如果不是字典，代表此结点为叶子结点
                thisDepth = 1 + getTreeDepth(secondDict[key])
            else:   thisDepth = 1
            if thisDepth > maxDepth: maxDepth = thisDepth            #更新层数
        return maxDepth
    
    """ 函数说明:绘制结点 Parameters: nodeTxt - 结点名 centerPt - 文本位置 parentPt - 标注的箭头位置 nodeType - 结点格式 """
    
    
    def plotNode(nodeTxt, centerPt, parentPt, nodeType):
        arrow_args = dict(arrowstyle="<-")  # 定义箭头格式
        font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)  # 设置中文字体
        createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',  # 绘制结点
                                xytext=centerPt, textcoords='axes fraction',
                                va="center", ha="center", bbox=nodeType, arrowprops=arrow_args, FontProperties=font)
    
    
    """ 标注有向边属性值 Parameters: cntPt、parentPt- 用于计算标注位置 txtString-标注内容 """
    
    
    def plotMidText(cntrPt, parentPt, txtString):
        xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]  # 计算标注位置
        yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]
        createPlot.ax1.text(xMid, yMid, txtString, va="center", ha="center", rotation=30)
    
    
    """ 绘制决策树 parameters myTree - 决策树（字典） parentPt - 标注的内容 nodeTxt -结点名 """
    def plotTree(myTree, parentPt, nodeTxt):
        decisionNode = dict(boxstyle="sawtooth", fc="0.8")                                        #设置结点格式
        leafNode = dict(boxstyle="round4", fc="0.8")                                            #设置叶结点格式
        numLeafs = getNumLeafs(myTree)                                                          #获取决策树叶结点数目，决定了树的宽度
        depth = getTreeDepth(myTree)                                                            #获取决策树层数
        firstStr = next(iter(myTree))                                                            #下个字典
        cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)    #中心位置
        plotMidText(cntrPt, parentPt, nodeTxt)                                                    #标注有向边属性值
        plotNode(firstStr, cntrPt, parentPt, decisionNode)                                        #绘制结点
        secondDict = myTree[firstStr]                                                            #下一个字典，也就是继续绘制子结点
        plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD                                        #y偏移
        for key in secondDict.keys():
            if type(secondDict[key]).__name__=='dict':                                            #测试该结点是否为字典，如果不是字典，代表此结点为叶子结点
                plotTree(secondDict[key],cntrPt,str(key))                                        #不是叶结点，递归调用继续绘制
            else:                                                                                #如果是叶结点，绘制叶结点，并标注有向边属性值
                plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
                plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
                plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
        plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD
    
    """ 创建绘制面板 parameters: inTree- 决策树（字典） """
    def createPlot(inTree):
        fig = plt.figure(1, facecolor='white')                                                    #创建fig
        fig.clf()                                                                                #清空fig
        axprops = dict(xticks=[], yticks=[])
        createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)                                #去掉x、y轴
        plotTree.totalW = float(getNumLeafs(inTree))                                            #获取决策树叶结点数目
        plotTree.totalD = float(getTreeDepth(inTree))                                            #获取决策树层数
        plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;                                #x偏移
        plotTree(inTree, (0.5,1.0), '')                                                            #绘制决策树
        plt.show()
    
    
    if __name__=='__main__':
        dataSet,labels=createDataSet()
        featLabels=[]
        myTree=createTree(dataSet,labels,featLabels)
        print(myTree)
        createPlot(myTree)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 2]

*  4 **使用决策树进行分类**
 *  用测试数据\[0,1\]表示没有房子，但是有工作，代码：

""" 数据集标注： 年龄：0代表青年，1代表中年，2代表老年； 有工作：0代表否，1代表是； 有自己的房子：0代表否，1代表是； 信贷情况：0代表一般，1代表好，2代表非常好； 类别(是否给贷款)：no代表否，yes代表是。 """
    from math import log
    import operator
    
    
    def createDataSet():
        dataSet = [[0, 0, 0, 0, 'no'],  # 数据集
                   [0, 0, 0, 1, 'no'],
                   [0, 1, 0, 1, 'yes'],
                   [0, 1, 1, 0, 'yes'],
                   [0, 0, 0, 0, 'no'],
                   [1, 0, 0, 0, 'no'],
                   [1, 0, 0, 1, 'no'],
                   [1, 1, 1, 1, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [1, 0, 1, 2, 'yes'],
                   [2, 0, 1, 2, 'yes'],
                   [2, 0, 1, 1, 'yes'],
                   [2, 1, 0, 1, 'yes'],
                   [2, 1, 0, 2, 'yes'],
                   [2, 0, 0, 0, 'no']]
        labels = ['年龄', '有工作', '有自己的房子', '信贷情况']  # 分类属性
        return dataSet, labels  # 返回数据集和分类属性
    
    
    """ 函数说明：计算给定数据集的经验熵 parameters: dataSet 数据集 Return： shannonEnt-经验熵 """
    
    
    def calcShannonEnt(dataSet):
        numEntires = len(dataSet)  # 返回数据集行数
        labelCounts = { }  # 保存每个标签出现次数的字典
        for featVec in dataSet:  # 对每组特征向量进行统计
            currentLabel = featVec[-1]  # 提取标签信息
            if currentLabel not in labelCounts.keys():  # 如果标签没有放入统计字典，就加入
                labelCounts[currentLabel] = 0
            labelCounts[currentLabel] += 1  # label计数
        shannonEnt = 0.0  # 经验熵
        for key in labelCounts:  # 计算香农熵
            prob = float(labelCounts[key]) / numEntires  # 选择该标签的概率
            shannonEnt -= prob * log(prob, 2)  # 利用公式计算
        return shannonEnt
    
    
    """ 函数说明：按照给定特征划分数据集 parameter： dataSet -待划分的数据集 axis-划分数据集的特征 value-需要返回的特征的值 """
    def splitDataSet(dataSet, axis, value):
        retDataSet = []  # 创建返回的数据集列表
        for featVec in dataSet:  # 遍历数据集
            if featVec[axis] == value:
                reducedFeatVec = featVec[:axis]  # 去掉axis特征
                reducedFeatVec.extend(featVec[axis + 1:])  # 将符合条件的添加到返回的数据集
                retDataSet.append(reducedFeatVec)
        return retDataSet  # 返回划分后的数据集
    
    
    """ 函数说明：选择最优特征 Parameters: dataSet returns: bestFeature -信息增益最大的（最优）特征的索引值 """
    
    
    def chooseBestFeatureToSplit(dataSet):
        numFeatures = len(dataSet[0]) - 1  # 特征数量
        baseEntropy = calcShannonEnt(dataSet)  # 计算数据集的香农熵
        bestInfoGain = 0.0  # 信息增益
        bestFeature = -1  # 最优特征的索引值
        for i in range(numFeatures):  # 遍历所有特征
            # 获取dataSet的第i个所有特征值
            featList = [example[i] for example in dataSet]
            uniqueVals = set(featList)  # 创建set集合{}，元素不可重复
            newEntropy = 0.0  # 经验条件熵
            for value in uniqueVals:  # 计算信息增益
                subDataSet = splitDataSet(dataSet, i, value)  # subDataSet划分后的子集
                prob = len(subDataSet) / float(len(dataSet))  # 计算子集的概率
                newEntropy += prob * calcShannonEnt(subDataSet)  # 根据公式计算经验条件熵
            infoGain = baseEntropy - newEntropy  # 信息增益
            print("第%d个特征的增益为%.3f" % (i, infoGain))  # 打印每个特征的信息增益
            if (infoGain > bestInfoGain):  # 计算信息增益
                bestInfoGain = infoGain  # 更新信息增益，找到最大的信息增益
                bestFeature = i  # 记录信息熵最大特征的索引值
        return bestFeature  # 返回信息增益最大的特征的索引值
    
    
    """ 函数说明：统计classList中出现此处最多的元素（类标签） parameters: classList -类标签列表 returns: sortedClassCount[0][0]- 出现此处最多的元素（类标签） """
    def majorityCnt(classList):
        classCount = { }
        for vote in classList:  # 统计classList中每个元素出现的次数
            if vote not in classCount.keys(): classCount[vote] = 0
            classCount[vote] += 1
        sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)  # 根据字典的值降序排序
        return sortedClassCount[0][0]  # 返回classList中出现次数最多的元素
    
    
    """ 函数说明：创建决策树 parameters： dataSet -训练数据集 labels- 分类属性标签 featLabels -存储选择的是最优特征标签 returns myTree - 决策树 """
    
    
    def createTree(dataSet, labels, featLabels):
        classList = [example[-1] for example in dataSet]  # 取分类标签（是否放贷：yes or no)
        if classList.count(classList[0]) == len(classList):  # 如果类别完全相同则停止继续划分
            return classList[0]
        if len(dataSet[0]) == 1 or len(labels) == 0:  # 遍历完所有特征时返回出现次数最多的类别标签
            return majorityCnt(classList)
        bestFeat = chooseBestFeatureToSplit(dataSet)  # 选择最优特征的标签
        bestFeatLabel = labels[bestFeat]
        featLabels.append(bestFeatLabel)
        myTree = { bestFeatLabel: { }}  # 根据最优特征的标签生成树
        del (labels[bestFeat])  # 删除已经使用的特征标签
        featValues = [example[bestFeat] for example in dataSet]  # 得到训练集中所有最优特征的属性值
        uniqueVals = set(featValues)  # 去掉重复的属性值
        for value in uniqueVals:  # 遍历特征，创建决策树
            subLabels = labels[:]
            myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels, featLabels)
        return myTree
    
    
    """ 使用决策树分类 parameter： inputTree-已经生成的决策树 featLabels-存储选择的最优特征标签 testVec -测试数据列表，顺序对应最优特征标签 returns classLabel - 分类结果 """
    def classify(inputTree,featLabels,testVec):
        firstStr=next(iter(inputTree))#获取决策树的结点
        secondDict=inputTree[firstStr] #下一个字典
        featIndex=featLabels.index(firstStr)
        for key in secondDict.keys():
            if testVec[featIndex]==key:
                if type(secondDict[key]).__name__=='dict':
                    classLabel=classify(secondDict[key],featLabels,testVec)
                else: classLabel=secondDict[key]
        return classLabel
    
    
    if __name__ == '__main__':
        dataSet, labels = createDataSet()
        featLabels = []
        myTree = createTree(dataSet, labels, featLabels)
        testVec=[0,1] #测试数据
        result=classify(myTree,featLabels,testVec)
        if result=='yes':
            print('放贷')
        else:
            print('不放贷')

![在这里插入图片描述][20201101153432273.png_pic_center]

*  **5 决策树的存储**
 *  构造一次决策树非常麻烦且耗时，所以可以使用封装耗的pickle.dump存储决策树：

import pickle
    """ 存储决策树 parameters: inputTree-已经生成的决策树 filename-决策树的存储文件名 """
    def storeTree(inputTree,filename):
        with open(filename,'wb') as fw:
            pickle.dump(inputTree,fw)
    
    if __name__=='__main__':
        myTree={ '有自己的房子':{ 0:{ '有工作':{ 0:'no',1:'yes'}},1:'yes'}}
        storeTree(myTree,'classifierStorage.txt')

![在这里插入图片描述][20201101154516959.png_pic_center]

*  运行成功之后会出现上面的txt表明决策树已经被存储下来了，存在该文件的同根目录下。
 *  可以用pickle.load载入决策树：

import pickle
    
    """ 读取决策树 parameters: filename -决策树的存储文件名 returns: pickle.load(fr)-决策树字典 """
    def grabTree(filename):
        fr=open(filename,'rb')
        return pickle.load(fr)
    
    if __name__=='__main__':
        myTree=grabTree('classifierStorage.txt')
        print(myTree)

![在这里插入图片描述][20201101155611133.png_pic_center]

*  **6 Sklearn之使用决策树预测隐形眼类型**  
    略

参考教程：

*  [机器学习实战教程（三）][Link 1]

[20201029195620489.png_pic_center]: /images/20221120/8c30a72581e84006bda8018bdfd8a849.png
[20201029195753338.png_pic_center]: https://img-blog.csdnimg.cn/20201029195753338.png#pic_center
[20201029202018530.png_pic_center]: https://img-blog.csdnimg.cn/20201029202018530.png#pic_center
[20201029202800920.png_pic_center]: https://img-blog.csdnimg.cn/20201029202800920.png#pic_center
[20201029202810207.png_pic_center]: https://img-blog.csdnimg.cn/20201029202810207.png#pic_center
[20201029203100258.png_pic_center]: https://img-blog.csdnimg.cn/20201029203100258.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20201029205910295.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201029214135220.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201101134644418.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2,size_16,color_FFFFFF,t_70#pic_center
[20201101153432273.png_pic_center]: https://img-blog.csdnimg.cn/20201101153432273.png#pic_center
[20201101154516959.png_pic_center]: https://img-blog.csdnimg.cn/20201101154516959.png#pic_center
[20201101155611133.png_pic_center]: https://img-blog.csdnimg.cn/20201101155611133.png#pic_center
[Link 1]: https://cuijiahua.com/blog/2017/11/ml_3_decision_tree_2.html