机器学习-决策树
目录
一、什么是决策树
1、决策树的定义
2、决策树模型
3、决策树学习
二、信息增益
三、决策树的构造及代码
一、背景前提：
二、数据处理
三、训练算法
五、实验总结
一、什么是决策树
1、决策树的定义
百度百科决策树的定义：
决策树(Decision Tree）是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策分析方法，是直观运用概率分析的一种图解法。由于这种决策分支画成图形很像一棵树的枝干，故称决策树。在机器学习中，决策树是一个预测模型，他代表的是对象属性与对象值之间的一种映射关系。Entropy = 系统的凌乱程度，使用算法ID3, C4.5和C5.0生成树算法使用熵。这一度量是基于信息学理论中熵的概念。
2、决策树模型
决策树模型是一种描述对实例进行分类的树形结构。其由结点（node）和有向边（directed edge）组成。结点有两种类型：内部结点（internal node）和叶结点（leaf node）。内部结点表示一个特征或属性（features），叶结点表示一个类（labels）。
3、决策树学习
决策树学习通常包括 3 个步骤：特征选择、决策树的生成和决策树的修剪。
二、信息增益
熵（entropy）：熵指的是体系的混乱的程度，在不同的学科中也有引申出的更为具体的定义，是各领域十分重要的参量。
信息论（information theory）中的熵（香农熵）：是一种信息的度量方式，表示信息的混乱程度，也就是说：信息越有序，信息熵越低。
信息增益（information gain）：在划分数据集前后信息发生的变化称为信息增益。
离散属性 a 有 V 个可能的取值 { a 1 , a 2 , ..., a V } ，用 a 来进行划分，则会产 生V 个分支结点，其中第 v 个分支结点包含了 D 中所有在属性 a 上取值为 a v 的样本，记为 D v 。则可计算出用属性 a 对样本集 D 进行划分所获得的 “信息增益” ：
一般而言， 信息增益越大 ，则意味着使用属性 a 来进行划分所获得的 “ 纯度提升 ”越大.
三、决策树的构造及代码
一、背景前提：
假设集美大学本部和诚毅学院都有开设智能科学与技术专业，且两个学校之间的快递驿站是同一个地方（两校离得近且互通）。 如果在快递驿站得知一名同学的以下信息，你能否知道他是否是集美大学本部的智能科学与技术专业的？
信息一：是否住在五社区
信息二：是否学习C语言
信息三：是否学习机器学习
（注：集美大学本部的智能科学与技术专业的同学都住在五社区，诚毅学院的智能科学与技术专业的同学不住五社区。只有智能科学与技术专业同时开设C语言和机器学习 ，有的其他专业开设C语言，但没开设机器学习；有的专业开设机器学习，但没开设C语言。）
根据上述信息，我们可以画出表格如下：
| 序号 | 是否住五社区 | 是否学C语言 | 是否学机器学习 | 是否是集大本部智能专业的学生 |
| 1 | 是 | 是 | 是 | 是 |
| 2 | 是 | 是 | 否 | 否 |
| 3 | 是 | 否 | 是 | 否 |
| 4 | 是 | 否 | 否 | 否 |
| 5 | 否 | 是 | 是 | 否 |
| 6 | 否 | 是 | 否 | 否 |
| 7 | 否 | 否 | 是 | 否 |
| 8 | 否 | 否 | 否 | 否 |
二、数据处理
1、收集、准备数据：
def createDataSet():
dataSet = [[1, 1, 1, 'yes'],
[1, 1, 0, 'no'],
[1, 0, 1, 'no'],
[1, 0, 0, 'no'],
[0, 1, 1, 'no'],
[0, 1, 0, 'no'],
[0, 0, 1, 'no'],
[0, 0, 0, 'no']]
labels = ['live in 5', 'learn c', "learn ML"]
return dataSet, labels2、分析数据：
计算给定数据集的香农熵的函数如下：
from math import log
def calcShannonEnt(dataSet):
'''
概率计算就是计算数据出现的频率
第一步：统计总体数据数
第二步：求出每个标签出现次数，这里需要用到字典的映射关系
第三步：遍历求出香农熵
熵越高，则混合额数据也就越多，数据的混乱程度也就越高
:param dataSet:
:return: shannonEnt
'''
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) #log后为底数
return shannonEnt按照给定特征划分数据集，将指定特征的特征值等于 value 的行剩下列作为子数据集。
def splitDataSet(dataSet,axis,value):
'''
:param dataSet:数据集
:param axis: 列（特征所对应的列）
:param value: 需要返回的特征的值
:return: index列为value的数据集【数据分离后要删除index列】
'''
retDataSet = []
for featVec in dataSet:
if featVec[axis] == value:
reducedFeatVec = featVec[:axis]
reducedFeatVec.extend(featVec[axis+1:])
retDataSet.append(reducedFeatVec)
return retDataSet
选择最好的数据集划分方式：
def chooseBestFeatureToSplit(dataSet):
"""
chooseBestFeatureToSplit(选择最好的特征)
Args:
dataSet 数据集
Returns:
bestFeature 最优的特征列
"""
# 求第一行有多少列的 Feature, 最后一列是label列
numFeatures = len(dataSet[0]) - 1
# 数据集的原始信息熵
baseEntropy = calcShannonEnt(dataSet)
# 最优的信息增益值, 和最优的Featurn编号
bestInfoGain, bestFeature = 0.0, -1
# iterate over all the features
for i in range(numFeatures):
# 获取对应的feature下的所有数据
featList = [example[i] for example in dataSet]
# 获取剔重后的集合，使用set对list数据进行去重
uniqueVals = set(featList)
# 创建一个临时的信息熵
newEntropy = 0.0
# 遍历某一列的value集合，计算该列的信息熵
# 遍历当前特征中的所有唯一属性值，对每个唯一属性值划分一次数据集，计算数据集的新熵值，并对所有唯一特征值得到的熵求和。
for value in uniqueVals:
subDataSet = splitDataSet(dataSet, i, value)
# 计算概率
prob = len(subDataSet) / float(len(dataSet))
# 计算条件熵
newEntropy += prob * calcShannonEnt(subDataSet)
# gain[信息增益]: 划分数据集前后的信息变化， 获取信息熵最大的值
# 信息增益是熵的减少或者是数据无序度的减少。最后，比较所有特征中的信息增益，返回最好特征划分的索引值。
infoGain = baseEntropy - newEntropy
print('infoGain=', infoGain, 'bestFeature=', i, baseEntropy, newEntropy)
if infoGain > bestInfoGain:
bestInfoGain = infoGain
bestFeature = i
return bestFeature
三、训练算法
构造树的数据结构，创建树的函数代码如下：
import operator
def majorityCnt(classList):
"""
majorityCnt(选择出现次数最多的一个结果)
Args:
classList label列的集合
Returns:
bestFeature 最优的特征列
"""
classCount = {}
for vote in classList:
if vote not in classCount.keys():
classCount[vote] = 0
classCount[vote] += 1
# 倒叙排列classCount得到一个字典集合，然后取出第一个就是结果（yes/no），即出现次数最多的结果
sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
return sortedClassCount[0][0]
def createTree(dataSet, labels):
classList = [example[-1] for example in dataSet]
# 如果数据集的最后一列的第一个值出现的次数=整个集合的数量，也就说只有一个类别，就只直接返回结果就行
# 第一个停止条件：所有的类标签完全相同，则直接返回该类标签。
# count() 函数是统计括号中的值在list中出现的次数
if classList.count(classList[0]) == len(classList):
return classList[0]
# 如果数据集只有1列，那么最初出现label次数最多的一类，作为结果
# 第二个停止条件：使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
if len(dataSet[0]) == 1:
return majorityCnt(classList)
# 选择最优的列，得到最优列对应的label含义
bestFeat = chooseBestFeatureToSplit(dataSet)
# 获取label的名称
bestFeatLabel = labels[bestFeat]
# 初始化myTree
myTree = {bestFeatLabel: {}}
# 注：labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
# 所以这行代码导致函数外的同名变量被删除了元素，造成例句无法执行，提示'no surfacing' is not in list
del (labels[bestFeat])
# 取出最优列，然后它的branch做分类
featValues = [example[bestFeat] for example in dataSet]
uniqueVals = set(featValues)
for value in uniqueVals:
# 求出剩余的标签label
subLabels = labels[:]
# 遍历当前选择特征包含的所有属性值，在每个数据集划分上递归调用函数createTree()
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
return myTree
储存决策树：
def storeTree(inputTree, filename):
import pickle
fw = open(filename, 'wb')
pickle.dump(inputTree, fw)
fw.close()
def loadTree(filename):
import pickle
fr = open(filename, 'rb')
return pickle.load(fr)使用Matplotlib注解绘制树形图：
import matplotlib.pyplot as plt
#定义文本框和箭头格式
decisionNode=dict(boxstyle="sawtooth",fc='0.8')
leafNode=dict(boxstyle="round4",fc='0.8')
arrow_args=dict(arrowstyle="<-")
#绘制带箭头的注释
def plotNode(nodeTxt,centerPt,parentPt,nodeType):
createPlot.axl.annotate(nodeTxt,xy=parentPt,xycoords='axes fraction',
xytext=centerPt,
textcoords='axes fraction',
va="center",ha="center",bbox=nodeType,arrowprops=arrow_args)
#获取叶节点的数目和树的层数
def getNumLeafs(myTree):
numLeafs=0
# firstStr=myTree.keys()[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 plotMidText(cntrPt,parentPt,txtString):
xMid=(parentPt[0]-cntrPt[0])/2.0+cntrPt[0]
yMid=(parentPt[1]-cntrPt[1])/2.0+cntrPt[1]
createPlot.axl.text(xMid,yMid,txtString)
def plotTree(mytree,parentPt,nodeTxt):
numLeafs=getNumLeafs(mytree)
depth=getTreeDepth(mytree)
firstStr=list(mytree.keys())[0]
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':
plotTree(secondDict[key],cntrPt,str(key))
else:
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.axl=plt.subplot(111,frameon=False,**axprops)
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.show()
代码测试：
if __name__ == '__main__':
dataSet, labels = createDataSet()
shannonEnt = calcShannonEnt(dataSet)
mytree = createTree(dataSet, labels)
storeTree(mytree, 'classifierStorage.pkl')
mytree = loadTree('classifierStorage.pkl')
print(mytree)
createPlot(mytree)
输出结果：
五、实验总结
决策树有以下优缺点：
- 优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。
- 缺点：可能会产生过度匹配的问题
- 适用数据类型：数值型和标称型