决策树 （二）

# -*- coding: utf-8 -*-
"""
熵定义为信息的期望值。
熵：表示随机变量的不确定性。
条件熵：在一个条件下，随机变量的不确定性。
信息增益：熵 - 条件熵
在一个条件下，信息不确定性减少的程度！
如果选择一个特征后，信息增益最大（信息不确定性减少的程度最大），那么我们就选取这个特征。
"""
from  math import log
import operator
"""
函数说明：创建测试集
Parameter：
    无
Returns:
    dataSet 数据集
    Labels  分类属性
"""

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 = ['不放贷', '放贷']
    Labels = ['年龄', '有工作', '有自己的房子', '信贷情况']
    return dataSet, Labels

"""
函数说明：计算给定数据集的经验熵（香农熵）
Parameters:
    dataSet 数据集
Returns:
    shannonEnt 经验熵
"""
def calcShannonEnt(dataSet):
    #返回数据集的行数
    numEntirs = 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]) / numEntirs
        #
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt

"""
函数说明：按照给定特征划分数据集
Parameters:
    dataSet 待划分的数据集
    axis 划分数据集的特征
    value 需要返回的特征值
Returns:
    retDataSet 返回的数据集列表
        
"""
def splitDataSet(dataSet, axis, value):
    #返回的数据集列表
    retDataSet = []
    for featVec in dataSet:
       if featVec[axis] == value:
            #去掉axis特征
            reducedFeatVec = featVec[:axis]
            #reducedFeatVec = []
            #将符合条件的添加到返回的数据集
            reducedFeatVec.extend(featVec[axis+1 : ])
            retDataSet.append(reducedFeatVec)
    return retDataSet
        
"""
函数说明：选择最优特征
Paramaters:
    dataSet
Returns:
    beatFeature 信息增益最优的特征的索引值
"""
def chooseBestFeatureToSplit(dataSet):
    #特征数量
    numFeatures = len(dataSet[0]) - 1
    #计算数据集的香农熵
    baseEntropy = calcShannonEnt(dataSet)
    #信息增益
    bestInfoGain = 0.0
    #最优特征的索引值
    bestFeature = -1
    for i in range(numFeatures):
        #获取dataSet的第i个所有特征
        #将dataSet中的数据先按行依次放入example中，
        #然后取得example中的example[i]元素，放入列表featList中
        #相当于取所有行的第一个值
        #之所以这样取，是因为dataSet是个列表，而不是矩阵，矩阵取第一列有方法
        featList = [ example[i] for example in dataSet]
        #创建集合set,元素不可重复
        uniqueVals = set(featList)
        #经验条件熵
        newEntropy = 0.0
        #计算信息增益
        for value in uniqueVals:
            #subDataSet是划分后的子集
            subDataSet = splitDataSet(dataSet, i, value)
            #计算子集的概率
            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 = {}
    #统计classList中每个元素出现的次数
    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]

"""
函数说明：创建决策树
Parameters:
    dataSet 训练集
    Labels 分类标签
    featLabels 存储选择的最优特征标签
Returns:
    myTree 决策树
"""
def createTree(dataSet, Labels, featLabels):
    #取dataSet每行的最后一列的元素构成新的列表
    #相当于取dataSet最后一列的值
    classList = [example[-1] for example in dataSet]
    #若类别完全相同就停止划分
    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:
        myTree[bestFeatLabel][value] = createTree(
                splitDataSet(dataSet, bestFeat, value),
                Labels, featLabels)
    return myTree
"""
函数说明：使用决策树分类
Parameters:
    imputTree 已经生成的决策树
    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('不放贷')