机器学习-决策树建立（一）

优点：计算复杂度不高，输出结果易于理解，对中间再缺失不敏感，可以处理不相关特性。

缺点：可能产生过渡匹配问题

使用类型：数字型和标称型

一，基本概念

1，信息熵

度量样本集合纯度的最常用指标之一。值越小，则纯度越高。

公式为：

其中，Pk为第k类占总数的比例。

例如，有10个样本，4个为好，6个为坏，则信息熵为：Ent(D)=-(4/10*log2(4/10)+6/10*log2(6/10))

2,信息增益

用于衡量分支影响力大小。信息增益越大，则影响力越大。ID3决策树就是采用信息增益划分属性。

公式为：

其中，D为分支下的总数，Dv为占总数比例。

例如：数据如下：

 

1,青绿,蜷缩,浊响,清晰,凹陷,硬滑,是
2,乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,是
3,乌黑,蜷缩,浊响,清晰,凹陷,硬滑,是
4,青绿,蜷缩,沉闷,清晰,凹陷,硬滑,是
5,浅白,蜷缩,浊响,清晰,凹陷,硬滑,是
6,青绿,稍蜷,浊响,清晰,稍凹,软粘,是
7,乌黑,稍蜷,浊响,稍糊,稍凹,软粘,是
8,乌黑,稍蜷,浊响,清晰,稍凹,硬滑,是
9,乌黑,稍蜷,沉闷,稍糊,稍凹,硬滑,否
10,青绿,硬挺,清脆,清晰,平坦,软粘,否
11,浅白,硬挺,清脆,模糊,平坦,硬滑,否
12,浅白,蜷缩,浊响,模糊,平坦,软粘,否
13,青绿,稍蜷,浊响,稍糊,凹陷,硬滑,否
14,浅白,稍蜷,沉闷,稍糊,凹陷,硬滑,否
15,乌黑,稍蜷,浊响,清晰,稍凹,软粘,否
16,浅白,蜷缩,浊响,模糊,平坦,硬滑,否
17,青绿,蜷缩,沉闷,稍糊,稍凹,硬滑,否

 

信息熵有最后一列计算。ENT（D）=-（（8/17）*log2（8/17）+（9/17）*log2（9/17））=0.998

第二列分类可知，青绿为编号{1,4,6,10,13,16},则信息熵Ent（D1）=-（（3/6）*log2（3/6）+（3/6）*log2（3/6））=1

乌黑和浅白计算类似信息熵为0.918和0.722

则最终信息增益为：Gain（D，色泽）=0.998-（6/17*1+6/17*0.918+5/17*0.722）=0.109

3，信息增益率

信息增益对属性多有偏好，信息增益对属性少的有偏好。是ID4.5决策树算法。

公式如下：

4，基尼指数

基尼指数䦹一种衡量数据集纯度指标。基尼指数越小，纯度越高。

公式如下：

python代码：

新建两个Python文件：tree.py，用于决策树分类；treePlotter.py用于绘制图形

tree.py代码：

 

from math import log
import operator
import treePlotter as tp

def createDataSet():
    dataSet=[]
    fr = open('watermelon1.txt')
    for line in fr.readlines():
        lineArr = line.strip().split(',')
        dataSet.append(lineArr[:])  # 添加数据
    labels = ['编号','色泽','根蒂','敲声','纹理','头部','触感','好瓜']
    return dataSet, labels

#计算信息熵 Ent（D）=-Σp*log2(p)
def calcShannonEnt(dataSet):
    numEntries = len(dataSet)                    #数据总数
    labelCounts = {}
    for featVec in dataSet:
        currentLabel = featVec[-1]               #获取类别
        if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0   #新key加入字典赋值为0
        labelCounts[currentLabel] += 1           #已经存在的key，value+=1
    shannonEnt = 0.0
    for key in labelCounts:
        prob = float(labelCounts[key])/numEntries
        shannonEnt -= prob * log(prob,2)             #计算信息熵
    return shannonEnt

#获取特征值数据集
# dataSet --整个数据集
# axis --数据列
# value --类别
def splitSubDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            retDataSet.append([featVec[axis],featVec[-1]])
    return retDataSet

#除去划分完成的决策树数据量
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 calcconplot(subDataSet)

# 计算信息增益并返回信息增益最高的列
def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1      #获取所有特征值数量(减1是除去最后一列分类)
    baseEntropy = calcShannonEnt(dataSet)   #计算基础信息熵Ent(D)
    bestInfoGain = 0.0; bestFeature = []
    for i in range(1,numFeatures):        #遍历所有特征值
        featList = [example[i] for example in dataSet]#将特征值保存在列表中
        uniqueVals = set(featList)       #获取特征值分类
        newEntropy = 0.0                                               #特征值不连续
        for value in uniqueVals:
            subDataSet = splitSubDataSet(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.iteritems(), 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:{}}
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)                             # 获取特征值分类
    del(labels[bestFeat])                                    # 删除已经建立节点的特征值
    for value in uniqueVals:
        subLabels = labels[:]                                 # 复制出建立节点外的所有特征值
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)  #建立子节点
    return myTree

if __name__ == '__main__':
    myData,label = createDataSet()
    mytree = createTree(myData,label)
    tp.createPlot(mytree)

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

# 获取树深度
def getTreeDepth(myTree):
    maxDepth = 0
    firstStr = list(myTree.keys())[0]
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[key]).__name__=='dict':  #如果是节点则深度加1
            thisDepth = 1 + getTreeDepth(secondDict[key])
        else:   thisDepth = 1
        if thisDepth > maxDepth: maxDepth = thisDepth
    return maxDepth

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 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()

# 绘制节点文字
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):
    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]).__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

结果如下图：

接下来，我们给出测试数据如下：

1,青绿,蜷缩,浊响,清晰,凹陷,软粘
2,乌黑,稍蜷,沉闷,清晰,凹陷,硬滑
3,青绿,蜷缩,浊响,稍糊,平坦,硬滑
4,青绿,稍蜷,沉闷,清晰,凹陷,硬滑
5,浅白,蜷缩,浊响,稍糊,凹陷,硬滑
6,青绿,稍蜷,浊响,清晰,平坦,软粘
7,乌黑,稍蜷,浊响,稍糊,稍凹,软粘
8,青绿,稍蜷,浊响,清晰,稍凹,硬滑
9,乌黑,稍蜷,沉闷,稍糊,稍凹,硬滑
10,青绿,硬挺,浊响,清晰,平坦,软粘
11,浅白,硬挺,清脆,模糊,平坦,硬滑
12,浅白,蜷缩,浊响,模糊,平坦,软粘
13,青绿,稍蜷,浊响,稍糊,凹陷,硬滑
14,浅白,稍蜷,沉闷,稍糊,凹陷,硬滑
15,乌黑,稍蜷,浊响,清晰,稍凹,软粘
16,浅白,蜷缩,浊响,模糊,平坦,硬滑

17,青绿,蜷缩,浊响,稍糊,稍凹,软粘

然后在tree.py新增：

 

# 决策树进行分类
def classify(inputTree,featLabels,testVec):
    firstStr = list(inputTree.keys())[0]
    secondDict = inputTree[firstStr]
    featIndex = featLabels.index(firstStr)
    key = testVec[featIndex]
    valueOfFeat = secondDict[key]
    if isinstance(valueOfFeat, dict):
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else: classLabel = valueOfFeat
    return classLabel

# 读取测试数据
def createtestDataSet():
    dataSet=[]
    fr = open('testData.txt')
    for line in fr.readlines():
        lineArr = line.strip().split(',')
        dataSet.append(lineArr[:])  # 添加数据
    labels = ['编号','色泽','根蒂','敲声','纹理','头部','触感']
    return dataSet, labels

if __name__ == '__main__':
    myData,label = createDataSet()
    mytree = createTree(myData,label)
    tp.createPlot(mytree)
    testData,testlabel = createtestDataSet()
    for data in testData:
        cla = classify(mytree,testlabel,data)
        print(data)
        print(cla)

决策树分类得到如下结果：

['1', '青绿', '蜷缩', '浊响', '清晰', '凹陷', '软粘']
是
['2', '乌黑', '稍蜷', '沉闷', '清晰', '凹陷', '硬滑']
是
['3', '青绿', '蜷缩', '浊响', '稍糊', '平坦', '硬滑']
否
['4', '青绿', '稍蜷', '沉闷', '清晰', '凹陷', '硬滑']
是
['5', '浅白', '蜷缩', '浊响', '稍糊', '凹陷', '硬滑']
否
['6', '青绿', '稍蜷', '浊响', '清晰', '平坦', '软粘']
是
['7', '乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘']
是
['8', '青绿', '稍蜷', '浊响', '清晰', '稍凹', '硬滑']
是
['9', '乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑']
否
['10', '青绿', '硬挺', '浊响', '清晰', '平坦', '软粘']
否
['11', '浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑']
否
['12', '浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘']
否
['13', '青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑']
否
['14', '浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑']
否
['15', '乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘']
否
['16', '浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑']
否
['17', '青绿', '蜷缩', '浊响', '稍糊', '稍凹', '软粘']
是