机器学习实战教程（三）：决策树实战篇之为本身配个隐形眼镜
原文连接：cuijiahua.com/blog/2017/1…html
1、前言
上篇文章机器学习实战教程（二）：决策树基础篇之让咱们从相亲提及讲述了机器学习决策树的原理，以及如何选择最优特征做为分类特征。本篇文章将在此基础上进行介绍。主要包括：node
- 决策树构建
- 决策树可视化
- 使用决策树进行分类预测
- 决策树的存储和读取
- sklearn实战之预测隐形眼睛类型
2、决策树构建
上篇文章也粗略提到过，构建决策树的算法有不少。篇幅缘由，本篇文章只使用ID3算法构建决策树。python
一、ID3算法
ID3算法的核心是在决策树各个结点上对应信息增益准则选择特征，递归地构建决策树。具体方法是：从根结点(root node)开始，对结点计算全部可能的特征的信息增益，选择信息增益最大的特征做为结点的特征，由该特征的不一样取值创建子节点；再对子结点递归地调用以上方法，构建决策树；直到全部特征的信息增益均很小或没有特征能够选择为止。最后获得一个决策树。ID3至关于用极大似然法进行几率模型的选择。git
在使用ID3构造决策树以前，咱们再分析下数据。github
利用上篇文章求得的结果，因为特征A3(有本身的房子)的信息增益值最大，因此选择特征A3做为根结点的特征。它将训练集D划分为两个子集D1(A3取值为"是")和D2(A3取值为"否")。因为D1只有同一类的样本点，因此它成为一个叶结点，结点的类标记为“是”。算法
对D2则须要从特征A1(年龄)，A2(有工做)和A4(信贷状况)中选择新的特征，计算各个特征的信息增益：数据库
根据计算，选择信息增益最大的特征A2(有工做)做为结点的特征。因为A2有两个可能取值，从这一结点引出两个子结点：一个对应"是"(有工做)的子结点，包含3个样本，它们属于同一类，因此这是一个叶结点，类标记为"是"；另外一个是对应"否"(无工做)的子结点，包含6个样本，它们也属于同一类，因此这也是一个叶结点，类标记为"否"。windows
这样就生成了一个决策树，该决策树只用了两个特征(有两个内部结点)，生成的决策树以下图所示。数组
这样咱们就使用ID3算法构建出来了决策树，接下来，让咱们看看如何进行代实现。bash
二、编写代码构建决策树
咱们使用字典存储决策树的结构，好比上小节咱们分析出来的决策树，用字典能够表示为：
{'有本身的房子': {0: {'有工做': {0: 'no', 1: 'yes'}}, 1: 'yes'}}
复制代码
建立函数majorityCnt统计classList中出现此处最多的元素(类标签)，建立函数createTree用来递归构建决策树。编写代码以下：
# -*- coding: UTF-8 -*-
from math import log
import operator
""" 函数说明:计算给定数据集的经验熵(香农熵) Parameters: dataSet - 数据集 Returns: shannonEnt - 经验熵(香农熵) Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def calcShannonEnt(dataSet):
numEntires = len(dataSet) #返回数据集的行数
labelCounts = {} #保存每一个标签(Label)出现次数的字典
for featVec in dataSet: #对每组特征向量进行统计
currentLabel = featVec[-1] #提取标签(Label)信息
if currentLabel not in labelCounts.keys(): #若是标签(Label)没有放入统计次数的字典,添加进去
labelCounts[currentLabel] = 0
labelCounts[currentLabel] += 1 #Label计数
shannonEnt = 0.0 #经验熵(香农熵)
for key in labelCounts: #计算香农熵
prob = float(labelCounts[key]) / numEntires #选择该标签(Label)的几率
shannonEnt -= prob * log(prob, 2) #利用公式计算
return shannonEnt #返回经验熵(香农熵)
""" 函数说明:建立测试数据集 Parameters: 无 Returns: dataSet - 数据集 labels - 特征标签 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-20 """
def createDataSet():
dataSet = [[0, 0, 0, 0, 'no'], #数据集
[0, 0, 0, 1, 'no'],
[0, 1, 0, 1, 'yes'],
[0, 1, 1, 0, 'yes'],
[0, 0, 0, 0, 'no'],
[1, 0, 0, 0, 'no'],
[1, 0, 0, 1, 'no'],
[1, 1, 1, 1, 'yes'],
[1, 0, 1, 2, 'yes'],
[1, 0, 1, 2, 'yes'],
[2, 0, 1, 2, 'yes'],
[2, 0, 1, 1, 'yes'],
[2, 1, 0, 1, 'yes'],
[2, 1, 0, 2, 'yes'],
[2, 0, 0, 0, 'no']]
labels = ['年龄', '有工做', '有本身的房子', '信贷状况'] #特征标签
return dataSet, labels #返回数据集和分类属性
""" 函数说明:按照给定特征划分数据集 Parameters: dataSet - 待划分的数据集 axis - 划分数据集的特征 value - 须要返回的特征的值 Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def splitDataSet(dataSet, axis, value):
retDataSet = [] #建立返回的数据集列表
for featVec in dataSet: #遍历数据集
if featVec[axis] == value:
reducedFeatVec = featVec[:axis] #去掉axis特征
reducedFeatVec.extend(featVec[axis+1:]) #将符合条件的添加到返回的数据集
retDataSet.append(reducedFeatVec)
return retDataSet #返回划分后的数据集
""" 函数说明:选择最优特征 Parameters: dataSet - 数据集 Returns: bestFeature - 信息增益最大的(最优)特征的索引值 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-20 """
def chooseBestFeatureToSplit(dataSet):
numFeatures = len(dataSet[0]) - 1 #特征数量
baseEntropy = calcShannonEnt(dataSet) #计算数据集的香农熵
bestInfoGain = 0.0 #信息增益
bestFeature = -1 #最优特征的索引值
for i in range(numFeatures): #遍历全部特征
#获取dataSet的第i个全部特征
featList = [example[i] for example in dataSet]
uniqueVals = set(featList) #建立set集合{},元素不可重复
newEntropy = 0.0 #经验条件熵
for value in uniqueVals: #计算信息增益
subDataSet = splitDataSet(dataSet, i, value) #subDataSet划分后的子集
prob = len(subDataSet) / float(len(dataSet)) #计算子集的几率
newEntropy += prob * calcShannonEnt(subDataSet) #根据公式计算经验条件熵
infoGain = baseEntropy - newEntropy #信息增益
# print("第%d个特征的增益为%.3f" % (i, infoGain)) #打印每一个特征的信息增益
if (infoGain > bestInfoGain): #计算信息增益
bestInfoGain = infoGain #更新信息增益，找到最大的信息增益
bestFeature = i #记录信息增益最大的特征的索引值
return bestFeature #返回信息增益最大的特征的索引值
""" 函数说明:统计classList中出现此处最多的元素(类标签) Parameters: classList - 类标签列表 Returns: sortedClassCount[0][0] - 出现此处最多的元素(类标签) Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def majorityCnt(classList):
classCount = {}
for vote in classList: #统计classList中每一个元素出现的次数
if vote not in classCount.keys():classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse = True) #根据字典的值降序排序
return sortedClassCount[0][0] #返回classList中出现次数最多的元素
""" 函数说明:建立决策树 Parameters: dataSet - 训练数据集 labels - 分类属性标签 featLabels - 存储选择的最优特征标签 Returns: myTree - 决策树 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-25 """
def createTree(dataSet, labels, featLabels):
classList = [example[-1] for example in dataSet] #取分类标签(是否放贷:yes or no)
if classList.count(classList[0]) == len(classList): #若是类别彻底相同则中止继续划分
return classList[0]
if len(dataSet[0]) == 1 or len(labels) == 0: #遍历完全部特征时返回出现次数最多的类标签
return majorityCnt(classList)
bestFeat = chooseBestFeatureToSplit(dataSet) #选择最优特征
bestFeatLabel = labels[bestFeat] #最优特征的标签
featLabels.append(bestFeatLabel)
myTree = {bestFeatLabel:{}} #根据最优特征的标签生成树
del(labels[bestFeat]) #删除已经使用特征标签
featValues = [example[bestFeat] for example in dataSet] #获得训练集中全部最优特征的属性值
uniqueVals = set(featValues) #去掉重复的属性值
for value in uniqueVals: #遍历特征，建立决策树。
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), labels, featLabels)
return myTree
if __name__ == '__main__':
dataSet, labels = createDataSet()
featLabels = []
myTree = createTree(dataSet, labels, featLabels)
print(myTree)
复制代码
递归建立决策树时，递归有两个终止条件：第一个中止条件是全部的类标签彻底相同，则直接返回该类标签；第二个中止条件是使用完了全部特征，仍然不能将数据划分仅包含惟一类别的分组，即决策树构建失败，特征不够用。此时说明数据纬度不够，因为第二个中止条件没法简单地返回惟一的类标签，这里挑选出现数量最多的类别做为返回值。
运行上述代码，咱们能够看到以下结果：
可见，咱们的决策树已经构建完成了。这时候，有的朋友可能会说，这个决策树看着好别扭，虽然这个能看懂，可是若是多点的结点，就很差看了。能直观点吗？彻底没有问题，咱们可使用强大的Matplotlib绘制决策树。
3、决策树可视化
这里代码都是关于Matplotlib的，若是对于Matplotlib不了解的，能够先学习下，Matplotlib的内容这里就再也不累述。可视化须要用到的函数：
- getNumLeafs：获取决策树叶子结点的数目
- getTreeDepth：获取决策树的层数
- plotNode：绘制结点
- plotMidText：标注有向边属性值
- plotTree：绘制决策树
- createPlot：建立绘制面板
我对可视化决策树的程序进行了详细的注释，直接看代码，调试查看便可。为了显示中文，须要设置FontProperties，代码编写以下：
# -*- coding: UTF-8 -*-
from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
from math import log
import operator
""" 函数说明:计算给定数据集的经验熵(香农熵) Parameters: dataSet - 数据集 Returns: shannonEnt - 经验熵(香农熵) Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def calcShannonEnt(dataSet):
numEntires = len(dataSet) #返回数据集的行数
labelCounts = {} #保存每一个标签(Label)出现次数的字典
for featVec in dataSet: #对每组特征向量进行统计
currentLabel = featVec[-1] #提取标签(Label)信息
if currentLabel not in labelCounts.keys(): #若是标签(Label)没有放入统计次数的字典,添加进去
labelCounts[currentLabel] = 0
labelCounts[currentLabel] += 1 #Label计数
shannonEnt = 0.0 #经验熵(香农熵)
for key in labelCounts: #计算香农熵
prob = float(labelCounts[key]) / numEntires #选择该标签(Label)的几率
shannonEnt -= prob * log(prob, 2) #利用公式计算
return shannonEnt #返回经验熵(香农熵)
""" 函数说明:建立测试数据集 Parameters: 无 Returns: dataSet - 数据集 labels - 特征标签 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-20 """
def createDataSet():
dataSet = [[0, 0, 0, 0, 'no'], #数据集
[0, 0, 0, 1, 'no'],
[0, 1, 0, 1, 'yes'],
[0, 1, 1, 0, 'yes'],
[0, 0, 0, 0, 'no'],
[1, 0, 0, 0, 'no'],
[1, 0, 0, 1, 'no'],
[1, 1, 1, 1, 'yes'],
[1, 0, 1, 2, 'yes'],
[1, 0, 1, 2, 'yes'],
[2, 0, 1, 2, 'yes'],
[2, 0, 1, 1, 'yes'],
[2, 1, 0, 1, 'yes'],
[2, 1, 0, 2, 'yes'],
[2, 0, 0, 0, 'no']]
labels = ['年龄', '有工做', '有本身的房子', '信贷状况'] #特征标签
return dataSet, labels #返回数据集和分类属性
""" 函数说明:按照给定特征划分数据集 Parameters: dataSet - 待划分的数据集 axis - 划分数据集的特征 value - 须要返回的特征的值 Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def splitDataSet(dataSet, axis, value):
retDataSet = [] #建立返回的数据集列表
for featVec in dataSet: #遍历数据集
if featVec[axis] == value:
reducedFeatVec = featVec[:axis] #去掉axis特征
reducedFeatVec.extend(featVec[axis+1:]) #将符合条件的添加到返回的数据集
retDataSet.append(reducedFeatVec)
return retDataSet #返回划分后的数据集
""" 函数说明:选择最优特征 Parameters: dataSet - 数据集 Returns: bestFeature - 信息增益最大的(最优)特征的索引值 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-20 """
def chooseBestFeatureToSplit(dataSet):
numFeatures = len(dataSet[0]) - 1 #特征数量
baseEntropy = calcShannonEnt(dataSet) #计算数据集的香农熵
bestInfoGain = 0.0 #信息增益
bestFeature = -1 #最优特征的索引值
for i in range(numFeatures): #遍历全部特征
#获取dataSet的第i个全部特征
featList = [example[i] for example in dataSet]
uniqueVals = set(featList) #建立set集合{},元素不可重复
newEntropy = 0.0 #经验条件熵
for value in uniqueVals: #计算信息增益
subDataSet = splitDataSet(dataSet, i, value) #subDataSet划分后的子集
prob = len(subDataSet) / float(len(dataSet)) #计算子集的几率
newEntropy += prob * calcShannonEnt(subDataSet) #根据公式计算经验条件熵
infoGain = baseEntropy - newEntropy #信息增益
# print("第%d个特征的增益为%.3f" % (i, infoGain)) #打印每一个特征的信息增益
if (infoGain > bestInfoGain): #计算信息增益
bestInfoGain = infoGain #更新信息增益，找到最大的信息增益
bestFeature = i #记录信息增益最大的特征的索引值
return bestFeature #返回信息增益最大的特征的索引值
""" 函数说明:统计classList中出现此处最多的元素(类标签) Parameters: classList - 类标签列表 Returns: sortedClassCount[0][0] - 出现此处最多的元素(类标签) Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def majorityCnt(classList):
classCount = {}
for vote in classList: #统计classList中每一个元素出现的次数
if vote not in classCount.keys():classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse = True) #根据字典的值降序排序
return sortedClassCount[0][0] #返回classList中出现次数最多的元素
""" 函数说明:建立决策树 Parameters: dataSet - 训练数据集 labels - 分类属性标签 featLabels - 存储选择的最优特征标签 Returns: myTree - 决策树 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-25 """
def createTree(dataSet, labels, featLabels):
classList = [example[-1] for example in dataSet] #取分类标签(是否放贷:yes or no)
if classList.count(classList[0]) == len(classList): #若是类别彻底相同则中止继续划分
return classList[0]
if len(dataSet[0]) == 1 or len(labels) == 0: #遍历完全部特征时返回出现次数最多的类标签
return majorityCnt(classList)
bestFeat = chooseBestFeatureToSplit(dataSet) #选择最优特征
bestFeatLabel = labels[bestFeat] #最优特征的标签
featLabels.append(bestFeatLabel)
myTree = {bestFeatLabel:{}} #根据最优特征的标签生成树
del(labels[bestFeat]) #删除已经使用特征标签
featValues = [example[bestFeat] for example in dataSet] #获得训练集中全部最优特征的属性值
uniqueVals = set(featValues) #去掉重复的属性值
for value in uniqueVals: #遍历特征，建立决策树。
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), labels, featLabels)
return myTree
""" 函数说明:获取决策树叶子结点的数目 Parameters: myTree - 决策树 Returns: numLeafs - 决策树的叶子结点的数目 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def getNumLeafs(myTree):
numLeafs = 0 #初始化叶子
firstStr = next(iter(myTree)) #python3中myTree.keys()返回的是dict_keys,不在是list,因此不能使用myTree.keys()[0]的方法获取结点属性，可使用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
""" 函数说明:获取决策树的层数 Parameters: myTree - 决策树 Returns: maxDepth - 决策树的层数 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def getTreeDepth(myTree):
maxDepth = 0 #初始化决策树深度
firstStr = next(iter(myTree)) #python3中myTree.keys()返回的是dict_keys,不在是list,因此不能使用myTree.keys()[0]的方法获取结点属性，可使用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
""" 函数说明:绘制结点 Parameters: nodeTxt - 结点名 centerPt - 文本位置 parentPt - 标注的箭头位置 nodeType - 结点格式 Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def plotNode(nodeTxt, centerPt, parentPt, nodeType):
arrow_args = dict(arrowstyle="<-") #定义箭头格式
font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14) #设置中文字体
createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction', #绘制结点
xytext=centerPt, textcoords='axes fraction',
va="center", ha="center", bbox=nodeType, arrowprops=arrow_args, FontProperties=font)
""" 函数说明:标注有向边属性值 Parameters: cntrPt、parentPt - 用于计算标注位置 txtString - 标注的内容 Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
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)
""" 函数说明:绘制决策树 Parameters: myTree - 决策树(字典) parentPt - 标注的内容 nodeTxt - 结点名 Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def plotTree(myTree, parentPt, nodeTxt):
decisionNode = dict(boxstyle="sawtooth", fc="0.8") #设置结点格式
leafNode = dict(boxstyle="round4", fc="0.8") #设置叶结点格式
numLeafs = getNumLeafs(myTree) #获取决策树叶结点数目，决定了树的宽度
depth = getTreeDepth(myTree) #获取决策树层数
firstStr = next(iter(myTree)) #下个字典
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 #y偏移
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
""" 函数说明:建立绘制面板 Parameters: inTree - 决策树(字典) Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def createPlot(inTree):
fig = plt.figure(1, facecolor='white') #建立fig
fig.clf() #清空fig
axprops = dict(xticks=[], yticks=[])
createPlot.ax1 = plt.subplot(111, frameon=False, **axprops) #去掉x、y轴
plotTree.totalW = float(getNumLeafs(inTree)) #获取决策树叶结点数目
plotTree.totalD = float(getTreeDepth(inTree)) #获取决策树层数
plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0; #x偏移
plotTree(inTree, (0.5,1.0), '') #绘制决策树
plt.show() #显示绘制结果
if __name__ == '__main__':
dataSet, labels = createDataSet()
featLabels = []
myTree = createTree(dataSet, labels, featLabels)
print(myTree)
createPlot(myTree)
复制代码
不出意外的话，咱们就能够获得以下结果，能够看到决策树绘制完成。plotNode函数的工做就是绘制各个结点，好比有本身的房子、有工做、yes、no，包括内结点和叶子结点。plotMidText函数的工做就是绘制各个有向边的属性，例如各个有向边的0和1。这部份内容呢，我的感受能够选择性掌握，能掌握最好，不能掌握能够放一放，由于后面会介绍一个更简单的决策树可视化方法。看到这句话，是否是想偷懒不仔细看这部分的代码了？(눈_눈)
4、使用决策树执行分类
依靠训练数据构造了决策树以后，咱们能够将它用于实际数据的分类。在执行数据分类时，须要决策树以及用于构造树的标签向量。而后，程序比较测试数据与决策树上的数值，递归执行该过程直到进入叶子结点；最后将测试数据定义为叶子结点所属的类型。在构建决策树的代码，能够看到，有个featLabels参数。它是用来干什么的？它就是用来记录各个分类结点的，在用决策树作预测的时候，咱们按顺序输入须要的分类结点的属性值便可。举个例子，好比我用上述已经训练好的决策树作分类，那么我只须要提供这我的是否有房子，是否有工做这两个信息便可，无需提供冗余的信息。
用决策树作分类的代码很简单，编写代码以下：
# -*- coding: UTF-8 -*-
from math import log
import operator
""" 函数说明:计算给定数据集的经验熵(香农熵) Parameters: dataSet - 数据集 Returns: shannonEnt - 经验熵(香农熵) Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def calcShannonEnt(dataSet):
numEntires = len(dataSet) #返回数据集的行数
labelCounts = {} #保存每一个标签(Label)出现次数的字典
for featVec in dataSet: #对每组特征向量进行统计
currentLabel = featVec[-1] #提取标签(Label)信息
if currentLabel not in labelCounts.keys(): #若是标签(Label)没有放入统计次数的字典,添加进去
labelCounts[currentLabel] = 0
labelCounts[currentLabel] += 1 #Label计数
shannonEnt = 0.0 #经验熵(香农熵)
for key in labelCounts: #计算香农熵
prob = float(labelCounts[key]) / numEntires #选择该标签(Label)的几率
shannonEnt -= prob * log(prob, 2) #利用公式计算
return shannonEnt #返回经验熵(香农熵)
""" 函数说明:建立测试数据集 Parameters: 无 Returns: dataSet - 数据集 labels - 特征标签 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-20 """
def createDataSet():
dataSet = [[0, 0, 0, 0, 'no'], #数据集
[0, 0, 0, 1, 'no'],
[0, 1, 0, 1, 'yes'],
[0, 1, 1, 0, 'yes'],
[0, 0, 0, 0, 'no'],
[1, 0, 0, 0, 'no'],
[1, 0, 0, 1, 'no'],
[1, 1, 1, 1, 'yes'],
[1, 0, 1, 2, 'yes'],
[1, 0, 1, 2, 'yes'],
[2, 0, 1, 2, 'yes'],
[2, 0, 1, 1, 'yes'],
[2, 1, 0, 1, 'yes'],
[2, 1, 0, 2, 'yes'],
[2, 0, 0, 0, 'no']]
labels = ['年龄', '有工做', '有本身的房子', '信贷状况'] #特征标签
return dataSet, labels #返回数据集和分类属性
""" 函数说明:按照给定特征划分数据集 Parameters: dataSet - 待划分的数据集 axis - 划分数据集的特征 value - 须要返回的特征的值 Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def splitDataSet(dataSet, axis, value):
retDataSet = [] #建立返回的数据集列表
for featVec in dataSet: #遍历数据集
if featVec[axis] == value:
reducedFeatVec = featVec[:axis] #去掉axis特征
reducedFeatVec.extend(featVec[axis+1:]) #将符合条件的添加到返回的数据集
retDataSet.append(reducedFeatVec)
return retDataSet #返回划分后的数据集
""" 函数说明:选择最优特征 Parameters: dataSet - 数据集 Returns: bestFeature - 信息增益最大的(最优)特征的索引值 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-20 """
def chooseBestFeatureToSplit(dataSet):
numFeatures = len(dataSet[0]) - 1 #特征数量
baseEntropy = calcShannonEnt(dataSet) #计算数据集的香农熵
bestInfoGain = 0.0 #信息增益
bestFeature = -1 #最优特征的索引值
for i in range(numFeatures): #遍历全部特征
#获取dataSet的第i个全部特征
featList = [example[i] for example in dataSet]
uniqueVals = set(featList) #建立set集合{},元素不可重复
newEntropy = 0.0 #经验条件熵
for value in uniqueVals: #计算信息增益
subDataSet = splitDataSet(dataSet, i, value) #subDataSet划分后的子集
prob = len(subDataSet) / float(len(dataSet)) #计算子集的几率
newEntropy += prob * calcShannonEnt(subDataSet) #根据公式计算经验条件熵
infoGain = baseEntropy - newEntropy #信息增益
# print("第%d个特征的增益为%.3f" % (i, infoGain)) #打印每一个特征的信息增益
if (infoGain > bestInfoGain): #计算信息增益
bestInfoGain = infoGain #更新信息增益，找到最大的信息增益
bestFeature = i #记录信息增益最大的特征的索引值
return bestFeature #返回信息增益最大的特征的索引值
""" 函数说明:统计classList中出现此处最多的元素(类标签) Parameters: classList - 类标签列表 Returns: sortedClassCount[0][0] - 出现此处最多的元素(类标签) Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-24 """
def majorityCnt(classList):
classCount = {}
for vote in classList: #统计classList中每一个元素出现的次数
if vote not in classCount.keys():classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse = True) #根据字典的值降序排序
return sortedClassCount[0][0] #返回classList中出现次数最多的元素
""" 函数说明:建立决策树 Parameters: dataSet - 训练数据集 labels - 分类属性标签 featLabels - 存储选择的最优特征标签 Returns: myTree - 决策树 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-25 """
def createTree(dataSet, labels, featLabels):
classList = [example[-1] for example in dataSet] #取分类标签(是否放贷:yes or no)
if classList.count(classList[0]) == len(classList): #若是类别彻底相同则中止继续划分
return classList[0]
if len(dataSet[0]) == 1 or len(labels) == 0: #遍历完全部特征时返回出现次数最多的类标签
return majorityCnt(classList)
bestFeat = chooseBestFeatureToSplit(dataSet) #选择最优特征
bestFeatLabel = labels[bestFeat] #最优特征的标签
featLabels.append(bestFeatLabel)
myTree = {bestFeatLabel:{}} #根据最优特征的标签生成树
del(labels[bestFeat]) #删除已经使用特征标签
featValues = [example[bestFeat] for example in dataSet] #获得训练集中全部最优特征的属性值
uniqueVals = set(featValues) #去掉重复的属性值
for value in uniqueVals: #遍历特征，建立决策树。
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), labels, featLabels)
return myTree
""" 函数说明:使用决策树分类 Parameters: inputTree - 已经生成的决策树 featLabels - 存储选择的最优特征标签 testVec - 测试数据列表，顺序对应最优特征标签 Returns: classLabel - 分类结果 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-25 """
def classify(inputTree, featLabels, testVec):
firstStr = next(iter(inputTree)) #获取决策树结点
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
if __name__ == '__main__':
dataSet, labels = createDataSet()
featLabels = []
myTree = createTree(dataSet, labels, featLabels)
testVec = [0,1] #测试数据
result = classify(myTree, featLabels, testVec)
if result == 'yes':
print('放贷')
if result == 'no':
print('不放贷')
复制代码
这里只增长了classify函数，用于决策树分类。输入测试数据[0,1]，它表明没有房子，可是有工做，分类结果以下所示：
看到这里，细心的朋友可能就会问了，每次作预测都要训练一次决策树？这也太麻烦了吧？有什么好的解决吗？
5、决策树的存储
构造决策树是很耗时的任务，即便处理很小的数据集，如前面的样本数据，也要花费几秒的时间，若是数据集很大，将会耗费不少计算时间。然而用建立好的决策树解决分类问题，则能够很快完成。所以，为了节省计算时间，最好可以在每次执行分类时调用已经构造好的决策树。为了解决这个问题，须要使用Python模块pickle序列化对象。序列化对象能够在磁盘上保存对象，并在须要的时候读取出来。
假设咱们已经获得决策树{'有本身的房子': {0: {'有工做': {0: 'no', 1: 'yes'}}, 1: 'yes'}}，使用pickle.dump存储决策树。
# -*- coding: UTF-8 -*-
import pickle
""" 函数说明:存储决策树 Parameters: inputTree - 已经生成的决策树 filename - 决策树的存储文件名 Returns: 无 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-25 """
def storeTree(inputTree, filename):
with open(filename, 'wb') as fw:
pickle.dump(inputTree, fw)
if __name__ == '__main__':
myTree = {'有本身的房子': {0: {'有工做': {0: 'no', 1: 'yes'}}, 1: 'yes'}}
storeTree(myTree, 'classifierStorage.txt')
复制代码
运行代码，在该Python文件的相同目录下，会生成一个名为classifierStorage.txt的txt文件，这个文件二进制存储着咱们的决策树。咱们可使用sublime txt打开看下存储结果。
看不懂？没错，由于这个是个二进制存储的文件，咱们也无需看懂里面的内容，会存储，会用便可。那么问题来了。将决策树存储完这个二进制文件，而后下次使用的话，怎么用呢？
很简单使用pickle.load进行载入便可，编写代码以下：
# -*- coding: UTF-8 -*-
import pickle
""" 函数说明:读取决策树 Parameters: filename - 决策树的存储文件名 Returns: pickle.load(fr) - 决策树字典 Author: Jack Cui Blog: http://blog.csdn.net/c406495762 Modify: 2017-07-25 """
def grabTree(filename):
fr = open(filename, 'rb')
return pickle.load(fr)
if __name__ == '__main__':
myTree = grabTree('classifierStorage.txt')
print(myTree)
复制代码
若是在该Python文件的相同目录下，有一个名为classifierStorage.txt的文件，那么咱们就能够运行上述代码，运行结果以下图所示：
从上述结果中，咱们能够看到，咱们顺利加载了存储决策树的二进制文件。
6、Sklearn之使用决策树预测隐形眼睛类型
一、实战背景
进入本文的正题：眼科医生是如何判断患者须要佩戴隐形眼镜的类型的？一旦理解了决策树的工做原理，咱们甚至也能够帮助人们判断须要佩戴的镜片类型。
隐形眼镜数据集是很是著名的数据集，它包含不少换着眼部状态的观察条件以及医生推荐的隐形眼镜类型。隐形眼镜类型包括硬材质(hard)、软材质(soft)以及不适合佩戴隐形眼镜(no lenses)。数据来源与UCI数据库，数据集下载地址：github.com/Jack-Cheris…
一共有24组数据，数据的Labels依次是age、prescript、astigmatic、tearRate、class，也就是第一列是年龄，第二列是症状，第三列是是否散光，第四列是眼泪数量，第五列是最终的分类标签。数据以下图所示：
可使用已经写好的Python程序构建决策树，不过出于继续学习的目的，本文使用Sklearn实现。
二、使用Sklearn构建决策树
官方英文文档地址：scikit-learn.org/stable/modu…
sklearn.tree模块提供了决策树模型，用于解决分类问题和回归问题。方法以下图所示：
本次实战内容使用的是DecisionTreeClassifier和export_graphviz，前者用于决策树构建，后者用于决策树可视化。
DecisionTreeClassifier构建决策树：
让咱们先看下DecisionTreeClassifier这个函数，一共有12个参数：
参数说明以下：
- criterion：特征选择标准，可选参数，默认是gini，能够设置为entropy。gini是基尼不纯度，是未来自集合的某种结果随机应用于某一数据项的预期偏差率，是一种基于统计的思想。entropy是香农熵，也就是上篇文章讲过的内容，是一种基于信息论的思想。Sklearn把gini设为默认参数，应该也是作了相应的斟酌的，精度也许更高些？ID3算法使用的是entropy，CART算法使用的则是gini。
- splitter：特征划分点选择标准，可选参数，默认是best，能够设置为random。每一个结点的选择策略。best参数是根据算法选择最佳的切分特征，例如gini、entropy。random随机的在部分划分点中找局部最优的划分点。默认的"best"适合样本量不大的时候，而若是样本数据量很是大，此时决策树构建推荐"random"。
- max_features：划分时考虑的最大特征数，可选参数，默认是None。寻找最佳切分时考虑的最大特征数(n_features为总共的特征数)，有以下6种状况：
- 若是max_features是整型的数，则考虑max_features个特征；
- 若是max_features是浮点型的数，则考虑int(max_features * n_features)个特征；
- 若是max_features设为auto，那么max_features = sqrt(n_features)；
- 若是max_features设为sqrt，那么max_featrues = sqrt(n_features)，跟auto同样；
- 若是max_features设为log2，那么max_features = log2(n_features)；
- 若是max_features设为None，那么max_features = n_features，也就是全部特征都用。
- 通常来讲，若是样本特征数很少，好比小于50，咱们用默认的"None"就能够了，若是特征数很是多，咱们能够灵活使用刚才描述的其余取值来控制划分时考虑的最大特征数，以控制决策树的生成时间。
- max_depth：决策树最大深，可选参数，默认是None。这个参数是这是树的层数的。层数的概念就是，好比在贷款的例子中，决策树的层数是2层。若是这个参数设置为None，那么决策树在创建子树的时候不会限制子树的深度。通常来讲，数据少或者特征少的时候能够无论这个值。或者若是设置了min_samples_slipt参数，那么直到少于min_smaples_split个样本为止。若是模型样本量多，特征也多的状况下，推荐限制这个最大深度，具体的取值取决于数据的分布。经常使用的能够取值10-100之间。
- min_samples_split：内部节点再划分所需最小样本数，可选参数，默认是2。这个值限制了子树继续划分的条件。若是min_samples_split为整数，那么在切份内部结点的时候，min_samples_split做为最小的样本数，也就是说，若是样本已经少于min_samples_split个样本，则中止继续切分。若是min_samples_split为浮点数，那么min_samples_split就是一个百分比，ceil(min_samples_split * n_samples)，数是向上取整的。若是样本量不大，不须要管这个值。若是样本量数量级很是大，则推荐增大这个值。
- min_samples_leaf：叶子节点最少样本数，可选参数，默认是1。这个值限制了叶子节点最少的样本数，若是某叶子节点数目小于样本数，则会和兄弟节点一块儿被剪枝。叶结点须要最少的样本数，也就是最后到叶结点，须要多少个样本才能算一个叶结点。若是设置为1，哪怕这个类别只有1个样本，决策树也会构建出来。若是min_samples_leaf是整数，那么min_samples_leaf做为最小的样本数。若是是浮点数，那么min_samples_leaf就是一个百分比，同上，celi(min_samples_leaf * n_samples)，数是向上取整的。若是样本量不大，不须要管这个值。若是样本量数量级很是大，则推荐增大这个值。
- min_weight_fraction_leaf：叶子节点最小的样本权重和，可选参数，默认是0。这个值限制了叶子节点全部样本权重和的最小值，若是小于这个值，则会和兄弟节点一块儿被剪枝。通常来讲，若是咱们有较多样本有缺失值，或者分类树样本的分布类别误差很大，就会引入样本权重，这时咱们就要注意这个值了。
- max_leaf_nodes：最大叶子节点数，可选参数，默认是None。经过限制最大叶子节点数，能够防止过拟合。若是加了限制，算法会创建在最大叶子节点数内最优的决策树。若是特征很少，能够不考虑这个值，可是若是特征分红多的话，能够加以限制，具体的值能够经过交叉验证获得。
- class_weight：类别权重，可选参数，默认是None，也能够字典、字典列表、balanced。指定样本各种别的的权重，主要是为了防止训练集某些类别的样本过多，致使训练的决策树过于偏向这些类别。类别的权重能够经过{class_label：weight}这样的格式给出，这里能够本身指定各个样本的权重，或者用balanced，若是使用balanced，则算法会本身计算权重，样本量少的类别所对应的样本权重会高。固然，若是你的样本类别分布没有明显的偏倚，则能够无论这个参数，选择默认的None。
- random_state：可选参数，默认是None。随机数种子。若是是证书，那么random_state会做为随机数生成器的随机数种子。随机数种子，若是没有设置随机数，随机出来的数与当前系统时间有关，每一个时刻都是不一样的。若是设置了随机数种子，那么相同随机数种子，不一样时刻产生的随机数也是相同的。若是是RandomState instance，那么random_state是随机数生成器。若是为None，则随机数生成器使用np.random。 min_impurity_split：节点划分最小不纯度,可选参数，默认是1e-7。这是个阈值，这个值限制了决策树的增加，若是某节点的不纯度(基尼系数，信息增益，均方差，绝对差)小于这个阈值，则该节点再也不生成子节点。即为叶子节点 。
- presort：数据是否预排序，可选参数，默认为False，这个值是布尔值，默认是False不排序。通常来讲，若是样本量少或者限制了一个深度很小的决策树，设置为true可让划分点选择更加快，决策树创建的更加快。若是样本量太大的话，反而没有什么好处。问题是样本量少的时候，我速度原本就不慢。因此这个值通常懒得理它就能够了。
除了这些参数要注意之外，其余在调参时的注意点有：
- 当样本数量少可是样本特征很是多的时候，决策树很容易过拟合，通常来讲，样本数比特征数多一些会比较容易创建健壮的模型
- 若是样本数量少可是样本特征很是多，在拟合决策树模型前，推荐先作维度规约，好比主成分分析（PCA），特征选择（Losso）或者独立成分分析（ICA）。这样特征的维度会大大减少。再来拟合决策树模型效果会好。
- 推荐多用决策树的可视化，同时先限制决策树的深度，这样能够先观察下生成的决策树里数据的初步拟合状况，而后再决定是否要增长深度。
- 在训练模型时，注意观察样本的类别状况（主要指分类树），若是类别分布很是不均匀，就要考虑用class_weight来限制模型过于偏向样本多的类别。
- 决策树的数组使用的是numpy的float32类型，若是训练数据不是这样的格式，算法会先作copy再运行。
- 若是输入的样本矩阵是稀疏的，推荐在拟合前调用csc_matrix稀疏化，在预测前调用csr_matrix稀疏化。
sklearn.tree.DecisionTreeClassifier()提供了一些方法供咱们使用，以下图所示：
了解到这些，咱们就能够编写代码了。
# -*- coding: UTF-8 -*-
from sklearn import tree
if __name__ == '__main__':
fr = open('lenses.txt')
lenses = [inst.strip().split('\t') for inst in fr.readlines()]
print(lenses)
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
clf = tree.DecisionTreeClassifier()
lenses = clf.fit(lenses, lensesLabels)
复制代码
运行代码，会获得以下结果：
咱们能够看到程序报错了，这是为何？由于在fit()函数不能接收string类型的数据，经过打印的信息能够看到，数据都是string类型的。在使用fit()函数以前，咱们须要对数据集进行编码，这里可使用两种方法：
- LabelEncoder ：将字符串转换为增量值
- OneHotEncoder：使用One-of-K算法将字符串转换为整数
为了对string类型的数据序列化，须要先生成pandas数据，这样方便咱们的序列化工做。这里我使用的方法是，原始数据->字典->pandas数据，编写代码以下：
# -*- coding: UTF-8 -*-
import pandas as pd
if __name__ == '__main__':
with open('lenses.txt', 'r') as fr: #加载文件
lenses = [inst.strip().split('\t') for inst in fr.readlines()] #处理文件
lenses_target = [] #提取每组数据的类别，保存在列表里
for each in lenses:
lenses_target.append(each[-1])
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate'] #特征标签
lenses_list = [] #保存lenses数据的临时列表
lenses_dict = {} #保存lenses数据的字典，用于生成pandas
for each_label in lensesLabels: #提取信息，生成字典
for each in lenses:
lenses_list.append(each[lensesLabels.index(each_label)])
lenses_dict[each_label] = lenses_list
lenses_list = []
print(lenses_dict) #打印字典信息
lenses_pd = pd.DataFrame(lenses_dict) #生成pandas.DataFrame
print(lenses_pd)
复制代码
从运行结果能够看出，顺利生成pandas数据。
接下来，将数据序列化，编写代码以下：
# -*- coding: UTF-8 -*-
import pandas as pd
from sklearn.preprocessing import LabelEncoder
import pydotplus
from sklearn.externals.six import StringIO
if __name__ == '__main__':
with open('lenses.txt', 'r') as fr: #加载文件
lenses = [inst.strip().split('\t') for inst in fr.readlines()] #处理文件
lenses_target = [] #提取每组数据的类别，保存在列表里
for each in lenses:
lenses_target.append(each[-1])
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate'] #特征标签
lenses_list = [] #保存lenses数据的临时列表
lenses_dict = {} #保存lenses数据的字典，用于生成pandas
for each_label in lensesLabels: #提取信息，生成字典
for each in lenses:
lenses_list.append(each[lensesLabels.index(each_label)])
lenses_dict[each_label] = lenses_list
lenses_list = []
# print(lenses_dict) #打印字典信息
lenses_pd = pd.DataFrame(lenses_dict) #生成pandas.DataFrame
print(lenses_pd) #打印pandas.DataFrame
le = LabelEncoder() #建立LabelEncoder()对象，用于序列化
for col in lenses_pd.columns: #为每一列序列化
lenses_pd[col] = le.fit_transform(lenses_pd[col])
print(lenses_pd)
复制代码
从打印结果能够看到，咱们已经将数据顺利序列化，接下来。咱们就能够fit()数据，构建决策树了。
三、使用Graphviz可视化决策树
Graphviz的是AT&T Labs Research开发的图形绘制工具，他能够很方便的用来绘制结构化的图形网络，支持多种格式输出，生成图片的质量和速度都不错。它的输入是一个用dot语言编写的绘图脚本，经过对输入脚本的解析，分析出其中的点，边以及子图，而后根据属性进行绘制。是使用Sklearn生成的决策树就是dot格式的，所以咱们能够直接利用Graphviz将决策树可视化。
在讲解编写代码以前，咱们须要安装两样东西，即pydotplus和Grphviz。
（1）安装Pydotplus
pydotplus能够在CMD窗口中，直接使用指令安装：
pip3 install pydotplus
复制代码
（2）安装Graphviz
Graphviz不能使用pip进行安装，咱们须要手动安装，下载地址：www.graphviz.org
下载好安装包，进行安装，安装完毕以后，须要设置Graphviz的环境变量。
首先，按快捷键win+r，在出现的运行对话框中输入sysdm.cpl，点击肯定，出现以下对话框：
选择高级->环境变量。在系统变量的Path变量中，添加Graphviz的环境变量，好比Graphviz安装在了D盘的根目录，则添加：D:\Graphviz\bin;
添加好环境变量以后，咱们就能够正常使用Graphviz了。
（3）编写代码
Talk is Cheap, show me the code.(废话少说，放码过来)。可视化部分的代码不难，都是有套路的，直接填参数就好，详细内容能够查看官方教程：scikit-learn.org/stable/modu…
# -*- coding: UTF-8 -*-
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.externals.six import StringIO
from sklearn import tree
import pandas as pd
import numpy as np
import pydotplus
if __name__ == '__main__':
with open('lenses.txt', 'r') as fr: #加载文件
lenses = [inst.strip().split('\t') for inst in fr.readlines()] #处理文件
lenses_target = [] #提取每组数据的类别，保存在列表里
for each in lenses:
lenses_target.append(each[-1])
print(lenses_target)
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate'] #特征标签
lenses_list = [] #保存lenses数据的临时列表
lenses_dict = {} #保存lenses数据的字典，用于生成pandas
for each_label in lensesLabels: #提取信息，生成字典
for each in lenses:
lenses_list.append(each[lensesLabels.index(each_label)])
lenses_dict[each_label] = lenses_list
lenses_list = []
# print(lenses_dict) #打印字典信息
lenses_pd = pd.DataFrame(lenses_dict) #生成pandas.DataFrame
# print(lenses_pd) #打印pandas.DataFrame
le = LabelEncoder() #建立LabelEncoder()对象，用于序列化
for col in lenses_pd.columns: #序列化
lenses_pd[col] = le.fit_transform(lenses_pd[col])
# print(lenses_pd) #打印编码信息
clf = tree.DecisionTreeClassifier(max_depth = 4) #建立DecisionTreeClassifier()类
clf = clf.fit(lenses_pd.values.tolist(), lenses_target) #使用数据，构建决策树
dot_data = StringIO()
tree.export_graphviz(clf, out_file = dot_data, #绘制决策树
feature_names = lenses_pd.keys(),
class_names = clf.classes_,
filled=True, rounded=True,
special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_pdf("tree.pdf")
复制代码
运行代码，在该python文件保存的相同目录下，会生成一个名为tree的PDF文件，打开文件，咱们就能够看到决策树的可视化效果图了。
肯定好决策树以后，咱们就能够作预测了。能够根据本身的眼睛状况和年龄等特征，看一看本身适合何种材质的隐形眼镜。使用以下代码就能够看到预测结果：
print(clf.predict([[1,1,1,0]])) #预测
复制代码
代码简单，官方手册都有，就不全贴出来了。
原本是想继续讨论决策树的过拟合问题，可是看到《机器学习实战》将此部份内容放到了第九章，那我也放在后面好了。
7、总结
决策树的一些优势：
- 易于理解和解释。决策树能够可视化。
- 几乎不须要数据预处理。其余方法常常须要数据标准化，建立虚拟变量和删除缺失值。决策树还不支持缺失值。
- 使用树的花费（例如预测数据）是训练数据点(data points)数量的对数。
- 能够同时处理数值变量和分类变量。其余方法大都适用于分析一种变量的集合。
-
- 能够处理多值输出变量问题。 使用白盒模型。若是一个状况被观察到，使用逻辑判断容易表示这种规则。相反，若是是黑盒模型（例如人工神经网络），结果会很是难解释。
- 即便对真实模型来讲，假设无效的状况下，也能够较好的适用。
决策树的一些缺点：
- 决策树学习可能建立一个过于复杂的树，并不能很好的预测数据。也就是过拟合。修剪机制（如今不支持），设置一个叶子节点须要的最小样本数量，或者数的最大深度，能够避免过拟合。
- 决策树多是不稳定的，由于即便很是小的变异，可能会产生一颗彻底不一样的树。这个问题经过decision trees with an ensemble来缓解。
- 概念难以学习，由于决策树没有很好的解释他们，例如，XOR, parity or multiplexer problems。
- 若是某些分类占优点，决策树将会建立一棵有误差的树。所以，建议在训练以前，先抽样使样本均衡。
其余：
- 下篇文章将讲解朴素贝叶斯算法
- 若有问题，请留言。若有错误，还望指正，谢谢！
相关文章和视频推荐
圆方圆学院聚集 Python + AI 名师，打造精品的 Python + AI 技术课程。 在各大平台都长期有优质免费公开课及录像，欢迎报名收看。
公开课地址：ke.qq.com/course/3627…
加入python学习讨论群 78486745 ，获取资料，和广大群友一块儿学习。
相关文章
- 1. Python3《机器学习实战》学习笔记（三）：决策树实战篇之为本身配个隐形眼镜
- 2. 机器学习实战教程（三）：决策树实战篇之为自己配个隐形眼镜
- 3. 《机器学习实战》：决策树之为自己配个隐形眼镜
- 4. python3.5《机器学习实战》学习笔记（五）：决策树算法实战之预测隐形眼镜类型
- 5. 机器学习实战（三）——决策树
- 6. 机器学习实战之决策树
- 7. 《机器学习实战》笔记——第三章：决策树实战
- 8. 《机器学习实战》学习笔记———使用决策树预测隐形眼镜类型
- 9. 机器学习实战--决策树（二）
- 10. 机器学习实战-决策树
- 更多相关文章...
- • 网站主机教程 - 网站主机教程
- • Spring实例化Bean的三种方法 - Spring教程
- • Docker容器实战(七) - 容器眼光下的文件系统
- • Docker容器实战(八) - 漫谈 Kubernetes 的本质
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
