决策树1 -- ID3_C4.5算法

最新推荐文章于 2019-11-08 18:24:49 发布

weixin_34294649

最新推荐文章于 2019-11-08 18:24:49 发布

阅读量127

点赞数

文章标签：数据结构与算法 python

声明：

1。本篇为个人对《2012.李航.统计学习方法.pdf》的学习总结。不得用作商用，欢迎转载，但请注明出处（即：本帖地址）。

2，因为本人在学习初始时有非常多数学知识都已忘记。因此为了弄懂当中的内容查阅了非常多资料，所以里面应该会有引用其它帖子的小部分内容。假设原作者看到能够私信我，我会将您的帖子的地址付到以下。

3，假设有内容错误或不准确欢迎大家指正。

4，假设能帮到你。那真是太好了。

简单介绍

决策树是一种主要的分类和回归方法，这里总结的是其分类方法部分。

决策树是一种对实例进行分类的树状结构，eg：

属于类1否？

/ \

属于且不属于

无法再分类且能够继续分类

那属于类2否？

/ \

属于且不属于且

无法再分类无法再分类

特征选择

经过上面的介绍可知：决策树就是用某个特征将样本集合进行分类。那么怎样选择特征就非常重要了。

由于每一次分类我们都要选取个能将样本集合分类的最好特征。

以下就介绍选取最优特征的方法，即：ID3算法和C4.5算法。

熵、条件熵、信息增益、信息增益比

就好像我们用皮肤的颜色来区分黄种人、白种人和黑种人一样，ID3和C4.5也须要一个统一的标准来对样本集合进行区分，而这个标准就是：熵、条件熵、信息增益和信息增益比。

我们如果X为一个取有限个值的离散随机变量。且其概率分布为：

P(X=x_i) = P_i I =1, 2, …, n

即：p_i= 某个类的数量x_i / 样本集合总数

于是熵、条件熵、信息增益和信息增益比的定义分别例如以下：

熵：

Ps1：在上式中，若P_i= 0。则定义0log0 = 0.

Ps2：通常上式中的对数以2或e为底。这是熵的单位各自是比特(bit)和纳特(nat)。

由定义可知，熵仅仅依赖于X中类的分布，与X即样本总数无关，所以也可将H(X)记作H(P)，即

熵越大，随机变量的不确定性就越大，从定义可验证：0 <= H(P) <= log n

若随机变量仅取两个值0和1。那X的分布为：

P(X=1) = P。 P(X=0) = 1 - P； 0 <= P <= 1

那么熵为：

H(P)= -Plog₂P + ( -(1-p)log₂(1-P) )

条件熵：

条件熵就是在随机变量X已确定的条件下，随机变量Y的条件概率分布的熵对X的数学期望：

上述的X代表样本集合总数，Y代表特征

于是：

P_j即“既属于熵中那个类x_i又属于条件熵中这个类的元素的数量 / 属于熵中那个类x_i的元素的数量”

信息增益：

g(X,Y) = H(X) – H(X|Y)

信息增益比：

g_R(X,Y) = g(X, Y) / H(X)

PS：“经验熵”和“经验条件熵”就是由数据预计(特别是极大似然预计)得到的“熵”和“条件熵”的概率。

在掌握了这些后就能够開始算法了。

决策树学习经常使用的算法有ID3。C4.5和CART。

PS：由于ID3和C4.5仅仅有树的生成，所以它们生成的树easy产生过拟合。

首先是ID3。

ID3算法

描写叙述：

输入：

训练数据集D。特征集A。阈值ε。

输出：

决策树T；

过程：

1。若当前可用的D中的全部实例仅有一个类C，则将类C作为当前T的当前结点，返回T；

2，若A=Ф(即：没有可用特征。

如：一開始就没有特征给你用或经过一定次数的分类后，特征已用过一遍)。则将D中实例数最大的那个类作为T的当前结点，返回T；

3，若A≠Ф，则计算各特征的信息增益，选择信息增益最大的特征A_g；

4，若A_g的信息增益小于阈值ε，则用当前D中实例数最大的类作为该节点的类标记，返回T。

5，否则。依据A_g中每个值a_i将当前的D切割成若干个非空子集D_i，将D_i中实例数最大的类作为标记，构建子结点，由节点集子结点构成T，返回T；

6，对第i个子结点，以D_i为训练集，以a_i为特征集。递归的调用1~5步。得到子树T_i，返回T_i。

样例：

对例如以下数据建立决策树：

（贷款申请样本数据表）

ID	年龄	有工作	有自己的房子	信贷情况	类别(是否能贷到款)
1	青年	否	否	一般	否
2	青年	否	否	好	否
3	青年	是	否	好	是
4	青年	是	是	一般	是
5	青年	否	否	一般	否
6	中年	否	否	一般	否
7	中年	否	否	好	否
8	中年	是	是	好	是
9	中年	否	是	很好	是
10	中年	否	是	很好	是
11	老年	否	是	很好	是
12	老年	否	是	好	是
13	老年	是	否	好	是
14	老年	是	否	很好	是
15	老年	否	否	一般	否

解：

1，计算熵：

由于该表的数据被分为两类：给予贷款，不给予贷款。

所以：

2，计算全部的条件熵：

我们用A1代表年龄。D1, D2,D3 代表中、青、老年。

由于中青老年各五人，所以：

而对于每一个年龄段都有：“能够贷款的青中老年”和“不可贷款的青中老年”。

所以，对于青年：

于是中年和老年同理，最后得：

H(T|A1)

同理。对于是否有工作（A2），是否有房子（A3）。信贷情况（A4）：

H(T|A2)= 0.647

H(T|A3)= 0.551

H(T|A4)= 0.608

3，计算信息增益

g(T,A1)= H(T) – H(T|A1) = 0.971 – 0.888 = 0.083

g(T,A2)= H(T) – H(T|A2) = 0.324

g(T,A3)= H(T) – H(T|A3) = 0.420

g(T,A4)= H(T) – H(T|A4) = 0.363

4，由于g(T,A3) 最大。所以选择“是否有房子”作为根节点的特征，于是这将数据集分成了两部分：T1（有房）和T2（无房）

因为T1的全可贷款（全部的元素都属于一类），所以它成为一个叶子节点。

而T2中既有能贷到款的也有贷不到的（全部的元素不属于一类）。所以对于T2须要从特征A1（年龄），A2（有无工作）。A4（信贷情况）中选出一个新特征。

到此形成例如以下决策树：

A3：有房子吗

/ \

T1：有房子 T2：无房子

全能贷到款有的能贷到，有的不能

5，对T2这个数据集再次调用1~3步，计算信息增益(注意：需用当前的数据集T2又一次计算)，得：

g(T2,A1) = H(T2) – H(T2|A1) = 0.251

g(T2,A2) = H(T2) – H(T2|A2) = 0.918

g(T2,A4) = H(T2) – H(T2|A4) = 0.474

于是选择A2（有无工作）来作为当前特征。

到此形成例如以下决策树：

A3：有房子吗

/ \

T1：有房子 T2：无房子，有工作吗？

全能贷到款 / \

有工作无工作

全能贷到款全都贷不到

由于到此，全部的子结点的元素全都仅仅属于一个类，所以到此以全然划分。

终于决策树如上。

C4.5算法

C4.5算法就是将ID3第三步的信息增益换成信息增益比。其它不变。

#-*-coding:utf-8-*-
# LANG=en_US.UTF-8
# ID3 和 ID4 算法
# 文件名称：ID3_ID4.py
#

import sys
import math
import copy

dict_all = {
        # 1: 青年。2：中年；3：老年
        '_age' : [
                1, 1, 1, 1, 1,
                2, 2, 2, 2, 2,
                3, 3, 3, 3, 3,
            ],

        # 0：无工作。1：有工作
        '_work' : [
                0, 0, 1, 1, 0,
                0, 0, 1, 0, 0,
                0, 0, 1, 1, 0,
            ],

        # 0：无房子；1：有房子
        '_house' : [
                0, 0, 0, 1, 0,
                0, 0, 1, 1, 1,
                1, 1, 0, 0, 0,
            ],

        # 1：信贷情况一般。2：好；3：很好
        '_credit' : [
                1, 2, 2, 1, 1,
                1, 2, 2, 3, 3,
                3, 2, 2, 3, 1,
            ],
    }

# 0：未申请到贷款。1：申请到贷款
_type = [
        0, 0, 1, 1, 0,
        0, 0, 1, 1, 1,
        1, 1, 1, 1, 0,
    ]

# 二叉树结点
class BinaryTreeNode( object ):
    def __init__( self, name=None, data=None, left=None, right=None, father=None ):
        self.name = name
        self.data = data
        self.left = left
        self.right = left

# 二叉树遍历
class BTree(object):
    def __init__(self,root=0):
        self.root = root

    # 中序遍历
    def inOrder(self,treenode):
        if treenode is None:
            return

        self.inOrder(treenode.left)
        print treenode.name, treenode.data
        self.inOrder(treenode.right)


# 遍历类型。统计每一个类型的数量，将其保存到字典中
# 如：对于 _type: 有9个类型1，6个类型0。

# 于是返回：{'1': 9.0, '0': 6.0} # 參数：类型列表 def get_type_num( type_list ): type_dict = {} tmp_item = '' for item in type_list: item = str(item) if tmp_item != item: if item in type_dict.keys(): type_dict[item] += 1.0 else: type_dict[item] = 1.0 tmp_item = item else: type_dict[item] += 1.0 return type_dict # 获得熵 # 參数：类型列表 def get_entropy( type_list ): entropy = 0.0 len_type = len(type_list) type_dict = get_type_num( type_list ) # 计算熵 for key in type_dict.keys(): tmp_num = type_dict[key] / len_type entropy = entropy - tmp_num * math.log(tmp_num, 2) return float('%.3f' % entropy) # 获得条件熵 # 參数：特征列表，类型列表，序号列表 # 如： # 第一轮时以 _house 为特征进行筛选(筛选使用ID3或ID4。不是在此函数中)，这是參数分别为：_house, _type, [0, 1, ..., 15] # 第一轮结束后：左子树的特征序号列表为：[3, 7, 8, 9, 10, 11]。右子树的特征序号列表为：[0, 1, 2, 4, 5, 6, 12, 13, 14] # 于是第二轮在对右子树以 _work 为特征进行筛选时传入參数：_house, _type, [0, 1, 2, 4, 5, 6, 12, 13, 14] def get_conditional_entropy( value_list, type_list, num_list ): # 整理 value_list 以 num_list 为序号形成的新列表中的不同类别 # value_dict = {特征名 : 包括的类别列表} # eg：对于 _work # 其“原始内容”和“以 num_list(即：[0, 1, 2, 4, 5, 6, 12, 13, 14]) 为序号形成的新列表为”分别例如以下： # [0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0] # [0, 0, 1, 0, 0, 0, 1, 1, 0] # 新列表有3个类型1和6个类型2。于是该函数返回：{'1': [1, 1, 1], '0': [0, 0, 0, 0, 0, 0]} def get_value_type(): value_dict = {} tmp_type = '' tmp_item = '' for num in num_list: item = str( value_list[num] ) if tmp_item != item: if item in value_dict.keys(): value_dict[item].append(type_list[num]) else: value_dict[item] = [type_list[num],] tmp_item = item else: value_dict[item].append(type_list[num]) return value_dict value_dict = get_value_type() conditional_entropy = 0 for key in value_dict.keys(): tmp_num = float( '%.3f' % (float(len(value_dict[key]))/len(value_list)) ) conditional_entropy += float( '%.3f' % (tmp_num * get_entropy(value_dict[key])) ) return conditional_entropy # 获得信息增益 def get_information_gain( value_list, type_list, num_list ): return float( '%.3f' % (get_entropy( type_list ) - get_conditional_entropy( value_list, type_list, num_list )) ) # 获得信息增益比 def get_information_gain_ratio( value_list, type_list, num_list ): entropy = get_entropy( type_list ) information_gain = entropy - get_conditional_entropy( value_list, type_list, num_list ) return float( '%0.3f' % (information_gain/entropy) ) # ID3 算法 def ID3( data, type_list, threshold ): # 获得最大的信息增益 def get_max_information_gain( num_list ): step = 'continue' tmp_value = 0.0 feature_name = '' for key in data.keys(): information_gain = get_information_gain( data[key], type_list, num_list ) if information_gain > tmp_value: feature_name = key tmp_value = information_gain # 假设信息增益小于阈值，则告诉后面的程序，不用在迭代了，到此就可以 if information_gain < threshold: step = 'over' return feature_name, step # 进行分类 def classify( root, note_name, note_data, note_type ): # 将'特征可能值名字'追加到 root.name 中 # 将[样本序号的列表]合并到 root.data 中 root.name.append( note_name ) root.data.extend( note_data ) # note_type=='exit' 意味着当前的数据所有属于某一类，不用在分类了 if not data or note_type=='exit': return feature_name, step = get_max_information_gain( note_data ) # 依据特征的可能值将样本数据分成数个集合，并保存成“特征字典”。 # 字典结构为：{ '特征可能值名字': [样本序号的列表] } feature_dict = {} tmp_item = '' for num in note_data: item = str( data[feature_name][num] ) if tmp_item != item: if item in feature_dict.keys(): feature_dict[item].append(num) else: feature_dict[item] = [num, ] tmp_item = item else: feature_dict[item].append(num) # 从样本集合中将该特征删除 del data[feature_name] # 准备左子节点和右子节点。节点的 name 和 data 是个空列表 root.left = BinaryTreeNode( [], [] ) root.right = BinaryTreeNode( [], [] ) # 计算“特征字典”中各个集合中是属于“能贷贷款”的多还是“不能贷贷款”的多 # 假设是前者： # 递归调用 classify，形成左子节点 # 假设是后者： # 递归调用 classify，形成右子节点 for key in feature_dict.keys(): num_yes = 0; num_no = 0 for num in feature_dict[key]: if type_list[num] == 1: num_yes = num_yes + 1 elif type_list[num] == 0: num_no = num_no + 1 else: print 'ERROR: wrong type in _type' exit() note_type = 'not_exit' if num_yes == 0 or num_no == 0 or step == 'over': note_type = 'exit' if num_yes >= num_no: classify( root.left, '%s:%s' % (feature_name, key), feature_dict[key], note_type ) else: classify( root.right, '%s:%s' % (feature_name, key), feature_dict[key], note_type ) return root tmp_list = [] for num in xrange( len(dict_all[dict_all.keys()[0]]) ): tmp_list.append( num ) return classify( BinaryTreeNode( [], [] ), 'root', tmp_list, 'not_exit' ) # C4.5 算法 def C4_5( data, type_list, threshold ): # 获得最大的信息增益比 def get_max_information_gain( num_list ): step = 'continue' tmp_value = 0.0 feature_name = '' for key in data.keys(): information_gain_ratio = get_information_gain_ratio( data[key], type_list, num_list ) if information_gain_ratio > tmp_value: feature_name = key tmp_value = information_gain_ratio # 假设信息增益比小于阈值，则告诉后面的程序，不用在迭代了，到此就可以 if information_gain_ratio < threshold: step = 'over' return feature_name, step # 进行分类 def classify( root, note_name, note_data, note_type ): # 将'特征可能值名字'追加到 root.name 中 # 将[样本序号的列表]合并到 root.data 中 root.name.append( note_name ) root.data.extend( note_data ) # note_type=='exit' 意味着当前的数据所有属于某一类。不用在分类了 if not data or note_type=='exit': return feature_name, step = get_max_information_gain( note_data ) # 依据特征的可能值将样本数据分成数个集合。并保存成“特征字典”。 # 字典结构为：{ '特征可能值名字': [样本序号的列表] } feature_dict = {} tmp_item = '' for num in note_data: item = str( data[feature_name][num] ) if tmp_item != item: if item in feature_dict.keys(): feature_dict[item].append(num) else: feature_dict[item] = [num, ] tmp_item = item else: feature_dict[item].append(num) # 从样本集合中将该特征删除 del data[feature_name] # 准备左子节点和右子节点，节点的 name 和 data 是个空列表 root.left = BinaryTreeNode( [], [] ) root.right = BinaryTreeNode( [], [] ) # 计算“特征字典”中各个集合中是属于“能贷贷款”的多还是“不能贷贷款”的多 # 假设是前者： # 递归调用 classify，形成左子节点 # 假设是后者： # 递归调用 classify。形成右子节点 for key in feature_dict.keys(): num_yes = 0; num_no = 0 for num in feature_dict[key]: if type_list[num] == 1: num_yes = num_yes + 1 elif type_list[num] == 0: num_no = num_no + 1 else: print 'ERROR: wrong type in _type' exit() note_type = 'not_exit' if num_yes == 0 or num_no == 0 or step == 'over': note_type = 'exit' if num_yes >= num_no: classify( root.left, '%s:%s' % (feature_name, key), feature_dict[key], note_type ) else: classify( root.right, '%s:%s' % (feature_name, key), feature_dict[key], note_type ) return root tmp_list = [] for num in xrange( len(dict_all[dict_all.keys()[0]]) ): tmp_list.append( num ) return classify( BinaryTreeNode( [], [] ), 'root', tmp_list, 'not_exit' ) # 阈值 threshold = 0.3 dict_all_id3 = copy.deepcopy( dict_all ) root = ID3( dict_all_id3, _type, threshold ) bt = BTree( root ) print '--------------ID3----------------' bt.inOrder( bt.root ) print '---------------------------------\n' dict_all_c45 = copy.deepcopy( dict_all ) root = C4_5( dict_all_c45, _type, threshold ) bt = BTree( root ) print '--------------C4.5----------------' bt.inOrder( bt.root ) print '----------------------------------\n'