机器学习：决策树--python

今天，我们介绍机器学习里比较常用的一种分类算法，决策树。决策树是对人类认知识别的一种模拟，给你一堆看似杂乱无章的数据，如何用尽可能少的特征，对这些数据进行有效的分类。

决策树借助了一种层级分类的概念，每一次都选择一个区分性最好的特征进行分类，对于可以直接给出标签 label 的数据，可能最初选择的几个特征就能很好地进行区分，有些数据可能需要更多的特征，所以决策树的深度也就表示了你需要选择的几种特征。

在进行特征选择的时候，常常需要借助信息论的概念，利用最大熵原则。

决策树一般是用来对离散数据进行分类的，对于连续数据，可以事先对其离散化。

在介绍决策树之前，我们先简单的介绍一下信息熵，我们知道，熵的定义为：

 

我们先构造一些简单的数据：

from sklearn import datasets

import numpy as np

import matplotlib.pyplot as plt

import math

import operator

def Create_data（）：

dataset = ［［1，1，‘yes’］，

［1， 1，‘yes’］，

［1， 0， ‘no’］，

［0， 1， ‘no’］，

［0， 1， ‘no’］，

［3， 0， ‘maybe’］］

feat_name = ［‘no surfacing’， ‘flippers’］

return dataset， feat_name

然后定义一个计算熵的函数：

def Cal_entrpy（dataset）：

n_sample = len（dataset）

n_label = {}

for featvec in dataset：

current_label = featvec［-1］

if current_label not in n_label.keys（）：

n_label［current_label］ = 0

n_label［current_label］ += 1

shannonEnt = 0.0

for key in n_label：

prob = float（n_label［key］） / n_sample

shannonEnt -= prob * math.log（prob， 2）

return shannonEnt

要注意的是，熵越大，说明数据的类别越分散，越呈现某种无序的状态。

下面再定义一个拆分数据集的函数：

def Split_dataset（dataset， axis， value）：

retDataSet = ［］

for featVec in dataset：

if featVec［axis］ == value：

reducedFeatVec = featVec［：axis］

reducedFeatVec.extend（featVec［axis+1 ：］）

retDataSet.append（reducedFeatVec）

return retDataSet

结合前面的几个函数，我们可以构造一个特征选择的函数：

def Choose_feature（dataset）：

num_sample = len（dataset）

num_feature = len（dataset［0］） - 1

baseEntrpy = Cal_entrpy（dataset）

best_Infogain = 0.0

bestFeat = -1

for i in range （num_feature）：

featlist = ［example［i］ for example in dataset］

uniquValus = set（featlist）

newEntrpy = 0.0

for value in uniquValus：

subData = Split_dataset（dataset， i， value）

prob = len（subData） / float（num_sample）

newEntrpy += prob * Cal_entrpy（subData）

info_gain = baseEntrpy - newEntrpy

if （info_gain 》 best_Infogain）：

best_Infogain = info_gain

bestFeat = i

return bestFeat

然后再构造一个投票及计票的函数

def Major_cnt（classlist）：

class_num = {}

for vote in classlist：

if vote not in class_num.keys（）：

class_num［vote］ = 0

class_num［vote］ += 1

Sort_K = sorted（class_num.iteritems（），

key = operator.itemgetter（1）， reverse=True）

return Sort_K［0］［0］

有了这些，就可以构造我们需要的决策树了：

def Create_tree（dataset， featName）：

classlist = ［example［-1］ for example in dataset］

if classlist.count（classlist［0］） == len（classlist）：

return classlist［0］

if len（dataset［0］） == 1：

return Major_cnt（classlist）

bestFeat = Choose_feature（dataset）

bestFeatName = featName［bestFeat］

myTree = {bestFeatName： {}}

del（featName［bestFeat］）

featValues = ［example［bestFeat］ for example in dataset］

uniqueVals = set（featValues）

for value in uniqueVals：

subLabels = featName［：］

myTree［bestFeatName］［value］ = Create_tree（Split_dataset

（dataset， bestFeat， value）， subLabels）

return myTree

def Get_numleafs（myTree）：

numLeafs = 0

firstStr = myTree.keys（）［0］

secondDict = myTree［firstStr］

for key in secondDict.keys（）：

if type（secondDict［key］）.__name__ == ‘dict’ ：

numLeafs += Get_numleafs（secondDict［key］）

else：

numLeafs += 1

return numLeafs

def Get_treedepth（myTree）：

max_depth = 0

firstStr = myTree.keys（）［0］

secondDict = myTree［firstStr］

for key in secondDict.keys（）：

if type（secondDict［key］）.__name__ == ‘dict’ ：

this_depth = 1 + Get_treedepth（secondDict［key］）

else：

this_depth = 1

if this_depth 》 max_depth：

max_depth = this_depth

return max_depth

我们也可以把决策树绘制出来：

def Plot_node（nodeTxt， centerPt， parentPt， nodeType）：

Create_plot.ax1.annotate（nodeTxt， xy=parentPt，

xycoords=‘axes fraction’，

xytext=centerPt， textcoords=‘axes fraction’，

va=“center”， ha=“center”， bbox=nodeType， arrowprops=arrow_args）

def Plot_tree（myTree， parentPt， nodeTxt）：

numLeafs = Get_numleafs（myTree）

Get_treedepth（myTree）

firstStr = myTree.keys（）［0］

cntrPt = （Plot_tree.xOff + （1.0 + float（numLeafs））/2.0/Plot_tree.totalW，

Plot_tree.yOff）

Plot_midtext（cntrPt， parentPt， nodeTxt）

Plot_node（firstStr， cntrPt， parentPt， decisionNode）

secondDict = myTree［firstStr］

Plot_tree.yOff = Plot_tree.yOff - 1.0/Plot_tree.totalD

for key in secondDict.keys（）：

if type（secondDict［key］）.__name__==‘dict’：

Plot_tree（secondDict［key］，cntrPt，str（key））

else：

Plot_tree.xOff = Plot_tree.xOff + 1.0/Plot_tree.totalW

Plot_node（secondDict［key］， （Plot_tree.xOff， Plot_tree.yOff），

cntrPt， leafNode）

Plot_midtext（（Plot_tree.xOff， Plot_tree.yOff）， cntrPt， str（key））

Plot_tree.yOff = Plot_tree.yOff + 1.0/Plot_tree.totalD

def Create_plot （myTree）：

fig = plt.figure（1， facecolor = ‘white’）

fig.clf（）

axprops = dict（xticks=［］， yticks=［］）

Create_plot.ax1 = plt.subplot（111， frameon=False， **axprops）

Plot_tree.totalW = float（Get_numleafs（myTree））

Plot_tree.totalD = float（Get_treedepth（myTree））

Plot_tree.xOff = -0.5/Plot_tree.totalW; Plot_tree.yOff = 1.0;

Plot_tree（myTree， （0.5，1.0）， ‘’）

plt.show（）

def Plot_midtext（cntrPt， parentPt， txtString）：

xMid = （parentPt［0］ - cntrPt［0］） / 2.0 + cntrPt［0］

yMid = （parentPt［1］ - cntrPt［1］） / 2.0 + cntrPt［1］

Create_plot.ax1.text（xMid， yMid， txtString）

def Classify（myTree， featLabels， testVec）：

firstStr = myTree.keys（）［0］

secondDict = myTree［firstStr］

featIndex = featLabels.index（firstStr）

for key in secondDict.keys（）：

if testVec［featIndex］ == key：

if type（secondDict［key］）.__name__ == ‘dict’ ：

classLabel = Classify（secondDict［key］，featLabels，testVec）

else：

classLabel = secondDict［key］

return classLabel

最后，可以测试我们的构造的决策树分类器：

decisionNode = dict（boxstyle=“sawtooth”， fc=“0.8”）

leafNode = dict（boxstyle=“round4”， fc=“0.8”）

arrow_args = dict（arrowstyle=“《-”）

myData， featName = Create_data（）

S_entrpy = Cal_entrpy（myData）

new_data = Split_dataset（myData， 0， 1）

best_feat = Choose_feature（myData）

myTree = Create_tree（myData， featName［：］）

num_leafs = Get_numleafs（myTree）

depth = Get_treedepth（myTree）

Create_plot（myTree）

predict_label = Classify（myTree， featName， ［1， 0］）

print（“the predict label is： ”， predict_label）

print（“the decision tree is： ”， myTree）

print（“the best feature index is： ”， best_feat）

print（“the new dataset： ”， new_data）

print（“the original dataset： ”， myData）

print（“the feature names are： ”， featName）

print（“the entrpy is：”， S_entrpy）

print（“the number of leafs is： ”， num_leafs）

print（“the dpeth is： ”， depth）

print（“All is well.”）

构造的决策树最后如下所示：