机器学习实战第三章 决策树

最新推荐文章于 2024-11-07 22:09:22 发布
最新推荐文章于 2024-11-07 22:09:22 发布
阅读量71 收藏
点赞数
分类专栏： 机器学习 文章标签： 机器学习 决策树 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68784427/article/details/131115564
版权

决策树

什么是决策树

简而言之，就是通过一步步的决策，来对某些事物分类（说着说最终做出什么选择）。其特点是树状结构，能够更快的分类，如下图：在这里插入图片描述

如何分类

大家应该都学过哈夫曼树，他的思想是用的最多的放在最靠近根节点的位置。决策树也类似，但是其分类依据是根据信息熵来分类，每次划分后，要求划分的两部分的信息熵的和最低。下面介绍下信息熵的概念

信息熵

信息熵可以看作是对于某个消息或者事件的平均预测的困难程度。

想象一下，如果你已经知道了一个事件一定会发生，那么这个事件就不会给你带来任何新的信息，因为你已经知道结果。相反，如果一个事件有很多可能的结果，你就无法准确地预测具体会发生什么，那么这个事件就会带来更多的信息。

信息熵的计算方法是基于事件发生的概率。如果一个事件有很高的概率发生，那么它所携带的信息量就会很低；而如果一个事件的发生概率很低，那么它所携带的信息量就会很高。信息熵的值越高，意味着事件的不确定性越大，需要更多的信息来描述。

如果用公式来表示的话，那就是：
H = − ∑ i = 1 n p ( x i ) l o g p ( x i ) H = -\sum_{i=1}^np(x_i)log p(x_i) H=−i=1∑n​p(xi​)logp(xi​)
其中 p ( x i ) p(x_i) p(xi​)表示随时事件 x i x_i xi​发生的概率，而 − l o g p ( x i ) -logp(x_i) −logp(xi​)则代表该事件的信息量

据此，我们就可以得到计算信息熵的方法了：

# 计算数据集的香农熵
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       # 求得每个标签的概率     # L(Xi) = -log2P(Xi)
        shannonEnt -= prob * log(prob, 2)   # 以2为底求对数      # H = - Σi=1 n  P(Xi)*log2P(Xi)
    return shannonEnt

分类的实现

有了前面的基础知识，我们可以分类了，假设每次只取一种特征进行二分类，那么我们只需要计算每一种特征值分类后的熵，取最小的那个进行分类就可以了。同时由于该特征已经用过了，所以之后的样本种可以将该特征去除来进行计算。代码如下：

# 按照给定特征划分数据集
def splitDataSet(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 chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1      # 计算特征的数目
    baseEntropy = calcShannonEnt(dataSet)   # 计算数据集的原始香农熵 用于与划分完的数据集的香农熵进行比较
    bestInfoGain = 0.0                      # 最佳信息增益初始化
    bestFeature = -1                        # 最佳划分特征初始化 TheBestFeatureToSplit
    for i in range(numFeatures):        # 遍历所有的特征
        featList = [example[i] for example in dataSet]  # 暂存每一个样本的第i个特征
        uniqueVals = set(featList)       # 特征去重
        newEntropy = 0.0                 # 划分后信息熵初始化
        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):       # 比较划分后的数据集的信息增益是否大于0 大于0 证明划分的有效
            bestInfoGain = infoGain         # 储存最佳信息增益值
            bestFeature = i                 # 储存最佳特征值索引
    return bestFeature                      # 返回最佳特征值索引

构建决策树

现在我们已经知道如何划分了，但是我们还不知道什么时候停止，虽然此处我们选择所有样本均属于同一类的时候停止，但是有的时候停止条件未必如此，最后的叶子节点中可能包含其他类，因此我们构造两个函数如下：

def majorityCnt(classList):
    classCount = {}
    for vote in 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]


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

实验

此时我们已经可以完整的构造一个决策树了（画图的代码参见下方完整代码），我们可以采用书中附赠的数据集来进行测试，实验结果如图：
在这里插入图片描述
完整代码如下：

from math import log
import operator
import matplotlib.pyplot as plt


# 计算数据集的香农熵
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       # 求得每个标签的概率     # L(Xi) = -log2P(Xi)
        shannonEnt -= prob * log(prob, 2)   # 以2为底求对数      # H = - Σi=1 n  P(Xi)*log2P(Xi)
    return shannonEnt


# 按照给定特征划分数据集
def splitDataSet(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 chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1      # 计算特征的数目
    baseEntropy = calcShannonEnt(dataSet)   # 计算数据集的原始香农熵 用于与划分完的数据集的香农熵进行比较
    bestInfoGain = 0.0                      # 最佳信息增益初始化
    bestFeature = -1                        # 最佳划分特征初始化 TheBestFeatureToSplit
    for i in range(numFeatures):        # 遍历所有的特征
        featList = [example[i] for example in dataSet]  # 暂存每一个样本的第i个特征
        uniqueVals = set(featList)       # 特征去重
        newEntropy = 0.0                 # 划分后信息熵初始化
        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):       # 比较划分后的数据集的信息增益是否大于0 大于0 证明划分的有效
            bestInfoGain = infoGain         # 储存最佳信息增益值
            bestFeature = i                 # 储存最佳特征值索引
    return bestFeature                      # 返回最佳特征值索引


def majorityCnt(classList):
    classCount = {}
    for vote in 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]


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




# 画图用的代码
def getNumLeafs(myTree):
    numLeafs = 0
    temp_keys = list(myTree.keys())
    firstStr = temp_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 = next(iter(myTree))
    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



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 )


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):
    numLeafs = getNumLeafs(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.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()


if __name__ == "__main__":
    with open("Ch03/lenses.txt", "rb") as fr:
        lenses = [inst.decode().strip().split('\t') for inst in fr.readlines()]
    lensesLabels = ['age', 'prescript', 'astigmatic', "tearRate"]
    lensesTree = createTree(lenses, lensesLabels)
    createPlot(lensesTree)

小结

还算简单的创建决策树的一章，本章的书有很多内容集中在如何画图上，由于笔者感觉这一部分相对而言不如原理重要，因此没有进行详细的解析。总的来说，这一张最重要的思想应该就是如何分类以及树这一结构。

别来这个网址
关注
专栏目录
机器学习实战 第三章 决策树 学习笔记
slicer的技术交流栈
05-05 1191
机器学习实战 第三章 决策树 学习笔记     第三章，决策树，主要讲了用ID3这种算法构建出决策树，并将其用于分类的方法。     原理：假设我们有一些待分类数据，那么可先按特征的某些规律将其一分为二（就成了二叉树，一分为n，就是n叉树），再将其子节点再分，分到不能再分时，训练结束。预测时按照分类的原则去找分支，直到找到叶子节点，叶节点的值就是预测的值。     那么就会有一个问题：以
机器学习python实战——第三章决策树
jia_shun_L的博客
07-31 280
机器学习python实战：第四章——决策树@TOC 决策树 【1】创造树 主函数：creattree 输入：待学习的数据包括标签以及数据（x and y） 输出：决策树 思路： 首先判断子树的所有实例类别是否完全相同，若是返回类别即可， 其次判断是都是否已无特征可作为分类依据（所以要更新标签），若是返回大多数实例（majority）的类别即可， 选择令信息增量最大的特征，choose包含calce...
机器学习实战 第三章 决策树
qq_59026468的博客
09-13 922
决策树
【机器学习实战】3、决策树
热门推荐
呆呆的猫的博客
03-13 36万+
(声明：本文内容来自机器学习实战和统计学习方法，是两者的整合，并非来自单个书籍）决策树（decision tree）：是一种基本的分类与回归方法，此处主要讨论分类的决策树。在分类问题中，表示基于特征对实例进行分类的过程，可以认为是if-then的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。决策树通常有三个步骤：特征选择、决策树的生成、决策树的修剪。用决策树分类：从根节点开始，对实例的某一特征进行测试，根据测试结果将实例分配到其子节点，此时每个子节点对应着该特征的一个取值，如此递归的对实例进行测
机器学习实战第三章决策树01决策树简介
weixin_42702666的博客
12-07 739
本章内容简介 决策树简介 在数据集中度量一致性 使用递归构造决策树 使用Matplotlib绘制树形图 你是否玩过二十个问题的游戏，游戏的规则很简单：参与游戏的一方在脑海里想某个事物，其他参与者向他提问题，只允许提20个问题，问题的答案也只能用对或者错回答。问问题的人通过推断分解，逐步缩小待猜测事物的范围。决策树的工作原理与20个问题类似，用户输入一系列数据，然后给出游戏答案。 我们经常...
边境的悍匪—机器学习实战：第六章 决策树
m0_46441844的博客
01-19 752
第六章 决策树 文章目录第六章 决策树前言一、思维导图二、主要内容1、训练和可视化决策树2、做出预测3、估计类概率4、CART训练算法5、计算复杂度6、基尼不纯度或熵7、正则化超参数8、回归9、不稳定性三、课后练习四、总结 前言 前一章我们学习一个很强大的机器学习模型，支持向量机。这一章我们来继续学习下一个强大的模型，决策树。它同样支持分类和回归，多用于做分类任务，决策树也是会面会提到的随机森林的基础。决策树同样是在训练集中拟合一个模型，不同的是，如果在不做任何限制的情况下，决策树容易过拟合训练数据，并且
机器学习实战-第3章-决策树算法（ID3）
weixin_43749999的博客
11-25 1548
详细介绍了《机器学习实战》书中的第3章-决策树的内容及python实现代码（所有代码使用pycharm测试均通过）。
《机器学习实战》学习——决策树算法代码
Qbbsm的博客
06-29 754
《机器学习实战》学习——决策树算法代码（Python）
机器学习实战（三）——决策树
weixin_44953928的博客
02-22 593
转载：https://blog.csdn.net/jiaoyangwm/article/details/79525237 决策树 (声明：本文内容来自机器学习实战和统计学习方法，是两者的整合，并非来自单个书籍） 决策树（decision tree）：是一种基本的分类与回归方法，此处主要讨论分类的决策树。 在分类问题中，表示基于特征对实例进行分类的过程，可以认为是if-then的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。 决策树通常有三个步骤：特征选择、决策树的生成、决策树的修剪。 用决策树分
机器学习实战第三章决策树02递归构建决策树
weixin_42702666的博客
01-08 632
3.1.3 递归构建决策树 目前我们已经学习了从数据集构造决策树算法所需要的子功能模块，其工作原理如下：得到原始数据集，然后基于最好的属性值划分数据集，由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后，数据将被向下传递到树分支的下一个节点，在这个节点上，我们可以再次划分数据。因此我们可以采用递归的原则处理数据集。 递归结束的条件是：程序遍历完所有划分数据集的属性，或...
机器学习实战第三章决策树
01-20
在机器学习实战第三章中，作者主要讲解了决策树的原理以及如何在实际问题中应用决策树模型。本章节的内容重点在于如何构建决策树、如何使用决策树进行预测，以及如何评价决策树模型的性能。 首先，决策树的构建基于...
【机器学习实战】机器学习实战第3章决策树算法数据集-数据集
03-08
在机器学习领域，决策树是一种广泛应用的算法，它通过构建决策模型来模拟一系列问题和可能的结果，从而实现预测。在本资源中，我们有两个数据集，"lenses.txt" 和 "data.txt"，它们通常用于教授和实践决策树算法。 ...
机器学习实战(第三章-决策树-ID3算法-所有代码与详细注解-python3.7)
12-09
总之，这个压缩包提供了对决策树和ID3算法的全面理解，包括理论和实践两方面，对于学习和应用机器学习的读者来说是一份宝贵的资料。通过阅读代码和注释，你可以深入掌握如何在Python中实现决策树，并理解其内在的...
机器学习—矩阵乘法
yn3535_的博客
11-06 463
让我们来看看向量矩阵乘法，也就是当你把一个向量乘以一个矩阵，又得到一个向量，列向量a转置后得到行向量a，所以与其把这看作是一个2×1的矩阵，转置后就变成了1×2的矩阵，现在用这四个元素创建一个2×2的矩阵w，如果你想计算Z，Z=a转置W，结果z是一个2×1的矩阵，计算z的第一个值，我们要做一个a转置乘w1，所以要计算z的第一个元素，最终得到(1*3)+(2*4),然后计算第二个元素，现在将转置乘w2，，所以计算第二个元素，最终得到(1*5)+(2*6)。如何在向量之间取点积？
8.机器学习--决策树
最新发布
我是个好人呀，????
11-07 746
(⊙﹏⊙)下周有要开组会，不知道该说啥，啊啊啊啊😫提到树，我们第一反应都是数据结构中的二叉树，那么决策树又是什么？他有什么特别之处呢？决策树是一类常见的机器学习算法。按照西瓜书里给出的定义👇：这个定义看起来还是有些晦涩，通俗的来讲，决策树就是一种依赖树型结构进行决策的模型。例如，我们买西瓜的时候肯定想挑一个熟透的好瓜，一般来讲我们都有一套判断这个西瓜怎么样的标准，比如拍一拍听西瓜的声音是怎么样的？西瓜的色泽是不是鲜明的等等，我们把每个判断标准作为一个树结点，判断结果作为两个子结点连接下一个判断条件，最终
随机采样之接受拒绝采样
Reaearcher-Du
11-07 475
接受-拒绝采样（Accept-Reject Sampling）方法是一种更为通用的采样方法，它可以用来生成具有任意分布的随机样本。这种方法不要求我们知道CDF的逆，而是利用一个简单的概率分布（称为提议分布）来生成样本，然后以一定的概率接受或拒绝这些样本。
Oracle 第28章：Oracle机器学习
hummhumm的专栏
11-07 526
通过Oracle提供的丰富工具和服务，企业和组织可以高效地进行数据科学和机器学习项目。从数据准备、模型训练、优化、解释，到模型监控、自动化机器学习，再到生产环境中的管理和维护，每一步都得到了充分的支持。这不仅加速了项目的交付周期，还提高了模型的准确性和实用性，为企业带来了显著的竞争优势。希望以上内容能为你提供有关如何在Oracle环境中实施和管理机器学习项目的深入见解。
【机器学习】机器学习中用到的高等数学知识
IT古董
11-07 290
机器学习是一个跨学科领域，涉及多种高等数学知识。掌握这些高等数学知识可以帮助理解机器学习算法的工作原理和实现过程。在实际应用中，建议结合编程实践，如使用 Python 中的 NumPy 和 SciPy 库进行线性代数和数值计算，使用 scikit-learn 进行统计分析和机器学习建模。通过理论与实践相结合，能够更深入地理解机器学习的核心概念和应用。
深入了解线性回归：机器学习中的经典算法
不迁怒，不贰过。小知识，大智慧。
11-04 929
在数据驱动的时代，机器学习已经成为各行各业不可或缺的工具。无论是在金融、医疗、零售还是科技领域，数据分析和预测能力都在不断推动着业务的创新与发展。在众多机器学习算法中，线性回归以其简单性、可解释性和高效性，成为了最受欢迎的基础算法之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值