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

爱被打了一巴掌 2022-05-17 02:43 285阅读 0赞

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

最近在学习决策树，在学习机器学习的过程中我发现这两本书确实很好用，推荐给大家~[机器学习实战和机器学习周志华][Link 1]（链接是在某宝随便找的~）。

--------------------

下面给大家奉上隐形眼镜数据集吧，在网上找了一会儿  
young myope no reduced no lenses  
young myope no normal soft  
young myope yes reduced no lenses  
young myope yes normal hard  
young hyper no reduced no lenses  
young hyper no normal soft  
young hyper yes reduced no lenses  
young hyper yes normal hard  
pre myope no reduced no lenses  
pre myope no normal soft  
pre myope yes reduced no lenses  
pre myope yes normal hard  
pre hyper no reduced no lenses  
pre hyper no normal soft  
pre hyper yes reduced no lenses  
pre hyper yes normal no lenses  
presbyopic myope no reduced no lenses  
presbyopic myope no normal no lenses  
presbyopic myope yes reduced no lenses  
presbyopic myope yes normal hard  
presbyopic hyper no reduced no lenses  
presbyopic hyper no normal soft  
presbyopic hyper yes reduced no lenses  
presbyopic hyper yes normal no lenses

--------------------

直接将这24段粘贴到自己的TXT文件中就可以啦~  
决策树的预测代码如下：

import imp
    import trees
    imp.reload(trees)
    imp.reload(treePlotter)
    #使用决策树预测隐形眼镜类型
    fr = open('lenses.txt','r')
    lenses = [inst.strip().split('\t') for inst in fr.readlines()]  
    #整理lenses.txt文件，让它变成列表 
    for value in lenses:
        for n in range(len(value)):
            value[n]=value[n].replace(' ','')
    print(lenses)
    lensesLabels=['age','prescript','astigmatic','tearRate']
    lensesTree=trees.createTree(lenses,lensesLabels)
    treePlotter.createPlot(lensesTree)

由于lenses.txt中有空格并且要分列所以用到了for循环、strip()和split()，最后的结果如下图：  
![这里写图片描述][70]  
用了Matplotlib注解绘制树形图之后可以对分类过程一目了然，很好的展示了决策树的优势。当然代码中的trees.createTree()和treePlotter.createPlot()都是事先编码好的，由于机器学习实战用的是python2（应该是这样），在用python3跑书上的代码时会有一些报错的地方，下面我把改过的trees.py和treePlotter.py的代码也附上。注：我用的是python3.5

trees.py：

#计算香农熵
    from math import log
    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
    
    #建立数据集
    def createDataSet ():
        dataSet=[[1,1,'yes'],
                 [1,1,'yes'],
                 [1,0,'no'],
                 [0,1,'no'],
                 [0,1,'no']]
        labels=['no surfacing','flippers']
        return dataSet,labels
    
    #按照给定特征划分数据集
    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
    #选择最好的划分数据集的方式
    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
    
    
    def majorityCnt(classList):
        classCount={}
        for vote in 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]
    #创建树的函数代码 
    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:
            subLables=labels[:]
            myTree[bestFeatLabel][value]=createTree(splitDataSet(dataSet,bestFeat,value),subLables)
        return myTree
    
    #import imp
    #import trees
    #imp.reload(trees)
    #myDat,labels=trees.createDataSet()
    #myTree=trees.createTree(myDat,labels)
    #myTree
    
    def classify(inputTree,featLabels,testVec):
        firstStr=list(inputTree.keys())[0]
        secondDict=inputTree[firstStr]
        featIndex=featLabels.index(firstStr)
        for key in secondDict.keys():
            if testVec[featIndex]==key:
                if type(secondDict[key])==dict:
                    classLabel=classify(secondDict[key],featLabels,testVec)
                else:classLabel=secondDict[key]
        return classLabel
    #分类器储存 
    def storeTree(inputTree,filename):      
        import pickle
        fw=open(filename,'wb+')
        pickle.dump(inputTree,fw)
        fw.close()
    #分类器读取
    def grabTree(filename):
        import pickle
        fr=open(filename,'rb')
        return pickle.load(fr)

treePlotter.py：

#使用文本注解绘制树节点
    import matplotlib.pyplot as plt
    
    decisionNode=dict(boxstyle="sawtooth",fc="0.8")
    leafNode=dict(boxstyle="round4",fc="0.8")
    arrow_args=dict(arrowstyle="<-")
    
    def plotNode(nodeTxt,centerPt,parentPt,nodeType):
        createPlot.ax1.annotate(nodeTxt,xy=parentPt,xycoords='axes fraction',xytext=centerPt,\
        textcoords='axes fraction',va="center",ha="center",bbox=nodeType,arrowprops=arrow_args)
    
    
    #获取叶节点的数目
    def getNumLeafs(myTree):
        numLeafs=0
        firstSides = list(myTree.keys())
        firstStr = firstSides[0]
        secondDict=myTree[firstStr]
        for key in secondDict.keys():
            if type(secondDict[key])==dict:
                numLeafs+=getNumLeafs(secondDict[key])
            else : numLeafs+=1
        return numLeafs
    #获取树的层数 
    def getTreeDepth(myTree):
        maxDepth=0
        firstSides = list(myTree.keys())
        firstStr = firstSides[0]
        secondDict=myTree[firstStr]
        for key in secondDict.keys():
            if type(secondDict[key])==dict:
                thisDepth=1+getTreeDepth(secondDict[key])
            else:thisDepth=1
            if thisDepth>maxDepth:maxDepth=thisDepth
        return maxDepth
    
    #预存树的信息
    def retrieveTree(i):
        listOfTrees=[{
       'no surfacing':{
       0:'no',1:{
       'flippers':{
       0:'no',1:'yes'}}}},
                     {
       'no surfacing':{
       0:'no',1:{
       'flippers':{
       0:{
       'head':{
       0:'no',1:'yes'}},1:'no'}}}}]
        return listOfTrees[i]
    
    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)
    
    def plotTree(myTree,parentPt,nodeTxt):
        numLeafs=getNumLeafs(myTree)
        depth=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)
        secondDict=myTree[firstStr]
        plotTree.yOff=plotTree.yOff-1.0/plotTree.totalD
        for key in secondDict.keys():
            if type(secondDict[key])==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
    
    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.01/plotTree.totalW;plotTree.yOff=1.0;
        plotTree(inTree,(0.5,1.0),'')
        plt.show()

每一个改动的点我就不一一列出来啦，可以对照书找一找  
虽然可以直接调python的机器学习库sklearn来做相关的算法练习，但是这些代码有利于我们对算法深入了解，还是有必要一步一步实现一下~~~

[Link 1]: https://detail.tmall.com/item.htm?id=572643478201&ali_refid=a3_430673_1006:1110435794:N:%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%20%E5%91%A8%E5%BF%97%E5%8D%8E:685ff6bc3bd63a8327865dbd5ff70f2b&ali_trackid=1_685ff6bc3bd63a8327865dbd5ff70f2b&spm=a2e15.8261149.07626516002.5
[70]: /images/20220517/7741d83a7a58452d82b472ca906da265.png