（四）统计学习方法 | 决策树

---

1. 决策树

1.1 简介与定义

决策树是一种基本的分类和回归方法，本文主要讨论其在分类上的作用。决策树模型呈树形结构，在分类问题中，表示基于特征对实例进行分类的过程。其主要优点是模型的可读性，分类速度快。在模型学习时，利用训练数据，根据损失函数最小化的原则建立决策树模型。预测时，对于新的数据，利用决策树模型进行分类。决策树的学习包含三个过程：特征选择、决策树的生成和决策树的修剪。

决策树模型 分类决策模型是一种描述对实例进行分类的树形结构。决策树由结点和有向边组成。结点有两种类型：内部结点和叶结点。内部结点表示一个特征或属性，叶结点表示一个类。相应地，用决策树模型分类时，从根结点开始，对实例的某一特征进行测试，根据测试结果，将实例分配到其子结点；这时，每一个子结点对应着该特征的一个取值。如此递归地对实例进行测试并分配，直到到达叶结点。最后将实例分到叶结点对应的类中。

1.2 决策树学习

给定训练集 D = { ( x 1 , y 2 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D=\{(x_1,y_2),(x_2,y_2),...,(x_N,y_N)\} D={(x1​,y2​),(x2​,y2​),...,(xN​,yN​)}

其中，$x_i=(x_i^{(1)},x_i^{(2)},...,x_i^{(n)}{)}^{\mathrm{T}}$为输入实例的特征向量，$n$为特征个数， y i ∈ { 1 , 2 , . . . , K } y_i\in\{1,2,...,K\} yi​∈{1,2,...,K}为类标记，$i=1,2,...,N$，$N$为样本容量。决策树学习的目标时根据给定的训练数据集构造一个决策树模型，使它能够对实例进行正确的分类。 其本质是从训练集上归纳出一组分类规则，与训练数据集不相矛盾的决策树模型可能有多个，也可能一个也没有。

1.3 特征选择

特征选择在于选取对训练数据具有分类能力的特征，这样可以提高决策树学习的效率。如果利用一个特征进行分类的结果与随机分类的结果没有很大的区别，则称这个特征是没有分类能力的。经验上扔掉这样的特征对最终决策树学习的影响不大。通常的特征选择的准则是信息增益或信息增益比。

例题 训练数据如下，由$15$个样本组成的贷款申请训练数据：

ID	年龄	有工作	有自己的房子	信贷情况	类别
1	青年	否	否	一般	否
2	青年	否	否	好	否
3	青年	是	否	好	是
4	青年	是	是	一般	是
5	青年	否	否	一般	否
6	中年	否	否	一般	否
7	中年	否	否	好	否
8	中年	是	是	好	是
9	中年	否	是	非常好	是
10	中年	否	是	非常好	是
11	老年	否	是	非常好	是
12	老年	否	是	好	是
13	老年	是	否	好	是
14	老年	是	否	非常好	是
15	老年	否	否	一般	否

现在通过所给的训练数据数据学习一个贷款申请的决策树，用以对未来的贷款申请进行分类，即当新的客户提出贷款申请时，根据申请人的特征利用决策树决定是否批准贷款申请。训练数据给出了年龄、有工作、有自己的房子、信贷情况共四个特征，究竟选择哪个特征更好些？直观上，如果一个特征具有更好的分类能力，那么就更应该选择这个特征。而下面介绍的细信息增益就能够很好地表示这一直观的准则。

1.3.1 信息增益

熵 是随机变量不确定性的度量。设$X$是一个取有限个值的离散随机变量，其概率分布为：$$P(X=x_i)=p_i,i=1,2,...,n$$

则随机变量的熵定义为：$$H(X)=-\sum _{i=1}^n{p}_i\log p_i\text{\hspace{1em}(1)}$$

由定义可知，熵只依赖于$X$的分布，而与$X$的取值无关，所以也可将$X$的熵记作$H(p)$，即：$$H(p)=-\sum _{i=1}^n{p}_i\log p_i$$

熵越大，随机变量的额不确定性就越大。从熵的定义可知：$$0\le H(p)\le \log n$$

然后来看条件熵的定义，设有随机变量$(X,Y)$，其联合概率分布为：$$P(X=x_i,Y=y_i)=p_{ij},i=1,2,...,n;j=1,2,...,m$$

条件熵$H(Y|X)$表示在已知随机变量$X$的条件下随机变量$Y$的不确定性。随机变量$X$给定的条件下随机变量$Y$的条件熵$H(Y|X)$，定义为$X$给定条件下$Y$的条件概率分布的熵对$X$的数学期望：$$H(Y|X)=\sum _{i=1}^n{p}_{i}H(Y|X=x_i),p_i=P(X=x_i),i=1,2,...,n\text{\hspace{1em}(2)}$$

当熵和条件熵中的概率由数据估计得到时，所对应的熵与条件熵分别成为经验熵和条件经验熵。 而信息增益表示得知特征$X$的信息而使$Y$的信息的不确定性减少的程度。

信息增益 特征$A$对训练数据集$D$的信息增益$g(D,A)$，定义为集合$D$的经验熵$H(D)$与特征$A$给定条件下$D$的经验条件熵$H(D|A)$之差，即：$$g(D,A)=H(D)-H(D|A)\text{\hspace{1em}(3)}$$

一般地，熵$H(Y)$与条件熵$H(Y|X)$之差称为互信息。决策树学习中的信息增益等价于训练数据集中类与特征的互信息。根据信息增益标准的特征选择方法是：对于训练数据集（或子集）$D$，计算其每个特征的信息增益，并比较它们的大小，选择信息增益最大的特征。

设训练数据集为$D$，$|D|$表示其样本容量。设有$K$个类$C_k,k=1,2,...,K$，$|C_k|$为属于类$C_k$的样本个数，$\sum _{k=1}^K|C_k|=|D|$。设特征$A$有$n$个不同的取值 { a 1 , a 2 , . . . , a n } \{a_1,a_2,...,a_n\} {a1​,a2​,...,an​}，根据特征$A$的取值将$D$划分为$n$个子集$D_1,D_2,...,D_n$，$|D_i|$为$D_i$的样本个数，$\sum _{i=1}^n|D_i|=|D|$。记子集$D_i$中属于类$C_k$的样本的集合为$D_{ik}$，即$D_{ik}=D_i\cap C_k$，$|D_{ik}|$为$D_{ik}$的样本个数。得到信息增益的算法如下：

信息增益的算法

输入 训练数据集$D$和特征$A$；

输出 特征$A$对训练数据集$D$的信息增益$g(D,A)$。

（1）计算数据集$D$的经验熵$H(D)$：$$H(D)=-\sum _{k=1}^K\frac{|C_k|}{|D|}{\log }_2\frac{|C_k|}{|D|}\text{\hspace{1em}(4)}$$

（2）计算特征$A$对数据集$D$的经验条件熵$H(D|A)$：$$H(D|A)=\sum _{i=1}^n\frac{|D_i|}{|D|}H(D_i)=-\sum _{i=1}^n\frac{|D_i|}{|D|}\sum _{k=1}^K\frac{|D_{ik}|}{|D_i|}{\log }_2\frac{|D_{ik}|}{|D_i|}\text{\hspace{1em}(5)}$$

（3）计算信息增益：$$g(D,A)=H(D)-H(D|A)\text{\hspace{1em}(6)}$$

解例题

（1）计算经验熵$H(D)$（数据集共包含是和否两个类）：$$H(D)=-\frac{9}{15}{\log }_2\frac{9}{15}-\frac{6}{15}{\log }_2\frac{6}{15}=0.971$$

（2）分别对特征年龄$A_1$、有工作$A_2$、有自己的房子$A_3$和信贷情况$A_4$计算条件经验熵和信息增益：$$g(D,A_1)=H(D)-\left[\frac{5}{15}H(D_1)+\frac{5}{15}H(D_2)+\frac{5}{15}H(D_3)\right]=0.971-0.888=0.083$$

其中，$D_1$、$D_2$和$D_3$分别表示年龄取值为青年、中年和老年，下同。
$$g(D,A_2)=H(D)-\left[\frac{5}{15}H(D_1)+\frac{10}{15}H(D_2)\right]=0.971-0.647=0.324$$

$$g(D,A_3)=H(D)-\left[\frac{6}{15}H(D_1)+\frac{9}{15}H(D_2)\right]=0.971-0.551=0.420$$

$$g(D,A_4)=H(D)-\left[\frac{5}{15}H(D_1)+\frac{6}{15}H(D_2)+\frac{4}{15}H(D_3)\right]=0.971-0.608=0.363$$

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

1.3.2 信息增益比

由信息增益的算法可以看到，以信息增益作为划分训练数据集的特征，存在偏向于选择取值较多的特征的问题。使用信息增益比可以对这一问题进行校正，这也是特征选择的又一准则。

信息增益比 特征$A$对训练数据集$D$的信息增益比$g_R(D,A)$定义为其信息增益$g(D,A)$与训练数据集$D$关于特征$A$的值的熵$H_A(D)$之比：$$g_R(D,A)=\frac{g(D,A)}{H_A(D)}$$

$$H_A(D)=-\sum _{i=1}^n\frac{|D_i|}{|D|}{\log }_2\frac{|D_i|}{|D|}$$

其中，$n$是特征$A$取值的个数。

1.4 决策树的生成

1.4.1 ID3算法

$\mathrm{I}\mathrm{D}3$算法的核心是在决策树各个结点上应用信息增益准则选择特征，递归地构建决策树。具体的过程是：从根结点开始，对结点计算所有可能的特征的信息增益，选择信息增益最大的特征作为结点的特征，由该特征的不同取值建立子结点；再对子结点递归地调用以上方法，构建决策树；直到所有特征的信息增益均很小或没有特征可以选择为止。

ID3算法

输入 训练数据集$D$，特征集$A$阈值$\epsilon$；

输出 决策树$T$。

（1）若$D$中所有实例属于同一类$C_k$，则$T$为单结点树，并将类$C_k$作为该结点的类标记，返回$T$；

（2）若$A=\varnothing$，则$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回$T$；

（3）否则，计算$A$中各特征对训练数据集$D$的信息增益，选择信息增益最大的特征$A_g$；

（4）如果$A_g$的信息增益小于阈值$\epsilon$，则置$T$为单结点树，并将$D$中实例数最大的类$C_k$作为该结点的类标记，返回$T$；

（5）否则，对$A_g$的每一可能值$a_i$，依$A_g=a_i$将$D$分割为若干非空子集$D_i$，将$D_i$中实例数最大的类作为标记，构建子结点，由结点及其子结点构成树$T$，返回$T$；

（6）对第$i$个子结点，以$D_i$为训练集，以 A − { A g } A-\{A_g\} A−{Ag​}为特征集，递归地调用步（1）~（5），得到子树$T_i$，返回$T$。

解例题

根据上面计算结果，特征有自己的房子$A_3$的信息增益值最大，所以选择$A_3$作为根结点特征。该结点将训练数据集$D$划分为两个子集有自己的房子$D_1$和没有自己的房子$D_2$。由于$D_1$只有同一类样本点，所以它称为一个叶结点，结点的类标记为是。现在我们来处理数据集$D_2$，计算信息增益：$$g(D_2,A_1)=H(D_2)-H(D_2|A_1)=0.918-0.667=0.251$$

$$g(D_2,A_2)=H(D_2)-H(D_2|A_2)=0.918-0=0.918$$

$$g(D_2,A_4)=H(D_2)-H(D_2|A_4)=0.918-0.444=0.474$$

选择信息增益值最大对应的特征有工作$A_2$作为结点的特征，$A_2$有两个可能的取值，从这一结点引出两个结点：一个对应于有工作，一个对应于没有工作。同时我们发现，对于有工作而言，结果均为是；对于没有工作而言，结果均为否，所以这里得到两个叶结点。最终得到的决策树如下：

1.4.2 C4.5算法

$\mathrm{C}4.5$算法是对$\mathrm{I}\mathrm{D}3$算法的改进，使用信息增益比代替信息增益来选择特征，其他步骤同。

1.5 决策树的剪枝

决策树生成算法递归地产生决策树，直到不能继续下去为止。这样产生的树往往对训练数据的分类很准确，但对未知的测试数据的分类却没有那么准确，即出现过拟合效应。出现过拟合的主要原因是基于训练数据集构建的决策树模型过于复杂，所以通常我们需要对决策树剪枝以减弱过拟合效应。而决策树的剪枝往往通过极小化决策树整体的损失函数来实现。设$T$的叶结点个数为$|T|$，$t$是树$T$的叶结点，该叶结点有$N_t$个样本点，其中$k$类的样本点有$N_{tk}$个，$k=1,2,...,K$，$H_t(T)$为叶结点$t$上的经验熵，$\alpha \ge 0$为参数，则决策树学习的损失函数可以定义为：$$C_{\alpha }(T)=\sum _{t=1}^{|T|}{N}_t{H}_t(T)+\alpha |T|\text{\hspace{1em}(7)}$$

其中经验熵定义为：$$H_t(T)=-\sum _k\frac{N_{tk}}{N_t}\log \frac{N_{tk}}{N_t}\text{\hspace{1em}(8)}$$

在损失函数中，将式（7）有段的第一项记作：$$C(T)=\sum _{t=1}^{|T|}{N}_t{H}_t(T)=-\sum _{t=1}^T\sum _{k=1}^K{N}_{tk}\log \frac{N_{tk}}{N_t}\text{\hspace{1em}(9)}$$

这时有：$$C_{\alpha }(T)=C(T)+\alpha |T|\text{\hspace{1em}(10)}$$

上式中，$C(T)$表示模型对训练数据的预测误差，即模型与训练数据的拟合程度，$|T|$表示模型复杂度，参数$\alpha \ge 0$控制两者之间的影响。较大的$\alpha$促使选择较简单的模型，较小的$\alpha$促使选择较复杂的模型，$\alpha =0$表示只考虑模型与训练数据的拟合程度，不考虑模型的复杂度。

剪枝，就是当$\alpha$确定时，选择损失函数最小时的模型，即损失函数最小的子树。当$\alpha$值确定时，子树越大，往往与训练数据的拟合越好，但是模型的复杂度就越高；相反，子树越小，模型的复杂度就越低，但是往往与训练数据的拟合不好。损失函数正好表示了对两者的平衡。总之，决策树生成学习局部的模型，而决策树剪枝学习整体的模型。

树的剪枝算法

输入 生成算法产生的整个树$T$，参数$\alpha$；

输出 修建后的子树$T_{\alpha }$。

（1）计算每个结点的经验熵；

（2）递归地从树的叶结点向上回缩。

设一组叶结点回缩到其父结点之前与之后的整体树分别为$T_B$和$T_A$，其对应的损失函数值分别是$C_{\alpha }(T_B)$和$C_{\alpha }(T_A)$，如果满足：$$C_{\alpha }(T_A)\le C_{\alpha }(T_B)$$

则进行剪枝，即将父结点变为新的叶结点。

---

2. CART算法

分类与回归树CART模型是应用广泛的决策树学习方法，同样由特征选择、树的生成和剪枝组成，既可以用于分类也可以用于回归。$\mathrm{C}\mathrm{A}\mathrm{R}\mathrm{T}$是在给定输入变量$X$条件下输出随机变量$Y$的条件概率分布的学习方法。$\mathrm{C}\mathrm{A}\mathrm{R}\mathrm{T}$假设决策树是二叉树，左子树表示取值为是，右子树表示取值为否。这样的决策树等价于递归地二分每个特征，将输入空间即特征空间划分为有限个单元，并在这些单元上确定预测的概率分布，也就是在输入给定的条件下输出的条件概率分布。$\mathrm{C}\mathrm{A}\mathrm{R}\mathrm{T}$算法由以下两个步骤组成：决策树生成，基于训练数据集生成决策树，生成的决策树要尽量大；决策树剪枝，用验证数据集对已生成的树进行剪枝并选择最优子树，这时用损失函数最小作为剪枝的标准。

2.1 CART生成

2.1.1 回归树的生成

假设$X$和$Y$分别为输入和输出变量，并且$Y$是连续变量，给定训练数据集 D = { ( x 1 , y 2 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } D=\{(x_1,y_2),(x_2,y_2),...,(x_N,y_N)\} D={(x1​,y2​),(x2​,y2​),...,(xN​,yN​)}

现假设将输入空间划分为$M$个单元$R_1,R_2,...,R_M$，并且在每个单元$R_m$上又一个固定的输出值$c_m$，于是回归树模型可以表示为：$$f(x)=\sum _{m=1}^M{c}_{m}I(x\in R_m)\text{\hspace{1em}(11)}$$

当输入空间的划分确定时，可以用平方误差$\sum _{x_i\in R_m}(y_i-f(x_i){)}^2$来表示回归树对于训练数据的预测误差，用平方误差最小准确地求解每个单元上的最优输出值。易知，单元$R_m$上的$c_m$的最优值${\hat{c}}_m$是$R_m$上的所有输入实例$x_i$对应的输出$y_i$的均值，即：$${\hat{c}}_m=\mathrm{a}\mathrm{v}\mathrm{e}(y_i|x_i\in R_m)\text{\hspace{1em}(12)}$$

这时采用启发式的方法来划分空间，选择第$j$个变量$x^{(j)}$和它的取值$s$作为切分变量和切分点，并定义两个区域： R 1 ( j , s ) = { x ∣ x ( j ) ≤ s } ,   R 2 ( j , s ) = { x ∣ x ( j ) > s } (13) R_1(j,s)=\{x|x^{(j)}\leq s\},\ R_2(j,s)=\{x|x^{(j)}> s\}\tag{13} R1​(j,s)={x∣x(j)≤s}, R2​(j,s)={x∣x(j)>s}(13)

然后寻找最优切分变量$j$和最优切分点$s$。具体地，求解：$$\underset{j,s}{\min }\left[\underset{c_1}{\min }\sum _{x_i\in R_1(j,s)}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2(j,s)}(y_i-c_2{)}^2\right]\text{\hspace{1em}(14)}$$

对固定输入变量$j$可以找到最优切分点$s$：$${\hat{c}}_1=\mathrm{a}\mathrm{v}\mathrm{e}(y_i|x_i\in R_1(j,s)),{\hat{c}}_2=\mathrm{a}\mathrm{v}\mathrm{e}(y_i|x_i\in R_2(j,s))\text{\hspace{1em}(15)}$$

遍历所有输入变量，找到最优的切分变量$j$，构成一个对$(j,s)$。以此将输入空间划分成两个区域，然后对每个区域重复上述的划分过程，直到满足终止条件为止。这样的回归树称为最小二乘回归树。

最小二乘回归树生成算法

输入 训练数据集$D$；

输出 回归树$f(x)$。

（1）选择最优切分变量$j$于切分点$s$，求解：$$\underset{j,s}{\min }\left[\underset{c_1}{\min }\sum _{x_i\in R_1(j,s)}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2(j,s)}(y_i-c_2{)}^2\right]$$

（2）用选定的对$(j,s)$划分区域并决定相应的输出值： R 1 ( j , s ) = { x ∣ x ( j ) ≤ s } ,   R 2 ( j , s ) = { x ∣ x ( j ) > s } R_1(j,s)=\{x|x^{(j)}\leq s\},\ R_2(j,s)=\{x|x^{(j)}> s\} R1​(j,s)={x∣x(j)≤s}, R2​(j,s)={x∣x(j)>s}

$${\hat{c}}_m=\frac{1}{N_m}\sum _{x_i\in R_m(j,s)}{y}_i,x\in R_m,m=1,2$$

（3）继续对两个子区域调用步骤（1）和（2），直至满足停止条件；

（4）将输入空间划分为$M$个区域$R_1,R_2,...,R_M$，生成决策树：$$f(x)=\sum _{m=1}^M{c}_{m}I(x\in R_m).$$

2.1.2 分类树的生成

分类树用基尼指数选择最优特征，同时决定该特征的最优二值切分点。基尼指数的定义如下：分类问题中，假设有$K$个类，样本点属于第$k$类的概率为$p_k$，则概率分布的基尼指数定义为：$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(p)=\sum _{k=1}^K{p}_k(1-p_k)=1-\sum _{k=1}^K{p}_k^2\text{\hspace{1em}(16)}$$

对于给定的样本集合$D$，其基尼指数为：$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D)=1-\sum _{k=1}^K{\left(\frac{|C_k|}{|D|}\right)}^2\text{\hspace{1em}(17)}$$

这里，$C_k$是$D$中属于第$k$类的样本子集，$K$是类的个数。如果样本集合$D$根据特征$A$是否取某一可能值$a$被分割称$D_1$和$D_2$两部分，即： D 1 = { ( x , y ) ∈ D ∣ A ( x ) = a } ,   D 2 = D − D 1 D_1=\{(x,y)\in D|A(x)=a\},\ D_2=D-D_1 D1​={(x,y)∈D∣A(x)=a}, D2​=D−D1​

则在特征$A$的条件下，集合$D$的基尼指数定义为：$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A)=\frac{|D_1|}{|D|}\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D_1)+\frac{|D_2|}{|D|}\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D_2)\text{\hspace{1em}(18)}$$

基尼指数$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D)$表示集合$D$的不确定性，基尼指数$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A)$表示经过$A=a$分割后的集合的不确定性。基尼指数越大，样本集合的不确定性也就越大，这一点与熵类似。

CART生成算法

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

输出 $\mathrm{C}\mathrm{A}\mathrm{R}\mathrm{T}$决策树。

（1）设训练数据集为$D$，计算现有特征对该数据集的基尼指数；

（2）对所有可能的特征$A$以及它们可能所有可能的切分点$a$中，选择基尼指数最小的特征及其对应的切分点作为最优特征与最优切分点；

（3）对两个子结点递归地调用（1）和（2），直至满足停止条件；

（4）生成$\mathrm{C}\mathrm{A}\mathrm{R}\mathrm{T}$决策树。

解例题

首先计算各特征的基尼指数，选择最优特征以及其最优切分点。特征表示符号同上，则首先求特征$A_1$的基尼指数：
$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_1=1)=\frac{5}{15}\times \left(2\times \frac{2}{5}\times \left(1-\frac{2}{5}\right)\right)+\frac{10}{15}\times \left(2\times \frac{7}{10}\times \left(1-\frac{7}{10}\right)\right)=0.44$$

$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_1=2)=\frac{5}{15}\times \left(2\times \frac{3}{5}\times \left(1-\frac{3}{5}\right)\right)+\frac{10}{15}\times \left(2\times \frac{6}{10}\times \left(1-\frac{6}{10}\right)\right)=0.48$$

$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_1=3)=\frac{5}{15}\times \left(2\times \frac{4}{5}\times \left(1-\frac{4}{5}\right)\right)+\frac{10}{15}\times \left(2\times \frac{5}{10}\times \left(1-\frac{5}{10}\right)\right)=0.44$$

综上，$A_1=1$和$A_1=3$可以作为特征$A_1$的最优切分点。同理计算其他特征的基尼指数：
$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_2=1)=\frac{5}{15}\times \left(2\times \frac{5}{5}\times \left(1-\frac{5}{5}\right)\right)+\frac{10}{15}\times \left(2\times \frac{4}{10}\times \left(1-\frac{4}{10}\right)\right)=0.32$$

$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_3=1)=\frac{6}{15}\times \left(2\times \frac{0}{5}\times \left(1-\frac{0}{5}\right)\right)+\frac{9}{15}\times \left(2\times \frac{3}{9}\times \left(1-\frac{3}{9}\right)\right)=0.27$$

由于$A_2$和$A_3$均只有一个切分点，所以它们就是最优切分点。
$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_4=1)=\frac{4}{15}\times \left(2\times \frac{5}{5}\times \left(1-\frac{5}{5}\right)\right)+\frac{11}{15}\times \left(2\times \frac{5}{11}\times \left(1-\frac{5}{11}\right)\right)=0.36$$

$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_4=2)=\frac{6}{15}\times \left(2\times \frac{4}{6}\times \left(1-\frac{4}{6}\right)\right)+\frac{9}{15}\times \left(2\times \frac{5}{9}\times \left(1-\frac{5}{9}\right)\right)=0.47$$

$$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_4=3)=\frac{5}{15}\times \left(2\times \frac{1}{5}\times \left(1-\frac{1}{5}\right)\right)+\frac{10}{15}\times \left(2\times \frac{8}{10}\times \left(1-\frac{8}{10}\right)\right)=0.32$$

综上，$A_4=3$可以作为特征$A_3$的最优切分点。在几个特征中，$\mathrm{G}\mathrm{i}\mathrm{n}\mathrm{i}(D,A_3=1)=0.27$最小，所以选择$A_3$为最优特征，$A_3=1$为最优切分点。于是根结点生成两个子结点，一个是叶结点。对另一个结点继续使用上述方法，直到所有结点均为叶结点。

2.2 CART剪枝

2.2.1 剪枝，形成一个子序列

同决策树的剪枝过程类似，在剪枝过程中，首先计算子树的损失函数：$$C_{\alpha }(T)=C(T)+\alpha |T|\text{\hspace{1em}(19)}$$

具体地，从整体树$T_0$开始剪枝。对$T_0$的任意内部结点$t$，以$t$为单结点树的损失函数是：$$C_{\alpha }(t)=C(T)+\alpha \text{\hspace{1em}(20)}$$

以$t$为根结点的子树$T_t$的损失函数是：$$C_{\alpha }(T_t)=C(T_t)+\alpha |T_t|\text{\hspace{1em}(21)}$$

当$\alpha =0$及$\alpha$充分小时，有不等式：$$C_{\alpha }(T_t)<C_{\alpha }(t)\text{\hspace{1em}(22)}$$

当$\alpha$增大时，在某一$\alpha$有：$$C_{\alpha }(T_t)=C_{\alpha }(t)\text{\hspace{1em}(23)}$$

当$\alpha$再增大时，式子（22）反向。只要满足$\alpha =\frac{C(t)-C(T_t)}{|T_t|-1}$，$T_t$与$t$有相同的损失函数，而$t$的结点少，因此$t$更好，继续对$T_t$剪枝。为此，对$T_0$中每一个内部节点$t$，计算：$$g(t)=\frac{C(t)-C(T_t)}{|T_t|-1}\text{\hspace{1em}(24)}$$

该式子表示剪枝后整体损失函数减少的程度。在$T_0$中剪去$g(t)$最小的$T_t$，将得到的子树作为$T_1$，同时将最小的$g(t)$设为${\alpha }_1$。$T_1$为区间$[{\alpha }_1,{\alpha }_2)$的最优子树。如此剪枝下去，直到得到根结点。在这一过程中，不断增大$\alpha$的值，产生新的区间。

2.2.2 在剪枝得到的子树序列$T_0,T_1,...,T_n$中通过交叉验证选取最优子树$T_{\alpha }$

具体地，利用独立的验证数据集，测试子树序列$T_0,T_1,...,T_n$中各棵子树的平方误差或基尼指数。在子树序列中，每棵子树$T_0,T_1,...,T_n$都对应于一个参数${\alpha }_0,{\alpha }_1,...,{\alpha }_n$。

CART剪枝算法

输入 $\mathrm{C}\mathrm{A}\mathrm{R}\mathrm{T}$算法生成的决策树$T_0$；

输出 最优决策树$T_{\alpha }$。

（1）设$k=0$，$T=T_0$；

（2）设$\alpha =+\infty$；

（3）自下而上地对各内部结点$t$计算$C(T_t)$，$|T_t|$以及$$g(t)=\frac{C(t)-C(T_t)}{|T_t|-1}$$

$$\alpha =\min (\alpha ,g(t))$$

（4）对$g(t)=\alpha$的内部结点$t$进行剪枝，并对叶结点$t$以多数表决法决定其类，得到树$T$；

（5）设$k=k+1$，${\alpha }_k=\alpha$，$T_k=T$；

（6）如果$T_k$不是由根结点及两个叶结点构成的树，则返回到步骤（2）；否则令$T_k=T_n$；

（7）采用交叉验证法在子树序列$T_0,T_1,...,T_n$中选取最优子树$T_{\alpha }$。

---

3. Python实现决策树

与前一节相同，首先加载数据集：

def load_data(file):
    # 定义空列表
    dataArr = []
    labelArr = []
    # 打开并处理文件
    with open(file, "r") as f:
        lines = f.readlines()
        for line in lines:
            # 针对csv文件格式，使用','分割数据
            curLine = line.strip().split(',')
            # csv文件第一列存放着具体类别
            labelArr.append(int(line[0]))
            # 处理具体数据，为了简化计算量，将像素取值限制在01两个部分
            # 如果不简化，处理的数据量是10×784×256，现在是10×784×2
            dataArr.append([int(int(num) > 128) for num in curLine[1:]])
        # 返回
        return dataArr, labelArr

然后定义函数计算数据集的经验熵，即公式（4）：

def cal_h_d(labels):
    # 计算训练数据集的经验熵
    h_d = 0
    # 训练标签集合，使用set避免出现对数真数为零的情况
    # https://github.com/Dod-o/Statistical-Learning-Method_Code/blob/master/DecisionTree/DecisionTree.py#L76
    trainLabelSet = set([label for label in labels])
    for i in trainLabelSet:
        # |Ck|/|D|，labels[labels==i].size相当于一个指示函数
        p = labels[labels == i].size / labels.size
        # 求和
        h_d += -1 * p * np.log2(p)
    return h_d

然后定义函数计算对应特征的条件经验熵，即公式（5）：

def cal_a_d(data_dev_features, labels):
    # 计算条件经验熵
    a_d = 0
    # 将特征取值放入集合内
    trainDataSet = set([label for label in data_dev_features])
    for i in trainDataSet:
        # 根据公式计算条件经验熵
        a_d += data_dev_features[data_dev_features == i].size / data_dev_features.size \
               * cal_h_d(labels[data_dev_features == i])
    return a_d

然后定义函数实现功能：基于信息增益完成最优特征的选取：

def major_class(labels):
    # 找到最大的标签数
    classDict = {}
    for i in range(len(labels)):
        if labels[i] in classDict.keys():
            classDict[labels[i]] += 1
        else:
            classDict[labels[i]] = 1
    # 对结果逆序排序
    classSort = sorted(classDict.items(), key=lambda x: x[1], reverse=True)
    return classSort[0][0]

def sel_best_feature(train_data, train_label):
    # 基于信息增益选择最优特征
    # 转换格式
    train_data = np.array(train_data)
    train_label = np.array(train_label)
    # 特征数目，784
    num_features = train_data.shape[1]
    # 初始化最大信息增益及对应的特征
    max_g_d_a = -1
    max_feature = -1
    # 信息增益算法，计算经验熵
    h_d = cal_h_d(train_label)
    # 遍历特征
    for i in range(num_features):
        # 由于每次计算特征仅针对特征参与运算，其他特征我们不关心，这些将待计算特征切分下来并展开
        # https://github.com/Dod-o/Statistical-Learning-Method_Code/blob/master/DecisionTree/DecisionTree.py#L148
        train_data_arr_dev_feature = np.array(train_data[:, i].flat)
        # 计算信息增益
        g_d_a = h_d - cal_a_d(train_data_arr_dev_feature, train_label)
        # 更新
        if g_d_a > max_g_d_a:
            max_g_d_a = g_d_a
            max_feature = i
    return max_feature, max_g_d_a

提取数据集中的某一列特征：

def get_sub_data(train_data, train_label, A, a):
    # 定义返回值
    re_data = []
    re_label = []
    for i in range(len(train_data)):
        # 当前样本特征为指定特征
        if train_data[i][A] == a:
            # 将样本的第A个特征切掉
            re_data.append(train_data[i][0: A] + train_data[i][A + 1:])
            re_label.append(train_label[i])
    return re_data, re_label

最后，使用递归的方式建立决策树：

def create_tree(*dataset):
    # 以递归的方式创建决策树
    # 设置阈值
    epsilon = 0.1
    # 训练数据集
    train_data_list = dataset[0][0]
    train_label_list = dataset[0][1]
    # 打印信息
    print("start a node", len(train_data_list[0]), len(train_label_list))
    # 将标签放入字典
    classDict = {i for i in train_label_list}
    # 只有一个类别，则会产生叶结点
    if len(classDict) == 1:
        return train_label_list[0]
    # 空字典，选择特征完成
    if len(train_data_list[0]) == 0:
        return major_class(train_label_list)
    # 计算信息增益，并选择最大信息增益的特征
    g_d_a, feature = sel_best_feature(train_data_list, train_label_list)
    # 与阈值比较
    if feature < epsilon:
        return major_class(train_label_list)
    # 递归建立决策树
    treeDict = {g_d_a: {}}
    treeDict[g_d_a][0] = create_tree(get_sub_data(train_data_list, train_label_list, g_d_a, 0))
    treeDict[g_d_a][1] = create_tree(get_sub_data(train_data_list, train_label_list, g_d_a, 1))
    # 返回
    return treeDict

测试集上的表现：

def predict(test_data, tree):
    # 定义死循环，直到找到一个合适的分类
    while 1:
        # 读取字典
        (key, value), = tree.items()
        # 如果当前的value是字典，还需要继续遍历下去
        if type(tree[key]).__name__ == "dict":
            # 获得当前特征并删除
            data_value = test_data[key]
            del test_data[key]
            # 将tree更新为其子结点的字典
            tree = value[data_value]
            # 返回分类
            if type(tree).__name__ == "int":
                return tree
        # 当前value不是字典，直接返回类别
        else:
            return value

def test(test_data_list, test_label_list, tree):
    # 记录错误个数
    errorCnt = 0
    # 遍历测试集数据
    for i in range(len(test_label_list)):
        # 错误数加一
        if test_label_list[i] != predict(test_data_list[i], tree):
            errorCnt += 1
    # 计算正确率
    return 1 - (errorCnt / len(test_data_list))

---

4. 决策树总结

分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转化成一个if-else规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。建立决策树模型的过程主要包括：特征选择，树的生成和树的剪枝。首先，通常使用信息增益、信息增益比或基尼指数为准则来选择最优特征；然后以递归的方式生成决策树；最后，由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学习到的决策树。

---

参考

1. 统计学习方法/李航著。—2版。—北京：清华大学出版社，2019（2019.6重印）.
2. https://github.com/Dod-o/Statistical-Learning-Method_Code（决策树代码）.

---

完

---