Decision Tree (2)

最新推荐文章于 2021-04-21 20:26:07 发布

苹果pie

最新推荐文章于 2021-04-21 20:26:07 发布

阅读量199

点赞数

分类专栏：机器学习

机器学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

上篇使用的是ID3算法，这次采用CART（Classification and Regression Tree）算法。采用‘基尼指数’（Gini index）来选择划分属性。

-》纯度低 -》纯度高

$Gini(D)=\sum_{k=1}^{\left | y \right |}\sum_{k'\neq k}^{ }p_{k}p_{k'}=1-\sum_{k=1}^{\left | y \right |}p_{k}^{2}$

y代表类别的个数，pk表示每一个类的概率
对于二分类，当两个类的概率相等时，Gini达到最大值0.5
当两个类中任意一个类的概率为0时，Gini达到最小值0

Gini(D)反映了从数据集D中随机抽取两个样本，其类别标记不一致的概率，Gini(D)越小，则数据集D的纯度越高。

属性a的基尼指数定义为： $Gini_index(D,a)=\sum_{v=1}^{V}\frac{\left |D^{v} \right |}{\left | D \right |}Gini(D^{v})$

预测注册用户

新建treepredict.py

#来源网站、位置、是否阅读过FAQ、浏览网页数、选择服务类型
my_data=[['slashdot','USA','yes',18,'None'],
         ['google','France','yes',23,'Premium'],
         ['digg','USA','yes',24,'Basic'],
         ['kiwitobes','France','yes',23,'Basic'],
         ['google','UK','no',21,'Premium'],
         ['(direct)','New Zealand','no',12,'None'],
         ['(direct)','UK','no',21,'Basic'],
         ['google','USA','no',24,'Premium'],
         ['slashdot','France','yes',19,'None'],
         ['digg','USA','no',18,'None'],
         ['google','UK','no',18,'None'],
         ['kiwitobes','UK','no',19,'None'],
         ['digg','New Zealand','yes',12,'Basic'],
         ['slashdot', 'UK', 'no', 21, 'None'],
         ['google','UK','yes',18,'Basic'],
         ['kiwitobes','France','yes',19,'Basic']]

class decisionnode:
    def __init__(self,col=-1,value=None,results=None,tb=None,fb=None):
        self.col=col
        self.value=value
        self.results=results
        self.tb=tb
        self.fb=fb

divideset(rows,column,value)：根据列表中某一栏的数据将列表拆分成两个数据集

#lambda作为一个表达式，定义了一个匿名函数
#在某一列上对数据进行拆分，能够处理数值型数据或名词性数据
def divideset(rows,column,value):
    #定义一个函数，令其告诉我们数据行属于第一组还是第二组
    split_function=None
    if isinstance(value,int) or isinstance(value,float):
        split_function=lambda row:row[column]>=value
    else:
        split_function=lambda row:row[column]==value
    #将数据集拆分成两个集合，并返回
    set1=[row for row in rows if split_function(row)]
    set2=[row for row in rows if not split_function(row)]
    return (set1,set2)

按照是否阅读过FAQ划分：

拆分结果并不理想，因为两边似乎都混杂了各种情况，我们需要一种方法来选择最合适的变量。

选择最合适的拆分方案

uniquecounts(rows)：找出所有不同的可能结果，并返回一个字典，其中包含了每一项的出现次数，其他函数将利用该函数来计算数据集合中的混杂程度

#对各种可能的结果进行计数（每一行数据的最后一列记录了这一计数结果）
def uniquecounts(rows):
    results={}
    for row in rows:
        #计数结果在最后一行
        r=row[len(row)-1]
        if r not in results: results[r]=0
        results[r]+=1
    return results

基尼不纯度：将来自集合中的某种结果随机应用于集合中某一数据项的预期误差率

#随机放置的数据项出现于错误分类中的概率
def giniimpurity(rows):     #******************************************
    total=len(rows)
    counts=uniquecounts(rows)
    imp=0
    #
    for k1 in counts:
        p1=float(counts[k1])/total
        for k2 in counts:
            if k1==k2: continue
            p2=float(counts[k2])/total
            imp+=p1*p2
    return imp

熵：代表集合的无序程度

#熵是遍历所有可能的结果之后所得的p(x)log(p(x))之和
def entropy(rows):    #******************************************
    from math import log
    log2=lambda x:log(x)/log(2)
    results=uniquecounts(rows)
    #此处开始计算熵的值
    ent=0.0
    for r in results.keys():
        p=float(results[r])/len(rows)
        ent=ent-p*log2(p)
    return ent

熵和基尼不纯度之间的主要区别在于，熵达到峰值的过程要相对慢一些。因此，熵对于混乱集合的‘判罚’往往更重一些

以递归方式构树

def buildtree(rows,scoref=giniimpurity):
    if len(rows)==0: return decisionnode()
    current_score=scoref(rows)

    #定义一些变量以记录最佳拆分条件
    best_gain=0.0
    best_criteria=None
    best_sets=None

    column_count=len(rows[0])-1
    for col in range(0,column_count):
        #在当前列中生成一个由不同值构成的序列
        column_values={}
        for row in rows:
            column_values[row[col]]=1
        #接下来根据这一列中的每个值，尝试对数据集进行拆分
        for value in column_values.keys():
            (set1,set2)=divideset(rows,col,value)
            #信息增溢
            p=float(len(set1))/len(rows)
            gain=current_score-p*scoref(set1)-(1-p)*scoref(set2)
            if gain>best_gain and len(set1)>0 and len(set2)>0:
                best_gain=gain
                best_criteria=(col,value)
                best_sets=(set1,set2)
    if best_gain>0:
        trueBranch=buildtree(best_sets[0])
        falseBranch=buildtree(best_sets[1])
        return decisionnode(col=best_criteria[0],value=best_criteria[1],
                            tb=trueBranch,fb=falseBranch)
    else:
        return decisionnode(results=uniquecounts(rows))

决策树显示

(1)文本显示

def printtree(tree,indent=''):
    #这是一个叶节点吗
    if tree.results!=None:
        print(str(tree.results))
    else:
        #打印判断条件
        print(str(tree.col)+':'+str(tree.value)+'?')
        #打印分支
        print(indent+'T->', )
        printtree(tree.tb,indent+'  ')
        print(indent+'F->', )
        printtree(tree.fb,indent+'  ')

(2)图形显示


def getwidth(tree):
    if tree.tb==None and tree.fb==None: return 1
    return getwidth(tree.tb)+getwidth(tree.fb)

def getdepth(tree):
    if tree.tb==None and tree.fb==None: return 0
    return max(getdepth(tree.tb),getdepth(tree.fb))+1

from PIL import Image,ImageDraw

def drawtree(tree,jpeg='tree.jpg'):
    w=getwidth(tree)*100
    h=getdepth(tree)*100+120

    img=Image.new('RGB',(w,h),(255,255,255))
    draw=ImageDraw.Draw(img)

    drawnode(draw,tree,w/2,20)
    img.save(jpeg,'JPEG')

def drawnode(draw,tree,x,y):
    if tree.results==None:
        #得到每个分支的宽度
        w1=getwidth(tree.fb)*100
        w2=getwidth(tree.tb)*100

        #确定此节点所要占据的总空间
        left=x-(w1+w2)/2
        right=x+(w1+w2)/2

        #绘制判断条件字符串
        draw.text((x-20,y-10),str(tree.col)+':'+str(tree.value),(0,0,0))

        #绘制到分支的连线
        draw.line((x,y,left+w1/2,y+100),fill=(255,0,0))
        draw.line((x, y, right - w2 / 2, y + 100), fill=(255, 0, 0))

        #绘制分支的节点
        drawnode(draw,tree.fb,left+w1/2,y+100)
        drawnode(draw, tree.tb, right - w2 / 2, y + 100)
    else:
        txt=' \n'.join(['%s:%d' %v for v in tree.results.items()])
        draw.text((x-20,y),txt,(0,0,0))

tree=buildtree(my_data)
drawtree(tree,jpeg='treeview.jpeg')

对新的观测数据进行分类

def classify(observation,tree):
    print(tree.results)
    if tree.results!=None:
        return tree.results
    else:
        v=observation[tree.col]
        branch=None
        if isinstance(v,int) or isinstance(v,float):
            if v>=tree.value: branch=tree.tb
            else: branch=tree.fb
        else:
            if v==tree.value: branch=tree.tb
            else: branch=tree.fb
        return classify(observation,branch)


print(classify(['(direct)','USA','yes',5],tree))

常见树的类型

名称	提出时间	特征选择方式	备注
CART	1984	Gini	可以进行分类和回归，离散或连续属性数据集
ID3	1975	熵	离散属性数据集
C4.5	1993	信息增益