集体智慧编程_第七章决策树建模

预测注册用户

针对某个web站点的用户行为及其最终购买决策。最后一栏的服务类型是我们需要预测的内容。
来源网站、位置、是否阅读过FAQ、浏览网页数、选择服务类型。

将数据文件加载进来：

my_data=[line.split('\t') for line in file('decision_tree.txt')]

引入决策树

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

对树进行训练

根据某一栏的数据将列表拆分成两个数据集。

def divideset(rows,column,value):
    #rows为数据集，columns为某一列的名字，
    split_function=None
    if isinstance(value,int) or isinstance(value,float):
        #如果value是数值型数据
        #分成两组,row[column]>=value的返回true
        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)

dividest(my_data,2,'yes')

选择最合适的拆分方案

对数据集中最后一列的结果进行计数。

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+=p2*p1
    return imp

熵

def entropy(rows):
    from math import log
    log2=lambda x:log(x)/log(2)
    results=uniquecounts(rows)
    ent=0
    for r in results.keys():
       p=float(results[r])/len(rows)
       ent=ent-p*log2(p)
     return ent

以递归的方式构造树

通过为当前数据集选择最合适的拆分条件来构造树。
函数首先接受一个由数据行构成的列表作为参数。它遍历了数据集中的每一列，针对各列查找每一种可能的取值，并将数据集拆分成两个新的子集。通过将每个子集的熵乘以子集中所含数据项在原数据集中所占的比重，并记录熵最低的那一对集。如果该值比当前集合的熵大，则拆分过程结束。否则继续使用buildtree函数。

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#获得该col列的值
      #根据该列中的每个值，尝试对数据集进行划分
      for value in column_values.keys():
          (set1,set2)=dividest(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(bestsets[0])
       falsebranch=buildtree(bestsets[1])
       return decisionnode(col=best_criteria[0],
       value=best_criteria[1],tb=truebranch,fb=falsebranch)
    else:
       return decisionnode(results=uniquecounts(rows))
          

决策树的显示

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+' ')

对新的观测数据进行分类

我们对新的观测数据作为参数，然后根据决策树进行分类。

def classify(observation,tree):
    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)

决策树的剪枝

存在过拟合现象，会比实际情况根据特殊性。它可能是专门针对训练集所创建的分支，其熵值比真实情况低。解决办法：当熵减少的数量小于某个最小值时，我们就停止分支的创建。剪枝就是消除多余的节点。

剪枝的过程就是对具有相同父节点的一组节点进行检查，如果将其合并，熵的增加值是否会小于某个指定的阈值。如果确实如此，则将其合并。

def prune(tree,mingain):
    #如果分支不是叶节点，则进行剪枝
    if tree.tb.results==None:
      prune(tree.tb,mingain)
    if tree.fb.results==None:
      prune(tree.fb,mingain)
    #如果两个子分支都是叶节点，则判断它们是否需要合并
    if tree.tb.results!=None and tree.fb.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=entrop(tb+fb)-(entropy(tb)+entropy(fb)/2)
       if delta<mingain:
          tree.tb,tree.fb=None,None
          tree.results=uniquecounts(tb,fb)

处理缺失数据

加权统计

def mdclassify(observation,tree):
    if tree.results!=None:
       return tree.results
     else:
       v=observation[tree.col]
       if v==None:
          tr,fr=mdclassify(observation,tree.tb),mdclassify(observation,tree.fb)
          tcount=sum(tr.values())
          fcount=sum(fr.values())
          tw=float(tcount)/(tcount+fcount)
          ....

决策树最大的优势就在于它可以轻易地对一个受训模型进行解释。决策树可以同时接受分类数据和数值数据作为输入。还允许数据的不确定性分配。对于少数的几种可能的结果有效。本章的决策树只能创建满足“大于\小于”条件的节点。决策树最适合处理的是那些带有分界点的、由大量的分类数据和数值数据共同组成的数据集。