決策樹的python實現

決策樹的Python實現

2017-04-07 Anne Python技術博文

前言：

決策樹的一個重要的任務 是為了理解數據中所蘊含的知識信息，因此決策樹可以使用不熟悉的數據集合，並從中提取出一系列規則，這些機器根據數據集創建規則的過程，就是機器學習的過程。

 

 

決策樹優點：

1：計算復雜度不高

2：輸出結果易於理解

3：對中間值的缺失不敏感

4：可以處理不相關特征數據

缺點：可能會產生過度匹配問題

使用數據類型：數值型和標稱型

 

基於Python逐步實現Decision Tree(決策樹)，分為以下幾個步驟：

• 加載數據集

• 熵的計算

• 根據最佳分割feature進行數據分割

• 根據最大信息增益選擇最佳分割feature

• 遞歸構建決策樹

• 樣本分類

1.加載數據集

1. from numpy import *  

2. #load "iris.data" to workspace  

3. traindata = loadtxt("D:\ZJU_Projects\machine learning\ML_Action\Dataset\Iris.data",delimiter = ',',usecols = (0,1,2,3),dtype = float)  

4. trainlabel = loadtxt("D:\ZJU_Projects\machine learning\ML_Action\Dataset\Iris.data",delimiter = ',',usecols = (range(4,5)),dtype = str)  

5. feaname = ["#0","#1","#2","#3"] # feature names of the 4 attributes (features)  

 

2. 熵的計算

entropy是香農提出來的（信息論大牛），定義見wiki

注意這里的entropy是H(C|X=xi)而非H(C|X), H（C|X）的計算見第下一個點，還要乘以概率加和

Code：

1. from math import log  

2. def calentropy(label):  

3.     n = label.size # the number of samples  

4.     #print n  

5.     count = {} #create dictionary "count"  

6.     for curlabel in label:  

7.         if curlabel not in count.keys():  

8.             count[curlabel] = 0  

9.         count[curlabel] += 1  

10.     entropy = 0  

11.     #print count  

12.     for key in count:  

13.         pxi = float(count[key])/n #notice transfering to float first  

14.         entropy -= pxi*log(pxi,2)  

15.     return entropy  

16.   

17. #testcode:  

18. #x = calentropy(trainlabel)  

3. 根據最佳分割feature進行數據分割

假定我們已經得到了最佳分割feature，在這里進行分割（最佳feature為splitfea_idx）

第二個函數idx2data是根據splitdata得到的分割數據的兩個index集合返回datal (samples less than pivot), datag(samples greater than pivot), labell, labelg。 這里我們根據所選特征的平均值作為pivot

Code:

1. #split the dataset according to label "splitfea_idx"  

2. def splitdata(oridata,splitfea_idx):  

3.     arg = args[splitfea_idx] #get the average over all dimensions  

4.     idx_less = [] #create new list including data with feature less than pivot  

5.     idx_greater = [] #includes entries with feature greater than pivot  

6.     n = len(oridata)  

7.     for idx in range(n):  

8.         d = oridata[idx]  

9.         if d[splitfea_idx] < arg:  

10.             #add the newentry into newdata_less set  

11.             idx_less.append(idx)  

12.         else:  

13.             idx_greater.append(idx)  

14.     return idx_less,idx_greater  

15.   

16. #testcode:2  

17. #idx_less,idx_greater = splitdata(traindata,2)  

18.   

19.   

20. #give the data and labels according to index  

21. def idx2data(oridata,label,splitidx,fea_idx):  

22.     idxl = splitidx[0] #split_less_indices  

23.     idxg = splitidx[1] #split_greater_indices  

24.     datal = []  

25.     datag = []  

26.     labell = []  

27.     labelg = []  

28.     for i in idxl:  

29.         datal.append(append(oridata[i][:fea_idx],oridata[i][fea_idx+1:]))  

30.     for i in idxg:  

31.         datag.append(append(oridata[i][:fea_idx],oridata[i][fea_idx+1:]))  

32.     labell = label[idxl]  

33.     labelg = label[idxg]  

34.     return datal,datag,labell,labelg 

這里args是參數，決定分裂節點的閾值（每個參數對應一個feature，大於該值分到>branch，小於該值分到<branch）,我們可以定義如下：

1. args = mean(traindata,axis = 0)  

測試：按特征2進行分類，得到的less和greater set of indices分別為：

 

也就是按args[2]進行樣本集分割，<和>args[2]的branch分別有57和93個樣本。

 

4. 根據最大信息增益選擇最佳分割feature

信息增益為代碼中的info_gain, 注釋中是熵的計算

Code:

1. #select the best branch to split  

2. def choosebest_splitnode(oridata,label):  

3.     n_fea = len(oridata[0])  

4.     n = len(label)  

5.     base_entropy = calentropy(label)  

6.     best_gain = -1  

7.     for fea_i in range(n_fea): #calculate entropy under each splitting feature  

8.         cur_entropy = 0  

9.         idxset_less,idxset_greater = splitdata(oridata,fea_i)  

10.         prob_less = float(len(idxset_less))/n  

11.         prob_greater = float(len(idxset_greater))/n  

12.           

13.         #entropy(value|X) = \sum{p(xi)*entropy(value|X=xi)}  

14.         cur_entropy += prob_less*calentropy(label[idxset_less])  

15.         cur_entropy += prob_greater * calentropy(label[idxset_greater])  

16.           

17.         info_gain = base_entropy - cur_entropy #notice gain is before minus after  

18.         if(info_gain>best_gain):  

19.             best_gain = info_gain  

20.             best_idx = fea_i  

21.     return best_idx    

22.   

23. #testcode:  

24. #x = choosebest_splitnode(traindata,trainlabel)  

這里的測試針對所有數據，分裂一次選擇哪個特征呢？

5. 遞歸構建決策樹

詳見code注釋，buildtree遞歸地構建樹。

遞歸終止條件：

①該branch內沒有樣本（subset為空） or

②分割出的所有樣本屬於同一類 or 

③由於每次分割消耗一個feature，當沒有feature的時候停止遞歸，返回當前樣本集中大多數sample的label

1. #create the decision tree based on information gain  

2. def buildtree(oridata, label):  

3.     if label.size==0: #if no samples belong to this branch  

4.         return "NULL"  

5.     listlabel = label.tolist()  

6.     #stop when all samples in this subset belongs to one class  

7.     if listlabel.count(label[0])==label.size:  

8.         return label[0]  

9.           

10.     #return the majority of samples' label in this subset if no extra features avaliable  

11.     if len(feanamecopy)==0:  

12.         cnt = {}  

13.         for cur_l in label:  

14.             if cur_l not in cnt.keys():  

15.                 cnt[cur_l] = 0  

16.             cnt[cur_l] += 1  

17.         maxx = -1   

18.         for keys in cnt:  

19.             if maxx < cnt[keys]:  

20.                 maxx = cnt[keys]  

21.                 maxkey = keys  

22.         return maxkey  

23.       

24.     bestsplit_fea = choosebest_splitnode(oridata,label) #get the best splitting feature  

25.     print bestsplit_fea,len(oridata[0])  

26.     cur_feaname = feanamecopy[bestsplit_fea] # add the feature name to dictionary  

27.     print cur_feaname  

28.     nodedict = {cur_feaname:{}}   

29.     del(feanamecopy[bestsplit_fea]) #delete current feature from feaname  

30.     split_idx = splitdata(oridata,bestsplit_fea) #split_idx: the split index for both less and greater  

31.     data_less,data_greater,label_less,label_greater = idx2data(oridata,label,split_idx,bestsplit_fea)  

32.       

33.     #build the tree recursively, the left and right tree are the "<" and ">" branch, respectively  

34.     nodedict[cur_feaname]["<"] = buildtree(data_less,label_less)  

35.     nodedict[cur_feaname][">"] = buildtree(data_greater,label_greater)  

36.     return nodedict  

37.       

38. #testcode:  

39. #mytree = buildtree(traindata,trainlabel)  

40. #print mytree  

Result:

mytree就是我們的結果，#1表示當前使用第一個feature做分割，'<'和'>'分別對應less 和 greater的數據。

6. 樣本分類

根據構建出的mytree進行分類，遞歸走分支

1. #classify a new sample  

2. def classify(mytree,testdata):  

3.     if type(mytree).__name__ != 'dict':  

4.         return mytree  

5.     fea_name = mytree.keys()[0] #get the name of first feature  

6.     fea_idx = feaname.index(fea_name) #the index of feature 'fea_name'  

7.     val = testdata[fea_idx]  

8.     nextbranch = mytree[fea_name]  

9.       

10.     #judge the current value > or < the pivot (average)  

11.     if val>args[fea_idx]:  

12.         nextbranch = nextbranch[">"]  

13.     else:  

14.         nextbranch = nextbranch["<"]  

15.     return classify(nextbranch,testdata)  

16.   

17. #testcode  

18. tt = traindata[0]  

19. x = classify(mytree,tt)  

20. print x 

Result：

 

 

為了驗證代碼准確性，我們換一下args參數，把它們都設成0（很小）

args = [0,0,0,0]

建樹和分類的結果如下：

可見沒有小於pivot(0)的項，於是dict中每個<的key對應的value都為空。

 

 

 

微信掃一掃
關注該公眾號