第五章:决策树
决策树(decision tree)是一种分类与回归方法,它可以认为是if-then结构
5.1 决策树模型与学习
5.1.1 决策树模型
定义 5.1 (决策树):
分类决策树模型是一种描述实例进行分类的树形结构,决策树由节点(node),和有向边(directed edge)组成。节点由两种类型:内节点(internal tree)和叶节点(leaf node),内部节点表示一个特征或者属性,叶节点表示一个类
5.1.2 决策树与if-then规则
5.1.3 决策树与条件概率分布
决策树还表示给定特征条件下类的条件概率分布,这一条概率分布定义在特征空间的一个划分上(partition),将特征空间分为互不交集的单元(cell)或区域(region)中,并在每一个单元定义一个类的概率分布就构成了一个条件概率。
5.1.4 决策树学习
假设给定训练数据集:
D
=
(
x
1
,
y
1
)
,
(
x
2
,
y
2
)
,
.
.
.
,
(
x
N
,
y
N
)
D=(x_1, y_1), (x_2, y_2), ...,(x_N, y_N)
D=(x1,y1),(x2,y2),...,(xN,yN)
其中:
x
i
=
(
x
i
(
1
)
,
x
i
(
2
)
,
.
.
.
,
x
i
(
n
)
)
T
x_i = (x_i^{(1)}, x_i^{(2)}, ..., x_i^{(n)})^T
xi=(xi(1),xi(2),...,xi(n))T为输入实例(特征向量),
n
n
n为特征个数,
y
i
∈
{
1
,
2
,
.
.
.
,
K
}
y_i \in \left\{1, 2, ..., K\right\}
yi∈{1,2,...,K}为类标记,
i
=
1
,
2
,
.
.
.
,
N
i = 1, 2, ..., N
i=1,2,...,N,
N
N
N为样本容量。学习的目标是更狠绝给定的训练数据集构建一个决策树模型,使它能够对实例进行正确的分类。
决策树学习的本质是从训练集中归纳出一组分类规则。我们需要找的是一个与训练数据矛盾较小的决策树,同时又具有很好的泛化能力。
决策树学习用损失函数表示这一目标。如下所述,损失函数通常是正则化的极大似然函数。决策树的学习策略是以损失函数为目标的最小化。
从所有可能的决策树中选取最优的是一种NP完全问题所以现实中决策树通常采用启发式学习的方式。
决策树的学习过程通常是递归的找到最优解,并根据该特征对训练数据进行分割,使得各个子数据集有一个最好的分类的一个过程。
- 选择一个最优特征,按照这个特征将训练集数据分割成子集,使得各个子集有一个在当前条件下最好的分类。
- 如果这些子集已经可以被基本正确分类,那么构建叶节点,并将子集分割到各个的叶节点之中去。
- 如果还有子集不能被正确分类,那么就对这些子集选择新的最优特征,继续对其进行分割,构建相应的节点。
- 递归的进行下去,直到所有训练数据子集被基本正确分类,或者没有合适的特征为止。
5.2 特征选择
5.2.1 特征选择问题
特征在选择时遵循的原则是特征增益或特征增益比。
其中,特征增益指的就是对于现有的数据集
D
D
D的信息熵(entropy),选取数据集中的一个特征后,由于选取了特征
A
A
A使数据集的信息熵产生了下降,下降的数值就是信息增益(information gain).也就是条件熵(conditional entropy)与信息熵的差。
5.2.2 信息增益
对于离散型随机变量X,其熵的定义为:
H
(
X
)
=
−
∑
i
=
1
n
p
i
l
o
g
p
i
H(X) = - \sum_{i=1}^n p_i logp_i
H(X)=−i=1∑npilogpi通常的时候,上述公式中的log以2为底,熵的单位为比特(bit)。从上述公式中可以看出离散型随机变量X的熵与X本身的取值无关,所以上述公式可以记作
H
(
p
)
=
−
∑
i
=
1
n
p
i
l
o
g
p
i
H(p) = - \sum_{i=1}^n p_i logp_i
H(p)=−i=1∑npilogpi熵越大,随机性就越大,由熵的定义可知:
0
⩽
H
(
p
)
⩽
log
n
0\leqslant H(p) \leqslant \log{n}
0⩽H(p)⩽logn
当随机变量只取两个值(例如0-1分布)即
P
(
X
=
1
)
=
p
,
P
(
X
=
0
)
=
1
−
p
P(X=1) = p,P(X=0) = 1-p
P(X=1)=p,P(X=0)=1−p
则熵为:
H
(
p
)
=
−
p
log
2
p
−
(
1
−
p
)
log
2
(
1
−
p
)
H(p)=-p \log_2p - (1-p) \log_2(1-p)
H(p)=−plog2p−(1−p)log2(1−p)
当 p=0 或者p=1 时,H§=0,随机变量没有不确定性。当p=0.5 时H§=1,熵的取值最大,随机变量的不确定性最大。
条件熵
H
(
Y
∣
X
)
H(Y|X)
H(Y∣X)表示在已知随机变量X的条件下,随机变量Y的不确定性。随机变量X给定的条件下随机变量Y的条件熵(conditional entropy)
H
(
Y
∣
X
)
H(Y|X)
H(Y∣X),定义为X给定条件下Y的条件概率分布的数学期望。
H
(
Y
∣
X
)
=
∑
i
=
1
n
p
i
H
(
Y
∣
X
=
x
i
)
H(Y|X) = \sum_{i=1}^n p_i H(Y|X=x_i)
H(Y∣X)=i=1∑npiH(Y∣X=xi)
对于条件熵的理解,在后面贷款人信息审核的计算中会有详细的讲解,但是在这里我个人暂时总结为:
在给定的数据集D中,数据集整体的熵是由标签列,也就是最后一列按照熵的计算公式来计算出来的。在选定一个条件A后,也就是选定个特征列之后(就是除了最后一列的其他列),选定这个动作会对整体的不确定性产生影响。(这其实很好理解,我们对于一个数据集确定的数据越多,那么这个数据集对于我们来说不确定性当然就越小)
定义5.2(信息增益):特征A队训练数据集D的信息增益g(D,A),定义为集合D的经验熵
H
(
D
)
H(D)
H(D)与特征A给定的条件下D的经验条件熵
H
(
D
∣
A
)
H(D|A)
H(D∣A)之差,即:
g
(
D
,
A
)
=
H
(
D
)
−
H
(
D
∣
A
)
g(D,A) = H(D) - H(D|A)
g(D,A)=H(D)−H(D∣A)
一般的熵与条件熵之差称为互信息(mutual information).决策树学习中的信息增益等价于训练集数据中类与特征的互信息
算法5.1(信息增益的算法):
输入:训练数据集D和特征A:
输出:特征A对训练数据集D的信息增益g(D,A)
(1) 计算数据集D的经验熵H(D):
H
(
D
)
=
−
∑
k
=
1
K
∣
C
k
∣
∣
D
∣
log
2
∣
C
k
∣
∣
D
∣
H(D)=- \sum_{k=1}^K \frac{|C_k|}{|D|} \log_2\frac{|C_k|}{|D|}
H(D)=−k=1∑K∣D∣∣Ck∣log2∣D∣∣Ck∣
(2) 计算特征A对数据集D的经验条件熵H(D|A):
H
(
D
∣
A
)
=
∑
i
=
1
n
∣
D
i
∣
∣
D
∣
H
(
D
i
)
=
−
∑
i
=
1
n
∣
D
i
∣
∣
D
∣
∑
k
=
1
K
∣
D
i
k
∣
∣
D
i
∣
log
2
∣
D
i
k
∣
∣
D
i
∣
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|}}
H(D∣A)=i=1∑n∣D∣∣Di∣H(Di)=−i=1∑n∣D∣∣Di∣k=1∑K∣Di∣∣Dik∣log2∣Di∣∣Dik∣
(3) 计算信息增益:
g
(
D
,
A
)
=
H
(
D
)
−
H
(
D
∣
A
)
g(D,A)=H(D)-H(D|A)
g(D,A)=H(D)−H(D∣A)
5.2.3 信息增益比
以信息增益作为划分训练数据集的特征,存在偏向于选择取值较多的特征的问题,使用信息增益比(information gain ratio),可以对这个问题进行矫正,这是特征选择的另一个准则。
5.3 决策树的生成
5.3.1 ID3算法
ID3算法的核心是在决策树的各个节点上应用信息增益准则选择特征,递归地构建决策树,具体方法是:从根节点(root node)开始,对节点计算所有可能的特征的信息增益,选择信息增益最大的特征作为节点的特征,由该特征的不同取值建立子节点;再对子节点递归的调用以上的方法,构建决策时;直到所有特征的信息增益均很小或者没有特征可以选为止。最后的到一个决策树。ID3相当于用极大似然估计法进行概率模型的选择
算法5.2(ID3算法)
输入:训练数据集D,特征集A,阈值
ϵ
\epsilon
ϵ
输出:决策树T
- 若 D D D中所有的实例都属于同一类 C k C_k Ck,则 T T T为单节点树,并将类 C k C_k Ck作为该节点的标记,返回 T T T;
- 若 A = ∅ A=\emptyset A=∅,则 T T T为单节点树,并将 D D D中实例数最大的类 C k C_k Ck作为该节点的累标记,返回 T T T;
- 否则,按算法5.1计算 A A A中各个特征对 D D D的信息增益,选择信息增益最大的特征 A g A_g Ag;
- 如果 A g A_g Ag的信息增益小于阈值 ϵ \epsilon ϵ,则置 T T T为单节点树,并将 D D D中实例树最大的类 C k C_k Ck作为该节点的类标记,返回 T T T;
- 否则,对 A g A_g Ag的每一个可能值 a i a_i ai,依 A g = a i A_g = a_i Ag=ai 将 D D D分割为若干非空子集 D i D_i Di,将 D i D_i Di中实例数最大的类作为标记,构建子节点,由节点以及子节点构成树 T T T,返回 T T T;
- 对于第i个子节点,以 D i D_i Di为训练集,以 A − A g A-A_g A−Ag为特征集,递归的调用1-5步,得到子树 T i T_i Ti,返回 T i T_i Ti
5.3.2 C4.5算法
C4.5s算法与ID3算法相似,对其进行了改进,C4.5在生成的过程中吗,用信息增益比来选择特征。
算法5.3(C4.5算法)
输入:训练数据集D,特征集A,阈值
ϵ
\epsilon
ϵ
输出:决策树T
- 若 D D D中所有的实例都属于同一类 C k C_k Ck,则 T T T为单节点树,并将类 C k C_k Ck作为该节点的标记,返回 T T T;
- 若 A = ∅ A=\emptyset A=∅,则 T T T为单节点树,并将 D D D中实例数最大的类 C k C_k Ck作为该节点的累标记,返回 T T T;
- 否则,按算法5.10计算 A A A中各个特征对 D D D的信息增益比,选择信息增益比最大的特征 A g A_g Ag;
- 如果 A g A_g Ag的信息增益比小于阈值 ϵ \epsilon ϵ,则置 T T T为单节点树,并将 D D D中实例树最大的类 C k C_k Ck作为该节点的类标记,返回 T T T;
- 否则,对 A g A_g Ag的每一个可能值 a i a_i ai,依 A g = a i A_g = a_i Ag=ai 将 D D D分割为若干非空子集 D i D_i Di,将 D i D_i Di中实例数最大的类作为标记,构建子节点,由节点以及子节点构成树 T T T,返回 T T T;
- 对于第i个子节点,以 D i D_i Di为训练集,以 A − A g A-A_g A−Ag为特征集,递归的调用1-5步,得到子树 T i T_i Ti,返回 T i T_i Ti
5.4决策树的剪枝
简而言之,决策树在对使用训练集进行训练时,往往都可以很好的拟合现有的数据,但是在出现新的数据进行预测时,由于过拟合,往往不能很好的进行预测,而决策树的剪枝就是要解决这一问题。
在决策树学习中,将已生成决策树进行简化的过程叫做剪枝(pruning)。具体地,剪枝从已生成的决策树熵裁掉一些叶子或者节点,并将其根节点或父节点作为新的叶子节点
决策树的剪枝往往通过极小化决策树整体的损失函数(loss function)或者代价函数(cost function)来实现。
决策树的损失函数可以定义为:
C
α
(
T
)
=
∑
t
=
1
∣
T
∣
N
t
H
t
(
T
)
+
α
∣
T
∣
C_{\alpha}(T)=\sum_{t=1}^{|T|}N_tH_t(T) + \alpha|T|
Cα(T)=t=1∑∣T∣NtHt(T)+α∣T∣
其中:
- ∣ T ∣ |T| ∣T∣:树T的叶节点总个数
- t t t:决策树的叶节点
- N t N_t Nt:叶节点中的样本点个数
- H t ( T ) H_t(T) Ht(T):叶子节点t上的经验熵
- α \alpha α:参数,当值较大的时候更偏向于选择较为简单的决策树模型
上式中经验熵 H t ( T ) H_t(T) Ht(T)定义为: H t ( T ) = − ∑ k N t k N t log N t k N t H_t(T)=-\sum_k \frac{N_{tk}}{N_t}\log\frac{N_{tk}}{N_t} Ht(T)=−k∑NtNtklogNtNtk
在损失函数中将第一个公式中右端的第一项记作:
C
(
T
)
=
∑
t
=
1
∣
T
∣
N
t
H
t
(
T
)
=
−
∑
t
=
1
∣
T
∣
∑
k
=
1
K
N
t
k
log
N
t
k
N
t
C(T)=\sum_{t=1}^{|T|}N_tH_t(T)=-\sum_{t=1}^{|T|}\sum_{k=1}^{K}N_{tk}\log\frac{N_{tk}}{N_t}
C(T)=t=1∑∣T∣NtHt(T)=−t=1∑∣T∣k=1∑KNtklogNtNtk
这时就会有: C α ( T ) = C ( T ) + α ∣ T ∣ C_{\alpha}(T) = C(T)+\alpha|T| Cα(T)=C(T)+α∣T∣
上式中 C ( T ) C(T) C(T)表示模型对训练数据的预测误差,即模型与训练数据的拟合程度 ∣ T ∣ |T| ∣T∣表示模型的复杂程度。
算法 5.4(树的剪枝算法):
输入:生成算法产生的整棵树
T
T
T,参数
α
\alpha
α;
输出:修建后的子树
T
α
T_{\alpha}
Tα
- 计算每一个节点的经验熵;
- 递归地从树的叶子节点向上回缩
设一组叶节点回缩到与其父节点之前与之后的整体树分别为 T B T_B TB与 T A T_A TA其对应的损失函数值分别是 C α ( T B ) C_{\alpha}(T_B) Cα(TB)和 C α ( T A ) C_{\alpha}(T_A) Cα(TA)如果: C α ( T A ) ⩽ C α ( T B ) C_{\alpha}(T_A)\leqslant C_{\alpha}(T_B) Cα(TA)⩽Cα(TB)则进行修剪,将父节点变为新的叶子节点 - 返回2,直到不能继续为止,得到损失函数最小的子树 T α T_{\alpha} Tα
5.5 CART算法
分类与回归树(classification and regression tree, CART)同样是由特征选择,树的生成以及树的剪枝组成,既可以用于分类也可以用于回归。
CART算法假定决策树是二叉树,
CART算法由以下两部分组成:
- 决策树的生成:基于训练数据集生成决策树,生成的决策树尽量要大;
- 决策树的剪枝:用验证数据集对已生成的树进行剪枝并选择最优子树,这时用损失函数最小作为剪枝的衡量标准
5.5.1 CART树的生成
5.5.1.1 回归树的生成
算法 5.5 (最小二乘回归树的生成算法):
输入:训练数据集D
输出:回归树
f
(
x
)
f(x)
f(x)
在训练数据集所在的输入空间中,递归地将每一个区域划分为两个子区域并决定每一个子区域上的输出值,构建二叉决策树:
- 选择最优切分变量
j
j
j以及切分点
s
s
s,求解:
min j , s [ min c 1 ∑ x i ∈ R 1 ( j , s ) ( y i − c 1 ) 2 + min c 2 ∑ x i ∈ R 2 ( j , s ) ( y i − c 2 ) 2 ] \min_{j,s}[\min_{c_1}\sum_{x_i\in{R_1(j,s)}}(y_i-c_1)^2 +\min_{c_2}\sum_{x_i\in{R_2(j,s)}}(y_i-c_2)^2] j,smin[c1minxi∈R1(j,s)∑(yi−c1)2+c2minxi∈R2(j,s)∑(yi−c2)2]遍历变量 j j j对固定的切分变量 j j j扫描切分点 s s s,选择使上式值达到最小的 ( j , s ) (j,s) (j,s) - 对选定的
(
j
,
s
)
(j,s)
(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}\leqslant s\}, R_2(j,s) = \{x|x^{j}> s\}
R1(j,s)={x∣xj⩽s},R2(j,s)={x∣xj>s}
c m n i c e = 1 N m ∑ x i ∈ R m ( j , s ) y i , x ∈ R m , m = 1 , 2 c_m^{nice} = \frac{1}{N_m}\sum_{x_i\in{R_m(j,s)}} y_i, x\in R_m, m=1,2 cmnice=Nm1xi∈Rm(j,s)∑yi,x∈Rm,m=1,2 - 继续对两个子区域巧用步骤(1),(2),直至满足条件。
- 将输入控件划分成
M
M
M个区域
R
1
,
R
2
,
.
.
.
,
R
m
R_1,R_2,...,R_m
R1,R2,...,Rm,生成决策树:
f ( x ) = ∑ m = 1 M c m n i c e I ( x ∈ R m ) f(x)=\sum_{m=1}^Mc_m^{nice}I(x\in R_m) f(x)=m=1∑McmniceI(x∈Rm)
5.5.1.2 分类树的生成
分类树选用基尼指数选择最优特征,同时决定改特征的最优二值切分点。
**定义 5.4(基尼指数):**分类问题中,假设有
K
K
K个类,样本点属于第
k
k
k类的概率为
p
k
p_k
pk,则概率分布的基尼指数的定义为:
G
i
n
i
(
p
)
=
∑
k
=
1
K
p
k
(
1
−
p
k
)
=
1
−
∑
k
=
1
K
p
k
2
Gini(p) = \sum_{k=1}^K p_k(1-p_k)=1-\sum_{k=1}^K {p_k}^2
Gini(p)=k=1∑Kpk(1−pk)=1−k=1∑Kpk2对于二分类问题,若样本点属于第一个类的概率是p,则概率分布的基尼指数是:
G
i
n
i
(
p
)
=
2
p
(
1
−
p
)
Gini(p) = 2p(1-p)
Gini(p)=2p(1−p)对于给定的集合D,其基尼指数为
G
i
n
i
(
D
)
=
1
−
∑
k
=
1
K
(
∣
C
k
∣
∣
D
∣
)
2
Gini(D)=1-\sum_{k=1}^K (\frac{|C_k|}{|D|})^2
Gini(D)=1−k=1∑K(∣D∣∣Ck∣)2这里,
C
k
C_k
Ck是
D
D
D中属于第k类的样本子集,K是类的个数。如果样本集合D根据特征A是否取某一可能指a被分割成
D
1
,
D
2
D_1,D_2
D1,D2两部分,即
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的基尼指数定义为:
G
i
n
i
(
D
,
A
)
=
∣
D
1
∣
D
G
i
n
i
(
D
1
)
+
∣
D
2
∣
∣
D
∣
G
i
n
i
(
D
2
)
Gini(D,A) = \frac{|D_1|}{D} Gini(D_1) + \frac{|D_2|}{|D|} Gini(D_2)
Gini(D,A)=D∣D1∣Gini(D1)+∣D∣∣D2∣Gini(D2)
基尼指数Gini(D)表示集合D的不确定性,基尼指数Gini(D,A)表示经过A=a分割后集合D的不确定性,基尼指数越大,样本集合不确定性也就越大,这样与熵相似
算法 5.6 (CART生成算法)
输入:训练数据集D,停止计算的条件
输出:CART决策树
根据训练数据集,从根节点开始,递归地对每一个节点进行以下操作,构建二叉决策树:
- 设结点的训练数据集为 D D D,计算现有特征对该数据集的基尼指数。此时,对每一个特征A,对其可能取值的每一个a,根据样本点对 A = a A=a A=a的测试为“是”或“否”将 D D D分割成 D 1 , D 2 D_1,D_2 D1,D2两个部分,利用公式计算 A = a A=a A=a时的基尼指数。
- 在所有可能的特征 A A A以及它们所有可能的切分点a中,选择基尼指数最小的特征及对应的切分点作为最优特征与最优切分点。依据最优特征与最优切分点,从现节点生成两个子节点,将训练数据集依特征分配到两个子节点中去。
- 对两个子节点递归的调用1. 2.,直到满足停止条件。
- 生成CART决策树。
5.5.2 CART剪枝
CART剪枝算法从“完全生长”的决策树低端减去一些叶子,使决策树变小,从而能对未知数据具有更加准确的预测。CART剪枝算法由两部分组成,首先从生成算法产生的决策树
T
0
T_0
T0底端开始不断剪枝,直到
T
0
T_0
T0的根节点,形成一个子树的序列;然后通过交叉验证的方法在独立的验证数据集上对子树序列进行测试,从中选择最优子树。
算法5.7 (CART剪枝算法):
输入:CART算法生成的决策树
T
0
T_0
T0
输出:最优决策树
T
α
T_{\alpha}
Tα
- 设 k = 0 , T = T 0 k=0, T=T_0 k=0,T=T0
- 设 α = + ∞ \alpha=+ \infty α=+∞
- 自上而下的对各内部节点
t
t
t计算
C
(
T
t
)
C(T_t)
C(Tt),
∣
T
t
∣
|T_t|
∣Tt∣以及
g ( t ) = C ( t ) − C ( T t ) ∣ T t ∣ − 1 g(t)= \frac{C(t)-C(T_t)}{|T_t|-1} g(t)=∣Tt∣−1C(t)−C(Tt)
α = m i n ( α , g ( t ) \alpha = min(\alpha, g(t) α=min(α,g(t)这里,
T t T_t Tt表示以 t t t为根节点的子树, C ( T t ) C(T_t) C(Tt)使对训练集数据的预测误差, ∣ T t ∣ |T_t| ∣Tt∣是 T t T_t Tt的叶子节点的个数。 - 对 g ( t ) = α g(t)= \alpha g(t)=α的内部节点 t t t进行剪枝,并对叶节点 t t t以多数表决法决定其类,得到树T。
- 设 k = k + 1 , α k = α , T k = T k=k+1, \alpha_k = \alpha, T_k = T k=k+1,αk=α,Tk=T
- 如果 T k T_k Tk不是由根节点及两个叶节点构成的树,则回到步骤3,否则 T k = T n T_k = T_n Tk=Tn
- 采用交叉验证的方法验证最佳子树。