机器学习实战（二）：决策树

最新推荐文章于 2023-12-06 16:54:02 发布
最新推荐文章于 2023-12-06 16:54:02 发布
阅读量1.2k 收藏 16
点赞数
分类专栏： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mys_mys/article/details/87076425
版权

机器学习实战（二）：决策树

一、决策树概述

1、决策树做预测需要以下过程：

  • 收集数据：比如想构建一个相亲系统，我们可以从媒婆那里，或者通过采访相亲对象获取数据。根据他们考虑的因素和最终的选择结果，就可以得到一些供我们利用的数据了。
  • 准备数据：收集完的数据，我们要进行整理，将这些所有收集的信息按照一定规则整理出来，并排版，方便我们进行后续处理。
  • 分析数据：可以使用任何方法，决策树构造完成之后，我们可以检查决策树图形是否符合预期。
  • 训练算法：这个过程也就是构造决策树，同样也可以说是决策树学习，就是构造一个决策树的数据结构。
  • 测试算法：**使用经验树计算错误率。**当错误率达到了可接收范围，这个决策树就可以投放使用了。
  • 使用算法：此步骤可以使用适用于任何监督学习算法，而使用决策树可以更好地理解数据的内在含义。

二、决策树实战

构建决策树：
过程概括为3个步骤：特征选择、决策树的生成和决策树的修剪。

1、特征选择
选取对训练数据具有分类能力的特征，通常特征选择的标准是信息增益(information gain)或信息增益比，看一组实例，贷款申请样本数据表
在这里插入图片描述
通过所给的训练数据学习一个贷款申请的决策树，用于对未来的贷款申请进行分类，即当新的客户提出贷款申请时，根据申请人的特征利用决策树决定是否批准贷款申请
在这里插入图片描述
具体选择哪个特征，应分别计算其信息增益，信息增益最高的特征就是最好的选择，在划分数据集之后信息发生的变化称为信息增益，先看以下几个公式：
（1）香农熵
集合信息的度量方式称为香农熵或者简称为熵(entropy)，这个名字来源于信息论之父克劳德·香农。熵定义为信息的期望值。在信息论与概率统计中，熵是表示随机变量不确定性的度量
在这里插入图片描述
# 1.编写代码计算经验熵
对数据集进行属性标注：
年龄：0代表青年，1代表中年，2代表老年；
有工作：0代表否，1代表是；
有自己的房子：0代表否，1代表是；
信贷情况：0代表一般，1代表好，2代表非常好；
类别(是否给贷款)：no代表否，yes代表是。
在这里插入图片描述
（2）信息增益
信息增益是相对于特征而言的，信息增益越大，特征对最终的分类结果影响也就越大，我们就应该选择对最终分类结果影响最大的那个特征作为我们的分类特征。
条件熵： 条件熵H(Y|X)表示在已知随机变量X的条件下随机变量Y的不确定性，随机变量X给定的条件下随机变量Y的条件熵(conditional entropy)H(Y|X)，定义为X给定条件下Y的条件概率分布的熵对X的数学期望：在这里插入图片描述
信息增益：熵H(D)与条件熵H(D|A)之差在这里插入图片描述
在这里插入图片描述
# 2.编写代码计算信息增益
在这里插入图片描述
2、决策树的生成
工作原理
1）得到原始数据集
2）基于最好的属性值划分数据集
由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后，数据集被向下传递到树的分支的下一个结点。在这个结点上，我们可以再次划分数据。因此我们可以采用递归的原则处理数据集。
构建决策树的算法有很多，比如C4.5、ID3和CART，但在此使用的是ID3算法构件决策树
ID3算法
核心： 在决策树各个结点上对应信息增益准则选择特征，递归地构建决策树。
具体方法： 从根结点(root node)开始，对结点计算所有可能的特征的信息增益，选择信息增益最大的特征作为结点的特征，由该特征的不同取值建立子节点；再对子结点递归地调用以上方法，构建决策树；直到所有特征的信息增益均很小或没有特征可以选择为止。最后得到一个决策树。ID3相当于用极大似然法进行概率模型的选择。
由上面计算的信息增益值可知：第二个特征 是否有自己的房子 信息增益最大，因此将训练集划分为两个子集，有自己的房子和没有自己的房子，然后分别对子集按照上面的方法进行划分，生成一个决策树如下：在这里插入图片描述
# 3.编写代码构件决策树
递归创建决策树时，递归有两个终止条件：

  • 1、所有的类标签完全相同，则直接返回该类标签；
  • 2、使用完了所有特征，仍然不能将数据划分仅包含唯一类别的分组，即决策树构建失败，出现数量最多的类别作为返回值。
    在这里插入图片描述
    3、决策树的可视化
    Matplotlib可视化需要用到的函数：
    getNumLeafs：获取决策树叶子结点的数目
    getTreeDepth：获取决策树的层数
    plotNode：绘制结点
    plotMidText：标注有向边属性值
    plotTree：绘制决策树
    createPlot：创建绘制面板
    # 4.编写代码可视化决策树
    在这里插入图片描述
    4、使用决策树进行分类、
    依靠训练数据构造了决策树之后，我们可以将它用于实际数据的分类。在执行数据分类时，需要决策树以及用于构造树的标签向量。然后，程序比较测试数据与决策树上的数值，递归执行该过程直到进入叶子结点；最后将测试数据定义为叶子结点所属的类型。
    # 5.编写代码 用决策树分类
    输入测试数据[0,1]，它代表没有房子，但是有工作
    在这里插入图片描述
    5、决策树的存储
    存储后能够在每次执行分类时调用已经构造好的决策树，需要使用Python模块pickle序列化对象。序列化对象可以在磁盘上保存对象，并在需要的时候读取出来。
    # 6.编写代码 存储决策树
    假设我们已经得到决策树{‘有自己的房子’: {0: {‘有工作’: {0: ‘no’, 1: ‘yes’}}, 1: ‘yes’}}，使用pickle.dump存储决策树。在该Python文件的相同目录下，会生成一个名为classifierStorage.txt的txt文件，这个文件二进制存储着我们的决策树
    # 7.编写代码 读取决策树
    在这里插入图片描述
    顺利加载了存储决策树的二进制文件

代码汇总

from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
from math import log
import operator
import pickle

"""
函数说明：计算给定数据集的经验熵（香农熵）
Parameters：
            dataSet - 数据集
Returns：
        shannonEnt - 检验熵（香农熵）
"""
def calcShannonEnt(dataSet):
    # 返回数据集的行数，即总标签数
    numEntires = len(dataSet)
    # 保存每个标签(Label)出现次数的字典
    labelCounts = {}
    # 对每组特征向量进行统计
    for featVec in dataSet:
        # 提取标签(Label)信息
        currentLabel = featVec[-1]
        # 如果标签(Label)没有放入统计次数的字典,添加进去
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1
        # 计算香农熵
        shannonEnt = 0.0
    for key in labelCounts:
        # 选择该标签的概率
        prob = float(labelCounts[key] / numEntires)
        # 利用公式计算
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt


"""
函数说明：创建测试数据集
Returns：
        dataSet - 数据集
        labels - 特征标签
"""
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

    # 数据集
    # 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：
        retDataSet - 划分后的数据集
"""
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 - 信息增益最大的特征索引值
"""
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]
        # 创建set集合，元素不可重复
        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
        # print("第%d个特征的增益为%.3f" % (i, infoGain))
        # 更新信息增益，找到最大增益
        if(infoGain > bestInfoGain):
            bestInfoGain = infoGain
            bestFeature = i
    # 返回最大信息增益索引值
    return bestFeature

"""
函数说明：统计classList中出现此处最多的元素（类标签）
Parameters：
            classList - 类标签
Returns：
        sortedClassCount[0][0] - 出现次数最多的类标签
"""
def majorityCnt(classList):
    # 统计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]

"""
函数说明：创建决策树
Parameters：
            dataSet - 训练数据集
            labels - 分类标签属性
            featLabels - 存储选择的最优特征属性
Returns：
        myTree - 决策树
"""
def createTree(dataSet, labels, featLabels):
    # 取分类标签
    classList = [example[-1] for example in dataSet]
    # 1.如果类别完全相同，则停止划分
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    # 2.遍历完所有特征时，返回出现次数最多的类标签
    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 - 决策树叶子结点数目
"""
def getNumLeafs(myTree):
    # 初始化叶子
    numLeafs = 0
    # myTree.keys()返回的是dict_keys,不在是list,所以不能使用myTree.keys()[0]
    # 的方法获取结点属性，可以使用list(myTree.keys())[0]
    firstStr = next(iter(myTree))
    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 - 决策树的层数
"""
def getTreeDepth(myTree):
    # 初始化决策树深度
    maxDepth = 0
    firstStr = next(iter(myTree))
    secondDic = myTree[firstStr]
    for key in secondDic.keys():
        if type(secondDic[key]).__name__ == 'dict':
            thisDepth = 1 + getTreeDepth(secondDic[key])
        else:
            thisDepth = 1
        # 更新层数
        if thisDepth > maxDepth:
            maxDepth = thisDepth
    return maxDepth

"""
函数说明：绘制结点
Parameters：
            nodeTxt - 结点名
            centerPt - 文本位置
            parentPt - 标注的箭头位置
            nodeType - 节点格式
"""


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 - 标注内容
"""
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)

"""
函数说明：绘制决策树
Paremeters：
            myTree - 决策树(字典)
            parentPt - 标注的内容
            nodeTxt - 结点名
"""
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 - 决策树（字典）
"""
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()

"""
函数说明：使用决策树分类
Paraneters：
            inputTree - 已经生成的决策树
            featLabels - 存储选择的最优特征标签
            testVec - 测试数据列表，顺序对应最有特征标签
Returns：
        classLabel - 分类结果
"""
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

"""
函数说明：存储决策树
Parameters:
            inputTree - 已经生成的决策树
            filename - 决策树的存储文件名
"""
def storeTree(inputTree, filename):
    with open(filename, 'wb') as fw:
        pickle.dump(inputTree, fw)

"""
函数说明：读取决策树
Parameters：
            fileName - 决策树的存储文件名
Returns：
        pickle.load(fr) - 决策树字典
"""
def grabTree(fileName):
    fr = open(fileName, 'rb')
    return pickle.load(fr)

if __name__ == '__main__':
    # 1.创建数据集，计算经验熵
    # dataSet, features = createDataSet()
    # print(dataSet)
    # print("经验熵：", calcShannonEnt(dataSet))

    # 2.计算信息增益
    # dataSet, features = createDataSet()
    # print("最优特征索引值：" + str(chooseBestFeatureToSplit(dataSet)))

    # 3.创建决策树
    # dataSet, labels = createDataSet()
    # featLabels = []
    # myTree = createTree(dataSet, labels, featLabels)
    # print(myTree)

    # 4.可视化决策树
    # dataSet, labels = createDataSet()
    # featLabels = []
    # myTree = createTree(dataSet, labels, featLabels)
    # print(myTree)
    # createPlot(myTree)

    # 5.使用决策树分类
    # 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("不放贷")

    # 6.存储决策树
    # myTree = {'有自己的房子': {0: {'有工作': {0: 'no', 1: 'yes'}}, 1: 'yes'}}
    # storeTree(myTree, 'classifierStorage.txt')

    # 7.读取决策树
    myTree = grabTree('classifierStorage.txt')
    print(myTree)
qmys
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习实战 决策树(附数据集)
枫林晚的博客
07-01 1万+
运行环境：Anaconda——Jupyter Notebook Python版本为：3.6.6 数据集:lense.txt 提取码：9wsp 1.决策树 决策树也是最经常使用的数据挖掘算法，长方形代表判断模块（decision block），椭圆形代表终止模块（terminating block），表示已经得出结论，可以终止运行。从判断模块引出的左右箭头称作分支（branch），它可以到达另一个判...
Python学习笔记9——基于iris数据集的决策树分类算法实战
制了个仗的博客
06-03 3133
本文以iris数据集为例，利用Python的决策树分类算法对鸢尾花进行分类实战，主要环节是数据预处理、模型训练及效果评估。预处理主要是对数据集进行拆分，得到训练数据和测试数据模型训练是利用拆分得到的训练集来训练模型；效果评估主要用到了准确率、精确率、召回率、F1值、混淆矩阵的指标，还用到了学习曲线进行过拟合、欠拟合评估，以及用到ROC曲线结合AUC值分析的方法。为了便于新手入门，大部分过程都写得比较细，希望能够对读者在学习和应用机器学习算法时有所帮助，若有不对的地方也请评论指正~
决策树算法（二）——构建数据集
编程小栈
07-14 4207
目录索引 目录索引 写在前面的话 决策树构建的一般流程 数据的构建 参考链接 写在后面的话 写在前面的话 如果您有任何地方看不懂的，那一定是我写的不好，请您告诉我，我会争取写的更加简单易懂！ 如果您有任何地方看着不爽，请您尽情的喷，使劲的喷，不要命的喷，您的槽点就是帮助我要进步的地方！ 1.决策树构建的一般流程 收集数据：任何你能收集数据的方法 准备数据：
【从零入门人工智能】决策树实战_数据集：iris_data.csv
David的博客
12-28 1332
本次实验通过建立决策树，实现对标签数据的有效分类;通过修改叶子节点最少样本数对应参数，可调控制树的分支深度;决策树是一种比较简单的分类方法，具有容易理解、容易处理分类特征等优点，但是也存在容易出现过拟合的问题。
机器学习系列(9)_决策树详解01
04-25 2510
文章目录一、种类介绍1、监督学习2、非监督学习3、半监督学习4、强化学习5、批量学习6、在线学习7、基于实例的学习8、基于模型的学习二、决策树random_state和splitter 一、种类介绍 1、监督学习 在监督学习中，提供给算法的包含所需解决方案的训练数据，称为标签或标记。 监督学习是包含自变量和因变量（有Y），同时可以用于分类和回归。下来常见的算法都是监督学习算法。 K近邻算法 线性回归 logistic回归 支持向量机（SVM） 决策树和随机森林 神经网络 2、非监督学习 聚类算法 K均值算
机器学习实战-手撕决策树
05-18
决策树模型在鸢尾花数据集上的实现，包括完整代码和可视化以及讲解，准确率很高，亲测可用！
机器学习python实战之决策树
12-24
决策树原理：从数据集中找出决定性的特征对数据集进行迭代划分，直到某个分支下的数据都属于同一类型，或者已经遍历了所有划分数据集的特征，停止决策树算法。 　每次划分数据集的特征都有很多，那么我们怎么来选择...
机器学习实战第三章决策树
01-20
这是以本人的笔记的形式写的，各个函数逐个来写，至于存放在那个模块大家可以看书，这里不再详细讲解。可能存在错误，有不对的的地方希望评论给予改正。多谢大家嘻嘻
决策树可视化：鸢尾花数据集分类(附代码数据集)
ABin_203的博客
05-08 1万+
决策树数据集实战可视化评价 决策树是什么？决策树(decision tree)是一种基本的分类与回归方法。举个通俗易懂的例子，流程图就是一种决策树。 有没有车，没车的话有没有房，没房的话有没有存款，没存款pass。这个流程就是一个简单的决策树。 分类决策树模型是一种描述对实例进行分类的树形结构。通过很多次判断来决定是否符合某类的特征。 数据集 首先附上数据集： 链接：https://pan.bai...
分类算法中决策树和KNN算法讲解及对iris数据集分类实战（附源码）
showswoller的博客
01-17 1936
分类算法中决策树和KNN算法讲解及对iris数据集分类实战（附源码）
决策树分类——附数据下载
ryo007gnnu的博客
10-06 5069
又在网络上搜罗了几个，凑了几个决策树的例子，原理的部分直接略去，说白了就是
机器学习--决策树
dasihudi的博客
10-28 634
目录 决策树的构造 决策树的一般流程 信息增益 编写代码计算经验熵 利用代码计算信息增益 划分数据集 选择最好的数据集划分方式 信息增益率 基尼系数 ID3、C4.5、CART的区别 信息增益 vs 信息增益比 gini指数 vs熵 决策树的可视化 总结 决策树的构造 决策树学习的算法通常是一个递归地选择最优特征，并根据该特征对训练数据进行分割，使得各个子数据集有一个最好的分类的过程。这一过程对应着对特征空间的划分，也对应着决策树的构建。（1）开始：...
使用决策树模型Titanic数据集预测
WHY的博客
05-24 1039
使用决策树模型Titanic数据集预测
决策树算法（四）——选取最佳特征划分数据集
编程小栈
07-19 2万+
写在前面的话咦，好神奇，我今天发现我莫名其妙的成了小三。原来我被卖了还不知道，还帮人家宣传博客和微信公众账号。我放弃了自己规划好的人生，然后决定跟另一个在一起，然后发现原来他有女朋友。我今天有点头大哎。哈哈哈哈哈。原来被劈腿也会被我遇到呢。可怜了我这个系列的博客，写的这么好却没有人知道欣赏。就像我这么好，哈哈哈，我好不要脸，却。。。。如果您有任何地方看不懂的，那一定是我写的不好，请您告诉我，我会争取
决策树原理剖析
Above the cloud
08-26 1148
ID3采用的信息增益度量存在一个缺点，它一般会优先选择有较多属性值的Feature,因为属性值多的Feature会有相对较大的信息增益(信息增益反映的给定一个条件以后不确定性减少的程度,必然是分得越细的数据集确定性更高,也就是条件熵越小,信息增益越大).为了避免这个不足C4.5中是用信息增益比率(gain ratio)来作为选择分支的准则。离散型数据(特征、属性)：取值可以具有有限个或无限可数个值，这个值可以用来定性描述属性的汉字、单词；构造决策树的基本思想是随着树的深度加深，节点的熵值迅速的降低。
使用决策树进行收入预测（Adult数据集）
m0_66187298的博客
12-06 674
使用决策树进行收入预测（Adult数据集）
机器学习之决策树（Decision Tree）
小火球儿
07-26 1667
决策树（Decision Tree） 决策树又称为判定树，是数据挖掘中的一种重要的分类与回归方法，它是一种以树结构(包括二叉树和多叉树)形式来表达的预测分析模型 是一种有监督的算法 决策树有两种，一种是分类树（输入是离散的），一种是回归树（输入是连续的） 决策树由节点和分支组成：（详情参考数据结构书本） 节点分为三种：根节点，内部节点，叶节点 分支：用于连接各个节点 决策树分为以下结构： 每个内部节点对应于某个属性上的测试(test)或者说是大类 每个分支对应于该测试的一种可能结果 每个叶节点对应
机器学习——决策树
linzixi0220的博客
11-06 410
决策树是一个基于树形结构的分类模型，它将数据集中的不同特征的不同取值对数据集进行分割，构造出一个树形结构，这个树形结构就是决策树，使用决策树能够进行分类任务，预测数据样本的分类。我们使用的分类算法是k近邻算法，它是一个很容易实现的分类模型，可以完成很多的分类任务，但它最大的缺点就是无法给出数据的内在含义，因为它只是通过计算样本点的距离来进行分类的，这个距离并不包含对该样本分类的实际意义，而决策树的每一个分类都有对应一组特征判断的条件，可以很直观的看出分类规则，其数据形式非常容易理解。
【机器学习】Decision Tree 决策树算法详解 + Python代码实战
热门推荐
知不足而奋进，望远山而前行
10-11 3万+
节点在分割之前必须具有的最小样本数：叶子节点必须具有的最小样本数：叶子节点的最大数量：在每个节点处评估用于拆分的最大特征数（除非特征非常多，否则不建议限制最大特征数）max_depth：树最大的深度。
《机器学习实战》决策树“IndexError: list index out of range
最新发布
05-07
《机器学习实战》中的决策树算法实现时，可能会出现“IndexError: list index out of range”的错误提示。这个错误通常是由于在使用决策树算法时，输入的数据有误或者缺失值较多导致的。 为了解决这个问题，可以进行以下操作： 1. 检查输入的数据是否正确，并确保数据完整性。 2. 使用合适的算法对缺失值进行处理或者填充。 3. 调整算法参数，尽量使得算法具有更好的鲁棒性。 如果以上操作仍然无法解决问题，请参考《机器学习实战》中提供的代码实现，或者参考其他相关资料寻求帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值