數據描述
每條數據項儲存在列表中，最后一列儲存結果
多條數據項形成數據集
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
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
