Python决策树分支图 python决策树模型

1. 引言

    决策树（decision tree）是一种基本的分类和回归方法，由于其采用的是一种树形的结构，因此，具有很强的解释性和计算速度，也正是因为这些特点，使得决策树在很多行业都得到了应用，比如风控行业等。决策树的建模过程一般分为三个步骤：特征选择、决策树的生成和决策树的剪枝，根据这三个步骤所采用的规则，衍生出了很多不同的模型，比较经典的有Quinlan在1986年提出的ID3算法和1993年提出的C4.5算法，以及Breiman等人在1984年提出的CART算法，本文将以分类决策树为例，对这几个算法分别进行介绍，并用python进行实现。

2. 常用决策树模型介绍

2.1 决策树的定义

    决策树是由结点和有向边组成的树形结构，其中，结点包含两种类型：内部结点和叶结点。内部结点表示一个特征或者属性，叶结点则表示一个类。如下图所示，其中每个圆圈表示内部结点，每个正方形表示叶结点。

    对于给定的训练数据集$D=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\}$，其中，$x_{i}=\left(x_{i}^{(1)}, x_{i}^{(2)}, \cdots, x_{i}^{(n)}\right)^{\mathrm{T}}$表示输入的特征向量，$n$为特征的个数，$y_{i} \in\{1,2, \cdots, K\}$为类别标记，$K$表示类别的个数，$N$表示训练集的大小。决策树的思想大致如下：

1. 首先，构建根结点，然后将整个训练集都放在根结点。
2. 接着，从所有特征中选择一个最优特征，并根据该特征将训练数据集分割为多个子集，使得每一个子集有一个当前条件下的最好分类，如果某个子集已经基本分类正确，则将其作为叶结点，其对应的类别作为该叶结点的类别，否则，对每个子集继续选择最优的特征进行分割，如此递归下去，直到所有的子集基本被正确分类为止。最后，每个叶结点都代表一个子集，也是特征空间中的一个子区域，每个子区域之间都是不相交的。
3. 最后，由于第二步为了将训练集划分正确，往往构建的决策树会过于庞大，这时，模型可能会出现过拟合，导致对新的测试数据可能分类效果不好，因此，需要对决策树自下而上进行剪枝，去掉一些过于细分的叶结点，使其回退到父结点或者更高的结点，然后将父结点或者更高的结点作为新的叶结点。

$x$进行预测时，会根据决策树的分支情况，将实例$x$划分到其归属的叶结点，并将该叶结点对应的类别作为实例$x$的预测类别，从而达到分类的效果。下面，我们将根据决策树的三个步骤，对各个算法的思想进行介绍和对比。

2.2 ID3算法

适用场景：特征和目标变量都是离散型

2.2.1 特征选择——信息增益

    特征选择是指决策树在每一次分支时，从所有的特征中选择能够对当前数据集具有最优分类能力的特征，这样可以提高模型的学习效率。ID3决策树的特征选择采用的是信息增益的方法。在介绍信息增益的概念之前，需要先介绍一下熵和条件熵的概念。

$X$是一个取有限个值的离散随机变量，则其熵的计算公式如下：
$H(X)=-\sum_{i=1}^{n} p_{i} \log p_{i}$其中，$p_{i}=P\left(X=x_{i}\right), \quad i=1,2, \cdots, n$表示$X$取某个类别时的概率，当$p_{i}=0$时，定义$0 \log 0=0$，由于熵只依赖于$X$的分布，因此，也可以将$X$的熵记作$H(p)$，即
$H(p)=-\sum_{i=1}^{n} p_{i} \log p_{i}$从熵的计算公式可以发现，当随机变量的不确定性越大时，熵的值会越大，其取值范围为：
$0 \leqslant H(p) \leqslant \log n$

$X$的条件下随机变量$Y$的不确定性，其计算公式如下：
$H(Y | X)=\sum_{i=1}^{n} p_{i} H\left(Y | X=x_{i}\right)$其中，$p_{i}=P\left(X=x_{i}\right), \quad i=1,2, \cdots, n$。

$X$的信息而使得类$Y$的信息的不确定性减少的程度。其计算公式如下：
$g(Y, X)=H(Y)-H(Y | X)$当信息增益越大时，表示给定$X$后，对$Y$进行分类后的不确定性越低，也就是说$X$对$Y$的分类能力越强。因此，ID3在每一次分支时，采用信息增益作为每个结点特征选择的规则。

2.2.2 ID3决策树的构造

    ID3算法构造决策树的思想大致如下：首先从根结点开始，对结点，对结点计算所有可能特征的信息增益，选择信息增益最大的特征作为结点的特征，由该特征的不同取值建立子结点，再对子结点递归地调用以上方法，构建决策树，直到所有特征的信息增益均很小或没有特征可以选择为止，最终得到一个决策树。其具体的算法步骤如下：

1. 给定训练数据集$D$，特征集$A$，阈值$\varepsilon$;
2. 若$D$中所有实例属于同一类$C_k$，则T为单结点树，并将类$C_k$作为该结点的类标记，返回决策树$T$;
3. 若$A=\varnothing$，则$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回决策树$T$；
4. 否则，计算$A$中各特征对$D$的信息增益，选择信息增益最大的特征$A_g$；
5. 如果$A_g$的信息增益小于阈值$\varepsilon$，则$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回决策树$T$;
6. 否则，对$A_g$的每一可能值$a_i$，依$A_{g}=a_{i}$将$D$分割为若干非空子集$D_i$，将$D_i$中实例数最大的类作为标记，构建子结点，由结点及其子结点构成树$T$，返回$T$；
7. 对第$i$个子结点，以$D_i$为训练集，以$A-{A_g}$为特征集，递归地调用2~6步，得到子树$T_i$，返回$T_i$。

以上就是ID3决策树的构造过程，但是该过程构建的决策树往往会出现过拟合，因此，需要对树进行剪枝。

2.2.3 ID3决策树的剪枝

$T$的$|T|$，$t$是树$T$的某个叶结点，该叶结点有$N_t$个样本点，其中$k$类的样本点有$N_{tk}$个，$k=1,2, \cdots, K$，$H_{t}(T)$为叶结点$t$上的经验熵，\alpha \geqslant 0为惩罚参数，则决策树的损失函数可以定义为：
$C_{\alpha}(T)=\sum_{t=1}^{|T|} N_{t} H_{t}(T)+\alpha|T|$其中，经验熵为：
$H_{t}(T)=-\sum_{k} \frac{N_{t k}}{N_{t}} \log \frac{N_{t k}}{N_{t}}$将损失函数中的第一项记作：
$C(T)=\sum_{i=1}^{|T|} N_{t} H_{t}(T)=-\sum_{t=1}^{|T|} \sum_{k=1}^{K} N_{t k} \log \frac{N_{t k}}{N_{t}}$则损失函数可以表达为：
$C_{\alpha}(T)=C(T)+\alpha|T|$其中，$C(T)$表示模型对训练数据的预测误差，即模型对训练数据的拟合程度，$|T|$表示模型的复杂度，参数$\alpha$则表示惩罚参数，当$\alpha$越大时，则会选择越简单的树，反之，则选择较复杂的树。可以看出，决策树的剪枝不仅考虑模型的拟合程度，还考虑模型的复杂度，因此，相比决策树的构造过程，决策树的剪枝过程是一个全局优化的过程。决策树的剪枝步骤具体如下：

1. 给定ID3算法生成的决策树$T$，参数$\alpha$;
2. 递归地从树的叶结点向上回缩，设一组叶结点回缩到其父结点之前与之后的整体树分别为$T_B$与$T_A$，其对应的损失函数值分别为$C_{\alpha}\left(T_{B}\right)$与$C_{\alpha}\left(T_{A}\right)$，如果$C_{\alpha}\left(T_{A}\right) \leqslant C_{\alpha}\left(T_{B}\right)$，则进行剪枝，将其父结点变为新的叶结点。
3. 重复步骤2，直到不能继续为止，此时得到损失函数最小的子树$T_{\alpha}$。

以上就是关于ID3算法的整个过程，下面介绍一个与ID3算法非常接近的决策树算法，即C4.5。

2.3 C4.5算法

适用场景：特征和目标变量都是离散型

2.3.1 特征选择——信息增益比

    ID3选择的信息增益是一个绝对值的概念，对于不同的数据集，信息增益值往往不一样，对于分类问题困难时，其经验熵比较大，对应的信息增益值也会比较大，反之则比较小，因此，为了克服这个问题，C4.5对ID3算法的特征选择准则进行了改进。C4.5选取的特征选择准则是信息增益比，其定义就是将信息增益$g(D, A)$与训练数据集$D$的经验熵$H(D)$之比，其计算公式如下：
$g_{R}(D, A)=\frac{g(D, A)}{H(D)}$

2.3.2 C4.5决策树的构造

     C4.5算法构造决策树的过程与ID3类似，只是将特征选择准则改为信息增益比，其他的都是一样的。

1. 给定训练数据集$D$，特征集$A$，阈值$\varepsilon$;
2. 若$D$中所有实例属于同一类$C_k$，则T为单结点树，并将类$C_k$作为该结点的类标记，返回决策树$T$;
3. 若$A=\varnothing$，则$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回决策树$T$；
4. 否则，计算$A$中各特征对$D$的信息增益比，选择信息增益比最大的特征$A_g$；
5. 如果$A_g$的信息增益比小于阈值$\varepsilon$，则$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回决策树$T$;
6. 否则，对$A_g$的每一可能值$a_i$，依$A_{g}=a_{i}$将$D$分割为若干非空子集$D_i$，将$D_i$中实例数最大的类作为标记，构建子结点，由结点及其子结点构成树$T$，返回$T$；
7. 对第$i$个子结点，以$D_i$为训练集，以$A-{A_g}$为特征集，递归地调用2~6步，得到子树$T_i$，返回$T_i$。

2.3.3 C4.5决策树的剪枝

    C4.5决策树的剪枝与ID3算法的一样，这里不再具体赘述。

2.4 CART算法

适用场景：支持数值型和离散型变量，支持分类和回归问题

2.4.1 特征选择——MSE或基尼指数

$K$个类，样本点属于第$k$类的概率为$p_{k}$，则概率分布的基尼指数的定义为：
$\operatorname{Gini}(p)=\sum_{k=1}^{K} p_{k}\left(1-p_{k}\right)=1-\sum_{k=1}^{K} p_{k}^{2}$如果样本集合$D$根据特征$A$是否取某一可能值$a$被分割成$D_1$和$D_2$两部分，即：
$D_{1}=\{(x, y) \in D | A(x)=a\}, \quad D_{2}=D-D_{1}$则在特征$A$的条件下，集合$D$的基尼指数定义为：
$\operatorname{Gini}(D, A)=\frac{\left|D_{1}\right|}{|D|} \operatorname{Gini}\left(D_{1}\right)+\frac{\left|D_{2}\right|}{|D|} \operatorname{Gini}\left(D_{2}\right)$当基尼指数越大时，表示数据的不确定性越大，因此，CART分类树每次分支时，选择当前基尼指数$\operatorname{Gini}(D, A)$最小的特征作为当前结点的特征选择。

2.4.2 CART决策树的构造

    (一) 回归树的构造

$X$与$Y$分别为输入和输出变量，并且$Y$是连续变量，给定训练数据集：
$D=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\}$则回归树在每次分支时，会依次从特征集中选择第$j$个变量$x^{(j)}$和它取的值$s$，作为切分变量和切分点，并定义两个区域：
$R_{1}(j, s)=\left\{x | x^{(j)} \leqslant s\right\} \\ R_{2}(j, s)=\left\{x | x^{(j)}>s\right\}$然后计算两个区域中$Y$的均值分别作为两个区域的预测值$c_1$和$c_2$，接着，计算两个区域的平方误差和，并从中选择可以平方误差和最小的变量和切分点作为当前的最优切分变量$j$和最优切分点$s$，具体地，求解：
$\min_{j,s}[\min _{c_{1}} \sum_{x_{i} \in R_{1}(j, s)}\left(y_{i}-c_{1}\right)^{2}+\min _{c_{2}} \sum_{x_{i} \in R_{2}(j, s)}\left(y_{i}-c_{2}\right)^{2}]$重复以上划分过程，直到满足停止条件为止，这样便形成了一棵回归树，这样的回归树通常称为最小二乘回归树。具体的算法步骤如下：

1. 输入训练数据集$D$;
2. 遍历变量$j$，求解：
   $\min_{j,s}[\min _{c_{1}} \sum_{x_{i} \in R_{1}(j, s)}\left(y_{i}-c_{1}\right)^{2}+\min _{c_{2}} \sum_{x_{i} \in R_{2}(j, s)}\left(y_{i}-c_{2}\right)^{2}]$确定使得上式达到最小值的最优切分变量$j$和最优切分点$s$；
3. 用选定的最小值对$(j, s)$划分区域并决定相应的输出值：
4. 继续对两个子区域调用步骤2、3，直至满足停止条件；
5. 将输入空间h划分为$M$区域$R_{1}, R_{2}, \cdots, R_{M}$，生成决策树：
   $f(x)=\sum_{m=1}^{M} \hat{c}_{m} I\left(x \in R_{m}\right)$

    (二) 分类树的构造

    分类树则采用基尼指数选择最优特征，其算法步骤如下：

1. 输入训练数据集D；
2. 从根结点开始，计算现有特征$A$取每个可能值$a$时的基尼指数：
   $\operatorname{Gini}(D, A)=\frac{\left|D_{1}\right|}{|D|} \operatorname{Gini}\left(D_{1}\right)+\frac{\left|D_{2}\right|}{|D|} \operatorname{Gini}\left(D_{2}\right)$
3. 选择基尼指数最小的特征及其对应的切分点作为最优特征和最优切分点，依最优特征和最优切分点，从现结点生成两个子结点，将训练集依特征分配到两个子结点中去；
4. 对两个子结点递归地调用步骤2、3，直至满足停止条件为止；
5. 生成CART决策树。

2.4.3 CART决策树的剪枝

$T_0$底端开始不断剪枝，直到$T_0$的根结点，形成一个子树序列$\left\{T_{0}, T_{1}, \cdots, T_{n}\right\}$；接着，通过交叉验证法在独立验证集上对子树序列进行测试，从中选择最优子树。

    从前面ID3算法我们可以知道，剪枝时的损失函数不仅考虑决策树对训练集的拟合程度，还考虑模型的复杂度，具体的公式如下：
$C_{\alpha}(T)=C(T)+\alpha|T|$CART首先从整体树$T_0$开始剪枝，对$T_0$的任意内部结点$t$，以t为单结点树的损失函数是：
$C_{\alpha}(t)=C(t)+\alpha$以$t$为根结点的子树$T_t$的损失函数是：
$C_{\alpha}\left(T_{t}\right)=C\left(T_{t}\right)+\alpha\left|T_{t}\right|$当$C_{\alpha}\left(T_{t}\right)=C_{\alpha}(t)$时，即$\alpha=\frac{C(t)-C\left(T_{t}\right)}{\left|T_{t}\right|-1}$时，$T_{t}$与$t$有相同的损失函数值，而$t$的结点少，因此$t$比$T_t$更可取，对$T_t$进行剪枝。

$T_0$中每一内部结点$t$，计算：
$g(t)=\frac{C(t)-C\left(T_{t}\right)}{\left|T_{t}\right|-1}$在$T_0$中减去$g(t)$最小的$T_t$，将得到的子树作为$T_1$，同时将最小的$g(t)$设为$\alpha_1$，$T_1$为区间$\left[\alpha_{1}, \alpha_{2}\right)$的最优子树，如此剪枝下去，直至根结点，在这一过程中，不断地增加$\alpha$值，产生新的区间。
    最后，利用独立的验证数据集，测试子树序列$T_{0}, T_{1}, \cdots, T_{n}$中各棵子树的平方误差或基尼指数，平方误差或基尼指数最小的子树即为最优的决策树，其所在的$\alpha$区间即为最终$\alpha$的取值。具体的剪枝算法步骤如下：

1. 给定CART算法生成的决策树$T_0$，初始化k=0，$\alpha=+\infty$
2. 自下而上地对各内部结点$t$计算$C\left(T_{t}\right)$，$\left|T_{t}\right|$以及$\begin{array}{c}{g(t)=\frac{C(t)-C\left(T_{t}\right)}{\left|T_{t}\right|-1}} \\ {\alpha=\min (\alpha, g(t))}\end{array}$其中，$T_{t}$表示以$t$为根结点的子树，$C(T_t)$为对训练数据的预测误差，$\left|T_{t}\right|$为$T_{t}$叶结点个数。
3. 自上而下地访问内部结点$t$，如果有$g(t)=\alpha$，则进行剪枝，并对叶结点$t$以多数表决法决定其类，得到树$T$；
4. 设$k=k+1, \quad \alpha_{k}=\alpha, \quad T_{k}=T$
5. 如果$T$不是由根结点单独构成的树，则回到步骤2
6. 采用交叉验证法在子树序列$T_{0}, T_{1}, \cdots, T_{n}$中选取最优子树$T_\alpha$

3. 常用决策树模型的python实现

    python中sklearn主要支持的是CART决策树，因为CART可适用的场景更广，不过，特征选择的准则sklearn也提供了两种选择，一种是“entropy”，对应本文介绍的信息增益，另一种是“gini”，对应本文的基尼指数，本文直接继承了sklearn.tree中的DecisionTreeClassifier，增加了对决策树的绘制函数，python绘制决策树需要安装graphviz，安装后如果出现中文乱码的话，可以参考这篇文章《graphviz Windows中文乱码》。具体的代码如下：

import os
from sklearn.tree import DecisionTreeClassifier, export_graphviz


class DecisionTreeClassifier(DecisionTreeClassifier):
    def draw_tree(self, model, feature_names, save_path):
        """
        绘制决策树
        :param model: 决策树模型
        :param feature_names: 结点名称. [list]
        :param save_path: 文件保存路径
        :return:
        """
        # 生成决策树的路径dot文件，保存到save_path
        export_graphviz(model, out_file=save_path,
                        feature_names=feature_names,
                        filled=True, rounded=True,
                        special_characters=True)

        # 替换dot文件中的字体为Microsoft YaHei,以防止中文乱码
        with open(save_path, 'r', encoding='utf-8') as f:
            dot_data = f.read()

        dot_data = dot_data.replace('fontname=helvetica', 'fontname="Microsoft YaHei"')

        with open(save_path, 'w', encoding='utf-8') as f:
            f.write(dot_data)

        # 生成决策树图像，格式默认为png格式
        os.system('dot -Tpng {0} -o {1}'.format(save_path, save_path.replace('dot', 'png')))

    绘制的决策树图形大致如下：

具体的项目代码还是参考本人的github地址：

• github地址：https://github.com/lch123456/machine-learning

4. 总结

    决策树由于其解释性强，计算速度快，非线性能力强，在一些对模型解释性强的行业得到了很多的应用，比如风控行业。另外，由于特征选择、决策树生成和决策树剪枝的不同，决策树衍生出了很多的算法，每个算法都有其对应的优缺点，因此，在使用时需要加以鉴别，比如ID3算法，由于不是二叉树的形式，因此该算法往往更倾向于选择类别多的特征。