机器学习--决策树(ID3)算法

一、基本原理

    决策树是一个预测模型。它代表的是对象属性与对象值之间的一种映射关系。树中每个节点表示某个对象，每个分支路径代表某个可能的属性值，每个叶结点则对应从根节点到该叶节点所经历的路径所表示的对象的值。一般情况下，决策树由决策结点、分支路径和叶结点组成。在选择哪个属性作为结点的时候，采用信息论原理，计算信息增益，获得最大信息增益的属性就是最好的选择。信息增益是指原有数据集的熵减去按某个属性分类后数据集的熵所得的差值。然后采用递归的原则处理数据集，并得到了我们需要的决策树。   

二、算法流程

    检测数据集中的每个子项是否属于同一分类：

        If 是，则返回类别标签；

        Else             

           计算信息增益，寻找划分数据集的最好特征          

           划分数据数据集

           创建分支节点（叶结点或决策结点）

               for 每个划分的子集

                   递归调用，并增加返回结果到分支节点中

           return 分支结点

三、算法的特点

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

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

    适用数据范围：数值型和标称型。

 

四、python代码实现

 

1、创建初始数据集，用于测试

 

######################################
#功能：创建数据集
#输入变量：空
#输出变量：data_set, labels 数据集，标签
######################################
def create_data_set():

    data_set = [[1, 1, 'yes'],  
                [1, 1, 'yes'],
                [1, 0, 'no'],
                [0, 1, 'no'],
                [0, 1, 'no']]    #  数据集最后一列表示叶结点，也称类别标签
    labels = ['no surfacing', 'flippers']   # 表示决策结点，也称特征标签

    return data_set, labels

 

2、计算给定数据集的信息熵

 

#############################
#功能：计算信息熵
#输入变量：data_set 数据集
#输出变量：shannon_ent 信息熵
#############################
def calc_shannon_ent(data_set):

    num_entries = len(data_set)
    label_counts = {}

    for feat_vec in data_set:
        current_label = feat_vec[-1]
        # get相当于一条if...else...语句
        # 如果参数current_label不在字典中则返回参数0，
        # 如果current_label在字典中则返回current_label对应的value值
        label_counts[current_label] = label_counts.get(current_label, 0) + 1

    shannon_ent = 0.0

    for key in label_counts:
        prob = float(label_counts[key])/num_entries
        shannon_ent -= prob*log(prob, 2)

    return shannon_ent

 

3、按照给定特征划分数据集。分类算法除了需要测量信息熵，还需要划分数据集，这就需要对每个特征划分数据集的结果计算一次信息熵，然后判断按照哪个特征划分数据集是最好的划分方式。

#################################
#功能：划分数据集
#输入变量：data_set, axis, value
# 数据集，数据集的特征，特征的值
#输出变量：ret_data_set, 划分后的数据集
#################################

def split_data_set(data_set, axis, value):

    ret_data_set = []

    for feat_vec in data_set:
        if feat_vec[axis] == value:

            # 把axis特征位置之前和之后的特征值切出来
            # 没有使用del函数的原因是，del会改变原始数据
            reduced_feat_vec = feat_vec[:axis]
            reduced_feat_vec.extend(feat_vec[axis+1:])
            ret_data_set.append(reduced_feat_vec)

    return ret_data_set

 

4、遍历整个数据集，循环划分数据并计算信息熵，通过计算最大信息增益来找到最好的特征划分方式。

具体做法是，遍历当前特征中的所有唯一属性值，对每个特征划分一次数据集，然后计算数据集的新熵值，并对所有唯一特征值得到的熵求和。最后用所求的和值与原始信息熵相减，计算寻找最大信息增益。

######################################
#功能：选择最好的数据集划分方式
#输入变量：data_set 待划分的数据集
#输出变量：best_feature 计算得出最好的划分数据集的特征
######################################
def choose_best_feature_to_split(data_set):

    num_features = len(data_set[0]) - 1  # 最后一个是类别标签，所以特征属性长度为总长度减1
    base_entropy = calc_shannon_ent(data_set)  # 计算数据集原始信息熵

    best_info_gain = 0.0
    best_feature = -1

    for i in xrange(num_features):

        # feat_vec[i]代表第i列的特征值，在for循环获取这一列的所有值
        feat_list = [feat_vec[i] for feat_vec in data_set]
        unique_vals = set(feat_list)  # set函数得到的是一个无序不重复数据集

        new_entropy = 0.0

        # 计算每种划分方式的信息熵
        for value in unique_vals:

            sub_data_set = split_data_set(data_set, i, value)
            prob = len(sub_data_set)/float(len(data_set))
            new_entropy += prob*calc_shannon_ent(sub_data_set)

        info_gain = base_entropy - new_entropy

        if info_gain > best_info_gain:

            best_info_gain = info_gain
            best_feature = i

    return best_feature

 

5、递归构建决策树

工作原理：得到原始数据集，然后基于最好的属性值划分数据集，由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后，数据将被向下传递到树分支的下一个节点，在这个节点上，我们可以再次划分数据。因此我们可以采用递归的原则处理数据集。

递归结束条件是：第一、所有的类别标签（叶结点）完全相同。第二、使用完了所有的特征，仍然不能将数据集划分成仅包含唯一类别的分组，则挑选出次数最多的类别作为返回值。

 

######################################
#功能：多数表决分类
#输入变量：class_list 所有数据的标签数组
#输出变量：sorted_class_count[0][0] 出现次数最多的分类名称
######################################
def majority_vote_sort(class_list):

    class_count = {}

    for vote in class_list:
        class_count[vote] = class_count.get(vote, 0) + 1

    # items以列表方式返回字典中的键值对，iteritems以迭代器对象返回键值对，而键值对以元组方式存储，即这种方式[(), ()]
    # operator.itemgetter(0)获取对象的第0个域的值，即返回的是key值
    # operator.itemgetter(1)获取对象的第1个域的值，即返回的是value值
    # operator.itemgetter定义了一个函数，通过该函数作用到对象上才能获取值
    # reverse=True是按降序排序
    sorted_class_count = sorted(class_count.iteritems(), key=operator.itemgetter(1), reverse=True)

    return sorted_class_count[0][0]

 

######################################
#功能：创建数
#输入变量：data_set, labels 待分类数据集，标签
#输出变量：my_tree 决策树
######################################
def create_tree(data_set, labels):

    class_list = [example[-1] for example in data_set]

    # 判断类别标签是否完全相同
    # count()是列表内置的方法，可以统计某个元素在列表中出现的次数
    if class_list.count(class_list[0]) == len(class_list):
        return class_list[0]

    # 遍历完所有特征时返回出现次数最多的
    if len(data_set[0]) == 1:
        return majority_vote_sort(class_list)

    best_feat = choose_best_feature_to_split(data_set)
    best_feat_label = labels[best_feat]
    my_tree = {best_feat_label: {}}
    del(labels[best_feat])

    # 得到列表包含的所有属性值
    feat_values = [example[best_feat] for example in data_set]
    unique_vals = set(feat_values)

    for value in unique_vals:

        sub_labels = labels[:]  # :复制特征标签，为了保证循环调用函数create_tree()不改变原始的内容
        ret_data_set = split_data_set(data_set, best_feat, value)
        my_tree[best_feat_label][value] = create_tree(ret_data_set, sub_labels)

    return my_tree

 

6、测试代码

def main():

    my_data, my_labels = create_data_set()
    #my_data[0][-1] = 'maybe'
    print 'my_data=', my_data
    print 'my_labels=', my_labels

    shannon_ent = calc_shannon_ent(my_data)
    print 'shannon_ent=', shannon_ent

    ret_data_set = split_data_set(my_data, 1, 1)  # 由第1个特征且特征值为1的数据集划分出来
    print 'ret_data_set=', ret_data_set

    best_feature = choose_best_feature_to_split(my_data)
    print 'best_feature=', best_feature

    my_tree = create_tree(my_data, my_labels)
    print 'my_tree=', my_tree

if __name__ == '__main__':
    main()