决策树
相比于其他方法，决策树是一种更为简单的机器学习方法，它是对被观测数据进行分类的一种相当直观的方法，决策树在经过训练之后，看起来更像是以树状形式排列的一系列if-then语句。只要沿着树的路径一直向下，正确回答每一个问题，最终就会得到答案，沿着最终的叶节点向上回溯，就会得到一个有关最终分类结果的推理过程。
一、预测注册用户
推出功能时，向所有注册用户群发邮件的方式，不具有针对性
如果我们知道有哪些因素可以表明用户将会成为付费顾客，那么就可以利用这些信息指导我们的广告策咯制定工作，让网站的某些功能具有更好的可用性，或者采取其他能够有效增加付费顾客数量的策略。
为了减少用户的工作量，使其能够尽快的注册账号，网站不会过多的询问用户的个人信息，相反，它会从服务器的日志中收集这些信息，比如：用户来自哪个网站，所在的地理位置，以及他们在注册之前曾经浏览过多少网页，等等。
新建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']]或使用 my_data=[line.split('\t') for line in open('decision_tree_example.txt')] 将文件加载进来
现在，只需找到一种方法，能够将一个合理的推测值填入‘服务’栏即可。
类 decisionnode代表树上的每一个节点
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
对树进行训练：CART
首先创建一个根节点，然后通过评估表中的所有观测变量，从中选出最合适的变量对数据进行拆分。
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=entropy):
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))buildtree遍历数据集中的每一列（最后一列除外），针对各列查找一种可能的取值（信息增溢最大），并将数据集拆分成两个新的子集若由熵值最低的一对子集求得的加权平均熵比当前的熵要大，则拆分过程就结束了，否则算法就会在新生成的子集上继续调用buildtree函数，并把调用所得的结果添加到树上。
决策树显示
文本显示：
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 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))
