第 8 章决策树 on 《从零学AI指南手册》

8.1 决策树的基本思想

Mon, 01 Jan 0001 00:00:00 +0000

经过前面几章的介绍，我们已经介绍过了3个分类算法模型，包括逻辑回归、K近邻和朴素贝叶斯。接下来我们将介绍下一个分类算法模型——决策树（Decision Tree）。整个第8章的学习路线如图8-1所示，首先我们将介绍决策树的基本思想和它的可视化过程，然后介绍ID3和C4.5这两种经典的决策树生成算法及其剪枝过程的原理，最后再来介绍如何从零实现决策树算法。

图 8-1 决策树算法学习路线图

8.1 决策树的基本思想#

8.1.1 冠军球队#

一说到决策树其实很多读者或多或少已经使用过，只是自己还不知道。例如最简单的决策树就是通过输入年龄，判读其是否为成年人，即if age >= 18 return True，想想自己是不是经常用到这样的语句。关于什么是决策树这里先来看一个例子。

假如我们错过了某次世界杯比赛，赛后我们问一个知道比赛结果的人“哪支球队获得了冠军”？但是对方并不愿意直接说出结果，而是让我们自己猜，且每猜一次对方都要收一元钱才肯告诉我们是否猜对了。现在的问题是要掏多少钱才能知道哪支球队是冠军球队呢？

现在我们可以把球队从1到16编上号，然后提问： “冠军球队在1~8号中吗？”。假如对方告诉我们猜对了，我们就会接着问： “冠军球队在1~4号中吗？”。假如对方告诉我们猜错了，那么我们也就自然知道冠军球队在5~8号中。这样只需4次就能知道哪支球队获得了冠军。上述过程背后所隐藏着的其实就是决策树的基本思想，并且还可以用更为直观的图来展示上述过程，如图8-2所示。

图 8-2 决策树思想示意图

由此可以得出，决策树的每一步决策过程就是降低信息不确定性的过程，甚至还可以将这些决策看成一个if then的规则集合。如图8-2所示，冠军球队一开始有16种可能性，经过一次决策后变成了8种。这意味着每次决策都可以得到更多确定的信息，而减少更多的不确定性。

不过现在的问题是，为什么要像图8-2这样来划分球队呢？对于熟悉足球的读者来讲，这样的决策树似乎略显多余。因为事实上只有少数几支球队才有夺冠的希望，而大多数球队是没有希望的，因此，一种改进做法是在一开始的时候就将几个热门的可能夺冠的球队分在一边，将剩余的球队放在另一边，这样就可以大大提高整个决策过程的效率。

例如最有可能夺冠的是1、2、3、4这4支球队，而其余球队夺冠的可能性远远小于这4支球队。那么一开始就可以将球队分成1~4和5~16。如果冠军是在1~4中，则后面很快就能知道哪支球队是冠军。退一步将，假如冠军真的在5~16中，那么接下来同样可以按照类似的思路将剩余的球队划分成最有可能夺冠和最不可能夺冠两部分，这样也能快速地找出哪支球队是冠军球队。

于是这时候可以发现，如何划分球队就变成了建立这棵决策树的关键。如果存在一种划分，能够使数据的“不确定性”减少得越多（哪支球队不可能夺冠），也就意味着该划分能获取更多的信息，而我们也就更倾向于采取这样的划分方式。因此采用不同的划分就会得到不同的决策树，所以现在的问题就变成了如何构建一棵“好”的决策树呢？要想回答这个问题，先来解决如何描述“信息”这个问题。

8.1.2 信息的度量#

关于如何定量地来描述信息，几千年来都没有人给出很好的解答。直到1948年，香农在他著名的论文《通信的数学原理》中提出了信息熵（Information Entropy）的概念，这才解决了信息的度量问题，并且还量化出信息的作用。

1. 信息熵

一条信息的信息量与其不确定性有着直接的关系。例如，要搞清楚一件非常不确定的事，就需要了解大量的信息。相反，如果已经对某件事了解较多，则不需要太多的信息就能把它搞清楚，所以从这个角度来看可以认为，信息量就等于不确定性的多少。我们经常说，一句话包含多少信息，其实就是指它不确定性的多与少[1]。

于是，上面8.1.1节中第1种划分方式的不确定性（信息量）就等于“4块钱”，因为我们花4块钱就可以解决这个不确定性问题。当然，香农用的不是钱，而是用比特（Bit）这个概念来度量信息量，1字节就是8比特。在上面的第1种情况中，“哪支球队是冠军”这条消息的信息量就是4比特。4比特是怎么计算出来的呢？第2种情况的信息量又是多少呢？

香农指出，它的准确信息量应该是

$$ H=-({{p}_{1}}\cdot \log {{p}_{1}}+{{p}_{2}}\cdot \log {{p}_{2}}+\cdots +{{p}_{16}}\cdot \log {{p}_{16}})\tag{8-1} $$

其中$\log$表示以2为底的对数，$p_1,p_2,...,p_{16}$分别是这16支球队夺冠的概率。香农把式(8-1)的结果称为信息熵（Entropy），一般用符号$H$表示，单位是比特。由于在第1种情况中，默认条件是16支球队夺冠概率相同，因此对应的信息熵就是4比特 [2]。

对于任意一个随机变量$X$（例如获得冠军的球队），它的熵定义如下：

$$ H(X)=-\sum\limits_{x\in X}{P}(x)\log P(x)\tag{8-2} $$

其中$\log$表示以2为底的对数。

例如在二分类问题中：设$P(y=0)=p,P(y=1)=1-p,\;0\leq p\leq1$，那么此时的信息熵$H(y)$即为

$$ H(y)=-(p\log p+(1-p)\log (1-p))\tag{8-3} $$

根据式(8-3)还能画出其对应的函数图形，如图8-3所示。

图 8-3 二分类中的信息熵

从图8-3可以发现，当两种情况发生的概率均等（$p=1-p=0.5$）时信息熵最大，也就是说此时的不确定性最大，要把这件事搞清楚所需要的信息量也就越大，并且这也很符合我们的常识，例如“明天下雨和不下雨的概率都是50%”，那么这一描述所存在的不确定性是最大的。

2. 条件熵

8.2 决策树建模与可视化

Mon, 01 Jan 0001 00:00:00 +0000

8.2 决策树建模与可视化#

在清楚决策树算法背后的思想以后，我们再来看如何利用sklearn进行建模并对构建完成的决策树可视化。下面依旧以前面介绍的iris数据集为例来进行建模，以下完整示例代码可参见 AllBooKCode/Chapter08/C02_decision_tree_gini.py 文件。

8.2.1 ID3 算法示例代码#

在sklearn中可以通过sklearn.tree下的DecisionTreeClassifier类模块来完成整个决策树算法的建模。下面，我们首先来对类DecisionTreeClassifier中的几个常用参数进行简单介绍，详细原理将在下一节内容中进行介绍，示例代码如下：

1 def __init__(self, criterion="gini", splitter="best", max_depth=None,
2     min_samples_split=2, min_samples_leaf=1, max_features=None,
3     min_impurity_split=None):

在上述代码中，第1行criterion用来选择划分时的度量标准，当criterion取值为"entropy"或"gini"时分别表示使用信息增益或基尼不纯度作为划分指标； splitter用来选择节点划分时的特征选择策略，当splitter="best"时，则每次节点进行划分时均在所有特征中通过度量标准来选择最优划分方式，而当splitter="random"时，则每次节点进行划分时只会随机地选择max_features个特征，并在这些特征上选择最优的划分方式； max_depth表示决策树的最大深度，默认为None表示直到所有叶子节点的样本均为同一类别或者样本数小于min_samples_split时停止划分。第2行min_samples_leaf用来指定构成一个叶子节点所需要的最少样本数，即如果划分后叶子节点中的样本数小于该阈值，则不会进行划分； min_impurity_split用来提前停止节点划分的阈值，默认为None，即无阈值。

1. 载入数据集

在介绍完类DecisionTreeClassifier的基本用法后，便可以通过其来完成决策树的生成。首先需要载入训练模型时所用到的数据集，同时为了后续更好地观察可视化后的决策树，这里也要返回各个特征的名称，代码如下：

1 def load_data():
2     data = load_iris()
3     X, y = data.data, data.target
4     feature_names = data.feature_names
5     X_train, X_test, y_train, y_test = \
6         train_test_split(X, y, test_size=0.3, random_state=42)
7     return X_train, X_test, y_train, y_test, feature_names

在上述代码中，第4行代码便是得到特征维度的名称，其结果为

['sepal length(cm)','sepal width(cm)','petal length (cm)','petal width (cm)']

2. 训练模型

在完成数据载入后，便可通过类DecisionTreeClassifier来完成决策树的生成。这里除了指定划分标准为'entropy'之外（使用ID3算法），其他参数保持默认即可，示例代码如下：

1 def train(X_train, X_test, y_train, y_test, feature_names):
2     model = tree.DecisionTreeClassifier(criterion='entropy')
3     model.fit(X_train, y_train)
4     print("在测试集上的准确率为：",model.score(X_test, y_test))

训练完成后，可以得到模型在测试集上的准确率为

8.3 决策树生成之ID3与C4.5

Mon, 01 Jan 0001 00:00:00 +0000

8.3 决策树生成之ID3与C4.5#

在正式介绍决策树的生成算法前，我们先将8.1.1节中介绍的几个概念重新梳理一下，同时再通过一个例子来理解整个计算过程，以便于后续更好地掌握决策树的生成算法。

8.3.1 基本概念与定义#

1. 信息熵

设$X$是一个取值有限的离散型随机变量（例如8.1.1节中可能夺冠的16支球队），其概率分布为$P(X=x_i)=p_i,i=1,2,...,n$（每支球队可能夺冠的概率），则随机变量$X$的信息熵定义为

$$ H(X)=-\sum\limits_{i=1}^{n}{{{p}_{i}}}\log {{p}_{i}}\tag{8-5} $$

其中，若$p_i=0$，定义$0\log_20=0$，并且通常$\log$取$2$为底或$e$为底时，其熵的单位分别称为比特（Bit）或纳特（Nat）。如无特殊说明，默认以$2$为底。

2. 条件熵

设有随机变量$(X,Y)$，其联合概率分布$P(X={{x}_{i}},Y={{y}_{j}})={{p}_{ij}}$，其中$i=1,2,...,n，j=1,2,...,m$，条件熵$H(Y|X)$表示在已知随机变量$X$的条件下，随机变量$Y$的不确定性，其定义为

$$ H(Y|X)=\sum\limits_{i=1}^{n}{{{p}_{i}}}H(Y|X={{x}_{i}})\tag{8-6} $$

其中，$p_i=P(X=x_i),i=1,2,...,n$。

同时，当信息熵和条件熵中的概率由样本数据估计（特别是极大似然估计）得到时，所对应的信息熵与条件熵分别称为经验熵（Empirical Entropy）和经验条件熵（Empirical Conditional Entropy）。这里暂时看不懂也没关系，可结合后续计算示例来理解。

3. 信息增益

根据8.1.1节的内容可知，所谓信息增益指的就是事物$U$的信息熵$H(U)$，在引入外部信息$I$以后后的变化量为$H(U)-H(U|I)$，因此，可以将特征$A$对训练数据集$D$的信息增益$g(D,A)$定义为集合$D$的信息熵$H(D)$与在给定特征$A$下$D$的条件熵$H(D|A)$之差，即

$$ g(D,A)=H(D)-H(D|A)\tag{8-7} $$

设训练集为$D$，$|D|$表示所有训练样本总数，同时$D$有$K$个类别$C_k,k=1,2,...,K$。$|C_k|$为属于类$C_k$的样本总数，即$\sum\nolimits_{k=1}^{K}{|{{C}_{k}}|}=|D|$ 。设特征$A$有$n$个不同的取值$a_1,a_2,...,a_n$，根据特征$A$的取值将$D$划分为$n$个子集$D_1,D_2,...,D_n$，$|D_i|$为子集$D_i$中的样本个数，即$\sum\nolimits_{i=1}^{n}{|{{D}_{i}}|=|D|}$。同时此子集$D_i$中，属于类$C_k$的样本集合为$D_{ik}$，即${{D}_{ik}}={{D}_{i}}\bigcap {{C}_{k}}$，$|D_{ik}|$为$D_{ik}$的样本个数。此时有如下定义[2]

(1) 数据集$D$的经验熵$H(D)$为

$$ H(D)=-\sum\limits_{k=1}^{K}{\frac{|{{C}_{k}}|}{|D|}}{{\log }_{2}}\frac{|{{C}_{k}}|}{|D|}\tag{8-8} $$

从式(8-8)可以看出，它计算的是“任意样本属于其中一个类别”这句话所包含的信息量。

(2) 数据集$D$在特征值$A$下的经验条件熵$H(D|A)$为

$$ H(D|A)=\sum\limits_{i=1}^{n}{\frac{|{{D}_{i}}|}{|D|}}H({{D}_{i}})=-\sum\limits_{i=1}^{n}{\frac{|{{D}_{i}}|}{|D|}}\sum\limits_{k=1}^{K}{\frac{|{{D}_{ik}}|}{|{{D}_{i}}|}}{{\log }_{2}}\frac{|{{D}_{ik}}|}{|{D}_{i}|}\tag{8-9} $$

从式(8-9)可以看出，它计算的是特征$A$在各个取值条件下“任意样本属于其中一个类别”这句话所包含的信息量。

(3) 信息增益为

$$ g(D,A)=H(D)-H(D|A)\tag{8-10} $$

8.3.2 计算示例#

如果仅看上面的公式肯定不那么容易理解，下面我们再进行举例说明。这里建议各位读者将上面的公式同下面的计算过程对比观看进行理解。表8-1同样是7.1.3节中用过的一个信用卡审批数据集，其一共包含15个样本和3个特征维度。其中特征$X^{(1)}\in A_1=\{1,0\}$表示有无工作，特征$X^{(2)}\in A_2=\{1,0\}$表示是否有房，特征${{X}^{(3)}}\in {{A}_{3}}=\{D,S,T\}$表示学历等级，$Y\in C=\{1,0\}$表示是否审批通过的类标记。

表 8-1 计算数据示例

1. 计算信息熵$H(D)$

根据式(8-8)可得

$$ H(D)=-\left( \frac{5}{15}{{\log }_{2}}\frac{5}{15}+\frac{10}{15}{{\log }_{2}}\frac{10}{15} \right)\approx 0.918\tag{8-11} $$

2. 计算条件熵

8.4 决策树剪枝过程

Mon, 01 Jan 0001 00:00:00 +0000

8.4 决策树剪枝过程#

8.4.1 剪枝思想#

在8.3节内容中我们介绍过，使用ID3算法进行构建决策树时容易产生过拟合现象，因此需要使用一种方法来缓解这一现象。通常，决策树过拟合的表现形式为这棵树有很多叶子节点。想象一下，如果这棵树为每个样本点都生成一个叶节点，也就代表着这棵树能够拟合所有的样本点，因为决策树的每个叶节点都表示一个分类类别。同时，出现过拟合的原因在于模型在学习时过多地考虑如何提高对训练数据的正确分类，从而构建出过于复杂的决策树，因此，解决这一问题的办法就是考虑减少决策树的复杂度，即对已经生成的决策树进行简化，也就是剪枝（Pruning）。

8.4.2 剪枝步骤#

决策树的剪枝往往通过最小化决策树整体的损失函数或者代价函数实现。设树$T$的叶节点个数为$|T|$，$t$是树$T$的一个叶节点，该叶节点有$N_t$个样本点，其中类别$k$的样本点有$N_{tk}$个，其中$k=1,2,...,K$。同时，$H_t(T)$为叶节点$t$上的经验熵，$\alpha \geq 0$为参数，则决策树的损失函数可以定义为

$$ {{C}_{\alpha }}(T)=\sum\limits_{t=1}^{|T|}{{{N}_{t}}}{{H}_{t}}(T)+\alpha |T|\tag{8-27} $$

其中经验熵为

$$ {{H}_{t}}(T)=-\sum\limits_{k}^{K}{\frac{{{N}_{tk}}}{{{N}_{t}}}}\log \frac{{{N}_{tk}}}{{{N}_{t}}}\tag{8-28} $$

进一步令

$$ C(T)=\sum\limits_{t=1}^{|T|}{{{N}_{t}}}{{H}_{t}}(T)=-\sum\limits_{t=1}^{|T|}{\sum\limits_{k=1}^{K}{{{N}_{tk}}}}\log \frac{{{N}_{tk}}}{{{N}_{t}}}\tag{8-29} $$

此时损失函数可以写为

$$ {{C}_{\alpha }}(T)=C(T)+\alpha |T|\tag{8-30} $$

其中$C(T)$表示模型对训练数据的分类误差，即模型与训练集的拟合程度，本质上就是所有叶子结点总的信息熵；$|T|$表示模型复杂度，参数$\alpha\geq0$用于控制两者之间的平衡。此时可以发现，较大的$\alpha$促使选择较简单的模型（树），较小的$\alpha$促使选择较复杂的模型（树），而$\alpha=0$则意味着只考虑模型与训练集的拟合程度，而不考虑模型的复杂度，因此，这里$\alpha$的作用就类似于正则化中惩罚系数。

具体地，决策树的剪枝步骤如下

输入：生成算法产生的整棵树$T$，参数$\alpha$。

输出：修剪后的子树$T_{\alpha}$

(1) 计算每个叶节点的经验（信息）熵。

(2) 递归地从树的叶节点往上回溯，设一组叶节点回溯到其父节点之前与之后的整体树分别为$T_B$和$T_A$，其对应的损失函数值分别是$C_{\alpha}(T_B)$和$C_{\alpha}(T_A)$，如果$C_{\alpha}(T_A)\leq C_{\alpha}(T_B)$，则进行剪枝，即将父节点变为新的叶节点。

(3) 返回步骤(2)，直到不能继续为止，得到损失函数最小的子树$T_{\alpha}$。

当然，如果仅看这些步骤依旧会很模糊，下面再来通过一个实际计算示例进行说明。

8.4.3 剪枝示例#

如图8-9所示，在考虑是否要减掉“学历等级”这个节点时，首先需要计算的就是剪枝前的损失函数数值$C_\alpha(T_B)$。由于剪枝时，每次只考虑一个节点，所以在计算剪枝前和剪枝后的损失函数值时，仅考虑该节点即可。因为其他叶节点的经验熵对于剪枝前和剪枝后都没有变化。

图 8-9 决策树剪枝

根据表8-4可知，“学历等级”这个节点对应的训练数据如表8-5所示。

表 8-5 学历等级样本分布表

根据式(8-29)有

$$ C({{T}_{B}})=-\sum\limits_{t=1}^{2}{\sum\limits_{k=1}^{2}{{{N}_{tk}}}}\log \frac{{{N}_{tk}}}{{{N}_{t}}}=-\left[ \left(2{{\log }_{2}}\frac{2}{2}+0\right)+\left(1{{\log }_{2}}\frac{1}{2}+1{{\log }_{2}}\frac{1}{2}\right) \right]=2\tag{8-31} $$

进一步，根据式(8-30)有

$$ {{C}_{\alpha }}({{T}_{B}})=C({{T}_{B}})+\alpha |{{T}_{B}}|=2+2\alpha\tag{8-32} $$

8.5 从零实现ID3与C4.5算法

Mon, 01 Jan 0001 00:00:00 +0000

8.5 从零实现ID3与C4.5算法#

在前面几节内容中，我们详细介绍了ID3与C4.5决策树算法的原理与计算示例，并且还介绍了如何借助开源的sklearn框架来完成整个建模的搭建流程。在接下来的这节内容中将会详细地来介绍如何从零一步步地实现ID3与C4.5这两种决策树算法。

8.5.1 节点定义实现#

由ID3与C4.5决策树算法的原理可知，两者的唯一差别就是体现在对于特征划分标准的不同上，前者采用的信息增益，而后者则采用的是信息增益比来进行判断。因此，两者在代码实现时只需要将这部分内容单独抽象成一个函数即可，其它部分的代码可以保持不变。本节所有实现代码可参见AllBooKCode/Chapter08/C03_id3_categorical.py 文件。

在实现决策树之前，需要先来定义决策树中每个节点的组成成份。同时，参考图8-4中的节点信息，这里将决策树的节点定义为如下形式：

 1 class Node(object):
 2     def __init__(self, ):
 3         self.sample_index = None  # 保存当前节点中对应样本在数据集中的索引
 4         self.values = None  # 保存每个类别的数量
 5         self.features = None  # 保存当前节点状态时特征集中剩余特征
 6         self.feature_id = -1  # 保存当前节点对应划分特征的id
 7         self.label = None  # 保存当前节点对应的类别标签（叶子节点才有）
 8         self.n_samples = 0  # 保存当前节点对应的样本数量
 9         self.children = {}  # 保存当前节点对应的孩子节点
10         self.criterion_value = 0.
11         self.n_leaf = 0  # 以当前节点为根节点时其叶子节点的个数
12         self.leaf_costs = 0.

在上述代码中，第3行sample_index用来保存当前节点中对应样本在数据集中的索引，这样我们在需要的时候可以直接通过索引去取到对应的样本而不是保存到每个节点中，同时也方便根据索引来取对应的样本标签。第4行values用来保存每个类别的数量，例如[10,4,6]则表示第0、1、2这三个类别在当前节点中的数量分别是10、4和6，其作用是根据这一结果可以知道当前叶子节点所代表的类别。第5行features用于保存在当前节点状态时特征集中剩余特征维度（即还剩下哪些特征没有被用于前面的划分中），例如[0,2,3]则表示对于当前节点来说，其备选特征为第0、2和3个。第6行feature_id用于保存当前节点对应划分特征的id，因为在决策树预测阶段时需要知道当前节点是用哪个特征来进行划分的。第7行label用来保存当前节点对应的类别标签（叶子节点才有），不过这个可选，因为通过前面的values也能够得到当前叶子节点的所属类别。第8行n_samples用来保存当前节点对应的样本数量，用于分析观察。第9行children用来保存当前节点对应的所有孩子节点，因为利用ID3和C4.5生成的决策树为n叉树，所以我们这里定义了一个字典来进行存储，其中key为特征取值，value为对应的孩子节点，值得一提的是在sklearn框架中这部分均采用的是二叉树来进行实现。第10行criterion_value则是用来保存当前节点对应的信息熵。第11行是记录以当前节点为根节点时其叶子节点的个数。第12行是记录以当前节点为根节点时其所有叶子节点的损失和，这两行主要用于后续剪枝部分的代码实现。

同时，为了在打印输出构建好的决策树的能够更加方便，需要定义如下方法，示例代码如下：

 1     def __str__(self):
 2         return f"<======================>\n" \
 3                f"当前节点所有样本的索引({self.sample_index})\n" \
 4                f"当前节点的样本数量({self.n_samples})\n" \
 5                f"当前节点每个类别的样本数({self.values})\n" \
 6                f"当前节点对应的信息增益（比）({round(self.criterion_value, 3)})\n" \
 7                f"当前节点状态时特征集中剩余特征({self.features})\n" \
 8                f"当前节点状态时划分特征ID({self.feature_id})\n" \
 9                f"当前节点对应的类别标签为({self.label})\n" \
10                f"当前节点为根节点对应孩子节点数为({self.n_leaf})\n" \
11                f"当前节点为根节点对应孩子节点损失为({self.leaf_costs})\n" \
12                f"当前节点对应的孩子为({self.children.keys()})"

这里值得一提的是__str__方法是Python中每个类对象都有的一个方法，只是默认情况下没有进行实现。__str__方法的作用是在通过print函数打印类的实例化对象时输出的便是上面定义的信息，而不是默认情况下的对象内存地址。例如：

 1 if __name__ == '__main__':
 2     node = Node()
 3     print(node)
 4 # <======================>
 5 # 当前节点所有样本的索引(None)
 6 # 当前节点的样本数量(0)
 7 # 当前节点每个类别的样本数(None)
 8 # 当前节点对应的信息增益（比）(0.0)
 9 # 当前节点状态时特征集中剩余特征(None)
10 ......

8.5.2 信息熵与条件熵实现#

根据8.3节内容可知，无论是ID3还是C4.5生成算法都需要计算样本的信息熵、特征的信息熵（在C4.5中）以及在某一特征取值下的条件熵。同时，需要说明的是，在本节内容中我们是以离散型输入特征为例进行的实现，在下一节内容中再来介绍能够同时处理离散型和连续型特征的实现方式。

8.6 连续型特征变量下决策树实现

Mon, 01 Jan 0001 00:00:00 +0000

8.6 连续型特征变量下决策树实现#

在上一节内容中，我们详细介绍了如何基于ID3与C4.5的原理来一步一步从零开始实现决策树模型，不过由于原始的决策树模型均是针对离散型的特征变量，因此并不能对连续型的特征变量进行建模处理。在这节内容中将采用sklearn库中的做法来对连续型特征进行离散化处理，并以此来实现ID3与C4.5的建模过程。值得一提的是，在sklearn中不管输入的是离散型变量还是连续型变量，都会先对其以同样的方式来进行离散化处理，下面我们也将采用同样的做法来进行处理。

8.6.1 特征离散化实现#

由于在8.5节内容中我们已经详细介绍了对于离散型特征输入的ID3与C4.5的决策树实现过程，因此接下来只需要以之前的代码框架为基础，对其中部分判断逻辑进行修改即可。在实现这部分内容之前，先来介绍如何对特征进行离散化。本节所有实现代码可参见AllBooKCode/Chapter08/C04_id3_continuous.py 文件。

根据8.3.5节内容可知，连续型特征变量的离散化过程可以先对原始特征进行排序处理，然后取所有连续两个值的均值来离散化整个连续型特征变量。在清楚上述特征离散化的原理后，便可以来进一步对其编码实现，示例代码如下：

 1     def _get_feature_values(self, data):
 2         n_features = data.shape[1]
 3         feature_values = {}
 4         for i in range(n_features):
 5             x_feature = sorted(set(data[:, i]))  # 去重与排序
 6             tmp_values = [x_feature[0]]  # 左边插入最小值
 7             for j in range(1, len(x_feature)):
 8                 tmp_values.append(round((x_feature[j - 1] + x_feature[j]) / 2, 4))
 9             tmp_values.append(x_feature[-1])  # 右边插入最大值
10             feature_values[i] = tmp_values
11         return feature_values

在上述代码中，第2行是得到特征的维度数量。第4~5行是遍历每一列特征维度并进行排序以及去重处理。第7~8行是计算得到两两相邻的特征值之间的平均值作为离散特征。第6、9行是为了方便后续决策树的实现，所以在离散化特征的两个端点分别加入了原始特征中的最小值和最大值。

最终，通过上述方法便可以得到离散化后的数据特征。例如对于如下测试数据来说

1 x = np.array([[3, 4, 5, 6, 7],
2               [2, 2, 3, 5, 8],
3               [3, 3, 8, 8, 9.]])
4 x = _get_feature_values(x)
5 print(x)
6 {0: [2.0, 2.5, 3.0], 1: [2.0, 2.5, 3.5, 4.0], 2: [3.0, 4.0, 6.5, 8.0],
7  3: [5.0, 5.5, 7.0, 8.0], 4: [7.0, 7.5, 8.5, 9.0]}

在上述结果中，第6~7行便是原始输入特征离散化后的结果，其中key表示特征维度的ID，value表示该特征维度对应的离散化特征取值。

8.6.2 信息熵与条件熵实现#

在完成特征离散化的编码工作后，下一步便可以开始对第8.5.2中实现的代码进行修改以满足离散化特征的需求，信息熵计算代码的修改部分如下：

1     def _compute_entropy(self, y_class):
2         y_unique = np.unique(y_class)
3         if y_unique.shape[0] == 1:  # 只有一个类别
4             return 0.  # 熵为0
5         ety = 0.
6         for i in range(len(y_unique)):  # 取每个类别
7             p = np.sum(np.abs(y_class - y_unique[i]) < 0.0001) / len(y_class)
8             ety += p * np.log2(p)
9         return -ety

在上述代码中，第1行是定义一个方法来计算信息熵，主要用于ID3和C4.5中计算样本的信息熵，以及C4.5中特征的信息熵。第2行是计算得到当前输入有多少种类别（或特征取值）。第3~4行则是判断如果只有一个类别则信息熵为0。第6~8行是分别遍历每一个类别，然后计算信息熵。值得注意的是，因为同时要计算特征维度的信息熵，而特征是浮点型所以一般不会用==来判断两者是否相等。

8.7 CART生成与剪枝算法

Mon, 01 Jan 0001 00:00:00 +0000

8.7 CART生成与剪枝算法#

在8.4节中，我们分别介绍了利用ID3和C4.5这两种算法来生成决策树的过程，其中ID3算法每次用信息增益最大的特征来划分数据样本，而C4.5算法则每次用信息增益比最大的特征来划分数据样本。接下来，再来看另外一种采用基尼不纯度（Gini Impurity）为标准的划分方法，CART算法。

8.7.1 CART算法#

分类与回归树（Classification And Regression Tree, CART），是一种既可以用于分类也可以用于回归的决策树，同时它也是应用最为广泛的决策树学习方法之一。CART假设决策树是一棵二叉树，内部节点的特征取值均为“是”或“否”，即左分支取值为“是”，右分支取值为“否”。这样，决策树在构建过程中就等价于递归地二分每个特征，将整个特征空间划分为有限个单元[2]。

在本书中，我们暂时只对其中的分类树进行介绍。总体来讲，利用CART算法来构造一棵分类树需要完成两步： ①基于训练数据集生成决策树，并且生成的决策树要尽可能大。②用验证集对已生成的树进行剪枝并选择最优子树。

8.7.2 分类树生成算法#

在介绍分类树的生成算法前先来介绍新引入的划分标准——基尼不纯度。在分类问题中，假设某数据集包含$K$个类别，样本点属于第$k$类的概率为$p_k$，则此时的基尼不纯度定义为

$$ \text{Gini}(p)=\sum\limits_{k=1}^{K}{{{p}_{k}}(1-{{p}_{k}})}=1-\sum\limits_{k=1}^{K}{p_{k}^{2}}\tag{8-34} $$

因此，对于给定的样本集合$D$，其基尼不纯度为

$$ \text{Gini}(D)=1-\sum\limits_{k=1}^{K}{{{\left( \frac{|{{C}_{k}}|}{|D|} \right)}^{2}}}\tag{8-35} $$

其中，$C_k$是$D$中属于第k类的样本子集，$C_k$表示类别$k$中的样本数，$K$是类别的个数。

从基尼不纯度的定义可以看出，若集合$D$中存在样本数的类别越多，则其对应的“不纯度”也会越大，直观地说也就是该集合“不纯”，这也很类似于信息熵的性质。相反，若该集合中只存在一个类别，则其对应的基尼不纯度就会是0，因此，在通过CART算法构造决策树时，会选择使基尼不纯度达到最小值时的特征取值进行样本划分。

同时，在决策树的生成过程中，如果样本集合$D$根据特征$A$是否取某一可能值$a$被分割成$D_1$和$D_2$两部分，即

$$ {{D}_{1}}=\{(x,y)\in D|A(x)=a\},{{D}_{2}}=D-{{D}_{1}}\tag{8-36} $$

则在特征$A$的条件下，集合$D$的基尼不纯度定义为

$$ \text{Gini}(D,A)=\frac{|{{D}_{1}}|}{|D|}\text{Gini}({{D}_{1}})+\frac{|{{D}_{2}}|}{|D|}\text{Gini}({{D}_{2}})\tag{8-37} $$

其中$\text{Gini}(D,A)$ 表示经$A=a$分割后集合$D$的不确定性。可以看出这类似于条件熵，$\text{Gini}(D,A)$越小则表示特征$A$越能降低集合$D$的不确定性。

在介绍完成基尼不纯度后，就能够列出CART分类树的生成步骤。

输入： 训练数据集$D$，停止计算条件。

输出： CART分类决策树。

根据训练集，从根节点开始，递归地对每个节点进行如下操作，并构建二叉决策树。

(1) 设训练集为$D$，根据式(8-35)计算现有特征对该数据集的基尼不纯度。接着，对于每个特征$A$，对其可能的每个值$a$，根据样本点对$A=a$是否成立将$D$划分成$D_1$和$D_2$两部分，然后利用式(8-37)计算$A=a$时的基尼不纯度。

(2) 在所有可能的特征$A$及它们所有可能的切分点$a$中，选择基尼不纯度最小的特征取值作为划分标准将原有数据集划分为两部分，并分配到两个子节点中去。

(3) 对两个子节点递归的调用步骤(1)和(2)，直到满足停止条件。

(4) 生成CART决策树。

其中，算法停止计算的条件通常是节点中的样本点个数小于设定阈值，或样本集合的基尼不纯度小于设定阈值，抑或没有更多的特征，这一点同8.3节中ID3和C4.5算法的停止条件类似。

8.7.3 分类树生成示例#

在介绍完上述理论性的内容后，这里同样还是采用之前的信用卡审批数据集来对具体的生成过程进行详细示例。由表8-1中的数据可知，此时整个数据集对应的基尼不纯度为

$$ \text{Gini}(D)=1-\sum\limits_{k=1}^{K}{{{\left( \frac{|{{C}_{k}}|}{|D|} \right)}^{2}}}=1-{{\left( \frac{5}{15} \right)}^{2}}-{{\left( \frac{10}{15} \right)}^{2}}\approx 0.444\tag{8-38} $$

进一步，对于特征$A_1$来讲，根据其取值是否为1，可以将原始样本划分为$D_1$和$D_2$两部分。由式(8-37)得

$$ \text{Gini}(D,{{A}_{1}}=1)=\frac{7}{15}\text{Gini}({{D}_{1}})+\frac{8}{15}\text{Gini}({{D}_{2}})=\frac{7}{15}\times \frac{24}{49}+\frac{8}{15}\times \frac{14}{64}\approx 0.345\tag{8-39} $$

同理，对于特征$A_2$来讲，根据其取值是否为1，也可以将原始样本划分为$D_1$和$D_2$两部分。此时有

8.8 从零实现CART算法及剪枝示例

Mon, 01 Jan 0001 00:00:00 +0000

8.8 从零实现CART算法及剪枝示例#

在8.7节内容中我们已经详细介绍了CART分类树的构建原理和剪枝过程，在本节内容中将开始介绍如何从零开始编码实现一个简易版的CART分类树。同时，由于在实际场景中数据集的特征维度大多都是连续型的特征变量，因此需要对其进行离散化处理，后续也将以连续型特征为例进行编码实现。具体离散化方法见8.6.1节内容，这里不再赘述。

下面，将直接通过表8-6中的样本数据来详细介绍在CART分类树中如何离散化连续型特征并构造相应的决策树。

8.8.1 连续型特征生成示例#

在处理连续型特征变量时，第一步便是需要将各个维度的特征进行离散化，然后再根据离散化后的区间来对特征进行判断。具体地，表8-6中对应的3个特征在离散化后各特征的取值分割点分别为： $[0.5]$ 、 $[0.5]$ 、$ [0.5,1.5]$。

由表8-6中的数据可知，根据式(8-35)可得，此时的其基尼不纯度为

$$ \text{Gini}(D)=1-\sum\limits_{k=1}^{K}{{{\left( \frac{|{{C}_{k}}|}{|D|} \right)}^{2}}}=1-{{\left( \frac{5}{15} \right)}^{2}}-{{\left( \frac{10}{15} \right)}^{2}}\approx 0.444\tag{8-51} $$

并且对于特征${{A}_{1}}$来说，根据其取值是否满足条件$A_1\leq0.5$，可以将原始样本划分为$D_1$和$D_2$两个部分。由式(8-37)得

$$ \text{Gini}(D,{A}_{1}\leq0.5)=\frac{7}{15}\text{Gini}({{D}_{1}})+\frac{8}{15}\text{Gini}({{D}_{2}})=\frac{7}{15}\times \frac{24}{49}+\frac{8}{15}\times \frac{14}{64}\approx 0.345\tag{8-52} $$

同理，对于特征${{A}_{2}}$来说，根据其取值是否满足条件$A_2\leq0.5$，也可以将原始样本划分为$D_1$和$D_2$两个部分。此时有

$$ \text{Gini}(D,{A}_{2}\leq0.5)=\frac{8}{15}\text{Gini}({{D}_{1}})+\frac{7}{15}\text{Gini}({{D}_{2}})=\frac{8}{15}\times \frac{1}{2}+\frac{7}{15}\times \frac{12}{49}\approx 0.381\tag{8-53} $$

进一步，对于特征${{A}_{3}}$来说，根据其取值是否分别满足条件$A_3\leq0.5$和$A_3\leq1.5$，每一次也可将原始样本划分为$D_1$和$D_2$两个部分。此时有

$$ \begin{aligned} \text{Gini}(D,{A}_{3}\leq0.5)&=\frac{12}{15}\text{Gini}({{D}_{1}})+\frac{3}{15}\text{Gini}({{D}_{2}})=\frac{12}{15}\times \frac{4}{9}+\frac{3}{15}\times \frac{4}{9}\approx 0.444\\[2ex] \text{Gini}(D,{A}_{3}\leq1.5)&=\frac{7}{15}\text{Gini}({{D}_{1}})+\frac{8}{15}\text{Gini}({{D}_{2}})=\frac{7}{15}\times \frac{20}{49}+\frac{8}{15}\times \frac{30}{64}\approx 0.441 \end{aligned}\tag{8-54} $$

注意：此时每次划分时都是将样本集合划分为两个部分，即$A_i \leq a$和$A_i> a$。

由以上计算结果可知，使用${A}_{1}\leq0.5$时对样本集合进行划分所得到的基尼不纯度最小。故，根节点应该以${A}_{1}\leq 0.5$是否成立来进行分割，如图8-21所示（在每个节点中，第1行表示当前节点的划分特征维度以及样本的索引，第2行分别表示判断区间和每个类别中的各个样本的数量）。

图 8-21. CART第一次划分

从图8-21可以看出，根据特征$A_1$是否存满足条件$A_1\leq0.5$可以将原始样本划分为$D_1$和$D_2$两个部分。经过这次划分后，原始的样本集合就被特征“有工作”分割成了左右两个部分。接下来，再对左右两个集合递归的进行上述步骤。

1. 对于左子$D_1$树来说

$$ \text{Gini}(D_1)=1-(\frac{4}{7})^2-(\frac{3}{7})^2\approx0.490\tag{8-55} $$

在特征$A_2$中有

$$ \text{Gini}(D_1, A_2\leq0.5)=\frac{3}{7}(1-1)+\frac{4}{7}(1-\frac{1}{16}-\frac{9}{16})\approx0.214\tag{8-56} $$

在特征$A_3$中有

引用

Mon, 01 Jan 0001 00:00:00 +0000

引用#

[1] 吴军.数学之美［M］.3版.北京：人民邮电出版社，2020.

[2] 李航.统计学习方法［M］.2版.北京：清华大学出版社,2019.

[3]Scikit-learn: Machine Learning in Python, Pedregosa et al., JMLR 12, pp. 2825-2830, 2011.

[4] http://www.graphviz.org/download/

[5] https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html

[6] https://scikit-learn.org/stable/modules/tree.html

第 8 章 决策树 on 《从零学AI指南手册》

8.1 决策树的基本思想

8.1 决策树的基本思想#

8.1.1 冠军球队#

8.1.2 信息的度量#

8.2 决策树建模与可视化

8.2 决策树建模与可视化#

8.2.1 ID3 算法示例代码#

8.3 决策树生成之ID3与C4.5

8.3 决策树生成之ID3与C4.5#

8.3.1 基本概念与定义#

8.3.2 计算示例#

8.4 决策树剪枝过程

8.4 决策树剪枝过程#

8.4.1 剪枝思想#

8.4.2 剪枝步骤#

8.4.3 剪枝示例#

8.5 从零实现ID3与C4.5算法

8.5 从零实现ID3与C4.5算法#

8.5.1 节点定义实现#

8.5.2 信息熵与条件熵实现#

8.6 连续型特征变量下决策树实现

8.6 连续型特征变量下决策树实现#

8.6.1 特征离散化实现#

8.6.2 信息熵与条件熵实现#

8.7 CART生成与剪枝算法

8.7 CART生成与剪枝算法#

8.7.1 CART算法#

8.7.2 分类树生成算法#

8.7.3 分类树生成示例#

8.8 从零实现CART算法及剪枝示例

8.8 从零实现CART算法及剪枝示例#

8.8.1 连续型特征生成示例#

引用

引用#

第 8 章决策树 on 《从零学AI指南手册》