机器学习实战笔记（二）决策树
决策树
决策树是一种十分常用的分类方法。由于这种决策分支画成图形很像一棵树的枝干，故称决策树。在机器学习中，决策树是一个预测模型，他代表的是对象属性与对象值之间的一种映射关系。Entropy=系统的凌乱程度，使用算法ID3,C4.5和C5.0生成树算法使用熵。这一度量是基于信息学理论中熵的概念。
分类决策树模型是一种描述对实例进行分类的树形结构。决策树由结点（node）和有向边（directed edge）组成。结点有两种类型：内部结点（internal node）和叶结点（leaf node）。内部结点表示一个特征或属性(features)，叶结点表示一个类(labels)。
用决策树对需要测试的实例进行分类：从根节点开始，对实例的某一特征进行测试，根据测试结果，将实例分配到其子结点；这时，每一个子结点对应着该特征的一个取值。如此递归地对实例进行测试并分配，直至达到叶结点。最后将实例分配到叶结点的类中。
决策树的特点
优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。
缺点：可能会产生过度匹配的问题
适用数据类型：数值型和标称型
决策树的一般流程
- 收集数据：一般方法都适用。
- 准备数据：需要将数值数据离散化。
- 分析数据：用可视化图形分析构造的树是否符合预期。
- 训练算法：构造树的数据结构。
- 测试算法: 使用经验树计算错误率。
- 使用算法: 结合实例。
决策树的构造
在构建决策树时要解决的第一个问题就是：要找到当前数据集上在划分数据分类时起决定性作用的那个特征。完成测试之后，原始数据集就被划分为几个数据子集。这些数据子集会分布在第一个决策点的所有分支上。如果某个分支下的数据属于同一类型，无需进一步对数据集进行分割。如果数据子集内的数据不属于同一类型，则需要重复划分数据子集的过程。如何划分数据子集的算法和划分原始数据集的方法相同，直到所有具有相同类型的数据均在一个数据子集内。
创建分支的伪代码函数createBranch()如下所示：
检测数据集中的每个子项是否属于同一分类：
If so return 类标签；
Else
寻找划分数据集的最好特征
划分数据集
创建分支节点
for 每个划分的子集
调用函数createBranch并增加返回结果到分支节点中
return 分支节点
这里将使用ID3算法，划分数据集，该算法处理如何划分数据集，何时停止划分数据集。
1.信息增益
划分数据集的大原则是：将无序的数据变得更加有序。在划分数据集之后信息发生的变化称为信息增益，知道如何计算信息增益，我们就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。
信息的定义： l ( x i ) = − l o g 2 p ( x i ) l(x_i) = -log_2p(x_i) l(xi)=−log2p(xi)
计算熵：信息期望值
H = − ∑ i = 1 n p ( x i ) l o g 2 p ( x i ) H = -\sum_{i=1}^np(x_i)log_2p(x_i) H=−i=1∑np(xi)log2p(xi)
#计算给定数据集的香农熵(经验熵)
from math import log
def calcShannonEnt(dataSet):
numEntries = len(dataSet) #表示参与训练的数据量，求list的长度
# 计算分类标签出现的次数
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
#计算香农熵，以2为底求对数，信息期望值
shannonEnt -= prob * log(prob,2)
return shannonEnt
测试给定数据集的香农熵:
#创建数据集
def createDataSet():
dataSet = [[1, 1, 'yes'],
[1, 1, 'yes'],
[1, 0, 'no'],
[0, 1, 'no'],
[0, 1, 'no']]
labels = ['no surfacing', 'flippers'] # 露出水面,脚蹼,表示数据集中特征的含义
return dataSet, labels
#测试
def test():
myDat,labels = createDataSet()
print(myDat)
print(calcShannonEnt(myDat))
结果如下：
2.划分数据集
划分数据集，度量划分数据集的熵。
#遍历dataSet数据集，求出index对应的colnum列的值为value的行
#依据index列进行分类，如果index列的数据等于value的时候，就要将index划分到新创建的列表中
def splitDataSet(dataSet, index, value):
#新建一个列表存储划分出来的数据
retDataSet = []
for featVec in dataSet:
if featVec[index] == value:
reducedFeatVec = featVec[:index]
reducedFeatVec.extend(featVec[index+1:])
#收集结果值index列为value的行,排除index列
retDataSet.append(reducedFeatVec)
return retDataSet
接下来我们将遍历整个数据集，循环计算香农熵和splitDataSet()函数，找到最好的特征划分方式。
#选择最好的数据集划分方式
def chooseBestFeatureToSplit(dataSet):
#求第一行有多少列的特征feature，label在最后一列
numFeatures = len(dataSet[0]) - 1
#计算整个数据集的原始香农熵
baseEntropy = calcShannonEnt(dataSet)
#最优的信息增益值，和最优的特征值的编号
bestInfoGain = 0.0; bestFeature = -1
#循环遍历数据集中的所有特征
for i in range(numFeatures):
#使用（List Comprehension）来创建新的列表
#获取数据集中所有的第i个特征值
featList = [example[i] for example in dataSet]
#获取去重之后的集合，使用set对list数据进行去重，set类型中每个值互不相同
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) #经验条件熵
#信息增益：划分数据集前后的信息变化，获取信息熵最大的值
#信息增益是熵的减少或者是数据无序度的减少
infoGain = baseEntropy - newEntropy
#比较所有特征中的信息增益，返回最好特征划分的索引值
if(infoGain > bestInfoGain):
bestInfoGain = infoGain
bestFeature = i
return bestFeature
3.构建决策树
用多数表决的方法决定叶节点的分类，在创建树的代码中需要用到。
#选择出现次数最多的结果
import operator
def majorityCnt(classList):
classCount = {}
for vote in classList:
if vote not in classCount.keys():
classCount[vote] = 0
classCount[vote] += 1
#排序得到出现次数最多的结果
sortedClassCount = sorted(classCount.iteritems(), key = operator.itemgetter(1), reverse = True)
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) #挑选出现次数最多的类别作为返回值
# 选择最优的列，得到最优列对应的label的含义
bestFeat = chooseBestFeatureToSplit(dataSet)
#获取label的名称
bestFeatLabel = labels[bestFeat]
#初始化myTree
myTree = {bestFeatLabel:{}}
#在标签列表中删除当前最优的标签
del(labels[bestFeat])
#得到最优特征包含的所有属性值
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
树形图的绘制
1.绘制树节点
import matplotlib.pyplot as plt
#定义文本框和箭头格式，sawtooth 波浪方框， round4矩形方框， fc表示字体颜色的深浅 0.1~0.9依次变浅
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.ax1.annotate(nodeTxt, xy = parentPt, xycoords ='axes fraction', xytext = centerPt,
textcoords = 'axes fraction',va="center",ha="center",bbox=nodeType,arrowprops=arrow_args)
2.构造注解树
获取叶节点的数目和树的层数。
#获取叶节点的数目
def getNumLeafs(myTree):
numLeafs = 0
#第一个关键字，第一次划分数据集的类别标签
firstStr = list(myTree.keys())[0]
secondDict = myTree[firstStr]
#从根节点开始遍历
for key in secondDict.keys():
#测试节点的数据类型是否为字典，如果子节点是字典类型，则该节点也是一个判断节点
#if type(secondDict[key]).__name__=='dict':
if type(secondDict[key]) is 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]) is dict:
thisDepth = 1 + getTreeDepth(secondDict[key])
else:
thisDepth = 1
if thisDepth > maxDepth:
maxDepth = thisDepth
# maxDepth = max(maxDepth, thisDepth)
return maxDepth
3.创建树
填充文本信息。
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)
createPlot.ax1.text(xMid, yMid, txtString, va="center", ha="center", rotation = 30)
递归绘制树形图。
def plotTree(myTree, parentPt, nodeTxt):
#计算宽与高
numLeafs = getNumLeafs(myTree)
defth = getTreeDepth(myTree)
firstStr = list(myTree.keys())[0]
#找到第一个中心点的位置，然后与parentPt定点进行划线
cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff) #中心位置
#打印输入对应的文字
plotMidText(cntrPt, parentPt, nodeTxt)
#可视化Node分支点
plotNode(firstStr, cntrPt, parentPt, decisionNode)
secondeDict = myTree[firstStr] #下一个字典
#减少y的偏移，按比例减少 ，y值 = 最高点 - 层数的高度[第二个节点位置]
plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD
for key in secondeDict.keys():
#这些节点既可以是叶子结点也可以是判断节点
#判断该节点是否是Node节点
if type(secondeDict[key]) is dict:
#如果是就递归调用
plotTree(secondeDict[key], cntrPt, str(key))
else:
#如果不是，就在原来节点一半的地方找到节点的坐标
plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
#可视化该节点的位置
plotNode(secondeDict[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='green')
#清空当前图像窗口
fig.clf()
axprops = dict(xticks = [], yticks = [])
createPlot.ax1 = 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()
4.测试
通过测试数据集，检测绘制出来的树形图。
#测试数据集，存储树的信息
def retrieveTree(i):
listOfTrees = [
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},
{'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}
]
return listOfTrees[i]
得到的效果如下图所示：
myTree = retrieveTree(1)
createPlot(myTree)
构建分类器
1.决策树的分类函数
'''
args:
inputTree: 已经训练好的决策树模型
featLabels: Feature标签对应的名称，特征标签
testVec: 测试输入的数据
'''
def classify(inputTree, featLabels, testVec):
#获取tree的根节点对应的key值
firstStr = list(inputTree.keys())[0]
#通过key得到根节点对应的value
secondDict = inputTree[firstStr]
#获取根节点在label中的先后顺序
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
2.决策树的存储
将分类器存储在硬盘上，不用每次对数据分类的时候重新学习一遍。
#使用pickle模块存储决策树
def storeTree(inputTree, filename):
import pickle
fw = open(filename, 'w')
pickle._dump(inputTree, fw)
fw.close()
'''
with open(filename, 'wb') as fw:
pickle.dump(inputTree, fw)
'''
#读取树
def grabTree(filename):
import pickle
fr = open(filename)
return pickle.load(fr)
示例：预测隐形眼镜类型
def ContactLensesTest():
#加载隐形眼镜相关的文本文件数据
fr = open('lenses.txt')
#解析数据，获取features数据
lenses = [inst.strip().split('\t') for inst in fr.readlines()]
#得到数据相应的Labels
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
#构造预测隐形眼镜的决策树
lensesTree = createTree(lenses, lensesLabels)
print(lensesTree)
#画图可视化展现
# treePlotter.createPlot(lensesTree)
小结
决策树分类器就像带有终止块的流程图，终止块表示分类结果。开始处理数据集时，我们首先需要测量集合中数据的不一致性，也就是熵，然后寻找最优方案划分数据集，直到数据集中的所有数据属于同一分类。ID3算法可以用于划分标称型数据集。构建决策树时，我们通常采用递归的方法将数据集转化为决策树。
所有的代码和数据集可以到github上下载。
参考文章
《机器学习实战》
https://github.com/apachecn/MachineLearning/blob/master/docs/3.决策树.md
https://blog.csdn.net/c406495762/article/details/75663451
https://blog.csdn.net/c406495762/article/details/76262487