机器学习：决策树

最新推荐文章于 2022-11-20 19:53:16 发布

Laker 23

最新推荐文章于 2022-11-20 19:53:16 发布

阅读量245

点赞数

分类专栏：机器学习文章标签：决策树机器学习 python

本文链接：https://blog.csdn.net/qq_51667621/article/details/121004605

版权

机器学习专栏收录该内容

8 篇文章 2 订阅

订阅专栏

一、决策树的构造
1.决策树
优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。
缺点：可能会产生过度匹配问题。
适用数据类型：数值型和标称型。

2.决策树的一般流程
（1）收集数据：可以使用任何方法。
（2）准备数据：树构造算法只适用于标称型数据，因此数值型数据必须来离散化。
（3）分析数据：可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。
（4）训练算法：构造树的数据结构。
（5）测试算法：使用经验树计算错误率。
（6）使用算法：此步骤可以适用于任何监督学习算法，而使用决策树可以更好地理解数据的内在含义。

二.ID3算法
2.1信息增益
在划分数据集之前之后信息发生的变化称为信息增益。计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。而集合信息的度量方式称为香农熵。
如果待分类的事务可能划分在多个分类之中，则符号xi的信息定义为：
l(xi)=-log₂p(xi)
其中p(xi)是选择该分类的概率。
为了计算熵，需要计算所有类别所有可能包含的信息期望值，公式为：
H = -∑p(xi)㏒₂p(xi)
其中n是分类的数目。

2.2代码实现

# 计算给定数据集的香农熵
def calcShannonEnt(dataSet):
    # 返回数据集行数
    numEntries = len(dataSet)
    # 保存每个标签（label）出现次数的字典
    labelCounts = {}
    # 对每组特征向量进行统计
    for featVec in dataSet:  # the the number of unique elements and their occurance
        # 提取标签信息
        currentLabel = featVec[-1]
        # 如果标签没有放入统计次数的字典，添加进去
        if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0
        # label计数
        labelCounts[currentLabel] += 1
    shannonEnt = 0.0
    # 计算香农熵
    for key in labelCounts:
        # 选择该标签的概率
        prob = float(labelCounts[key]) / numEntries
        shannonEnt -= prob * log(prob, 2)  # log base 2
    # shannonEnt：信息增益最大特征的索引值
    return shannonEnt

2.3划分数据集
将对每个特征分数据集的结果计算一次信息熵，然后判断按照哪个特征划分数据集。

# 按照给定特征划分数据集
def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]  # chop out axis used for splitting
            reducedFeatVec.extend(featVec[axis + 1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet
# dataSet：待划分的数据集
# axis：划分数据集的特征
# value：需要返回的特征的值

3.3选择最好的数据集划分方式

# 选择最好的数据集划分方式
def chooseBestFeatureToSplit(dataSet):
    # 特征数量
    numFeatures = len(dataSet[0]) - 1  # the last column is used for the labels
    # 计数数据集的香农熵
    baseEntropy = calcShannonEnt(dataSet)
    # 信息增益
    bestInfoGain = 0.0;
    # 最优特征的索引值
    bestFeature = -1
    # 遍历所有特征
    for i in range(numFeatures):  # iterate over all the features
        # 获取dataSet的第i个所有特征
        featList = [example[i] for example in dataSet]  # create a list of all the examples of this feature
        # 创建set集合{}，元素不可重复
        uniqueVals = set(featList)  # get a set of unique values
        newEntropy = 0.0
        # 计算信息增益
        for value in uniqueVals:
            # subDataSet划分后的子集
            subDataSet = splitDataSet(dataSet, i, value)
            # 计算子集的概率
            prob = len(subDataSet) / float(len(dataSet))
            # 根据公式计算经验条件熵
            newEntropy += prob * calcShannonEnt(subDataSet)
        # 信息增益
        infoGain = baseEntropy - newEntropy  # calculate the info gain; ie reduction in entropy
        # 打印每个特征的信息增益
        # print("第%d个特征的增益为%.3f" % (i, infoGain))
        if (infoGain > bestInfoGain):  # compare this to the best gain so far
            # 更新信息增益，找到最大的信息增益
            bestInfoGain = infoGain  # if better than current best, set to best
            # 记录信息增益最大的特征的索引值
            bestFeature = i
    # 返回信息增益最大特征的索引值
    return bestFeature  # returns an integer

3.4递归构建决策树
从数据集构造决策树算法所需要的子功能模块工作原理：得到原始数据集，然后基于最好的属性值划分数据集，由于特征值一般多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后数据将被向下传递到树分支的下一个结点，在这个结点上，可以再次划分数据。因此可以采用递归处理数据集。
递归结束的条件是：程序遍历完所有划分数据集的属性，或者每个分支下的所有实例都具有相同的分类。
如果数据集已经处理了所有属性，但是类标签依然不是唯一的，此时需要决定如何定义该叶子节点，一般采用多数表决的方法来决定该叶子节点的分类。

def majorityCnt(classList):
    classCount = {}
    # 统计classList中每个元素出现的次数
    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]

该函数使用分类名称的列表，然后创建键值为classList中唯一值的数据字典，字典对象存储了classList中每个标签出现的频率，最后利用operator操作键值排序字典，并返回出现次数最多的分类名称。

# 创建树的函数代码
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[:]  # copy all of labels, so trees don't mess up existing labels
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
    return myTree

3.5算法训练和测试
数据集：请添加图片描述
输出决策树：

三、决策树的可视化
3.1Matplotlib注解

import matplotlib.pyplot as plt

decisionNode = dict(boxstyle="sawtooth", fc="0.8")
leafNode = dict(boxstyle="round4", fc="0.8")
arrow_args = dict(arrowstyle="<-")

# 绘制节点
# nodeTxt - 结点名
# centerPt - 文本位置
# parentPt - 标注的箭头位置
# nodeType - 结点格式
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)
    
    
# 创建绘制面板
# inTree - 决策树(字典)
def createPlot(inTree):
    # 创建fig
    fig = plt.figure(1, facecolor='white')
    # 清空fig
    fig.clf()
    axprops = dict(xticks=[], yticks=[])
    # 去掉x、y轴
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
    # 获取决策树叶结点数目
    plotTree.totalW = float(getNumLeafs(inTree))
    # 获取决策树层数=
    plotTree.totalD = float(getTreeDepth(inTree))
    # x偏移
    plotTree.xOff = -0.5 / plotTree.totalW;
    plotTree.yOff = 1.0;
    # 绘制决策树
    plotTree(inTree, (0.5, 1.0), '')
    # 显示绘制结果
    plt.show()

代码定义了树节点格式的常量，然后plotNode()函数执行了实际的绘图功能，而createPlot()函数首先创建了一个新图形并清空绘图区，然后在绘图区上绘制代表两个不同类型的树节点。

3.2构造注解树
必须知道有多少个叶节点，以便确定x轴的长度，还需要知道树有多少层，用以确定y轴的高度。

# 获取叶节点的数目
# myTree:决策树
def getNumLeafs(myTree):
    numLeafs = 0
    firstStr = list(myTree.keys())[0]
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[
                    key]).__name__ == 'dict':  # test to see if the nodes are dictonaires, if not they are leaf nodes
            numLeafs += getNumLeafs(secondDict[key])
        else:
            numLeafs += 1
    return numLeafs


# 获取决策树的层数
# maxDepth:决策树的层数
def getTreeDepth(myTree):
    # 初始化决策树深度
    maxDepth = 0
    firstStr = list(myTree.keys())[0]
    # 获取下一个字典
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        # 测试该结点是否为字典，如果不是字典，代表此结点为叶子结点
        if type(secondDict[
                    key]).__name__ == 'dict':  # test to see if the nodes are dictonaires, if not they are leaf nodes
            thisDepth = 1 + getTreeDepth(secondDict[key])
        else:
            thisDepth = 1
        # 更新层数
        if thisDepth > maxDepth: maxDepth = thisDepth
    return maxDepth

输出决策树的可视化图像：
请添加图片描述
3.3测试算法
这里使用函数将数据集里的奇数行数据作为测试集。

def file_test(filename):  # 取数据集的奇数作为测试集
    fr = open(filename)
    lines = fr.readlines()
    # print(lines)
    res = []
    i = 0
    for line in lines:
        line = line.strip()
        temp = line.split(",")
        if i % 2 == 1:  # 取总数据集里的奇数
            res.append(temp)
        i += 1
    labels = ['shoot', 'threePoint', 'block', 'assist', 'point', 'strong', 'vsudu']
    return res, labels

请添加图片描述
四、C4.5算法
采用信息增益率来构建决策树。

def GainRatio(dataSet):  # 选择信息增益率最大的属性
    numFeatures = len(dataSet[0]) - 1
    baseEntropy = calcShannonEnt(dataSet)
    bestGainRatio = 0.0  # 最佳信息增益率
    bestFeature = -1
    for i in range(numFeatures):
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList)
        splitInfo = 0.0  # 信息分类率
        newEntropy = 0.0
        for value in uniqueVals:
            subdataSet = splitdataSet(dataSet, i, value)
            prob = len(subdataSet) / float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subdataSet)
            splitInfo -= prob * log(prob, 2)
        infoGain = baseEntropy - newEntropy
        if splitInfo == 0.0:  # 预防除数为0的情况
            gainratio = 0.0
        else:
            gainratio = infoGain / splitInfo  # 信息增益率计算
        if gainratio > bestGainRatio:
            bestGainRatio = gainratio
            bestFeature = i
    return bestFeature

测试C4.5算法：
请添加图片描述

五、CART算法
采用基尼指数来构建决策树。

def countProb(subdataSet):  #计算基尼指数
    num=len(subdataSet)
    featCount=0
    feat=subdataSet[0][-1]
    for i in subdataSet:
        if i[-1]==feat:
            featCount+=1
    prob=float(featCount)/num
    return prob

def GiniIndex(dataSet):
    # 计算以特征A为分割的最小基尼指数
    dataSetLen=len(dataSet)
    numFeatures = len(dataSet[0]) - 1
    bestGini = 1.0  # 初始基尼指数
    bestFeature = -1
    for i in range(numFeatures):
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList)
        giniSplit=0.0
        for value in uniqueVals:
            subdataSet = splitdataSet(dataSet, i, value)
            prob=countProb(subdataSet)  # 计算p值
            featSplit=featList.count(value)
            newGiniPercent=float(featSplit)/dataSetLen      # 计算该value的占比
            giniSplit+=newGiniPercent*2*prob*(1-prob)
        if giniSplit < bestGini:
            bestGini = giniSplit
            bestFeature = i
    return bestFeature

测试CART算法：
请添加图片描述

Laker 23

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
机器学习：决策树

一、决策树的构造1.决策树优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。缺点：可能会产生过度匹配问题。适用数据类型：数值型和标称型。2.决策树的一般流程（1）收集数据：可以使用任何方法。（2）准备数据：树构造算法只适用于标称型数据，因此数值型数据必须来离散化。（3）分析数据：可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。（4）训练算法：构造树的数据结构。（5）测试算法：使用经验树计算错误率。（6）使用算法：此步骤可以适用于任何监
复制链接

扫一扫