决策树建模

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

数据集

# -*- 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']]

节点对象

每一个节点都有5个属性，这5个属性都是在initializer中设置，包括：

col——待检验的判断条件所对应的列索引值（分裂属性的Index）

value——对应于为了使结果为true,当前列必须匹配的值（分裂值）

tb,fb——都是decisionnode,它们对应于结果分别为true和false时，相对于当前节点的字树上的节点

result——保存的是针对当前分支的结果，是一个字典。除叶子节点外，在其他节点上该值都为None

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

分支

在某一列上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

长树

为了找到分裂属性，我们首先需要计算整个数据集的熵，然后尝试利用每个属性的可能取值 对数据集进行拆分，并求出新分裂的数据集的熵。

信息增益：指当前熵与两个新数据集经加权平均后的熵之间的差值

长树的过程如下

遍历每个属性（类属性除外）的每种取值所带来的信息增益，找到最佳分裂属性和最佳分裂值

将数据集进行分裂，创建左右分支

创建当前节点，赋予当前节点所有属性（包括2中创建的左右分支）

若最佳信息增益为负值，表示不能再分，将此节点创建为叶子节点，叶子节点返回当前节点的类别计数

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

该节点所能到达的总深度：纵向总空间

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，而此时，每个分支的权重等于该分支的数据所占的比重

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

对住房价格进行建模

决策树一个潜在的非常受关注的应用领域是对商品价格的理解，尤其是针对那些拥有大量可测度的观测变量的商品价格。

Zillow是一个免费的Web服务，对房地产价格进行追踪，并利用这些信息来评估住房的价格,所预测的价格近似房产评估人员给出的实际价格。通过Zillow

API(http://www.zillow.com/howto/api/APIOverview.htm)可以获得房屋的详细信息及其评估值在该API网站上有详细的接口调用格式，如下面的GetDeepSearchResults返回房屋的很多信息，再利用parseString对返回的网页进行解析。

import xml.dom.minidom
import urllib2

zwskey="X1-ZWz19qaqwi2wwb_5qhl2" # 打开API网址即可申请一个开发者密钥

def getaddressdata(address,city):
escad=address.replace(' ','+')

# 构造URL
url='http://www.zillow.com/webservice/GetDeepSearchResults.htm?'
url+='zws-id=%s&address=%s&citystatezip=%s' % (zwskey,escad,city)

# 解析XML形式的返回结果
doc=xml.dom.minidom.parseString(urllib2.urlopen(url).read())
code=doc.getElementsByTagName('code')[0].firstChild.data

# 状态码为0代表操作成功，否则代表不成功
if code!='0': return None

# 提取有关该房产的信息
try:
zipcode=doc.getElementsByTagName('zipcode')[0].firstChild.data
use=doc.getElementsByTagName('useCode')[0].firstChild.data
year=doc.getElementsByTagName('yearBuilt')[0].firstChild.data
bath=doc.getElementsByTagName('bathrooms')[0].firstChild.data
bed=doc.getElementsByTagName('bedrooms')[0].firstChild.data
rooms=doc.getElementsByTagName('totalRooms')[0].firstChild.data
price=doc.getElementsByTagName('amount')[0].firstChild.data
except:
return None

return (zipcode,use,int(year),float(bath),int(bed),int(rooms),price)

'''
去http://kiwitobes.com/addresslist.txt网站下下载一个随机生成的马塞诸塞州剑桥地区附近的地址列表
'''
def getpricelist():
l1=[]
for line in file('addresslist.txt'):
data=getaddressdata(line.strip(),'Cambridge,MA')
l1.append(data)
return l1

#==============================================================================
# housedata=getpricelist()
# '''
# [(u'02139', u'Condominium', 1895, 1.5, 3, 6, u'582697'),
# (u'02138', u'SingleFamily', 1847, 1.5, 2, 5, u'855355'),
# (u'02139', u'Triplex', 1884, 3.5, 5, 11, u'1442176'),
# (u'02138', u'MultiFamily2To4', 1920, 1.0, 2, 5, u'677738'),
# (u'02138', u'MultiFamily2To4', 1925, 1.0, 1, 3, u'506527'), None,
# (u'02138', u'Condominium', 1914, 1.0, 2, 4, u'676616'),
# (u'02138', u'Triplex', 1916, 3.5, 9, 21, u'1792965'), None,
# (u'02140', u'Duplex', 1894, 3.5, 4, 9, u'1005743'), None,
# ...
# '''
# housedata=[data for data in housedata if data!=None] # 剔除掉housedata中的None数据
# housetree=buildtree(housedata,scoref=variance)
# drawtree(housetree,'housetree.jpg')
#==============================================================================

上述代码为决定房子价格所要考虑的因素建立起了一个模型，从根节点开始，影响房价的因素的重要性依次降低。

决策树在此处有一个很显著的缺陷：我们必须建立大量的价格数据才行，这是因为住房价格千差万别，而且为了能够得出有价值的结论，我们需要以某种方式对其进行有效的分组。

对“热度”评价进行建模

Hot or Not是一个允许用户上传自己照片的网站，网站初衷是让用户能够根据他人的外表形象对其进行评价。然后网站会将评论结果综合起来，并为每个人设立一个介于1到10之间的评分。Hot or Not随后演变为一个约会交友网站，开放了一个API，允许我们获取网站成员的个人信息以及他们的”热度”评价情况。Hot or Not有一组输入变量和一个输出变量，暗藏有趣的推理过程。

通过http://dev.hotornot.com/signup上注册并获取一个相应的密钥Hot or Not API与前面的API的工作机理是完全一样的，我们只需要向某个URL传送查询所需的参数，并对返回的XML结果进行解析就可以了。

api_key='479NUNJHETN' # 书上的密钥，我无法获取到密钥

接下来获取一个随机的人员列表，用于构造数据集。它提供了一个API调用，能够返回符合指定条件的人员的列表本例中唯一的查询条件是是否有’meet me’描述信息。因为我们从这些描述信息中才能获取到其他诸如家庭住址和兴趣爱好这样的兴趣。

def getrandomratings(c):
# 为getRandomProfile构造URL
url="http://services.hotornot.com/rest/?app_key=%s" % api_key
url+="&method=Rate.getRandomProfile&retrieve_num=%d" % c
url+="&get_rate_info=true&meet_users_only=true"

f1=urllib2.urlopen(url).read()

doc=xml.dom.minidom.parseString(f1)

emids=doc.getElementsByTagName('emid')
ratings=doc.getElementsByTagName('rating')

# 将emids和ratings组合到一个列表中
result=[]
for e,r in zip(emids,ratings):
if r.firstChild!=None:
result.append((e.firstChild.data,r.firstChild.data))
return result

当生成了包含用户ID和评价信息的列表之后，还需要一个函数来下载人员信息——包含性别，年龄，住址和关键字。将所有50个州都作为住址变量的取值范围会太大，因此将其分组为一个个区。

stateregions={'New England':['ct','mn','ma','nh','ri','vt'],
'Mid Atlantic':['de','md','nj','ny','pa'],
'South':['al','ak','fl','ga','ky','la','ms','mo',
'nc','sc','tn','va','wv'],
'Midwest':['il','in','ia','ks','mi','ne','nd','oh','sd','wi'],
'West':['ak','ca','co','hi','id','mt','nv','or','ut','wa','wy']}

API提供了一个下载个人详细信息的方法调用，因此函数getpeopledata只需要遍历第一遍搜索得到的所有结果，并依次调用API即可查询到相关人员的详细信息。

def getpeopledata(ratings):
result=[]
for emid,rating in ratings:
# 对应于MeetMe.getProfile方法调用的URL

url="http://services.hotornot.com/rest/?app_key=%s" % api_key
url+="&method=MeetMe.getProfile&emid=%s&get_keywords=true" % emid

# 得到所有关于此人的详细信息
try:
rating=int(float(rating)+0.5)
doc2=xml.dom.minidom.parseString(urllib2.urlopen(url).read())
gender=doc2.getElementsByTagName('gender')[0].firstChild.data
age=doc2.getElementsByTagName('age')[0].firstChild.data
loc=doc2.getElementsByTagName('location')[0].firstChild.data[0:2]

# 将州转换为地区
for r,s in stateregions.items():
if loc in s:
region=r

if region!=None:
result.append((gender,int(age),region,rating))
except:
pass
return result

生成数据集

l1=getrandomratings(500)
print len(l1)
pdata=getpeopledata(l1)
print pdata[0]
'''
(u'female',28,'West',9)
'''

利用上述信息构造决策树：

hottree=buildtree(pdata,scoref=variance)
prune(hottree,0.5)
drawtree(hottree,'hottree.jpg')

由于决策树可以处理缺失值，因此我们可以依据为数众多的变量对人员进行聚类：比如像对比一下南部地区与中大西洋地区，看看这两个地区人们的热度如何？

south=mdclassify((None,None,'South'),hottree)
midat=mdclassify((None,None,'Mid Atlantic'),hottree)
print south[10]/sum(south.values())
'''
0.055820815183261735
'''
print midat[10]/sum(midat.values())
'''
0.048972797320600864
'''

从上述数据集中可以发现，south[10]表示评分为10的样本数，南方地区的高“热度”者相对而言要稍多一些，我们还可以尝试比如看看年龄的分组情况或者检测一下男士是否赢得了比女士更高的评价。

什么时候使用决策树

决策树最大的优势就在于它可以轻易的对一个受训模型给出解释，比如上面的例子构造的决策树：我们可以发现那些通过Slashdot找到该站点的用户从来都不会成为付费用户，而那些通过google找到该站点并且浏览了至少21个网页的用户则很有可能会成为付费用户。根据这一情况，我们也许就会对广告策略做出相应的调整，使其更倾向于那些能够为我们带来更高访问流量的目标站点。比如我们还发现某些变量比如用户的初始户籍，对于最终输出结果的确定并没有起到什么作用。假如我们知道某些数据的收集很昂贵或者很困难，并且这些数据无关痛痒时，那么我们完全可以不用对其进行收集。

并且可以发现在第一个例子中，我们的数据有数值型数据（浏览网页数）和分类数据。不仅如此，其他的机器学习算法通常需要对数据集进行预处理或是归一化处理，而决策树却可以接受分类数据和数值型数据在内的任何数据列表，并且还允许缺失数据的分类（不确定性分类）。并且最终的结果是一个字典（叶子节点中存放的是每个类别的样本数），借助这一信息我们可以判断出结果的可信度。

决策树的缺点：当输出结果（类别）有上百个时，决策树会变得异常复杂，而且预测的效果也会大打折扣。

决策树另一个较大的缺点：由于它只能创建”大于/小于”条件的节点，而有些数据对其进行分类的因素往往取决于多个变量的复杂组合（比如结果值是由两个变量的差值来决定的），此时决策树预测的准确性就会迅速降低。

总之，对于有大量数值型输入和输出的问题，不适合用决策树；如果数值型数据之间存在错综复杂的关系时，比如金融数据分析或者影响分析时，决策树也不适用；决策树最适合用来处理那些带分界点（breakpoints）的，由大量分类数据和数值数据共同组成的数据集。如果决策过程的理解至关重要，那么使用决策树再适合不过了。

练习1——针对结果的概率

前面给出的classify和mdclassify都是返回总计数值的形式，请对其进行修改，以给出最终结果属于某个分类的概率。下面给出了修改的代码，返回的结果有对比：

def mdclassify1(tree,data):
results=mdclassify(tree,data)
total=sum(results.values())
for k in results.keys():
results[k]/=total
return results
tree=buildtree(my_data)
print mdclassify(tree,['google','France',None,None])
print mdclassify1(tree,['google','France',None,None])

'''
修改前：{'None': 0.125, 'Premium': 2.25, 'Basic': 0.125}
修改后：{'None': 0.05, 'Premium': 0.9, 'Basic': 0.05}
'''

练习2——针对结果的概率

mdclassify允许我们使用None来表示一个缺失值，对于数值型数据而言，其结果未必绝对是未知的，也许相应的取值会落在某个已知的范围内。修改mdclassify函数，允许使用如(20,25)这样的元祖来替代原来的单一值，并且有必要的话，对两个分支都进行遍历。

题目的意思大概是这样的：在预测的时候，我们给的一些数据很模糊，比如这个人浏览网页的数据并不是未知，而是20或者25这其中的一个数，对于这种属性值不确定但并不代表完全未知的数据，我们该如何分析？

很显然，我们可以将这个属性的每一种取值都进行一个预测，然后对最终的预测进行加权（权值是这个取值的概率），但是在给出的数据中通常不会表示概率，我们可以从样本中获取某个值的概率，为了简单，下面我认为每个取值的概率都相同：

算法修改说明（##区间的代码即为修改）： 在分支时遇到属性取值为（20,25）这样的数据表示属性取值长度大于1，遍历其所有取值可能，然后返回每个可能分支的结果，最后进行汇总得到该节点的预测结果。

from collections import defaultdict
def mdclassify2(tree,data):
if tree.results!=None:
return tree.results
else:
if data[tree.col]==None:
tr,fr=mdclassify2(tree.tb,data),mdclassify2(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
#########################################################
elif len(data[tree.col])>=1:  #表示属性取值不是单一值
results=[] # 存储每个取值所带来的结果
for value in data[tree.col]: # 遍历所有的取值
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
results.append(mdclassify2(branch,data))

mdresult=defaultdict(int)
for result in results:  #将结果汇总
for k,v in result.items():
mdresult[k]+=v
return mdresult
##########################################################
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 mdclassify2(branch,data)