决策树建模

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

# -*- 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
时间: 2024-10-30 00:59:25

决策树建模的相关文章

集体智慧编程——决策树建模(上)

本文主要介绍一种非常流行的分类算法:决策树分类算法. 例子:一个网站上有多少用户会愿意为某些高级会员功能而支付费用. 步骤一:导入数据: 新建一个treepredict.py的问价,将下面数据写入.数据的具体信息分别是:来源网站,位置,是否读过FAQ,浏览网页数,选择服务类型. my_data=[['slashdot','USA','yes',18,'None'], ['google','France','yes',23,'Premium'], ['digg','USA','yes',24,'B

集体智慧编程——决策树建模(下)

一.决策树的显示: 前面我们已经得到了一棵决策树,下一步也许我们该进行数的浏览了.下面这段函数就是一个以纯文本的方式显示决策树的方法,虽然输出不是很美观,但是对于显示节点不是太多的树而言,这也是一种简单的方式. def printtree(tree,indent=''): if tree.results!=None: print str(tree.results) else: print str(tree.col)+':'+str(tree.value)+'?' print indent+'T-

数据挖掘十大算法之决策树详解(2)

在2006年12月召开的 IEEE 数据挖掘国际会议上(ICDM, International Conference on Data Mining),与会的各位专家选出了当时的十大数据挖掘算法( top 10 data mining algorithms ),可以参见文献[1].本博客已经介绍过的位列十大算法之中的算法包括: [1] k-means算法(http://blog.csdn.net/baimafujinji/article/details/50570824) [2] 支持向量机SVM

sklearn之决策树

''' 决策树: 基本算法原理: 核心思想:相似的输入必会产生相似的输出.例如预测某人薪资: 年龄:1-青年,2-中年,3-老年 学历:1-本科,2-硕士,3-博士 经历:1-出道,2-一般,3-老手,4-骨灰 性别:1-男性,2-女性 | 年龄 | 学历 | 经历 | 性别 | ==> | 薪资 | | ---- | ---- | ---- | ---- | ---- | -----------| | 1 | 1 | 1 | 1 | ==> | 6000(低) | | 2 | 1 | 3 |

Python大数据处理案例

分享 知识要点:lubridate包拆解时间 | POSIXlt利用决策树分类,利用随机森林预测利用对数进行fit,和exp函数还原 训练集来自Kaggle华盛顿自行车共享计划中的自行车租赁数据,分析共享自行车与天气.时间等关系.数据集共11个变量,10000多行数据.https://www.kaggle.com/c/bike-sharing-demand 首先看一下官方给出的数据,一共两个表格,都是2011-2012年的数据,区别是Test文件是每个月的日期都是全的,但是没有注册用户和随意用户

[转]算法的简单归类。大数据常用算法

无论是机器学习.模式识别.数据挖掘.统计学习.计算机视觉.语音识别.自然语言处理都涉及到算法. 1.树:决策树(Decision Tree)是在已知各种情况发生概率的基础上,通过构成决策树来求取净现值的期望值大于等于零的概率,评价项目风险,判断其可行性的决策分析方法,是直观运用概率分析的一种图解法.由于这种决策分支画成图形很像一棵树的枝干,故称决策树.在机器学习中,决策树是一个预测模型,他代表的是对象属性与对象值之间的一种映射关系.Entropy = 系统的凌乱程度,使用算法ID3, C4.5和

集体智慧编程中相关章节对应论文数

准备开题报告了,先要熟悉一下领域范围,<集体智慧编程>参考一下论点.简单的思路是看一下哪个话题最热门,用google学术来衡量一下论文数,虽然不够精确但是足以反应一点什么. 当然是选择最近比较热门的,同时参考一下国内的论文数目情况. 关键字 总的 2014 国内总数 2014 推荐 2,480,000 42,600 223,124 2728 协同过滤 194,000 4,350 11,239 112 聚类 2,550,000 54,600 141,003 1598 搜索与排名 2,120,00

集体智慧编程--勘误(5章~10章)

chapter5 随机优化技术: 1.randomoptimize中,返回值应为bestr 2.geneticoptimize中,mute函数应该将所有路径都返回一个编译结果,否则会在后续的dorm测试中 报出异常,应该修改为: 3.crosscount中,应该添加float类型的强制类型转换,否则得出的结果仍然有交叉线 4.drawnetwork应该保存到本地文件,之后才能打开 chapter 7 决策树建模: P167:如果使用从文件decision_tree_example.txt中加载数

机器学习——决策树算法原理及案例

机器学习在各个领域都有广泛的应用,特别在数据分析领域有着深远的影响.决策树是机器学习中最基础且应用最广泛的算法模型.本文介绍了机器学习的相关概念.常见的算法分类和决策树模型及应用.通过一个决策树案例,着重从特征选择.剪枝等方面描述决策树的构建,讨论并研究决策树模型评估准则.最后基于 R 语言和 SPSS Modeler这两个工具,分别设计与实现了决策树模型的应用实例. 1.机器学习概念 机器学习 (Machine Learning) 是近 20 多年兴起的一门多领域交叉学科,涉及概率论.统计学.