【机器学习】笔记6：Decision Tree 决策树

 
 

简简单单一棵决策树，Eivind却差点死在这上面。
A long way to go.
 
 

Reference

机器学习技法课–台湾大学 林轩田
机器学习–周志华
统计学习方法–李航
CART算法
Machine Learning WIKI – CART算法
 

前言

1.符号

本文符号使用习惯与西瓜书和轩田老师的讲义保持一致。

• 训练资料 = 训练数据 = 训练集 = $learningset$
• $DataSet=${$(x_1,y_1),...,(x_N,y_N)$}
• 样本数目： $|D|=N$
• 输出空间 ：类别数目 $K=|OutputSpace|$
• 输入空间 ：特征数目 $d=|InputSpace|$
• 输入空间：特征 Attribute Set $A$= {$a_1,a_2,...,a_d$}$,i=1,2,...,d$
• 输入空间：离散型特征的取值 $a_i=${$a_i^1,a_i^2,...,a_i^V$}$,v=1,2,...,V$
• 输入空间： 样本 ${\mathbf{x}}_{\mathbf{n}}$ 在某一特征 $a_i$上的取值 $x_n^{(i)}$
• 输入空间：在特征 $a_i$上取值为 $a_i^{(v)}$的样本集合 $D^v=${$x|x^{(i)}=a_i^v$}
• 输入空间：划分区域 $R=${$R_1,R_2,...,R_M$; $m=1,2,...,M$}
• 输出空间：划分区域上 $y$的均值 $c_m=average(y_n|x_n\in R_m)=\frac{1}{N_m}\sum _{x_n\in R_m}^{N_m}{y}_n$
• 输出空间：训练误差 $Er{r}_{in}$
• 输出空间：测试误差 $Er{r}_{out}$
• hypothesis candidate： $h(\mathbf{x})$
• base learner / subtree： $g_t(\mathbf{x}),t=1,2,...,T$
• branch： $b(\mathbf{x}),c=1,2,...,C$
• 在第 $k$次迭代剪枝中，所有的非叶结点集合：$nod{e}^{(k)}$
• 在第 $k$次迭代剪枝中，选择剪枝的结点：$nod{e}_{\ast }^{(k)}$
• 在第 $k$次迭代剪枝中，以结点 $t\leftarrow nod{e}^{(k)}$为根结点的子树（在剪枝处理中，指的是被剪掉的那一部分 candidates）：$T_t^{(k)}$
• 在第 $k$次迭代剪枝中，剪掉结点$nod{e}^{(k)}$以下的所有树枝，剩余的树：$T^{(k)}=T_{rootnode}^{(k)}$

 

2. 递归问题

• 用较简单的问题来表示较复杂的问题。
• 不能产生自己调用自己的无穷序列。即必须要有一个是递归出去的出口。
   

3. P问题

1. P类问题 ( Polynomial )：所有可以在多项式时间内求解的判定问题构成P类问题，P类问题就是指那些计算机比较容易算出答案的问题。

2. 判定问题：判断是否有一种能够解决某一类问题的能行算法的研究课题。

3. NP类问题 (Non-deterministic Polynomial )：所有的非确定性多项式时间可解的判定问题构成NP类问题，指那些已知答案以后计算机可以比较容易地验证答案的问题。

4. 非确定性算法：非确定性算法将问题分解成猜测和验证两个阶段。

5. NPC问题：NP中的某些问题的复杂性与整个类的复杂性相关联.这些问题中任何一个如果存在多项式时间的算法,那么所有NP问题都是多项式时间可解的.这些问题被称为NP-完全问题(NPC问题)。
    
    

1.Decision Tree

1.1 What is Decision Tree?

1.11 Intuitively

  决策树是一种基本的分类与回归方法。在分类问题中，决策树表示的是基于特征对于实例进行分类的过程，我们可以也认为它是定义在特征空间和类空间上的条件概率分布。
  一般情况下，决策树由结点和有向边组成 (下图中的橘色有向枝干)。结点有三种类型，一个根节点 ( 如下图所示的“quitting time”)，内若干个内部节点 ( “has a date” & “deadline”) 和若干个叶节点( i.e.“YES” 和 “NO”)。
  根节点包含全体样本，内部节点对应着实例的特征测试，其包含着根据测试结果分配到此的样本。如此递归地对实例进行特征测试和分配，直至叶节点。最后，叶节点对应着决策的结果。

 我们提到某个节点的时候，不仅仅是说这个节点的判断条件，还有在当前结点下的样本。

 从根节点到叶节点对应了一个判定测试序列，可以将其看成是一个 if-then 规则的集合。这样的规则集合具有一个重要性质：互斥且完备。
 决策树还可以表示在给定特征条件下类的概率分布。假设 $X$为表示特征的随机变量，$Y$表示类的随机变量，那么这个条件概率分布可以表示为 $P(Y|X)$.

• 分类与回归方法
• 决策，条件概率
• 有向，有序
   

1.12 Mathematically

决策树可以用两种基本的数学形式表示：

1. 条件概率的形式：

$$G(\mathbf{x})=\sum _{t=1}^T{q}_t(\mathbf{x})g_t(\mathbf{x})$$

• base hypothesis $g_t(\mathbf{x})$: leaf at end of path $t$, a constant here
• condition $q_t(\mathbf{x}):I[is\mathbf{x}onpatht?]$
• $t=|rootnode|=|path|,eg:t=5$ in the figure above

2. 递归的形式：
$$\begin{gathered} G(\mathbf{x})=\sum _{c=1}^{C}I[b(\mathbf{x})=c]G_c(\mathbf{x}) \\ ... \end{gathered}$$

• $G(\mathbf{x})$: full-tree hypothesis
• $b(\mathbf{x})$: branching critieria
• $G_c(\mathbf{x})$: sub-tree hypothesis at the c_th branch. For example, C=3 at root node，C=2 at the left leaf node and 3 for the right one.
   
   

1.2 Why Decision Tree?

模型具有可解释性，可读性；分类速度快，学习的时候，利用训练数据，根据损失函数最小化的原则建立决策树模型。

• explainable
• simple and efficient
   

1.3 How Decision Tree?

目标：生成一棵泛化能力强的树

决策树学习通常包括三个步骤：特征选择 → 决策树的生成 → 决策树的修剪

本小节先介绍决策树（分类树和回归树）的基本生成方法，再介绍特征选择和修剪。

1.31 Generation

1.31-1 ClassificationTree

Input: $DataSetD=[(x_1,y_1),...,(x_N,y_N)];AttributeSetA=[a_1,...,a_d]$
Output: $Treewithrootnodes$

$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$

1. $getnode$
2. $if{y}_{n}allthesame,\mathbf{t}\mathbf{h}\mathbf{e}\mathbf{n}$
3.   $leafnode\leftarrow y_n{}^{\prime }slable$
4. $\mathbf{e}\mathbf{n}\mathbf{d}\mathbf{i}\mathbf{f}$
5. $if{\mathbf{x}}_{\mathbf{n}}allthesameorA=\varphi ,\mathbf{t}\mathbf{h}\mathbf{e}\mathbf{n}$
6.   leaf node $\leftarrow$ the majority of $y_n{}^{\prime }s$lable
7. $\mathbf{e}\mathbf{n}\mathbf{d}\mathbf{i}\mathbf{f}$
8. $choose{a}_{\ast }\in A(\mathbf{b}\mathbf{a}\mathbf{s}\mathbf{e}\mathbf{d}\mathbf{o}\mathbf{n}\mathbf{s}\mathbf{o}\mathbf{m}\mathbf{e}\mathbf{r}\mathbf{u}\mathbf{l}\mathbf{e}\mathbf{s})$
9. $foreveryvaluein{a}_{\ast }^{v}do(\mathbf{d}\mathbf{i}\mathbf{s}\mathbf{c}\mathbf{e}\mathbf{r}\mathbf{e}\mathbf{t}\mathbf{v}\mathbf{a}\mathbf{l}\mathbf{u}\mathbf{e}\mathbf{s})$
10.   $getbranchfornode;and{D}_v$
11.   $if{D}_{v}is\varphi ,\mathbf{t}\mathbf{h}\mathbf{e}\mathbf{n}$
12.     $leafnode\leftarrow branchnode\leftarrow themajorityof{y}_n{}^{\prime }slable$
13.   $\mathbf{e}\mathbf{l}\mathbf{s}\mathbf{e}(\mathbf{r}\mathbf{e}\mathbf{p}\mathbf{e}\mathbf{a}\mathbf{t}1-12)$
14.    $branchnode\leftarrow TreeGenerate(D_v,A$\ {$a_{\ast }$})
15.   $\mathbf{e}\mathbf{n}\mathbf{d}\mathbf{i}\mathbf{f}$
16. $\mathbf{e}\mathbf{n}\mathbf{d}\mathbf{i}\mathbf{f}$

$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$
 

1.31-2 OLS RegressionTree

Input: $DataSetD=[(x_1,y_1),...,(x_N,y_N)];AttributeSetA=[a_1,...,a_d]$
Output: $RegressionTreewithrootnodes$
$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$

1. Split the input space $X$
2. for every attribute $a_i\in A$ do
3.   choose a value $s_j(s_j\in range({\mathbf{x}}^{(\mathbf{i})}))$, calculate
4.     $R_1(a_i,s_j)=[x|x^{(i)}\le s_j],R_2(a_i,s_j)=[x|x^{(i)}>s_j]$
5.    $c_1(a_i,s_j)=average(R_1(a_i,s_j)),c_2(a_i,s_j)=average(R_2(a_i,s_j))byOLS$
6.   $s^{\ast }\leftarrow \underset{s_j}{\min }\sum _{{\mathbf{x}}_{\mathbf{n}}\in R_1}(y_n-c_1{)}^2+\underset{s_j}{\min }\sum _{{\mathbf{x}}_{\mathbf{n}}\in R_2}(y_n-c_1{)}^{2}byOLS$
7. $a^{\ast }\leftarrow \underset{a_i}{\min }[\underset{s_j}{\min }\sum _{{\mathbf{x}}_{\mathbf{n}}\in R_1}(y_n-c_1{)}^2+\underset{s_j}{\min }\sum _{{\mathbf{x}}_{\mathbf{n}}\in R_2}(y_n-c_1{)}^2]$
8. $R_1^{\ast },R_2^{\ast }\leftarrow R_1(a^{\ast },s^{\ast })=[x|x^{(i)}\le s^{\ast }],R_2(a^{\ast },s^{\ast })=[x|x^{(i)}>s^{\ast }]$
9. $|X|remainsN,howeverd=d-1,A=A$ \ {$a^{\ast }$}$,repeat1to9$
10. Meet termination
11. Return RegressionTree : $G(\mathbf{x})={\sum }_{m=1}^M{c}_{m}I[\mathbf{x}\in {\mathbf{R}}_{\mathbf{m}}]$

$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$
 

1.31-3 二分法 Bi-Partition

在决策树的生成过程中，可能存在一部分特征为连续型变量的情况。可以采用二分法对其进行离散化，之后再按照离散型变量的特征选择方式进行处理。

Input: $DataSetD=[(x_1,y_1),...,(x_N,y_N)];AttributeSetA=[a_1,...,a_d]$
Output: $continuousvariablewiththresholdt.$
$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$

1. 将离散型特征 $a_i$进行排序（$a_i$共有$V$种取值）得到：{$a_i^1,a_i^2,...,a_i^V$}$,v=1,2,...,V$
2. 选择划分点 $t_i$，$D_t{}_i^{+}=$ {${\mathbf{x}}_{\mathbf{n}}|{{\mathbf{x}}_{\mathbf{n}}}^{(i)}>t_i$}, $D_{t_i}^{-}=$ {${\mathbf{x}}_{\mathbf{n}}|{{\mathbf{x}}_{\mathbf{n}}}^{(i)}\le t_i$}
3.  $t_i^{\ast }\leftarrow \underset{t_i\in (\frac{a_i^v+a_i^{v+1}}{2}|1\le v\le V-1）}{\mathrm{argmin}}impurity(D_t^{+},D_t^{-})$
4. 输出特征 $a_i$ 和其划分点 $t_i^{\ast }$

$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$
 
 

1.32 Feauture selection ( Impurity )

1.32-1 信息增益 Information Gain

熵 (entropy)
对于离散型特征变量，$P(X=x_k)=p_k,k=1,2,...,K$

• 表示随机变量不确定性的度量
• 离散变量中，$H(X)=-\sum p_{k}log{p}_k(define0log0=0)$
• $H(\mathbf{x})$越大，随机变量的不确定性就越大，样本纯度越低
• 对数往往以2或自然数e为底
• $p=0$ 或 $p=1$时，随机变量完全没有不确定性。
• $p=0.5$，熵最大，随机变量不确定性最大，样本纯度最低。
• 条件熵：$H(Y|X)=\sum p_{k}H(Y|X=x_k)$
• 熵，条件熵 → 数据估计（特别是极大似然估计）→ 经验熵，条件经验熵

记样本的信息熵为 $$entro(D)=-\sum _{k=1}^K{p}_{k}lo{g}_{2}k$$
 

信息增益 (information gain)

• 熵与条件熵的差值称之为互信息 → 决策树中→训练数据中类 (lable)与特征 (attribute)的互信息
• 特征 $a$ 对于训练数据 $D$的信息增益：$gain(D,a)=entro(D)-entro(D|a)$
• 表示由于特征 $a$而使得对于数据集 $D$进行分类的不确定减少的程度
• 信息增益越大的特征，具有更强的分类能力 → the bigger，the better
• 对于可取数值数目较多的特征有所偏好

记特征 $a$对于样本 $D$ 的信息增益为 $$gain(D,a)=entro(D)-\sum _{v=1}^V\frac{|D^v|}{|D|}entro(D^v)$$
 

1.32-2 信息增益率 Information Gain Ratio

• 矫正信息增益的偏好：$|a_i|$ 大的。 例如，颜色这一特征有17个取值，分支后每个结点只有一两个样本，不具备泛化能力。
• 对于可取数值数目较少的特征有所偏好
• 特征 $a$ 的取值越多，即 $V$越大，则 $IV(a)$往往越大

记特征 $a$对于样本 $D$的信息增益率为：
$$\begin{gathered} gainRatio(D,a)=\frac{gain(D,a)}{IV(a)} \\ IV=-\sum _{v=1}^V\frac{|D^v|}{|D|}lo{g}_2\frac{|D^v|}{|D|} \end{gathered}$$
 

1.32-3 基尼指数 Gini Index

• 反映了从$D$中随机抽取两个样本，其标记类别 (lable) 不一样的概率
• $Gini(D)$越小，$D$ 纯度越高 $\to$ the smaller, the better

记数据集 $D$的基尼指数为
$$Gini(D)=1-\sum _{v=1}^V{p_k}^2$$

 

1.32-4 Regression Error

• 回归问题
• 二分

选择最优属性 $a_{\ast }$和 分支阈值 branch criteria $s_{\ast }$
$$a^{\ast },s^{\ast }=\underset{a_i}{\min }[\underset{s_j}{\min }\sum _{{\mathbf{x}}_{\mathbf{n}}\in R_1}(y_n-c_1{)}^2+\underset{s_j}{\min }\sum _{{\mathbf{x}}_{\mathbf{n}}\in R_2}(y_n-c_2{)}^2]$$
 

1.33 剪枝 Pruning

1.33-1 预剪枝

1. 在每个结点划分前先进行估计
2. 基于信息增益准则
3. 留出验证法
4. 划分后，并不能提升验证集的精准度，则禁止划分
5. 决策树桩 decision stump；带来欠拟合风险

 

1.33-2 后剪枝

在生成决策树的时候， 我们往往考虑最小化其损失函数 [ in Lin’s PPT ]
$$\begin{gathered} \underset{allpossibleG}{\mathrm{argmin}}Er{r}_{in}(G)+\lambda \Omega (G) \\ \to asGcannotenumerateallpossibleGcomputationally \\ \to \underset{G^{(1)}{G}^{(2)}...,G^{(t)}}{\mathrm{argmin}}Er{r}_{in}(G^{(i)})+\lambda \Omega (G^{(i)}) \end{gathered}$$
$\lambda \ge 0$ 是参数，$\Omega (G)$是该树的叶节点个数

$$\begin{gathered} G^{(0)}=fully-growntree \\ {G}^{(i)}=argmi{n}_{G}Er{r}_{in}(G)suchthatGisone-leaf(orwecansayone-node)removedfrom{G}^{(i-1)} \end{gathered}$$

1. NP问题：不能遍历穷举所有的树再取最优
2. 考虑：在生成完整的决策树之后，根据验证集上各个子树的预测精度表现，决定如何进行剪枝处理。
3. 对树中所有非叶节点的结点（根结点和内部结点）进行逐一考察
4. 自下向上，直至根节点
5. 比预剪枝决策树往往保留了更多的分支
    

1.33-3 CART剪枝

为了便于理解，在后文中，我们定义树 $T$的损失函数为：
$$Cost(T,\alpha )=Er{r}_{in}(T)+\alpha |T|$$
定义内部结点的损失函数为$$Cost(nod{e}^{(i)},\alpha )=Er{r}_{in}(nod{e}^{(i)})+\alpha (as|nod{e}^{(i)}|=1)$$

以上图为例，$treeT$表示已经生成的完整的树，共包含4个内部结点（1个根结点和3个叶结点）。需要注意的是，如果最终在根节点处进行剪枝处理，说明这棵树根本没有存在的必要，经过层层决策，带来的只是复杂度的增加）。
现在，我们选择结点 $t_2$, 判断是否在当前结点进行剪枝处理（若进行剪枝处理，则结点 $t_4，t_5，t_8$和 $t_9$内的样本都向上退回到结点 $t_2$内）。记以 $t_2$为根结点的子树为$T_{t_2}$，以$t_2$为单结点（之一叶节点）的子树 ( 即对整树剪枝之后得到的子树 ) 为 $T-T_{t_2}$。

对于原整树 $T_{t_1}$来说，其损失函数为：
$$Cost(treeT,\alpha )=Cost(T_{t_1},\alpha )=Er{r}_{in}(T_{t_1})+\alpha |T_{t_1}|$$
对于被剪掉的子树 $T_{t_2}$：$$Cost(T_{t_2},\alpha )=Er{r}_{in}(T_{t_2})+\alpha |T_{t_2}|$$

对于剪枝后的子树 $T-T_{t_2}$：
$$Cost(T-T_{t_2},\alpha )=Er{r}_{in}(T-T_{t_2})+\alpha |T-T_{t_1}|$$

判断是否进行剪枝处理，我们考虑的当然是剪枝之后的树和原来的树相比，损失函数有没有大幅度增加。在上例中，我们对 $Cost(T-T_{t_2},\alpha )$和 $Cost(T_{t_1},\alpha )$进行比较。

若剪枝之后，损失函数较原树增加，则不进行剪枝处理：
$$Cost(T-T_{t_2},\alpha )-Cost(T_{t_1},\alpha )>0\to \alpha <\frac{Er{r}_{in}(T-T_{t_2})-Er{r}_{in}(T_{t_1})}{|T_{t_1}|-|T-T_{t_2}|}$$
若剪枝之后，损失函数跟原树相同，但是剪枝之后的树的复杂度减少，因而应该进行剪枝处理：
$$Cost(T-T_{t_2},\alpha )-Cost(T_{t_1},\alpha )=0\to \alpha =\frac{Er{r}_{in}(T-T_{t_2})-Er{r}_{in}(T_{t_1})}{|T_{t_1}|-|T-T_{t_2}|}$$
若剪枝之后，损失函数反而减少，要进行剪枝处理：
$$Cost(T-T_{t_2},\alpha )-Cost(T_{t_1},\alpha )<0\to \alpha >\frac{Er{r}_{in}(T-T_{t_2})-Er{r}_{in}(T_{t_1})}{|T_{t_1}|-|T-T_{t_2}|}$$

因此，如果 $\alpha \in (0,\frac{Er{r}_{in}(T-T_{t_2})-Er{r}_{in}(t_1)}{|T_{t_1}|-|T-T_{t_2}|}$$)$, 则不进行剪枝处理，当前整树就是最优的。
如果 $\alpha \in [\frac{Er{r}_{in}(T-T_{t_2})-Er{r}_{in}(t_1)}{|T_{t_1}|-|T-T_{t_2}|},+\infty$$)$, 则需要进行剪枝处理。

 

对$\frac{Er{r}_{in}(T-T_{t_2})-Er{r}_{in}(T_{t_1})}{|T_{t_1}|-|T-T_{t_2}|}$进行化简，子树 $T-T_{t_2}$与原树的损失函数之差，相当于结点 {$t_2,t_6,t_7$}与{$t_8,t_9,t_5,t_6,t_7$}的损失函数之差，进一步简化后为 {$t_2$}与 {$t_8,t_9,t_5$}的损失函数之差，此为结点 $t_2$与以该点为根结点的子树的损失函数之差；而原树 $T_{t_1}$和剪枝处理后的子树 $T-T_{t_2}$的结点数目之差相当于被剪掉的那个树 $T_{t_2}$的结点数目再减去一 ( 因为结点$t_2$在剪枝处理后，作为单结点（叶结点）仍保留在树中)。
$$\begin{gathered} Er{r}_{in}(T-T_{t_2})-Er{r}_{in}(t_1)=Er{r}_{in}(nod{e}_{t_2})-Er{r}_{in}(T_{t_2}) \\ |T_{t_1}|-|T-T_{t_2}|=|T_{t_2}|-1 \end{gathered}$$
 

不失一般性地，定义子树 $T_t^{(i)}$（以 $t\leftarrow nod{e}^{(i)}$为根结点的子树）损失函数为：
$$Cost(T_t^{(i)},\alpha )=Er{r}_{in}(T_t^{(i)})+\alpha |T_t^{(i)}|$$
同样地，定义内部结点 $i$ 内的损失函数为$$Cost(nod{e}^{(i)},\alpha )=Er{r}_{in}(nod{e}^{(i)})+\alpha ,(as|nod{e}^{(i)}|=1)$$
当$\alpha$一定时，将剪枝处理后整体的损失函数减少的程度定义如下；如果 $g_i$过小，我们则认为相较于复杂程度的增加，该树的损失函数并没有明显改善（平均计算下来，被剪掉的部分里，每个结点消灭的“损失”很小），则应该进行剪枝处理。$$g^{(k)}=\frac{Er{r}_{in}(nod{e}_t^{(k)})-Er{r}_{in}(T_t^{(k)})}{|T_t^{(k)}|-1}$$

 

剪枝处理，可以概括为遍历和循环。
遍历指的是，在进行每次选结点的时候，要对当前树内所有的结点计算 $g_t$，每次都选择 $g_t$最小的结点进行剪枝处理。
循环指的是，在剪枝后剩下来的树中，反复迭代上述操作。
 

Input : a fully tree $T^{(1)}withinnernodes{t}_1,t_2,t_3,...$
Output: the best pruning tree $T^{\ast }$
$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$

1. generate sub-trees
2.  initialize $k=1,{\alpha }^{(1)}=0$
3.  for all innner nodes $t\in$ $T^{(1)}$ do
    $Cost(T_t^{(1)},\alpha )=Er{r}_{in}(T_t^{(1)})+\alpha |T_t^{(1)}|$
    $Cost(nod{e}^{(1)},\alpha )=Er{r}_{in}(nod{e}^{(1)})+\alpha$
    $g_t^{(1)}=\frac{Er{r}_{in}(nod{e}^{(1)})-Er{r}_{in}(T_t^{(1)})}{|T_t^{(1)}|-|nod{e}^{(1)}|},g_t^{(1)}=(g_{t_1}^{(1)},g_{t_2}^{(1)},...,)$
    $nod{e}_{\ast }^{(1)}=\underset{t}{\mathrm{argmin}}{g}_t^{(1)}$
    $\mathbf{t}\mathbf{h}\mathbf{e}\mathbf{n}$

   $T^{(2)}=T^{(1)}-T_{nod{e}_{\ast }^{(1)}}^{(1)}$
  ${\alpha }^{(1)}=min(g_t^{(1)})$
 

4.   $k=k+1$
    for all innner nodes $t\in$ $T^{(k)}$ do
    $Cost(T_t^{(k)},\alpha )=Er{r}_{in}(T_t^{(k)})+\alpha |T_t^{(k)}|$
    $Cost(nod{e}^{(k)},\alpha )=Er{r}_{in}(nod{e}^{(k)})+\alpha$
    $g_t^{(k)}=\frac{Er{r}_{in}(nod{e}^{(k)})-Er{r}_{in}(T_t^{(k)})}{|T_t^{(k)}|-|nod{e}^{(k)}|},g_t^{(k)}=(g_{t_1}^{(k)},g_{t_2}^{(k)},...,)$
    $nod{e}_{\ast }^{(k)}=\underset{t}{\mathrm{argmin}}{g}_t^{(k)}$
    $\mathbf{t}\mathbf{h}\mathbf{e}\mathbf{n}$

   $T^{(k+1)}=T^{(k)}-T_{nod{e}_{\ast }^{(k)}}^{(k)}$
  ${\alpha }^{(k)}=min(g_t^{(k)})$

 

5. return {${\alpha }^{(k)},T^{(k)}$}，
    
    ${\alpha }^{(1)}\le {\alpha }^{(2)}\le {\alpha }^{(3)}\le ...$
    $T^{(1)}\supseteq T^{(2)}\supseteq T^{(3)}\supseteq ...$
    $T^{(1)}\leftarrow (0,{\alpha }^{(1)}),T^{(2)}\leftarrow [{\alpha }^{(1)},{\alpha }^{(2)}),...$

$$----\ast \ast Algorithm\ast \ast ------------------------------------------------------------$$

 

1. 子树和内部节点的损失函数
2. 交叉验证法选择最优子树
    
    

1.4 常见算法

1.41 CART

 Classification：Gini-Index+CART 剪枝
  Regression：OLS Regression Error+CART 剪枝
 

1.42 ID3

 信息增益+？
 

1.43 C4.5

 信息增益比+？