决策树建模

Posted 2020-07-06 小丫头い

第一个例子是基于假想的服务器日志数据构建决策树，我们利用构建好的决策树来预测用户是否可能成为付费用户。

# -*- coding: utf-8 -*-
"""
Created on Mon May 16 15:31:51 2016

@author: ZM
"""
##################################### 数据集 ###############################
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:
    ‘‘‘
    每一个节点都要5和实例变量，这5个变量都是在initializer中设置，包括：
    col：待检验的判断条件所对应的列索引值（分裂属性的Index）
    value：对应于为了使结果为true,当前列必须匹配的值（分裂值）
    tb,fb：都是decisionnode,它们对应于结果分别为true和false时，相对于当前节点的字树上的节点
    result：保存的是针对当前分支的结果，是一个字典。除叶子节点外，在其他节点上该值都为None
    ‘‘‘
    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

‘‘‘
在某一列上column对数据集rows进行拆分，能够处理数值型数据或名字性数据
数值型数据：拆分的依据是大于或者小于value
名词性数据：拆分的依据是是否等于value
‘‘‘
##################################### 分支 ###############################
def divideset(rows,column,value):
    # 定义一个函数，令其告诉我们数据行属于第一组（返回值为true）还是第二组（返回值为false）
    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

# 我们需要一个函数来对数据集合中的每一项结果进行计数
# 每一行元素的类别存储在row的最后一列数据中
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

##################################### 熵 ###############################
‘‘‘
熵：代表的是集合的无序程度——相当于我们所说的集合的混杂程度
‘‘‘
def entropy(rows):
    from math import log
    log2=lambda x :log(x)/log(2)
    results=uniquecounts(rows)
    # 此处开始计算熵的值
    ent=0.0   
    for r in results:
        p=float(results[r])/len(rows)
        ent=ent-p*log2(p)
    return ent

##################################### 长树 ###############################
‘‘‘
为了找到分裂属性，我们首先需要计算整个数据集的熵，然后尝试利用每个属性的可能取值
对数据集进行拆分，并求出新分裂的数据集的熵。
信息增益：指当前熵与两个新数据集经加权平均后的熵之间的差值

1.遍历每个属性（类属性除外）的每种取值所带来的信息增益，找到最佳分裂属性和最佳分裂值
2.将数据集进行分裂，创建左右分支
3.创建当前节点，赋予当前节点所有属性
4.若最佳信息增益为负值，表示不能再分，将此节点创建为叶子节点，叶子节点返回当前节点的类别计数
‘‘‘ 
def buildtree(rows,scoref=entropy):
    if len(rows)==0:
        return decisionnode()
    current_score=scoref(rows)

    # 定义一些变量以记录最佳拆分条件
    best_gain=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))

##################################### 打印文本树 ###############################        
‘‘‘
现在创建一棵决策树时返回的是一个descisionnode对象，它是根节点对象，我们可以通过遍历来找到其它节点
使用print函数将决策树显示出来
‘‘‘
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+‘  ‘)
#==============================================================================
# tree=buildtree(my_data)
# printtree(tree)
# ‘‘‘
# 0:google?
# T-> 3:21?
#   T-> {‘Premium‘: 3}
#   F-> 2:yes?
#     T-> {‘Basic‘: 1}
#     F-> {‘None‘: 1}
# F-> 0:slashdot?
#   T-> {‘None‘: 3}
#   F-> 2:yes?
#     T-> {‘Basic‘: 4}
#     F-> 3:21?
#       T-> {‘Basic‘: 1}
#       F-> {‘None‘: 3}
# ‘‘‘
#==============================================================================

##################################### 打印二叉树 ###############################
‘‘‘
像上面这样以文本的方式显示树，在树很小的时候可行，太大时追踪起来很困难
需要将其打印为二叉树的形式

需要两个个函数计算一个给定节点需要占据多少空间，包括：
1所有子节点的总宽度：横向总空间，一个分支的总宽度等于其所有子分支的宽度之和，如果没有分支，宽度为1
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

‘‘‘
为了将树真正打印出来，我们还需要安装Python Imaging Library
‘‘‘
from PIL import Image,ImageDraw
‘‘‘
drawtree为待绘制的树确定了一个合理的尺寸，并设置好了画布（canvas），然后将画布和根节点传给了drawnode函数
‘‘‘
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，最右边right
        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后，我们可以从根节点通过递归的方法遍历树，来找到新数据的类别
该函数采用了和printtree完全相同的方式来对树进行比那里，函数会调用结果来判断是否到达末端，如果没有则会进行分支评估
‘‘‘
def classify(tree,data):
    if tree.results!=None:    
        return tree.results
    else:
        branch=None
        if isinstance(data[tree.col],int) or isinstance(data[tree.col],float):
            if data[tree.col]<tree.value:
                branch=tree.fb
            else:
                branch=tree.tb
        else:
            if data[tree.col]!=tree.value:
                branch=tree.fb
            else:
                branch=tree.tb
        return classify(branch,data)
#==============================================================================
# tree=buildtree(my_data)
# print classify(tree,[‘(direct)‘,‘USA‘,‘yes‘,5])
# 
# ‘‘‘{‘Basic‘: 4}‘‘‘
#==============================================================================

##################################### 剪枝 ############################### 
‘‘‘
决策树的构造是自动进行的，利用生成的决策树可以帮助我们理解某些关键因素，然后对其加以改进。

众所周知，决策树容易过拟合，常见的方法就是剪枝：由于前面我们长树的停止条件是熵不再减小就停止，我们可以稍作修改
只要熵减少的数量小于某个给定的阈值时，我们就停止长树。这个方法的缺陷：某一次分支的创建并不会令熵降低很多，
但是随后创建的分支却会使熵大幅降低。对此一个替代的策略是：先构建好整棵树，然后再尝试消除多余的节点，这个过程就是剪枝
‘‘‘    
def prune(tree,mingain):
    if tree.fb.results==None:
        prune(tree.fb,mingain)        
    if tree.tb.results==None:
        prune(tree.tb,mingain)

    # 如果两个分支都是叶子节点，那么需要判断是否将其与父节点合并
    if tree.fb.results!=None and tree.tb.results!=None:
        tb,fb=[],[]
        for v,c in tree.tb.results.items():
            tb+=[[v]]*c
        for v,c in tree.fb.results.items():
            fb+=[[v]]*c

        # 检查熵的减少情况        
        #delta=entropy(tb+fb)-(entropy(tb)+entropy(fb)/2) 书上这么写的，我修改如下：
        p=float(len(tb))/len(tb+fb)
        delta=entropy(tb+fb)-p*entropy(tb)-(1-p)*entropy(fb)

        if delta<mingain:
            # 合并分支
            tree.tb,tree.fb=None,None
            tree.results=uniquecounts(tb+fb)
#==============================================================================
# tree=buildtree(my_data)
# prune(tree,1.0)
# printtree(tree)
# ‘‘‘
# 0:google?
# T-> 3:21?
#   T-> {‘Premium‘: 3}
#   F-> 2:yes?
#     T-> {‘Basic‘: 1}
#     F-> {‘None‘: 1}
# F-> {‘None‘: 6, ‘Basic‘: 5}
# ‘‘‘      
#==============================================================================

##################################### 处理缺失值 ###############################   
‘‘‘
除了易解释外，决策树还有一个优点：处理缺失数据的能力
比如前面数据中或许用户地理位置无法从其IP地址中识别出来，那么这个字段将为空，为了处理这种情况，需要实现一个新的预测函数

1.如果我们缺失了某些数据，而这些数据是确定分支走向所必须的，那么我们可以选择两个分支都走
2.此处我们不是平均的统计各个分支对应的结果值，而是对其进行加权统计
3.之前我们默认分支时，某个分支的权重为1，而此时，每个分支的权重等于该分支的数据所占的比重

mdclassify余classify相比，唯一的区别在于末尾处：如果发现有重要数据缺失，则每个分支对应结果值都会被计算一遍
并且最终的结果值会乘以它们各自的权重

‘‘‘
def mdclassify(tree,data):
    if tree.results!=None:    
        return tree.results
    else:       
        if data[tree.col]==None:
            tr,fr=mdclassify(tree.tb,data),mdclassify(tree.fb,data)
            tcount=sum(tr.values()) # 该分支的样本总数
            fcount=sum(fr.values())
            tw=float(tcount)/(tcount+fcount) # 流入该分支的样本占父节点样本的比重
            fw=float(fcount)/(tcount+fcount)
            result={}
            for k,v in tr.items():
                result[k]=v*tw
            for k,v in fr.items():
                if k not in result:
                    result[k]=0
                result[k]+=v*fw
            return result       
        else:
            branch=None
            if isinstance(data[tree.col],int) or isinstance(data[tree.col],float):
                if data[tree.col]<tree.value:
                    branch=tree.fb
                else:
                    branch=tree.tb
            else:
                if data[tree.col]!=tree.value:
                    branch=tree.fb
                else:
                    branch=tree.tb
            return mdclassify(branch,data)    

#==============================================================================
# tree=buildtree(my_data)
# print mdclassify(tree,[‘google‘,‘France‘,None,None])
# ‘‘‘
# {‘None‘: 0.125, ‘Premium‘: 2.25, ‘Basic‘: 0.125}
# ‘‘‘
#==============================================================================

##################################### 回归 ###############################  
‘‘‘
当我们拥有一棵以数字作为输出结果的决策树时，我们可以使用方差作为评价函数来取代熵或者基尼不纯度

下面这个函数是计算数据集的统计方差：偏低的方差表示数字之间彼此非常接近，高方差意味着数字分散得很开
当采用方差作为评估函数来构造决策树时，分支条件变为：拆分后令数字较大者位于树的右侧，较小者位于左侧
这样可以降低分支的整体方差
‘‘‘ 
def variance(rows):
    if len(rows)==0:
        return 0
    data=[float(row[len(row)-1]) for row in rows] # 遍历rows的类属性
    mean=sum(data)/len(data)
    variance=sum([(d-mean)**2 for d in data])/len(data)
    return variance