机器学习算法之决策树算法_机器学习决策树

决策树 综述

决策树（Decision Tree）算法是一种基本的分类与回归方法，根据数据的属性采用树状结构建立决策模型。决策树模型常常用来解决分类和回归问题。常见的算法包括CART(Classification And Regression Tree)、ID3、C4.5、C5.0、随机森林 (Random Forest) 等，是最经常使用的数据挖掘算法之一。
决策树是附加概率结果的一个树状的决策图，是直观的运用统计概率分析的图法。机器学习中决策树是一个预测模型，它表示对象属性和对象值之间的一种映射，树中的每一个节点表示对象属性的判断条件，其分支表示符合节点条件的对象。树的叶子节点表示对象所属的预测结果。在分类问题中，表示基于特征对实例进行分类的过程。它可以认为是if-then规则的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。
决策树学习通常包括 3 个步骤：特征选择、决策树的生成和决策树的修剪。

特征选择

选择一个合适的特征作为判断节点，可以快速的分类，减少决策树的深度。决策树的目标就是把数据集按对应的类标签进行分类。最理想的情况是，通过特征的选择能把不同类别的数据集贴上对应类标签。特征选择的目标使得分类后的数据集比较纯。如何衡量一个数据集纯度，这里就需要引入数据纯度函数。下面将介绍两种表示数据纯度的函数。

• 信息增益

熵（entropy）： 熵指的是体系的混乱的程度，在不同的学科中也有引申出的更为具体的定义，是各领域十分重要的参量。

信息论（information theory）中的熵（香农熵）： 是一种信息的度量方式，表示信息的混乱程度，也就是说：信息越有序，信息熵越低。例如：火柴有序放在火柴盒里，熵值很低，相反，熵值很高。

信息增益（information gain）： 在划分数据集前后信息发生的变化称为信息增益。

假设在样本数据集 D 中，混有 c 种类别的数据。构建决策树时，根据给定的样本数据集选择某个特征值作为树的节点。在数据集中，可以计算出该数据中的信息熵：

其中 D 表示训练数据集，c 表示数据类别数，Pi 表示类别 i 样本数量占所有样本的比例。

对应数据集 D，选择特征 A 作为决策树判断节点时，在特征 A 作用后的信息熵的为 Info(D)，计算如下：

其中 k 表示样本 D 被分为 k 个部分。

信息增益表示数据集 D 在特征 A 的作用后，其信息熵减少的值。公式如下：

对于决策树节点最合适的特征选择，就是 Gain(A) 值最大的特征。

• 基尼指数

基尼指数是另一种数据的不纯度的度量方法，其公式为：

其中 c 表示数据集中类别的数量，Pi 表示类别 i 样本数量占所有样本的比例。

从该公式可以看出，当数据集中数据混合的程度越高，基尼指数也就越高。当数据集 D 只有一种数据类型，那么基尼指数的值为最低 0。

如果选取的属性为 A，那么分裂后的数据集 D 的基尼指数的计算公式为：

其中 k 表示样本 D 被分为 k 个部分，数据集 D 分裂成为 k 个 Dj 数据集。

对于特征选取，需要选择最小的分裂后的基尼指数。也可以用基尼指数增益值作为决策树选择特征的依据。公式如下：

在决策树选择特征时，应选择基尼指数增益值最大的特征，作为该节点分裂条件。

剪枝

在分类模型建立的过程中，很容易出现过拟合的现象。过拟合是指在模型学习训练中，训练样本达到非常高的逼近精度，但对检验样本的逼近误差随着训练次数而呈现出先下降后上升的现象。过拟合时训练误差很小，但是检验误差很大，不利于实际应用。

决策树的过拟合现象可以通过剪枝进行一定的修复。剪枝分为预先剪枝和后剪枝两种。

预先剪枝指在决策树生长过程中，使用一定条件加以限制，使得产生完全拟合的决策树之前就停止生长。预先剪枝的判断方法也有很多，比如信息增益小于一定阀值的时候通过剪枝使决策树停止生长。但如何确定一个合适的阀值也需要一定的依据，阀值太高导致模型拟合不足，阀值太低又导致模型过拟合。

后剪枝是在决策树生长完成之后，按照自底向上的方式修剪决策树。后剪枝有两种方式，一种用新的叶子节点替换子树，该节点的预测类由子树数据集中的多数类决定。另一种用子树中最常使用的分支代替子树。

预先剪枝可能过早的终止决策树的生长，后剪枝一般能够产生更好的效果。但后剪枝在子树被剪掉后，决策树生长的一部分计算就被浪费了。

决策树模型评估

建立了决策树模型后需要给出该模型的评估值，这样才可以来判断模型的优劣。学习算法模型使用训练集 (training set) 建立模型，使用校验集 (test set) 来评估模型。本文通过评估指标和评估方法来评估决策树模型。

评估指标有分类准确度、召回率、虚警率和精确度等。而这些指标都是基于混淆矩阵 (confusion matrix) 进行计算的。

混淆矩阵是用来评价监督式学习模型的精确性，矩阵的每一列代表一个类的实例预测，而每一行表示一个实际的类的实例。以二类分类问题为例，如下表所示：

P (Positive Sample)：正例的样本数量。
N(Negative Sample)：负例的样本数量。
TP(True Positive)：正确预测到的正例的数量。
FP(False Positive)：把负例预测成正例的数量。
FN(False Negative)：把正例预测成负例的数量。
TN(True Negative)：正确预测到的负例的数量。

根据混淆矩阵可以得到评价分类模型的指标有以下几种。

分类准确度，就是正负样本分别被正确分类的概率，计算公式为：

召回率，就是正样本被识别出的概率，计算公式为：

虚警率，就是负样本被错误分为正样本的概率，计算公式为：

精确度，就是分类结果为正样本的情况真实性程度，计算公式为：

评估方法有保留法、随机二次抽样、交叉验证和自助法等。

保留法 (holdout) 是评估分类模型性能的最基本的一种方法。将被标记的原始数据集分成训练集和检验集两份，训练集用于训练分类模型，检验集用于评估分类模型性能。但此方法不适用样本较小的情况，模型可能高度依赖训练集和检验集的构成。

随机二次抽样 (random subsampling) 是指多次重复使用保留方法来改进分类器评估方法。同样此方法也不适用训练集数量不足的情况，而且也可能造成有些数据未被用于训练集。

交叉验证 (cross-validation) 是指把数据分成数量相同的 k 份，每次使用数据进行分类时，选择其中一份作为检验集，剩下的 k-1 份为训练集，重复 k 次，正好使得每一份数据都被用于一次检验集 k-1 次训练集。该方法的优点是尽可能多的数据作为训练集数据，每一次训练集数据和检验集数据都是相互独立的，并且完全覆盖了整个数据集。也存在一个缺点，就是分类模型运行了 K 次，计算开销较大。

自助法 (bootstrap) 是指在其方法中，训练集数据采用的是有放回的抽样，即已经选取为训练集的数据又被放回原来的数据集中，使得该数据有机会能被再一次抽取。用于样本数不多的情况下，效果很好。

决策树 场景

一个叫做 “二十个问题” 的游戏，游戏的规则很简单：参与游戏的一方在脑海中想某个事物，其他参与者向他提问，只允许提20个问题，问题的答案也只能用对或错回答。问问题的人通过推断分解，逐步缩小待猜测事物的范围，最后得到游戏的答案。
一个邮件分类系统，大致工作流程如下：

决策树定义
分类决策树模型是一种描述对实例进行分类的树形结构。决策树由结点（node）和有向边（directed edge）组成。结点有两种类型：内部结点（internal node）和叶结点（leaf node）。内部结点表示一个特征或属性(features)，叶结点表示一个类(labels)。

用决策树对需要测试的实例进行分类：从根节点开始，对实例的某一特征进行测试，根据测试结果，将实例分配到其子结点；这时，每一个子结点对应着该特征的一个取值。如此递归地对实例进行测试并分配，直至达到叶结点。最后将实例分配到叶结点的类中。

决策树 原理

决策树 工作原理

如何构造一个决策树?
我们使用 createBranch() 方法，如下所示：

def createBranch():
'''
此处运用了迭代的思想。 感兴趣可以搜索 迭代 recursion， 甚至是 dynamic programing。
'''
    检测数据集中的所有数据的分类标签是否相同:
        If so return 类标签
        Else:
            寻找划分数据集的最好特征（划分之后信息熵最小，也就是信息增益最大的特征）
            划分数据集
            创建分支节点
                for 每个划分的子集
                    调用函数 createBranch （创建分支的函数）并增加返回结果到分支节点中
            return 分支节点
1
2
3
4
5
6
7
8
9
10
11
12
13

决策树 开发流程

收集数据：可以使用任何方法。
准备数据：树构造算法 (这里使用的是ID3算法，只适用于标称型数据，这就是为什么数值型数据必须离散化。 还有其他的树构造算法，比如CART)
分析数据：可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。
训练算法：构造树的数据结构。
测试算法：使用训练好的树计算错误率。
使用算法：此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义。
1
2
3
4
5
6

决策树 算法特点

优点：计算复杂度不高，输出结果易于理解，数据有缺失也能跑，可以处理不相关特征。
缺点：容易过拟合。
适用数据类型：数值型和标称型。
1
2
3

决策树 项目案例

项目案例1: 判定鱼类和非鱼类

根据以下 2 个特征，将动物分成两类：鱼类和非鱼类。
特征：

1. 不浮出水面是否可以生存
2. 是否有脚蹼
   
   我们利用 createDataSet() 函数输入数据

def createDataSet():
    dataSet = [[1, 1, 'yes'],
            [1, 1, 'yes'],
            [1, 0, 'no'],
            [0, 1, 'no'],
            [0, 1, 'no']]
    labels = ['no surfacing', 'flippers']
    return dataSet, labels
1
2
3
4
5
6
7
8
'
运行
运行

准备数据：树构造算法

此处，由于我们输入的数据本身就是离散化数据，所以这一步就省略了。

分析数据：可以使用任何方法，构造树完成之后，我们可以将树画出来。

计算给定数据集的香农熵的函数

def calcShannonEnt(dataSet):
    # 求list的长度，表示计算参与训练的数据量
    numEntries = len(dataSet)
    # 计算分类标签label出现的次数
    labelCounts = {}
    # the the number of unique elements and their occurrence
    for featVec in dataSet:
        # 将当前实例的标签存储，即每一行数据的最后一个数据代表的是标签
        currentLabel = featVec[-1]
        # 为所有可能的分类创建字典，如果当前的键值不存在，则扩展字典并将当前键值加入字典。每个键值都记录了当前类别出现的次数。
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1

    # 对于 label 标签的占比，求出 label 标签的香农熵
    shannonEnt = 0.0
    for key in labelCounts:
        # 使用所有类标签的发生频率计算类别出现的概率。
        prob = float(labelCounts[key])/numEntries
        # 计算香农熵，以 2 为底求对数
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'
运行
运行

按照给定特征划分数据集
将指定特征的特征值等于 value 的行剩下列作为子数据集。

def splitDataSet(dataSet, index, value):
    """splitDataSet(通过遍历dataSet数据集，求出index对应的colnum列的值为value的行)
        就是依据index列进行分类，如果index列的数据等于 value的时候，就要将 index 划分到我们创建的新的数据集中
    Args:
        dataSet 数据集                 待划分的数据集
        index 表示每一行的index列        划分数据集的特征
        value 表示index列对应的value值   需要返回的特征的值。
    Returns:
        index列为value的数据集【该数据集需要排除index列】
    """
    retDataSet = []
    for featVec in dataSet: 
        # index列为value的数据集【该数据集需要排除index列】
        # 判断index列的值是否为value
        if featVec[index] == value:
            # chop out index used for splitting
            # [:index]表示前index行，即若 index 为2，就是取 featVec 的前 index 行
            reducedFeatVec = featVec[:index]
            '''
            请百度查询一下： extend和append的区别
            music_media.append(object) 向列表中添加一个对象object
            music_media.extend(sequence) 把一个序列seq的内容添加到列表中 (跟 += 在list运用类似， music_media += sequence)
            1、使用append的时候，是将object看作一个对象，整体打包添加到music_media对象中。
            2、使用extend的时候，是将sequence看作一个序列，将这个序列和music_media序列合并，并放在其后面。
            music_media = []
            music_media.extend([1,2,3])
            print music_media
            #结果：
            #[1, 2, 3]
            
            music_media.append([4,5,6])
            print music_media
            #结果：
            #[1, 2, 3, [4, 5, 6]]
            
            music_media.extend([7,8,9])
            print music_media
            #结果：
            #[1, 2, 3, [4, 5, 6], 7, 8, 9]
            '''
            reducedFeatVec.extend(featVec[index+1:])
            # [index+1:]表示从跳过 index 的 index+1行，取接下来的数据
            # 收集结果值 index列为value的行【该行需要排除index列】
            retDataSet.append(reducedFeatVec)
    return retDataSet
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
'
运行
运行

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

def chooseBestFeatureToSplit(dataSet):
    """chooseBestFeatureToSplit(选择最好的特征)

    Args:
        dataSet 数据集
    Returns:
        bestFeature 最优的特征列
    """
    # 求第一行有多少列的 Feature, 最后一列是label列嘛
    numFeatures = len(dataSet[0]) - 1
    # 数据集的原始信息熵
    baseEntropy = calcShannonEnt(dataSet)
    # 最优的信息增益值, 和最优的Featurn编号
    bestInfoGain, bestFeature = 0.0, -1
    # iterate over all the features
    for i in range(numFeatures):
        # create a list of all the examples of this feature
        # 获取对应的feature下的所有数据
        featList = [example[i] for example in dataSet]
        # get a set of unique values
        # 获取剔重后的集合，使用set对list数据进行去重
        uniqueVals = set(featList)
        # 创建一个临时的信息熵
        newEntropy = 0.0
        # 遍历某一列的value集合，计算该列的信息熵 
        # 遍历当前特征中的所有唯一属性值，对每个唯一属性值划分一次数据集，计算数据集的新熵值，并对所有唯一特征值得到的熵求和。
        for value in uniqueVals:
            subDataSet = splitDataSet(dataSet, i, value)
            # 计算概率
            prob = len(subDataSet)/float(len(dataSet))
            # 计算信息熵
            newEntropy += prob * calcShannonEnt(subDataSet)
        # gain[信息增益]: 划分数据集前后的信息变化， 获取信息熵最大的值
        # 信息增益是熵的减少或者是数据无序度的减少。最后，比较所有特征中的信息增益，返回最好特征划分的索引值。
        infoGain = baseEntropy - newEntropy
        print 'infoGain=', infoGain, 'bestFeature=', i, baseEntropy, newEntropy
        if (infoGain > bestInfoGain):
            bestInfoGain = infoGain
            bestFeature = i
    return bestFeature
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

问：上面的 newEntropy 为什么是根据子集计算的呢？
答：因为我们在根据一个特征计算香农熵的时候，该特征的分类值是相同，这个特征这个分类的香农熵为 0；这就是为什么计算新的香农熵的时候使用的是子集。
1
2

训练算法：构造树的数据结构

创建树的函数代码如下：

def createTree(dataSet, labels):
    classList = [example[-1] for example in dataSet]
    # 如果数据集的最后一列的第一个值出现的次数=整个集合的数量，也就说只有一个类别，就只直接返回结果就行
    # 第一个停止条件：所有的类标签完全相同，则直接返回该类标签。
    # count() 函数是统计括号中的值在list中出现的次数
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    # 如果数据集只有1列，那么最初出现label次数最多的一类，作为结果
    # 第二个停止条件：使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
    if len(dataSet[0]) == 1:
        return majorityCnt(classList)

    # 选择最优的列，得到最优列对应的label含义
    bestFeat = chooseBestFeatureToSplit(dataSet)
    # 获取label的名称
    bestFeatLabel = labels[bestFeat]
    # 初始化myTree
    myTree = {bestFeatLabel: {}}
    # 注：labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
    # 所以这行代码导致函数外的同名变量被删除了元素，造成例句无法执行，提示'no surfacing' is not in list
    del(labels[bestFeat])
    # 取出最优列，然后它的branch做分类
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        # 求出剩余的标签label
        subLabels = labels[:]
        # 遍历当前选择特征包含的所有属性值，在每个数据集划分上递归调用函数createTree()
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
        # print 'myTree', value, myTree
    return myTree
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
'
运行
运行

测试算法：使用决策树执行分类

def classify(inputTree, featLabels, testVec):
    """classify(给输入的节点，进行分类)

    Args:
        inputTree  决策树模型
        featLabels Feature标签对应的名称
        testVec    测试输入的数据
    Returns:
        classLabel 分类的结果值，需要映射label才能知道名称
    """
    # 获取tree的根节点对于的key值
    firstStr = inputTree.keys()[0]
    # 通过key得到根节点对应的value
    secondDict = inputTree[firstStr]
    # 判断根节点名称获取根节点在label中的先后顺序，这样就知道输入的testVec怎么开始对照树来做分类
    featIndex = featLabels.index(firstStr)
    # 测试数据，找到根节点对应的label位置，也就知道从输入的数据的第几位来开始分类
    key = testVec[featIndex]
    valueOfFeat = secondDict[key]
    print '+++', firstStr, 'xxx', secondDict, '---', key, '>>>', valueOfFeat
    # 判断分枝是否结束: 判断valueOfFeat是否是dict类型
    if isinstance(valueOfFeat, dict):
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else:
        classLabel = valueOfFeat
    return classLabel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

使用算法：此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义。

项目案例2: 使用决策树预测隐形眼镜类型

项目概述

隐形眼镜类型包括硬材质、软材质以及不适合佩戴隐形眼镜。我们需要使用决策树预测患者需要佩戴的隐形眼镜类型。

开发流程

1. 收集数据: 提供的文本文件。
2. 解析数据: 解析 tab 键分隔的数据行
3. 分析数据: 快速检查数据，确保正确地解析数据内容，使用 createPlot() 函数绘制最终的树形图。
4. 训练算法: 使用 createTree() 函数。
5. 测试算法: 编写测试函数验证决策树可以正确分类给定的数据实例。
6. 使用算法: 存储树的数据结构，以便下次使用时无需重新构造树。

收集数据：提供的文本文件

文本文件数据格式如下：

young myope no reduced no lenses
pre myope no reduced no lenses
presbyopic myope no reduced no lenses

解析数据：解析 tab 键分隔的数据行

lecses = [inst.strip().split('\t') for inst in fr.readlines()]
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
1
2

分析数据：快速检查数据，确保正确地解析数据内容，使用 createPlot() 函数绘制最终的树形图。

>>> treePlotter.createPlot(lensesTree)
1

训练算法：使用 createTree() 函数

>>> lensesTree = trees.createTree(lenses, lensesLabels)
>>> lensesTree
{'tearRate': {'reduced': 'no lenses', 'normal': {'astigmatic':{'yes':
{'prescript':{'hyper':{'age':{'pre':'no lenses', 'presbyopic':
'no lenses', 'young':'hard'}}, 'myope':'hard'}}, 'no':{'age':{'pre':
'soft', 'presbyopic':{'prescript': {'hyper':'soft', 'myope':
'no lenses'}}, 'young':'soft'}}}}}
1
2
3
4
5
6
7

测试算法: 编写测试函数验证决策树可以正确分类给定的数据实例。

使用算法: 存储树的数据结构，以便下次使用时无需重新构造树。

使用pickle模块存储决策树

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

def grabTree(filename):
    import pickle
    fr = open(filename, 'rb')
    return pickle.load(fr)
1
2
3
4
5
6
7
8
9
10
'
运行
运行

ID3算法

ID3算法的核心是在决策树各个子节点上应用信息增益准则选择特征，递归的构建决策树，具体方法是:从根节点开始，对节点计算所有可能的特征的信息增益，选择信息增益最大的特征作为节点的特征，由该特征的不同取值建立子节点；再对子节点递归调用以上方法，构建决策树。

直到所有特征的信息增益均很小或没有特征可以选择为止。最后得到一个决策树。
例子：贷款申请样本数据表

根据贷款申请样本数据表，我们有15条样本记录，则样本容量为15。最终分为是否贷款2个类，其中是有9条记录，否有6条记录。有年龄、有工作、有自己的房子和信贷情况4个不同特征。每个特征有不同的取值，如年龄有老、中、青3种取值。
由熵的定义计算：

然后计算各特征对数据集D的信息增益。分别以A1，A2，A3，A4表示年龄、有工作、有自己的房子和信贷情况4个特征。

根据年龄有取值青年、中年、老年。
青年贷款是2条记录，否3条记录，共5条记录
中年贷款是3条记录，否2条记录，共5条记录
老年贷款是4条记录，否1条记录，共5条记录

由条件熵公式

年龄为已知条件的条件熵为

以年龄为条件的信息增益为

同理，有工作的信息增益为：

有房子的信息增益为：

信贷情况的信息增益为：

最后比较各特征的信息增益值，对于特征A3有自己房子的信息增益值最大，所以选择特征A3作为最优特征。

由于特征A3(有自己房子)的信息增益值最大，所以选择特征A3作为根节点的特征。它将训练数据集划分为两个子集D1(A3取值为是)和D2(A3取值为否)。由于D1只有同一类样本点，可以明确要贷款给D1，所以它成为一个叶节点，节点类标记为“是”。
对于D2则需要从特征A1(年龄)，A2(有工作)和A4(信贷情况)中选择新的特征。计算各个特征的信息增益:



选择信息增益最大的特征A2(有工作)作为节点特征。A2有2个取值，一个对应“是”(有工作)的子节点，包含3个样本，他们属于同一类，所以这是一个叶节点，类标记为“是”；另一个对应“否”(无工作)的子节点，包含6个样本，属于同一类，这也是一个叶节点，类标记为“否”。
换句话有15个贷款人，经过是否有房这一筛选条件，有房子的6个人能够贷款。剩余9个人需要进一步筛选，以是否有工作为筛选条件，有工作的3个人可以贷款，无工作的6个人不能够贷款。

该决策树只用了两个特征(有两个内部结点)，以有自己的房子作为首要判决条件，然后以有工作作为判决条件是否可以贷款。
ID3算法只有树的生成，所以该算法生成的树容易产生过拟合，分得太细，考虑条件太多。

缺点：1.用信息增益选择属性时偏向于选择分枝比较多的属性值，即取值多的属性。2.不能处理连续属性。

C4.5算法

C4.5算法是对ID3算法的改进，相对于ID3算法主要有以下几个改进：
（1）用信息增益比来选择属性
（2）在决策树的构造过程中对树进行剪枝
（3）对非离散数据也能处理
（4）能够对不完整数据进行处理
以下例子以ID3的过程为主，穿插着增添了C4.5的特性：

假如我家办了电信的宽带，有一天宽带不能上网了，于是我打电话给电信报修，然后电信派相关人员进行维修，修好以后电信的回访专员询问我对这次修理障碍的过程是否满意，我会给我对这次修理障碍给出相应评价，满意或者不满意。根据历史数据可以建立满意度预警模型，建模的目的就是为了预测哪些用户会给出不满意的评价。目标变量为二分类变量：满意（记为0）和不满意（记为1）。自变量为根据修理障碍过程产生的数据，如障碍类型、障碍原因、修障总时长、最近一个月发生故障的次数、最近一个月不满意次数等等。简单的数据如下：

客户ID    故障原因    故障类型    修障时长       满意度
001          1          5         10.2           1
002    		 1  	    5  		   12   		 0
003  		 1          5          14            1
004          2          5          16            0
005          2          5          18            1
006          2          6          20            0
007          3          6          22            1
008          3          6          23            0
009          3          6          24            1
010          3          6          25            0
1
2
3
4
5
6
7
8
9
10
11

故障原因和故障类型都为离散型变量，数字代表原因ID和类型ID。修障时长为连续型变量，单位为小时。满意度中1为不满意、0为满意。

下面沿着分裂属性的选择和树剪枝两条主线，去描述三种决策树算法构造满意度预警模型：
分裂属性的选择：即该选择故障原因、故障类型、修障时长三个变量中的哪个作为决策树的第一个分支。
ID3算法是采用信息增益来选择树叉，c4.5算法采用增益率，CART算法采用Gini指标。此外离散型变量和连续型变量在计算信息增益、增益率、Gini指标时会有些区别。详细描述如下：
1.ID3算法的信息增益：
信息增益的思想来源于信息论的香农定理，ID3算法选择具有最高信息增益的自变量作为当前的树叉（树的分支），以满意度预警模型为例，模型有三个自变量：故障原因、故障类型、修障时长。分别计算三个自变量的信息增益，选取其中最大的信息增益作为树叉。信息增益=原信息需求-要按某个自变量划分所需要的信息。
如以自变量故障原因举例，故障原因的信息增益=原信息需求（即仅仅基于满意度类别比例的信息需求，记为a）-按照故障原因划分所需要的信息需求（记为a1）。
其中原信息需求a的计算方式为:

其中D为目标变量，此例中为满意度。m=2，即满意和不满意两种情况。Pi为满意度中属于分别属于满意和不满意的概率。此例中共计10条数据，满意5条，不满意5条。概率都为1/2。Info（满意度）即为仅仅基于满意和满意的类别比例进行划分所需要的信息需求，计算方式为：

按照故障原因划分所需要的信息需求（记为a1）可以表示为：

其中A表示目标变量D（即满意度）中按自变量A划分所需要的信息，即按故障类型进行划分所需要的信息。V表示在目标变量D（即满意度）中，按照自变量A（此处为故障原因）进行划分，即故障原因分别为1、2、3进行划分，将目标变量分别划分为3个子集，{D1、D2、D3}，因此V=3。即故障原因为1的划分中，有2个不满意和1个满意。D1即指2个不满意和1个满意。故障原因为2的划分中，有1个不满意和2个满意。D2即指1个不满意和2个满意。故障原因为3的划分中，有2个不满意和2个满意。D3即指2个不满意和2个满意。具体公式如下：

因此变量故障原因的信息增益Gain(故障原因)=Info(满意度)- Info故障原因（满意度）=1-0.165=0.835
同样的道理，变量故障类型的信息增益计算方式如下：


故障原因和故障类型两个变量都是离散型变量，按上述方式即可求得信息增益，但修障时长为连续型变量，对于连续型变量该怎样计算信息增益呢？
（此处的方法来自于C4.5）

只需将连续型变量由小到大递增排序，取相邻两个值的中点作为分裂点，然后按照离散型变量计算信息增益的方法计算信息增益，取其中最大的信息增益作为最终的分裂点。如求修障时长的信息增益，首先将修障时长递增排序，即10.2、12、14、16、18、20、22、23、24、25,取相邻两个值的中点，如10.2和12，中点即为（10.2+12）/2=11.1,同理可得其他中点，分别为11.1、13、15、17、19、21、22.5、23.5、24.5。对每个中点都离散化成两个子集，如中点11.1，可以离散化为两个<=11.1和>11.1两个子集，然后按照离散型变量的信息增益计算方式计算其信息增益，如中点11.1的信息增益计算过程如下：


中点11.1的信息增益Gain(修障时长)=1-1=0
同理分别求得各个中点的信息增益，选取其中最大的信息增益作为分裂点，如取中点11.1。然后与故障原因和故障类型的信息增益相比较，取最大的信息增益作为第一个树叉的分支，此例中选取了故障原因作为第一个分叉。按照同样的方式继续构造树的分支。
总之，信息增益的直观解释为选取按某个自变量划分所需要的期望信息，该期望信息越小，划分的纯度越高。因为对于某个分类问题而言，Info(D)都是固定的，而信息增益Gain(A)=Info(D)-InfoA(D) 影响信息增益的关键因素为：-InfoA(D)，即按自变量A进行划分，所需要的期望信息越小，整体的信息增益越大，越能将分类变量区分出来。

由于信息增益选择分裂属性的方式会倾向于选择具有大量值的属性（即自变量），如对于客户ID，每个客户ID对应一个满意度，即按此变量划分每个划分都是纯的（即完全的划分，只有属于一个类别），客户ID的信息增益为最大值1。但这种按该自变量的每个值进行分类的方式是没有任何意义的。为了克服这一弊端，有人提出了采用增益率（GainRate）来选择分裂属性。计算方式如下：

其中Gain(A)的计算方式与ID3算法中的信息增益计算方式相同。
以故障原因为例：

=1.201
Gain(故障原因)=0.835（前文已求得）
GainRate故障原因（满意度）=1.201/0.835=1.438
同理可以求得其他自变量的增益率。
选取最大的信息增益率作为分裂属性。

CART算法

参考资源 :
决策树算法介绍
机器学习决策树