python中计算如何实现_python如何实现决策树算法?（代码）

本篇文章给大家带来的内容是关于python如何实现决策树算法?（代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

数据描述

每条数据项储存在列表中，最后一列储存结果

多条数据项形成数据集data=[[d1,d2,d3...dn,result],

[d1,d2,d3...dn,result],

.

.

[d1,d2,d3...dn,result]]

决策树数据结构class DecisionNode:

'''决策树节点

'''

def __init__(self,col=-1,value=None,results=None,tb=None,fb=None):

'''初始化决策树节点

args：

col -- 按数据集的col列划分数据集

value -- 以value作为划分col列的参照

result -- 只有叶子节点有，代表最终划分出的子数据集结果统计信息。｛‘结果’：结果出现次数｝

rb,fb -- 代表左右子树

'''

self.col=col

self.value=value

self.results=results

self.tb=tb

self.fb=fb

决策树分类的最终结果是将数据项划分出了若干子集，其中每个子集的结果都一样，所以这里采用｛‘结果’：结果出现次数｝的方式表达每个子集def pideset(rows,column,value):

'''依据数据集rows的column列的值，判断其与参考值value的关系对数据集进行拆分

返回两个数据集

'''

split_function=None

#value是数值类型

if isinstance(value,int) or isinstance(value,float):

#定义lambda函数当row[column]>=value时返回true

split_function=lambda row:row[column]>=value

#value是字符类型

else:

#定义lambda函数当row[column]==value时返回true

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)

def uniquecounts(rows):

'''计算数据集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):

'''返回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):

'''返回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 build_tree(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)=pideset(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=build_tree(best_sets[0])

falseBranch=build_tree(best_sets[1])

return DecisionNode(col=best_criteria[0],value=best_criteria[1],

tb=trueBranch,fb=falseBranch)

# 如果划分的两个数据集熵不小于原数据集，停止划分

else:

return DecisionNode(results=uniquecounts(rows))

def print_tree(tree,indent=''):

if tree.results!=None:

print(str(tree.results))

else:

print(str(tree.col)+':'+str(tree.value)+'? ')

print(indent+'T->',end='')

print_tree(tree.tb,indent+' ')

print(indent+'F->',end='')

print_tree(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

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:

# Get the width of each branch

w1=getwidth(tree.fb)*100

w2=getwidth(tree.tb)*100

# Determine the total space required by this node

left=x-(w1+w2)/2

right=x+(w1+w2)/2

# Draw the condition string

draw.text((x-20,y-10),str(tree.col)+':'+str(tree.value),(0,0,0))

# Draw links to the branches

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

# Draw the branch nodes

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

对测试数据进行分类（附带处理缺失数据）def mdclassify(observation,tree):

'''对缺失数据进行分类

args：

observation -- 发生信息缺失的数据项

tree -- 训练完成的决策树

返回代表该分类的结果字典

'''

# 判断数据是否到达叶节点

if tree.results!=None:

# 已经到达叶节点，返回结果result

return tree.results

else:

# 对数据项的col列进行分析

v=observation[tree.col]

# 若col列数据缺失

if v==None:

#对tree的左右子树分别使用mdclassify，tr是左子树得到的结果字典，fr是右子树得到的结果字典

tr,fr=mdclassify(observation,tree.tb),mdclassify(observation,tree.fb)

# 分别以结果占总数比例计算得到左右子树的权重

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():

# fr的结果k有可能并不在tr中，在result中初始化k

if k not in result:

result[k]=0

# fr的结果累加到result中

result[k]+=v*fw

return result

# col列没有缺失，继续沿决策树分类

else:

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 mdclassify(observation,branch)

tree=build_tree(my_data)

print(mdclassify(['google',None,'yes',None],tree))

print(mdclassify(['google','France',None,None],tree))

决策树剪枝def prune(tree,mingain):

'''对决策树进行剪枝

args：

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=entropy(tb+fb)-(entropy(tb)+entropy(fb)/2)

#熵的增加量小于mingain，可以合并分支

if delta

tree.tb,tree.fb=None,None

tree.results=uniquecounts(tb+fb)

以上就是python如何实现决策树算法?（代码）的详细内容，更多请关注Gxl网其它相关文章！

本条技术文章来源于互联网，如果无意侵犯您的权益请点击此处反馈版权投诉

本文系统来源：php中文网