【10月31日】机器学习实战（二）决策树：隐形眼镜数据集

决策树的优点：计算的复杂度不高，输出的结果易于理解，对中间值的确实不敏感，可以处理不相关的特征数据

决策树的缺点：可能会产生过度匹配的问题。

其本质的思想是通过寻找区分度最好的特征（属性），用于支持分类规则的制定。

那么哪些特征是区分度好的，哪些特征是区分度坏的呢？换句话说，如何衡量数据集中特征（属性）对实例的区分程度呢？

依据香农的信息论，引入信息熵的思想作为对特征区分程度的度量。当然，信息熵并不是唯一的度量指标，在一些机器学习的开源包中，也提供了别的依据。跟着书走，本次实验还是选择信息熵作为划分数据集的标准。原书《机器学习实战》中使用的是python2，本人在python3实现，略有不同。

源码+实验数据地址：https://github.com/MoonTreee/machine_learning

代码如下。
shannon.py

from math import log
import operator


# 计算信息熵
def clacShannon(data):
    num = len(data)
    # 用于计算每个类别出现的次数，配合num就可以计算该类别的概率了
    label_count = {}
    for feat_vec in data:
        # 向量的最后一个为标签（类别）
        current_label = feat_vec[-1]
        if current_label in label_count.keys():
            label_count[current_label] += 1
        else:
            label_count[current_label] = 1
    entropy = 0.0
    for key in label_count.keys():
        prob = float(label_count[key]) / num
        entropy -= prob * log(prob, 2)
    return entropy


# 划分数据集
# data 需要划分的数据，双重列表[[],[],……,[]]
# axis 划分的特征
# value 上述axis的值
def splitData(data, axis, value):
    result = []
    for feature_vec in data:
        if feature_vec[axis] == value:
            # 将符合条件的实例加入到result中（并去除了相应的特征）
            # result.append(feature_vec[:axis].extend(feature_vec[axis + 1:]))
            reduce_feat = feature_vec[:axis]
            reduce_feat.extend(feature_vec[axis+1:])
            result.append(reduce_feat)
    return result


# 选择分类效果最好的特征
def chooseFeature(data):
    num_data = len(data)
    num_feature = len(data[0]) - 1
    # 原始数据的香农熵
    base_entropy = clacShannon(data)
    # 信息增益
    best_info_gain = 0.0
    # 分类效果最好的特征
    best_feature = -1
    # 计算各个特征的信息增益
    for i in range(num_feature):
        # 获取特征i下所有可能的取值,并去重
        feature_list = [example[i] for example in data]
        values = set(feature_list)
        # 新的香农熵
        new_entropy = 0.0
        for value in values:
            sub_data = splitData(data, i, value)
            prob = len(sub_data) / float(num_data)
            new_entropy += prob * clacShannon(sub_data)
        info_gain = base_entropy - new_entropy
        # 选择分类效果最好--信息增益最大
        if info_gain > best_info_gain:
            best_info_gain = info_gain
            best_feature = i
    return best_feature


# 使用投票机制确定节点的类别
def majorityCnt(class_list):
    class_count = {}
    for vote in class_list:
        if vote not in class_count.keys():
            class_count[vote] = 0
        class_count[vote] += 1
    # 选取票数最多的作为分类作为该节点的最终类别
    sorted_class_count = sorted(class_count.items(), key=operator.itemgetter(1), reversed=True)
    return sorted_class_count[0][0]


# 创建决策树
# data 数据集，每条记录的最后一项为该实例的类别
# labels 为了增加结果的可解释性，设定标签
def createTree(data, labels):
    # data中每条记录的最后一项为该实例的类别
    class_list = [example[-1] for example in data]
    # 结束条件一：该分支下所有记录的类别相同，则为叶子节点，停止分类
    if class_list.count(class_list[0]) == len(class_list):
        return class_list[0]
    # 结束条件二：所有特征使用完毕，该节点为叶子节点，节点类别投票决定
    if len(data[0]) == 1:
        return majorityCnt(class_list)
    best_feature = chooseFeature(data)
    best_label = labels[best_feature]
    my_tree = {best_label: {}}
    del(labels[best_feature])
    feature_values = [example[best_feature] for example in data]
    unique_values = set(feature_values)
    for value in unique_values:
        sub_lables = labels[:]
        # 递归
        my_tree[best_label][value] = createTree(splitData(data, best_feature, value), sub_lables)
    return my_tree


# 使用决策树进行分类
# 参数说明：决策树， 标签， 待分类数据
def classify(input_tree, feature_labels, test_vec):
    first_str = input_tree.keys()[0]
    second_dict = input_tree[first_str]
    # 得到第特征的索引，用于后续根据此特征的分类任务
    feature_index = feature_labels.index(first_str)
    for key in second_dict.keys():
        if test_vec[feature_index] == key:
            if type(second_dict[key]).__name__ == 'dict':
                classLabel = classify(second_dict[key], feature_labels, test_vec)
            # 达到叶子节点，返回递归调用，得到分类
            else:
                classLabel = second_dict[key]
    return classLabel


# 决策树的存储
# 决策树的构造是一个很耗时的过程，因此需要将构造好的树保存起来以备后用
# 使用pickle序列化对象
def storeTree(input_tree, filename):
    import pickle
    fw = open(filename, "w")
    pickle.dump(input_tree, fw)
    fw.close()


# 读取文件中的决策树
def grabTree(filename):
    import pickle
    fr = open(filename)
    return pickle.load(fr)

tree_plot.py

import matplotlib.pyplot as plt

# 用字典进行存储
# boxstyle为文本框属性， 'sawtooth'：锯齿型；fc为边框粗细
decision_node = dict(boxstyle='sawtooth', fc='0.8')
leaf_node = dict(boxstyle='round4', fc='0.8')
arrow_args = dict(arrowstyle='<-')


# node_txt 要注解的文本，center_pt文本中心点，箭头指向的点，parent_pt箭头的起点
def plotNode(node_txt, center_pt, parent_pt, node_type):
    createPlot.ax1.annotate(node_txt, xy=parent_pt, xycoords='axes fraction',
                            xytext=center_pt, textcoords='axes fraction',
                            va="center", ha="center", bbox=node_type, arrowprops=arrow_args)


# 创建画板
def createPlot(in_tree):
    # figure创建画板，‘1’表示第一个图，背景为白色
    fig = plt.figure(1, facecolor='white')
    # 清空画板
    fig.clf()
    axprops = dict(xticks=[], yticks=[])
    # subplot(x*y*z）,表示把画板分割成x*y的网格，z是画板的标号，
    # frameon=False表示不绘制坐标轴矩形
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
    # plotNode('decision_node', (0.5, 0.1), (0.1, 0.5), decision_node)
    # plotNode('leaf_node', (0.8, 0.1), (0.8, 0.3),  leaf_node)
    # plt.show()
    # 存储树的宽度
    plotTree.totalW = float(getNumLeafs(in_tree))
    # 存储树的深度
    plotTree.totalD = float(getTreeDepth(in_tree))
    # xOff用于追踪已经绘制的节点的x轴位置信息，为下一个节点的绘制提供参考
    plotTree.xOff = -0.5/plotTree.totalW
    # yOff用于追踪已经绘制的节点y轴的位置信息，为下一个节点的绘制提供参考
    plotTree.yOff = 1.0
    plotTree(in_tree, (0.5, 1.0), '')
    plt.show()


# 为了绘制树，要先清楚叶子节点的数量以及树的深度--以便确定x轴的长度和y轴的高度
# 下面就分别定义这两个方法
def getNumLeafs(my_tree):
    num_leafs = 0
    first_str = next(iter(my_tree))  # 找到第一个节点
    second_dic = my_tree[first_str]
    # 测试节点数据是否为字典类型，叶子节点不是字典类型
    for key in list(second_dic.keys()):
        # 如果节点为字典类型，则递归使用getNumLeafs()
        if type(second_dic[key]).__name__ == 'dict':
            num_leafs += getNumLeafs(second_dic[key])
        else:
            num_leafs += 1
    return num_leafs


def getTreeDepth(my_tree):
    max_depth = 0
    first_str = next(iter(my_tree))
    second_dic = my_tree[first_str]
    # 测试节点数据是否为字典类型，叶子节点不是字典类型
    for key in list(second_dic.keys()):
        # 如果节点为字典类型，递归使用getTreeDepth()
        if type(second_dic[key]).__name__ == 'dict':
            this_depth = 1 + getTreeDepth(second_dic[key])
        else:
            # 当节点不为字典型，为叶子节点，深度遍历结束
            # 从递归中调用返回，且深度加1
            this_depth = 1
        # 最大的深度存储在max_depth中
        if this_depth > max_depth:
            max_depth = this_depth

    return max_depth


# 在父子节点之间填充文本信息进行标注
# 在决策树中此处应是对应父节点的属性值
def plotMidText(center_pt, parent_pt, txt_string):
    x_mid = (parent_pt[0] - center_pt[0])/2.0 + center_pt[0]
    y_mid = (parent_pt[1] - center_pt[1])/2.0 + center_pt[1]
    createPlot.ax1.text(x_mid, y_mid, txt_string)


def plotTree(my_tree, parent_pt, node_txt):
    num_leafs = getNumLeafs(my_tree)
    depth = getTreeDepth(my_tree)
    first_str = list(my_tree.keys())[0]
    # 以第一次调用为例说明
    # 此时 绘制的为根节点，根节点的x轴：-0.5/plotTree.totalW + (1.0 + float(num_leafs))/2.0/plotTree.totalW
    # 假设整个树中叶子节点的数目为6 则上述根节点的x轴：-0.5/6 + (1 + 6)/2.0/6 = 0.5
    # 实际上，对于根节点而言，下式的值始终是0.5
    center_pt = (plotTree.xOff + (1.0 + float(num_leafs))/2.0/plotTree.totalW, plotTree.yOff)
    plotMidText(center_pt, parent_pt, node_txt)
    plotNode(first_str, center_pt, parent_pt, decision_node)
    second_dict = my_tree[first_str]
    # y轴的偏移--深度优先的绘制策略
    plotTree.yOff -= 1.0 / plotTree.totalD
    for key in list(second_dict.keys()):
        if type(second_dict[key]).__name__ == 'dict':
            plotTree(second_dict[key], center_pt, str(key))
        else:
            plotTree.xOff += 1.0 / plotTree.totalW
            plotNode(second_dict[key], (plotTree.xOff, plotTree.yOff), center_pt, leaf_node)
            plotMidText((plotTree.xOff, plotTree.yOff), center_pt, str(key))
    plotTree.yOff += 1.0 / plotTree.totalD

测试代码

fr = open('lenses.txt')
    lenses = [inst.strip().split('\t') for inst in fr.readlines()]
    lenses_labels = ['age', 'prescript', 'astigmatic', 'tear_rate']
    lenses_tree = shannon.createTree(lenses, lenses_labels)
    print(lenses_tree)
    tree_plotter.createPlot(lenses_tree)

实验结果：