机器学习实战——决策树代码解析（py3）

创建树部分代码

from math import log
import operator

"""
输入自己的createDataSet()
"""

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
myDat,labels=createDataSet()
#print("myDat=\n",myDat)
#print("labels=\n",labels)
"""
计算给定数据集的香农熵
"""
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
calcShannonEnt(myDat)
#shannonEnt=calcShannonEnt(myDat)
#print(shannonEnt)

"""
测试熵的变化
myDat[0][-1]='maybe'
calcShannonEnt(myDat)
shannonEnt=calcShannonEnt(myDat)

"""


"""
按照给定特征划分数据集
              [[1, 1, 'yes'],
               [1, 1, 'yes'],
               [1, 0, 'no'],
               [0, 1, 'no'],
               [0, 1, 'no']]

"""
def splitDataSet(dataSet, axis, value):  #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
splitDataSet(myDat, 0, 1)
#retDataSet=splitDataSet(myDat, 0, 1)
#print(retDataSet)


"""
选择最好的数据集划分方式（最优特征）
"""
def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1  # 第一个元素中所包含元素-1（特征数量）
    baseEntropy = calcShannonEnt(dataSet)  # 计算数据集的香农熵
    bestInfoGain = 0.0  # 信息增益
    bestFeature = -1    # 最优特征的索引值
    for i in range(numFeatures):   # 遍历所有特征
        featList = [example[i] for example in dataSet]   #把该特征的属性值取出
        uniqueVals = set(featList)  # 创建set集合{},元素不可重复
        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  # 返回索引值
chooseBestFeatureToSplit(myDat)



"""多数表决函数"""
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)
    #sorted:对可迭代对象进行排序操作（everse = True 降序 ，False 升序）
    #itemgetter函数用于获取对象的哪些维的数据  
    return sortedClassCount[0][0]  # 返回classList中出现次数最多的元素（key值）
List1=['yes','yes','no','yes','no']
majorityCnt(List1)



"""
创建决策树
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
"""


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[:]       #得到labels的拷贝
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)
#递归（取value值）  
    return myTree

myDat,labels=createDataSet()
createTree(myDat,labels) 


'''
 使用决策树分类
''' 

def classify(inputTree, featLabels, testVec):   # 决策树、特征标签向量、欲分类数据
    first = list(inputTree.keys())
    firstStr = first[0]  
    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 



myDat,labels=createDataSet()
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]
myTree=retrieveTree(0)
classify(myTree, labels, [1,0])

'''#测试
'''


'''
使用pickle模块存储决策树
'''

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)#反序列化对象，返回数据类型与存储前一致

'''
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]
myTree=retrieveTree(0)
storeTree(myTree,'classifierStorage.txt')
grabTree('classifierStorage.txt')    
'''   


'''
示例：使用决策树预测隐形眼镜类型 
'''
import treePlotter
fr=open('lenses.txt')
lenses=[inst.strip().split('\t') for inst in fr.readlines()]#处理数据：去除空格，并分割成以Tab分隔的字符串
lensesLabels=['age','prescript','astigmatic','tearRate']#特征为年龄、症状、是否散光、眼泪数量
lensesTree=createTree(lenses,lensesLabels)
treePlotter.createPlot(lensesTree)


'''
应用
storeTree(lensesTree,'lenses.classifierStorage.txt')
grabTree('lenses.classifierStorage.txt') 
lensesLabels=['age','prescript','astigmatic','tearRate']  
classify(lensesTree, lensesLabels, ['young','myope','yes','reduced'])



''' 

创建树部分代码

"""
使用文本注解绘制树节点
"""
import matplotlib.pyplot as plt

decisionNode = dict(boxstyle="sawtooth", fc="0.8")    # 判断节点，文本框的类型为锯齿形，fc是文本框背景颜色
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 )
#xycoords和textcoords是xy（被注释的坐标点）与xytext（注释文字的坐标）的坐标系说明
#axes fraction：子图坐标系：0,0 是轴域左下角，1,1 是右上角
#va/ha 相对于注释点垂直/水平对齐方式
    
'''
第一个版本的createPlot():

def createPlot():
    fig = plt.figure(1, facecolor='white')  # 定义一个画布，背景为白色
    fig.clf() #清空
    createPlot.ax1 = plt.subplot(111, frameon=False)
# createPlot.ax1为全局变量，绘制图像的句柄，subplot为定义了一个绘图，
# frameon为是否绘制坐标轴矩形
    plotNode('a decision node', (0.5, 0.1), (0.1, 0.5), decisionNode)
    plotNode('a leaf node', (0.8, 0.1), (0.3, 0.8), leafNode)
    plt.show()
createPlot()
'''

'''
获取叶节点的数目和树的层数
'''
def getNumLeafs(myTree):
    numLeafs = 0
    # firstStr = myTree.keys()[0] python2写法
    first = list(myTree.keys())   #mytree的第一个特征值 
    firstStr = first[0]           #（以字符串显示）
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[key]).__name__=='dict':
            numLeafs += getNumLeafs(secondDict[key])
        else:   numLeafs +=1
    return numLeafs


def getTreeDepth(myTree):
    maxDepth = 0
    # firstStr = myTree.keys()[0] 
    first = list(myTree.keys()) 
    firstStr = first[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

'''
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]

myTree=retrieveTree(0)

getNumLeafs(myTree)
getTreeDepth(myTree)

'''

'''
构造树
'''
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)
    
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)  # 层数
    first = list(myTree.keys())   
    firstStr = first[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  # 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
    

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()
#myTree['no surfacing'][3]='maybe'
#createPlot(myTree)