如何构造决策树来做分类（西瓜书+机器学习实战）

前言

数据结构和算法先等刷一波题有点心得再继续，刷题和复习不矛盾，就开始搞搞机器学习基础知识！参考了《机器学习》（西瓜书）和《机器学习实战》，这两本书真的好！

基本流程

基本算法

参考《机器学习》（西瓜书）

决策树中的几种情况

1. D中样本都是一个类别C，那么就没必要继续分了，所以可以标记为C类叶结点
2. $A=\varnothing$代表没有没划分的属性了，D中样本在A上取值相同

划分标准

信息熵

信息增益

代码+注解

参考《机器学习实战》，对《机器学习》中的西瓜数据集2.0进行操作，这里面的createDataset函数直接写了数据集上去

画图的代码这里没有附上，因为有一点bug，等我改好了再放链接。
trees.py

from math import log
import operator
import pickle

"""
决策树的一般流程
1. 收集数据
2. 准备数据：树构造算法只适用于标称型数据，因此必须离散化数据
3. 分析数据：可以使用任何方法，构造树完成后要判断是否符合预期
4. 训练算法：构造树的数据结构
5. 测试算法：使用经验树计算错误率
6. 使用该算法：决策树能更好理解划分的内在含义
"""


def createDataset():
    dataset = [
        [0, 0, 0, 0, 0, 0, 'yes'],
        [1, 0, 1, 0, 0, 0, 'yes'],
        [1, 0, 0, 0, 0, 0, 'yes'],
        [0, 0, 1, 0, 0, 0, 'yes'],
        [2, 0, 0, 0, 0, 0, 'yes'],
        [0, 1, 0, 0, 1, 1, 'yes'],
        [1, 1, 0, 1, 1, 1, 'yes'],
        [1, 1, 0, 0, 1, 0, 'yes'],
        [1, 1, 1, 1, 1, 0, 'no'],
        [0, 2, 2, 0, 2, 1, 'no'],
        [2, 2, 2, 2, 2, 0, 'no'],
        [2, 0, 0, 2, 2, 1, 'no'],
        [0, 1, 0, 1, 0, 0, 'no'],
        [2, 1, 1, 1, 0, 0, 'no'],
        [1, 1, 0, 0, 1, 1, 'no'],
        [2, 0, 0, 2, 2, 0, 'no'],
        [0, 0, 1, 1, 1, 0, 'no']
    ]

    # labels = ['no surfacing', 'flippers']
    labels = ['color', 'root', 'sound', 'texture', 'bottom', 'touch']
    return dataset, labels


def calShannonEnt(dataset):
    '''
    计算信息熵
    :param dataset:
    :return:
    '''
    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
        # 以2为底求对数
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt


# 根据某一个属性的某个值来分割原本dataset
def splitDataSet(dataset, axis, value):
    '''
    :param dataset: 就是dataset
    :param axis: 某个属性
    :param value: 某个属性的某个值
    :return: 分割之后的新dataset
    '''
    # 创建新的list对象，避免更改原本的dataset
    retDataSet = []
    for featVec in dataset:
        if featVec[axis] == value:
            reducedDataSet = featVec[:axis]
            reducedDataSet.extend(featVec[axis + 1:])
            retDataSet.append(reducedDataSet)
    return retDataSet


def chooseBestFeatureToSplit(dataset):
    '''
    ID3就是用能使得信息增益最高的属性作为划分属性的，这个函数就是用来做这个作用的
    :param dataset:
    :return: bestFeature，也就是最好的特征的下标
    '''
    numFeatures = len(dataset[0]) - 1  # dataset的最后一列是label，所以feature的数量就要比原本-1了
    baseEntropy = calShannonEnt(dataset)  # 计算没划分前的entropy
    bestInfoGain = 0.0  # 初始化最好的信息增益为0
    bestFeature = -1  # 初始化最好的feature的位置为-1
    for i in range(numFeatures):
        # 以下两行是创建唯一的分类标签列表，也就是找出这个标签有几个选项
        # 比如i=0是血型这个属性，血型这个属性有ABO三个可能取值
        # 然后featList就会是比如AABBOOOOABOA
        featList = [example[i] for example in dataset]
        # 而我们只要筛选出ABO三个取值，所以用个直接用个set强转就可以了
        uniqueVals = set(featList)

        newEntropy = 0.0
        # 以下五行计算每种划分方式的信息熵
        for value in uniqueVals:
            subDataSet = splitDataSet(dataset, i, value)
            # print('subDataSet: ', subDataSet) # 如果不是很清楚信息增益的定义，就打印这个细节出来看
            prob = float(len(subDataSet)) / float(len(dataset))
            newEntropy += prob * calShannonEnt(subDataSet)
        infoGain = baseEntropy - newEntropy
        if infoGain > bestInfoGain:
            # 计算最好的信息增益
            bestInfoGain = infoGain
            bestFeature = i
    return bestFeature  # 我们不需要最好的信息增益的值，我们需要的是最好的那个feature的下标


def majorityCnt(classList):
    '''
    将classList中每个类别的出现的次数统计出来，并且进行降序，也就是出现最多次的排最前面
    :param classList:
    :return: 出现最多次的类别
    '''
    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)  # items()返回的是key-value形成的tuple，itemgetter(1)代表取第一维度的
    print('sortedClassCount: ',sortedClassCount)
    return sortedClassCount[0][0]


def createTree(dataset, labels):
    '''
    递归进行造树
    :param dataset: 训练集
    :param labels: 标签
    :return: 训练好的树
    '''
    labels_copy = labels.copy()
    classList = [example[-1] for example in dataset]
    # 以下两行代码表示类别完全相同则停止继续划分
    # 如果一整个classList里面的类别都是一样的，那么代表从第0个到最后一个都是一样的，所以可以这样判断
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    # 以下两行遍历完所有特征时，仍然不能将数据集划分成仅包含唯一类别的分组
    # 因此返回出现次数最多的类别
    if len(dataset[0]) == 1:
        return majorityCnt(classList)
    bestFeat = chooseBestFeatureToSplit(dataset)
    bestFeatLabel = labels_copy[bestFeat]
    myTree = {bestFeatLabel: {}}  # 使用字典作为树的结点

    del (labels_copy[bestFeat])
    featValues = [example[bestFeat] for example in dataset]  # best feature的所有值
    uniqueVals = set(featValues)
    for value in uniqueVals:
        subLabels = labels_copy[:]  # 因为python的参数是按照引用传递的，为了防止原labels被改变，所以要一个sublabels来传递
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataset, bestFeat, value), subLabels)
    return myTree


def classify(inputTree, featLabels, testVec):
    '''
    对新的目标进行分类
    :param inputTree: 训练好的决策树
    :param featLabels: 标签
    :param testVec: 要进行分类的数据（单条）
    :return: 类别
    '''
    firstStr = list(inputTree.keys())[0]
    secondDict = inputTree[firstStr]

    featIndex = featLabels.index(firstStr)
    classlabel = None
    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


def storeTree(inputTree, filename):
    '''
    使用pickle来储存树
    :param inputTree: 树
    :param filename: 文件名
    :return:
    '''
    fw = open(filename, 'w')
    pickle.dump(inputTree, fw)
    fw.close()


def grabTree(filename):
    '''
    使用pickle来读取储存的树
    :param filename: 文件名
    :return:
    '''
    fr = open(filename)
    return pickle.load(fr)

main.py

import trees

if __name__ == '__main__':
    myDat, labels = trees.createDataset()
    print('labels: ', labels)
    print(myDat)
    shannonEnt = trees.calShannonEnt(myDat)
    print(shannonEnt)
    print(trees.chooseBestFeatureToSplit(myDat))
    myTree = trees.createTree(myDat, labels)
    print(myTree)
    treePlotter.createPlot(myTree)
    classLabel = trees.classify(myTree, labels, [0, 0, 0, 0, 0, 0])
    print('class label is ',classLabel)