决策树分类-学习笔记

最新推荐文章于 2022-11-14 18:48:56 发布

wisfy_21

最新推荐文章于 2022-11-14 18:48:56 发布

阅读量1.1k

点赞数 1

分类专栏：机器学习算法

本文链接：https://blog.csdn.net/wisfy_21/article/details/81125297

版权

机器学习同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

算法

1 篇文章 0 订阅

订阅专栏

基本概念
数据划分
递归构建决策树
分类器
训练结果保存

基本概念

一般的，一棵决策树包含一个根结点、若干个内部结点和若干个页结点；叶结点对应于决策结果，其他每个结点则对应于一个属性测试；每个结点包含的样本根据属性测试的结果被划分到子结点中;根结点包含样本全集。从根结点到每个叶结点的路径对应了一个判定测试序列。决策树学习的目的是为了产生一棵泛化能力强，即处理未见实力能力强的决策树。

在构造决策树时，需要解决的第一个问题就是，找到当前决定性的特征，划分不同的数据子集。如果数据子集内的数据不属于同一类型数据，需要继续划分数据子集，直到数据子集全部为同一类型或者为空集。

伪代码createBranch()的表示如下：

检测数据集中每个子项是否属于同一分类：
if so return 类标签
Else 
    寻找划分数据集的最好特征
    划分数据集
    创建分支节点
        for 每个划分的子集
            递归调用createBranch并增加返回结果到分支节点中
    return 分支节点

数据划分

决策树构建的关键是，如何选择最优的划分属性。划分数据集的最大原则是：将无序的数据变得更加有序。组织杂乱无章数据的一种方法是使用信息论度量信息。在划分数据集之前之后信息发生的变化称为信息增益，知道如何计算信息增益，就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。

因此在评测哪种数据划分方式是最好的数据划分之前，需要学习如何计算信息增益。

首先看一下数据集的无序程度的度量方式。集合信息的度量方式成为香农熵或者简称熵。熵定义为信息的期望值。如果待分类的事物可能划分在多个分类之中，则符号 $x_i$ 的信息定义为

l (x i) = - log 2 p (x i)

$l(x_i)=-\log_2p(x_i)$
其中

p(xi) p ( x i ) $p(x_i)$ 是选择该分类的概率。

计算熵需要计算所有类别所有可能值包含的信息期望值，可以使用下面的公式：

H = - \sum i = 1 n p (x i) log 2 p (x i)

$H=-\sum_{i=1}^np(x_i)\log_2p(x_i)$
其中

n n <script type="math/tex" id="MathJax-Element-5">n</script>是分类的数目。

对于案例数据集两个特征（不浮出水面是否可以生存、是否有脚蹼)以及结果分类是否属于鱼类：

def createDataSet():
    dataSet = [[1, 1, 'yes'],
               [1, 1, 'yes'],
               [1, 0, 'no'],
               [0, 1, 'no'],
               [0, 1, 'no']]
    labels = ['no surfacing','flippers'] #特征标签列表
    #change to discrete values
    return dataSet, labels

计算给定数据集的香农熵的Python实现：

from math import log

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
        shannonEnt -= prob * log(prob,2) #log base 2
    return shannonEnt

使用上面的案例数据计算出的熵为0.9709505944546686。假如不改变数据数量增加一个类别，将数据集改为：

dataSet = [[1, 1, 'maybe'],
           [1, 1, 'yes'],
           [1, 0, 'no'],
           [0, 1, 'no'],
           [0, 1, 'no']]

重新计算出的熵为1.3709505944546687。熵越高，混合的数据越多。

要选择最优的划分属性，需要对每个特征划分数据集的结果各进行计算信息熵，根据每个特征数据集对应的熵值选择最好的划分方式。

对于上面的例子按照给定特征划分数据集的实现如下：

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

如果要根据第一个特征（不浮出水面是否可以生存）划分数据集（可以生存为1，不可以生存为0）的话，那么要这样做：

splitDataSet(dataSet, 0, 1) # 可以生存数据集
splitDataSet(dataSet, 0, 0) # 不可以生存数据集

对根据第一个特征划分的两个数据集分别计算熵，并求和作为按此特征划分之后的信息无序程度的度量，这里也是熵。
同理，如果按照第二个特征划分数据集的话，也可以求出划分数据集之后的熵。这里两种不同划分对应的熵值相对最初集合的熵值都一定是减小了，也就是数据的无序度减少了。

信息增益就是指熵的减少或者数据无序度的减少。那么这里最优的划分特征就是取划分之后使得熵值最小（与最初熵比差值最大）的那个特征。
完整的Python计算最优划分特征的实现如下：

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
        featList = [example[i] for example in dataSet]  # create a list of all the examples of this feature
        uniqueVals = set(featList)  # get a set of unique values
        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  # calculate the info gain; ie reduction in entropy
        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

数据无序程度的度量以及如何确定最优的划分特征已经明确了，接下来需要构建树结构。

递归构建决策树

对于原始数据集，然后基于最优的特征进行划分数据集（分支数据集有可能大于两个），之后对于划分的子数据集再分别进行递归划分。递归结束的条件是每个分支下所有的数据都是同一个类别的数据。任何到达叶子节点的数据必然数据叶子节点的分类。

如果数据集已经处理了所有属性，类标签依然不是唯一的情况下（比如特征很多，类别很多，因为不可知原因，使得部分特征最终划分的数据集包含的类别标注始终不止一个），需要决定如何定义该叶子节点的类别。在这种情况下，通常会采用多数表决方法决定该叶子节点的分类。

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]  # stop splitting when all of the classes are equal
    if len(dataSet[0]) == 1:  # stop splitting when there are no more features in dataSet
        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

对于上面案例，构造出来的树结构表示如下：

{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}

这里表示的意思是(暂时不知道怎么markdown生成很好的图形，只好用文字来描述)：
1. 判断不浮出水面是否可以生存
2. 如果不是，那么不是鱼类，结束判断；否则，进行下面一步
3. 判断是否有脚蹼
4. 如果没有，则不是鱼类，如果是那么是鱼类

分类器

到目前为止，根据训练数据集构造的决策树已经完成。决策树的分类用法就是，从根结点开始，每个非叶子节点都会对一个特征依据特征标签进行判断，根据判断结果走不同的分支，最终可以走到叶子结点确定类别。

对上面的案例来说，如果使用不同的测试数据或者增加类别，最终构造出的决策树的根结点是无法预测的。要对真实的数据进行分类，第一个要判断的特征是哪个，需要确定根结点对应数据所在的位置。这时候就要借助最初的训练数据集里面的特征标签列表[‘no surfacing’,’flippers’]了。对于上面的案例分类器的python实现如下：

# 参数分别是已构造的决策树、特征标签列表、待分类的真实数据
def classify(inputTree, featLabels, testVec):
    firstStr = inputTree.keys()[0]
    secondDict = inputTree[firstStr] 
    #根据特征标签列表中的索引位置找到根结点对应的数据位置
    featIndex = featLabels.index(firstStr)
    key = testVec[featIndex]
    #取到下次判断的子决策树
    valueOfFeat = secondDict[key]
    if isinstance(valueOfFeat, dict):
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else:
        classLabel = valueOfFeat
    return classLabel

完整的构建树和使用如下：

>>> data, label = createDataSet()
>>> labels = label[:]
>>> tree = createTree(data, label)
>>> tree
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
>>> labels
['no surfacing', 'flippers']
>>> classify(tree, labels, [0, 1])
'no'
>>> classify(tree, labels, [1, 1])
'yes'
>>> classify(tree, labels, [1, 0])
'no'

训练结果保存

真实案例中不可能每次分类都要重新构造一次决策树，所以需要保存训练结果。持久化方法很多，比如，在Python中可以使用pickle模块来序列化对象。

import pickle

def storeTree(inputTree, filename):
    fw = open(filename, 'w')
    pickle.dump(inputTree, fw)
    fw.close()


def grabTree(filename):
    fr = open(filename)
    return pickle.load(fr)

注：代码以及内容均来自于《机器学习实战》

wisfy_21

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
决策树分类-学习笔记

基本概念数据划分递归构建决策树分类器训练结果保存基本概念一般的，一棵决策树包含一个根结点、若干个内部结点和若干个页结点；叶结点对应于决策结果，其他每个结点则对应于一个属性测试；每个结点包含的样本根据属性测试的结果被划分到子结点中;根结点包含样本全集。从根结点到每个叶结点的路径对应了一个判定测试序列。决策树学习的目的是为了产生一棵泛化能力强，即处理未见实力能力强的决策树...
复制链接

扫一扫