python如何实现决策树分类算法

前置信息1、决策树

重写后的句子:

在监督学习中,常用的一种分类算法是决策树,其基于一批样本,每个样本都包含一组属性和对应的分类结果。利用这些样本进行学习,算法可以生成一棵决策树,该决策树可以对新数据进行正确分类

2、样本数据

假设现有用户14名,其个人属性及是否购买某一产品的数据如下:

编号年龄收入范围工作性质信用评级购买决策01<
30高不稳定较差否02<
30高不稳定好否0330-40高不稳定较差是04>
40中等不稳定较差是05>
40低稳定较差是06>
40低稳定好否0730-40低稳定好是08<
30中等不稳定较差否09<
30低稳定较差是10>
40中等稳定较差是11<
30中等稳定好是1230-40中等不稳定好是1330-40高稳定较差是14>
40中等不稳定好否策树分类算法1、构建数据集

为了方便处理,对模拟数据按以下规则转换为数值型列表数据:

Python实现决策树分类算法

年龄:<
30赋值为0;30-40赋值为1;>
40赋值为2

收入:低为0;中为1;高为2

工作性质:不稳定为0;稳定为1

信用评级:差为0;好为1

#创建数据集
def createdataset():
dataSet=[[0,2,0,0,'
N'
],
[0,2,0,1,'
N'
],
[1,2,0,0,'
Y'
],
[2,1,0,0,'
Y'
],
[2,0,1,0,'
Y'
],
[2,0,1,1,'
N'
],
[1,0,1,1,'
Y'
],
[0,1,0,0,'
N'
],
[0,0,1,0,'
Y'
],
[2,1,1,0,'
Y'
],
[0,1,1,1,'
Y'
],
[1,1,0,1,'
Y'
],
[1,2,1,0,'
Y'
],
[2,1,0,1,'
N'
],]
labels=['
age'
,'
income'
,'
job'
,'
credit'
]
return dataSet,labels

调用函数,可获得数据:

ds1,lab = createdataset()
print(ds1)
print(lab)

[[0, 2, 0, 0, &
lsquo;
N&
rsquo;
], [0, 2, 0, 1, &
lsquo;
N&
rsquo;
], [1, 2, 0, 0, &
lsquo;
Y&
rsquo;
], [2, 1, 0, 0, &
lsquo;
Y&
rsquo;
], [2, 0, 1, 0, &
lsquo;
Y&
rsquo;
], [2, 0, 1, 1, &
lsquo;
N&
rsquo;
], [1, 0, 1, 1, &
lsquo;
Y&
rsquo;
], [0, 1, 0, 0, &
lsquo;
N&
rsquo;
], [0, 0, 1, 0, &
lsquo;
Y&
rsquo;
], [2, 1, 1, 0, &
lsquo;
Y&
rsquo;
], [0, 1, 1, 1, &
lsquo;
Y&
rsquo;
], [1, 1, 0, 1, &
lsquo;
Y&
rsquo;
], [1, 2, 1, 0, &
lsquo;
Y&
rsquo;
], [2, 1, 0, 1, &
lsquo;
N&
rsquo;
]][&
lsquo;
age&
rsquo;
, &
lsquo;
income&
rsquo;
, &
lsquo;
job&
rsquo;
, &
lsquo;
credit&
rsquo;
]

2、数据集信息熵

信息熵也称为香农熵,是随机变量的期望。度量信息的不确定程度。信息的熵越大,信息就越不容易搞清楚。处理信息就是为了把信息搞清楚,就是熵减少的过程。

def calcShannonEnt(dataSet):
numEntries = len(dataSet)
labelCounts = {}
for featVec in dataSet:
currentLabel = featVec[-1]
if currentLabel not in labelCounts.keys():
labelCounts[currentLabel] = 0

labelCounts[currentLabel] += 1

shannonEnt = 0.0
for key in labelCounts:
prob = float(labelCounts[key])/numEntries
shannonEnt -= prob*log(prob,2)

return shannonEnt

样本数据信息熵:

shan = calcShannonEnt(ds1)
print(shan)

0.9402859586706309

3、信息增益

信息增益:用于度量属性A降低样本集合X熵的贡献大小。信息增益越大,越适于对X分类。

def chooseBestFeatureToSplit(dataSet):
numFeatures = len(dataSet[0])-1
baseEntropy = calcShannonEnt(dataSet)
bestInfoGain = 0.0;
bestFeature = -1
for i in range(numFeatures):
featList = [example[i] for example in dataSet]
uniqueVals = set(featList)
newEntroy = 0.0
for value in uniqueVals:
subDataSet = splitDataSet(dataSet, i, value)
prop = len(subDataSet)/float(len(dataSet))
newEntroy += prop * calcShannonEnt(subDataSet)
infoGain = baseEntropy - newEntroy
if(infoGain >
bestInfoGain):
bestInfoGain = infoGain
bestFeature = i
return bestFeature

以上代码实现了基于信息熵增益的ID3决策树学习算法。其核心逻辑原理是:依次选取属性集中的每一个属性,将样本集按照此属性的取值分割为若干个子集;对这些子集计算信息熵,其与样本的信息熵的差,即为按照此属性分割的信息熵增益;找出所有增益中最大的那一个对应的属性,就是用于分割样本集的属性。

计算样本最佳的分割样本属性,结果显示为第0列,即age属性:

col = chooseBestFeatureToSplit(ds1)
col

0

4、构造决策树def majorityCnt(classList):
classCount = {}
for vote in classList:
if vote not in classCount.keys():classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classList.iteritems(),key=operator.itemgetter(1),reverse=True)#利用operator操作键值排序字典
return sortedClassCount[0][0]

#创建树的函数
def createTree(dataSet,labels):
classList = [example[-1] for example in dataSet]
if classList.count(classList[0]) == len(classList):
return classList[0]
if len(dataSet[0]) == 1:
return majorityCnt(classList)
bestFeat = chooseBestFeatureToSplit(dataSet)
bestFeatLabel = labels[bestFeat]
myTree = {bestFeatLabel:{}}
del(labels[bestFeat])
featValues = [example[bestFeat] for example in dataSet]
uniqueVals = set(featValues)
for value in uniqueVals:
subLabels = labels[:]
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)

return myTree

majorityCnt函数用于处理一下情况:最终的理想决策树应该沿着决策分支到达最底端时,所有的样本应该都是相同的分类结果。但是真实样本中难免会出现所有属性一致但分类结果不一样的情况,此时majorityCnt将这类样本的分类标签都调整为出现次数最多的那一个分类结果。

createTree是核心任务函数,它对所有的属性依次调用ID3信息熵增益算法进行计算处理,最终生成决策树。

5、实例化构造决策树

利用样本数据构造决策树:

Tree = createTree(ds1, lab)
print("
样本数据决策树:"
)
print(Tree)

样本数据决策树:{&
lsquo;
age&
rsquo;
: {0: {&
lsquo;
job&
rsquo;
: {0: &
lsquo;
N&
rsquo;
, 1: &
lsquo;
Y&
rsquo;
}},1: &
lsquo;
Y&
rsquo;
,2: {&
lsquo;
credit&
rsquo;
: {0: &
lsquo;
Y&
rsquo;
, 1: &
lsquo;
N&
rsquo;
}}}}

6、测试样本分类

给出一个新的用户信息,判断ta是否购买某一产品:

年龄收入范围工作性质信用评级<
30低稳定好<
30高不稳定好def classify(inputtree,featlabels,testvec):
firststr = list(inputtree.keys())[0]
seconddict = inputtree[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 labels=['
age'
,'
income'
,'
job'
,'
credit'
]
tsvec=[0,0,1,1]
print('
result:'
,classify(Tree,labels,tsvec))
tsvec1=[0,2,0,1]
print('
result1:'
,classify(Tree,labels,tsvec1))

result: Yresult1: N

后置信息:绘制决策树代码

以下代码用于绘制决策树图形,非决策树算法重点,有兴趣可参考学习

import matplotlib.pyplot as plt

decisionNode = dict(box, fc="
0.8"
)
leafNode = dict(box, fc="
0.8"
)
arrow_args = dict(arrow)

#获取叶节点的数目
def getNumLeafs(myTree):
numLeafs = 0
firstStr = list(myTree.keys())[0]
secondDict = myTree[firstStr]
for key in secondDict.keys():
if type(secondDict[key]).__name__=='
dict'
:#测试节点的数据是否为字典,以此判断是否为叶节点
numLeafs += getNumLeafs(secondDict[key])
else: numLeafs +=1
return numLeafs

#获取树的层数
def getTreeDepth(myTree):
maxDepth = 0
firstStr = list(myTree.keys())[0]
secondDict = myTree[firstStr]
for key in secondDict.keys():
if type(secondDict[key]).__name__=='
dict'
:#测试节点的数据是否为字典,以此判断是否为叶节点
thisDepth = 1 + getTreeDepth(secondDict[key])
else: thisDepth = 1
if thisDepth >
maxDepth: maxDepth = thisDepth
return maxDepth

#绘制节点
def plotNode(nodeTxt, centerPt, parentPt, nodeType):
createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='
axes fraction'
,
xytext=centerPt, textcoords='
axes fraction'
,
va="
center"
, ha="
center"
, bbox=nodeType, arrowprops=arrow_args )

#绘制连接线
def plotMidText(cntrPt, parentPt, txtString):
xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]
yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]
createPlot.ax1.text(xMid, yMid, txtString, va="
center"
, ha="
center"
, rotation=30)

#绘制树结构
def plotTree(myTree, parentPt, nodeTxt):#if the first key tells you what feat was split on
numLeafs = getNumLeafs(myTree) #this determines the x width of this tree
depth = getTreeDepth(myTree)
firstStr = list(myTree.keys())[0] #the text label for this node should be this
cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)
plotMidText(cntrPt, parentPt, nodeTxt)
plotNode(firstStr, cntrPt, parentPt, decisionNode)
secondDict = myTree[firstStr]
plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD
for key in secondDict.keys():
if type(secondDict[key]).__name__=='
dict'
:#test to see if the nodes are dictonaires, if not they are leaf nodes
plotTree(secondDict[key],cntrPt,str(key)) #recursion
else: #it'
s a leaf node print the leaf node
plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD

#创建决策树图形
def createPlot(inTree):
fig = plt.figure(1, facecolor='
white'
)
fig.clf()
axprops = dict(xticks=[], yticks=[])
createPlot.ax1 = plt.subplot(111, frameon=False, **axprops) #no ticks
#createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses
plotTree.totalW = float(getNumLeafs(inTree))
plotTree.totalD = float(getTreeDepth(inTree))
plotTree.xOff = -0.5/plotTree.totalW;
plotTree.yOff = 1.0;

plotTree(inTree, (0.5,1.0), '
'
)
plt.savefig('
决策树.png'
,dpi=300,bbox_inches='
tight'
)
plt.show()

决策树是一种常用的机器学习算法,它可以将数据集划分成多个分类或者预测出目标变量的值。Python是一种功能强大的编程语言,它提供了许多库和函数来实现决策树分类算法。本文将介绍如何使用Python实现决策树分类算法。
1. 决策树分类算法概述
决策树是一种树型结构,在每一个结点上都包含了一个问题,通过回答这个问题可以沿着树的分支到达叶子结点。叶子结点代表了一个分类或者目标变量的值。决策树分类算法通过生成这样的一棵决策树来对数据进行分类。
在分类问题中,决策树根据训练数据将属性划分为多个不同的分类。通过对训练数据的学习,决策树可以自动识别有用的属性和属性值,并将这些属性组合成规则,从而对新的数据进行分类。
2. Python实现决策树分类算法
Python提供了许多实现决策树分类算法的库和函数。其中最常用的是sklearn库中的DecisionTreeClassifier类。这个类支持使用多种不同的指标,如信息增益、基尼不纯度等来计算属性划分。以下是Python实现决策树分类算法的一些步骤:
(1)准备数据集
首先需要准备一个包含训练数据和测试数据的数据集。这个数据集需要包含多个属性,每个属性都是用数字或者字符串来表示的。其中最后一列是用来表示目标变量的值。
(2)分割数据集
将数据集分割成训练数据和测试数据两部分。通常将70%的数据用于训练,30%的数据用于测试。
(3)训练模型
在训练数据上训练决策树分类器。可以设置不同的参数来改变决策树的构建方式,比如树的深度、节点划分的指标等等。
(4)测试模型
使用测试数据来测试决策树分类器的准确度。可以计算出分类器的准确度或者混淆矩阵等指标来评估分类器的性能。
3. Python决策树分类算法实例
下面是一个使用Python实现决策树分类算法的实例。在这个实例中,我们使用一个名为iris的数据集进行训练和测试。这个数据集包含了3个不同的鸢尾花品种,每个品种包含50个样本,每个样本都包含了4个属性。
首先需要导入所需要的库:
```python
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
```
然后导入数据集并将其分割成训练数据和测试数据:
```python
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=42)
```
接下来就可以使用DecisionTreeClassifier类来训练和测试模型。
```python
clf = DecisionTreeClassifier(max_depth=3, criterion='entropy', random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
score = accuracy_score(y_test, y_pred)
print('Accuracy score:', score)
```
在这里,我们设置决策树的最大深度为3,使用熵来计算节点的信息增益。运行结果如下:
```
Accuracy score: 1.0
```
这说明我们的决策树分类器在测试数据上取得了100%的准确度。
4. 总结
Python是一种功能强大的编程语言,它提供了许多库和函数来实现决策树分类算法。本文介绍了如何使用Python和sklearn库来实现决策树分类算法,并给出了一个实例来说明决策树分类算法的使用方法。决策树分类算法是机器学习中最常用的算法之一,它可以根据数据集将属性划分为多个不同的分类,从而对新的数据进行分类。