《机器学习实战》读书笔记（三）决策树（下）（使用决策树预测隐形眼镜类型）

本文为《决策树》实战:使用决策树预测隐形眼镜类型

与本文相关的上面两篇文章链接如下：

https://blog.youkuaiyun.com/qq_38172282/article/details/91794946

https://blog.youkuaiyun.com/qq_38172282/article/details/91874517

决策树中所有文件代码您均可以通过该链接进行下载：

https://download.youkuaiyun.com/download/qq_38172282/11242433

3.4使用决策树预测隐形眼镜类型

问题描述：

由于隐形眼镜类型较多，患者选择方式众多，且患者眼部观察数据类型较多，因此有经验的医生也不能很好地给出适合患者佩戴的隐形眼镜类型。针对这种情况，如果有一些已知的患者眼部观察数据及其所佩戴的隐形眼镜类型的数据，则可通过这些数据构建决策树代替医生来判断患者所适合的隐形眼镜类型。

所需文件：

链接中trees_final.py文件功能：使用决策树预测隐形眼镜类型

我们使用的lenses.txt内容文件如下：

特征有四个：age（年龄）、prescript（症状）、astigmatic（是否散光）、tearRate（眼泪数量） 

隐形眼镜类别有三类(最后一列)：硬材质(hard)、软材质(soft)、不适合佩戴隐形眼镜(no lenses) 

如何编写代码使其能运行呢？（完全是自己的理解，如有不对请私聊！）

1、收集资料（lenses.txt）

2、对资料进行处理，使其能够被系统可理解（主函数中第2行）

3、分析数据（这里我们使用了程序清单3-1：计算给定数据集的香农熵(经验熵)；程序清单3-2：按照给定特征划分数据集；程序清单3-3：选择最好的数据集划分方式）

4、训练算法（这里我们使用了程序清单3-4：创建决策树）

5：绘制决策树（这里我们使用了程序清单3-5：使用文本注解绘制树节点；程序清单3-6：获取叶节点的数目和树层数；程序清单3-7：绘制决策函数）

6：编写主函数（完成整个决策树）

完整代码如下：（如果想了解代码含义请阅读我之前写的文章！本篇代码注解将减少！）

from math import log
import operator
import matplotlib.pyplot as plt

# #添加这段代码的目的是让图片中的中文能够正常显示！
# from pylab import *  
# mpl.rcParams['font.sans-serif'] = ['SimHei']  

# 程序清单3-1：计算给定数据集的香农熵(经验熵)
def calcShannonEnt(dataSet):
    numEntries = len(dataSet) 
    labelCounts = {}     
    for featVec in dataSet:         
        currentLabel = featVec[-1] 
        if currentLabel not in labelCounts.keys():         
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1 
    shannonEnt = 0.0 
    for key in labelCounts:    
        prob = float(labelCounts[key])/numEntries 
        shannonEnt -= prob * log(prob, 2)      
    return shannonEnt 

#程序清单3-2：按照给定特征划分数据集
def splitDataSet(dataSet, axis, value): 
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]     
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

#程序清单3-3：选择最好的数据集划分方式
def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1 
    baseEntropy = calcShannonEnt(dataSet) 
    bestInfoGain = 0.0 
    bestFeature = -1     
    for i in range(numFeatures):  
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList) 
        newEntropy = 0.0 
        for value in uniqueVals: 
            subDataSet = splitDataSet(dataSet, i, value) 
            prob = len(subDataSet)/float(len(dataSet)) 
            newEntropy += prob * calcShannonEnt(subDataSet)   
        infoGain = baseEntropy - newEntropy             
        if (infoGain > bestInfoGain):        
            bestInfoGain = infoGain        
            bestFeature = i             
    return bestFeature 

#统计classList中出现此处最多的元素（类标签）,即选择出现次数最多的结果
def majorityCnt(classList):
    classCount={}
    for vote in classList:
        if vote not in classCount.keys(): 
            classCount[vote] = 0
        classCount[vote] += 1
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

#程序清单3-4：创建决策树
def createTree(dataSet, labels):
    classList = [example[-1] for example in dataSet]
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    if len(dataSet[0]) == 1:
        return majorityCnt(classList)  
    bestFeat = chooseBestFeatureToSplit(dataSet)
    bestFeatLabel = labels[bestFeat]
    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)
    return mytree

#程序清单3-5：使用文本注解绘制树节点
# decisionNode = dict(boxstyle = "sawtooth", fc = "0.8")
# leafNode = dict(boxstyle = "round4", fc = "0.8")
# arrow_args = dict(arrowstyle = "<-")

#程序清单3-5：绘制带箭头的注解
def plotNode(nodeTxt, centerPt, parentPt, nodeType):
    arrow_args = dict(arrowstyle = "<-")
    createPlot.ax1.annotate(nodeTxt, xy = parentPt, xycoords ='axes fraction', xytext = centerPt,
                            textcoords = 'axes fraction',va="center",ha="center",bbox=nodeType,arrowprops=arrow_args)

#程序清单3-5：创建绘图区，计算树形图的全局尺寸
def createPlot(inTree):
    fig = plt.figure(1, facecolor='white')
    fig.clf()
    axprops = dict(xticks = [], yticks = [])
    createPlot.ax1 = plt.subplot(111, frameon = False, **axprops)
    plotTree.totalW = float(getNumLeafs(inTree))
    plotTree.totalD = float(getTreeDepth(inTree))
    plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0
    plotTree(inTree, (0.5, 1.0), '')
    plt.show()

#程序清单3-6：获取叶节点的数目
def getNumLeafs(myTree):
    numLeafs = 0 #初始化叶子
    firstStr = 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

#程序清单3-6：获取树的层数
def getTreeDepth(myTree):
    maxDepth = 0 
    firstStr = 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

#程序清单3-7：标注有向边属性
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)

#程序清单3-7：绘制决策函数
def plotTree(myTree, parentPt, nodeTxt):
    decisionNode = dict(boxstyle = "sawtooth", fc = "0.8")
    leafNode = dict(boxstyle = "round4", fc = "0.8")
    numLeafs = getNumLeafs(myTree)
    defth = getTreeDepth(myTree)
    firstStr = list(myTree.keys())[0]
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)  
    plotMidText(cntrPt, parentPt, nodeTxt)
    plotNode(firstStr, cntrPt, parentPt, decisionNode)
    secondeDict = myTree[firstStr]  
    plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD
    for key in secondeDict.keys():
        if type(secondeDict[key]) is dict:
            plotTree(secondeDict[key], cntrPt, str(key))
        else:
            plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
            plotNode(secondeDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
    plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD


if __name__ == '__main__':
    fr = open('lenses.txt')
    lenses = [inst.strip().split('\t') for inst in fr.readlines()]
    print(lenses)
    lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
    myTree_lenses = createTree(lenses, lensesLabels)
    createPlot(myTree_lenses)

运行结果如下：