文章目录
简简单单一棵决策树,Eivind却差点死在这上面。
A long way to go.
Reference
机器学习技法课–台湾大学 林轩田
机器学习–周志华
统计学习方法–李航
CART算法
Machine Learning WIKI – CART算法
前言
1.符号
本文符号使用习惯与西瓜书和轩田老师的讲义保持一致。
- 训练资料 = 训练数据 = 训练集 = l e a r n i n g s e t learning \,set learningset
- D a t a S e t = DataSet= DataSet={ ( x 1 , y 1 ) , . . . , ( x N , y N ) (x_1,y_1),...,(x_N,y_N) (x1,y1),...,(xN,yN)}
- 样本数目: ∣ D ∣ = N |D|=N\quad ∣D∣=N
- 输出空间 :类别数目 K = ∣ O u t p u t S p a c e ∣ K=|Output \,Space| K=∣OutputSpace∣
- 输入空间 :特征数目 d = ∣ I n p u t S p a c e ∣ d=|Input \,Space| d=∣InputSpace∣
- 输入空间:特征 Attribute Set A A A= { a 1 , a 2 , . . . , a d a_1,a_2,...,a_d a1,a2,...,ad} , i = 1 , 2 , . . . , d ,\; i=1,2,...,d ,i=1,2,...,d
- 输入空间:离散型特征的取值 a i = a_i= ai={ a i 1 , a i 2 , . . . , a i V a_i^1,a_i^2,...,a_i^V ai1,ai2,...,aiV} , v = 1 , 2 , . . . , V ,\; v=1,2,..., V ,v=1,2,...,V
- 输入空间: 样本 x n \bf x_n xn 在某一特征 a i a_i ai上的取值 x n ( i ) x_n^{(i)} xn(i)
- 输入空间:在特征 a i a_i ai上取值为 a i ( v ) a_i^{(v)} ai(v)的样本集合 D v = D^v= Dv={ x ∣ x ( i ) = a i v x|x^{(i)}=a_i^{v} x∣x(i)=aiv}
- 输入空间:划分区域 R = R= R={ R 1 , R 2 , . . . , R M R_1, R_2, ...,R_M R1,R2,...,RM; m = 1 , 2 , . . . , M m=1,2,...,M m=1,2,...,M}
- 输出空间:划分区域上 y y y的均值 c m = a v e r a g e ( y n ∣ x n ∈ R m ) = 1 N m ∑ x n ∈ R m N m y n c_m=average(y_n|x_n\in R_m)={1 \over N_m} \mathop{\sum} \limits_{x_n \in R_m} ^{N_m} y_n\\[2ex] cm=average(yn∣xn∈Rm)=Nm1xn∈Rm∑Nmyn
- 输出空间:训练误差 E r r i n Err_{in} Errin
- 输出空间:测试误差 E r r o u t Err_{out} Errout
- hypothesis candidate: h ( x ) h({\bf x})\; h(x)
- base learner / subtree: g t ( x ) , t = 1 , 2 , . . . , T g_t({\bf x}),\; t=1,2,...,T gt(x),t=1,2,...,T
- branch: b ( x ) , c = 1 , 2 , . . . , C b({\bf x}),\;c=1,2,...,C b(x),c=1,2,...,C
- 在第 k k k次迭代剪枝中,所有的非叶结点集合: n o d e ( k ) node^{(k)} node(k)
- 在第 k k k次迭代剪枝中,选择剪枝的结点: n o d e ∗ ( k ) node^{(k)}_* node∗(k)
- 在第 k k k次迭代剪枝中,以结点 t ← n o d e ( k ) t \leftarrow node^{(k)} t←node(k)为根结点的子树(在剪枝处理中,指的是被剪掉的那一部分 candidates): T t ( k ) T_t^{(k)} Tt(k)
- 在第 k k k次迭代剪枝中,剪掉结点 n o d e ( k ) node^{(k)} node(k)以下的所有树枝,剩余的树: T ( k ) = T r o o t n o d e ( k ) T^{(k)}=T^{(k)}_{rootnode} T(k)=Trootnode(k)
2. 递归问题
- 用较简单的问题来表示较复杂的问题。
- 不能产生自己调用自己的无穷序列。即必须要有一个是递归出去的出口。
3. P问题
-
P类问题 ( Polynomial ):所有可以在多项式时间内求解的判定问题构成P类问题,P类问题就是指那些计算机比较容易算出答案的问题。
-
判定问题:判断是否有一种能够解决某一类问题的能行算法的研究课题。
-
NP类问题 (Non-deterministic Polynomial ):所有的非确定性多项式时间可解的判定问题构成NP类问题,指那些已知答案以后计算机可以比较容易地验证答案的问题。
-
非确定性算法:非确定性算法将问题分解成猜测和验证两个阶段。
-
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
X
X为表示特征的随机变量,
Y
Y
Y表示类的随机变量,那么这个条件概率分布可以表示为
P
(
Y
∣
X
)
P(Y|X)
P(Y∣X).
- 分类与回归方法
- 决策,条件概率
- 有向,有序
1.12 Mathematically
决策树可以用两种基本的数学形式表示:
1. 条件概率的形式:
G ( x ) = ∑ t = 1 T q t ( x ) g t ( x ) G{(\bf x)}=\sum_{t=1}^{T}q_t {(\bf x)} g_t(\bf x) G(x)=t=1∑Tqt(x)gt(x)
- base hypothesis g t ( x ) g_t(\bf x) gt(x): leaf at end of path t t t, a constant here
- condition q t ( x ) : I [ i s x o n p a t h t ? ] q_t({\bf x}): \; {I\,[}\,is \; {\bf x}\; on \;path\; t\;?] qt(x):I[isxonpatht?]
- t = ∣ r o o t n o d e ∣ = ∣ p a t h ∣ , e g : t = 5 t= |root\;node|=|path|,\quad eg: t=5 t=∣rootnode∣=∣path∣,eg:t=5 in the figure above
2. 递归的形式:
G
(
x
)
=
∑
c
=
1
C
I
[
b
(
x
)
=
c
]
G
c
(
x
)
.
.
.
G{(\bf x)}=\sum_{c=1}^{C}I \,[\,b({\bf x})=c]\,G_c({\bf x})\\ ...
G(x)=c=1∑CI[b(x)=c]Gc(x)...
- G ( x ) G({\bf x}) G(x): full-tree hypothesis
- b ( x ) b({\bf x}) b(x): branching critieria
-
G
c
(
x
)
G_c({\bf x})
Gc(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:
D
a
t
a
S
e
t
D
=
[
(
x
1
,
y
1
)
,
.
.
.
,
(
x
N
,
y
N
)
]
;
A
t
t
r
i
b
u
t
e
S
e
t
A
=
[
a
1
,
.
.
.
,
a
d
]
Data \,Set\;D=[(x_1,y_1),\;...,\; (x_N,y_N)] ; \;Attribute \,Set \;A=[a_1,\;...,a_d]
DataSetD=[(x1,y1),...,(xN,yN)];AttributeSetA=[a1,...,ad]
Output:
T
r
e
e
w
i
t
h
r
o
o
t
n
o
d
e
s
Tree \,with\, root\, nodes
Treewithrootnodes
− − − − ∗ ∗ A l g o r i t h m ∗ ∗ − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − ----\blue{**Algorithm**}------------------------------------------------------------ −−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
- g e t n o d e get \; node getnode
- i f y n a l l t h e s a m e , t h e n if \; y_n\; all\; the\; same, \bf then ifynallthesame,then
- l e a f n o d e ← y n ′ s l a b l e leaf\; node \leftarrow \; y_n\;'s \;lable leafnode←yn′slable
- e n d i f \bf end\; if endif
- i f x n a l l t h e s a m e o r A = ϕ , t h e n if \; {\bf {x_n}}\; all \;the\; same \;or \;A=\phi\;, \bf then ifxnallthesameorA=ϕ,then
- leaf node ← \leftarrow \; ← the majority of y n ′ s y_n\;'s \; yn′slable
- e n d i f \bf end \;if endif
- c h o o s e a ∗ ∈ A ( b a s e d o n s o m e r u l e s ) choose \;a_*\in A \;(\bf \red{based \;on \;some\; rules}) choosea∗∈A(basedonsomerules)
- f o r e v e r y v a l u e i n a ∗ v d o ( d i s c e r e t v a l u e s ) for\; every\; value \;in \;a_*^v\; do\,(\bf \red { disceret\; values}) foreveryvalueina∗vdo(disceretvalues)
- g e t b r a n c h f o r n o d e ; a n d D v get\; branch\; for\; node; and \; D_v getbranchfornode;andDv
- i f D v i s ϕ , t h e n if\; D_v \; is \; \phi,\;\bf then ifDvisϕ,then
- l e a f n o d e ← b r a n c h n o d e ← t h e m a j o r i t y o f y n ′ s l a b l e leaf\; node \leftarrow \; branch\; node\;\leftarrow the \; majority\; of \; y_n\,'s \;lable leafnode←branchnode←themajorityofyn′slable
- e l s e ( r e p e a t 1 − 12 ) \bf else\,(\bf \red { repeat\; 1-12}) else(repeat1−12)
- b r a n c h n o d e ← T r e e G e n e r a t e ( D v , A branch \;node\leftarrow TreeGenerate (D_v, A branchnode←TreeGenerate(Dv,A\ { a ∗ a_* a∗})
- e n d i f \bf end\; if endif
- e n d i f \bf end\; if endif
−
−
−
−
∗
∗
A
l
g
o
r
i
t
h
m
∗
∗
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
----\blue{**Algorithm**}------------------------------------------------------------
−−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
1.31-2 OLS RegressionTree
Input:
D
a
t
a
S
e
t
D
=
[
(
x
1
,
y
1
)
,
.
.
.
,
(
x
N
,
y
N
)
]
;
A
t
t
r
i
b
u
t
e
S
e
t
A
=
[
a
1
,
.
.
.
,
a
d
]
Data \,Set\;D=[(x_1,y_1),\;...,\; (x_N,y_N)] ; \; Attribute \,Set \;A=[a_1,\;...,a_d]
DataSetD=[(x1,y1),...,(xN,yN)];AttributeSetA=[a1,...,ad]
Output:
R
e
g
r
e
s
s
i
o
n
T
r
e
e
w
i
t
h
r
o
o
t
n
o
d
e
s
Regression \; Tree \,with\, root\, nodes
RegressionTreewithrootnodes
−
−
−
−
∗
∗
A
l
g
o
r
i
t
h
m
∗
∗
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
----\blue{**Algorithm**}------------------------------------------------------------
−−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
- Split the input space X X X
- for every attribute a i ∈ A a_i \in A ai∈A do
- choose a value s j ( s j ∈ r a n g e ( x ( i ) ) ) s_j(s_j\in range(\bf x^{(i)}))\\[2ex] sj(sj∈range(x(i))), calculate
- R 1 ( a i , s j ) = [ x ∣ x ( i ) ≤ s j ] , R 2 ( a i , s j ) = [ x ∣ x ( i ) > s j ] R_1(a_i, s_j)=[x| x^{(i)}\leq s_j],\quad R_2(a_i, s_j)=[x| x^{(i)}> s_j]\\[2ex] R1(ai,sj)=[x∣x(i)≤sj],R2(ai,sj)=[x∣x(i)>sj]
- c 1 ( a i , s j ) = a v e r a g e ( R 1 ( a i , s j ) ) , c 2 ( a i , s j ) = a v e r a g e ( R 2 ( a i , s j ) ) b y O L S c_1(a_i, s_j)=average(R_1(a_i, s_j)),\quad c_2(a_i, s_j)=average(R_2(a_i, s_j) )\quad \red{by \; OLS}\\[2ex] c1(ai,sj)=average(R1(ai,sj)),c2(ai,sj)=average(R2(ai,sj))byOLS
- s ∗ ← m i n s j ∑ x n ∈ R 1 ( y n − c 1 ) 2 + m i n s j ∑ x n ∈ R 2 ( y n − c 1 ) 2 b y O L S s^* \; \leftarrow \, \mathop{min} \limits_{s_j} \mathop{\sum}\limits_{{\bf x_n}\in R_1}(y_n-c_1)^2 +\mathop{min} \limits_{s_j} \mathop{\sum}\limits_{{\bf x_n}\in R_2}(y_n-c_1)^2 \quad \red{by \; OLS}\\[2ex] s∗←sjminxn∈R1∑(yn−c1)2+sjminxn∈R2∑(yn−c1)2byOLS
- a ∗ ← m i n a i [ m i n s j ∑ x n ∈ R 1 ( y n − c 1 ) 2 + m i n s j ∑ x n ∈ R 2 ( y n − c 1 ) 2 ] a^* \leftarrow \mathop{min} \limits_{a_i}\;[ \mathop{min} \limits_{s_j} \mathop{\sum}\limits_{{\bf x_n}\in R_1}(y_n-c_1)^2 +\mathop{min} \limits_{s_j} \mathop{\sum}\limits_{{\bf x_n}\in R_2}(y_n-c_1)^2]\\[2ex] a∗←aimin[sjminxn∈R1∑(yn−c1)2+sjminxn∈R2∑(yn−c1)2]
- R 1 ∗ , R 2 ∗ ← R 1 ( a ∗ , s ∗ ) = [ x ∣ x ( i ) ≤ s ∗ ] , R 2 ( a ∗ , s ∗ ) = [ x ∣ x ( i ) > s ∗ ] R_1^*,\,R_2^*\leftarrow R_1(a^*, s^*)=[x| x^{(i)}\leq s^*],\;R_2(a^*, s^*)=[x| x^{(i)}> s^*]\\[2ex] R1∗,R2∗←R1(a∗,s∗)=[x∣x(i)≤s∗],R2(a∗,s∗)=[x∣x(i)>s∗]
- ∣ X ∣ r e m a i n s N , h o w e v e r d = d − 1 , A = A |X|\, remains\;N,\,however \; d=d-1,\; A=A ∣X∣remainsN,howeverd=d−1,A=A \ { a ∗ a^* a∗} , r e p e a t 1 t o 9 ,\; repeat \;1 \;to\; 9 ,repeat1to9
- Meet termination
- Return RegressionTree : G ( x ) = ∑ m = 1 M c m I [ x ∈ R m ] \;G({\bf x})=\sum_{m=1}^{M}c_mI \,[{\bf x \in R_m}] G(x)=∑m=1McmI[x∈Rm]
−
−
−
−
∗
∗
A
l
g
o
r
i
t
h
m
∗
∗
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
----\blue{**Algorithm**}------------------------------------------------------------
−−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
1.31-3 二分法 Bi-Partition
在决策树的生成过程中,可能存在一部分特征为连续型变量的情况。可以采用二分法对其进行离散化,之后再按照离散型变量的特征选择方式进行处理。
Input:
D
a
t
a
S
e
t
D
=
[
(
x
1
,
y
1
)
,
.
.
.
,
(
x
N
,
y
N
)
]
;
A
t
t
r
i
b
u
t
e
S
e
t
A
=
[
a
1
,
.
.
.
,
a
d
]
Data \,Set\;D=[(x_1,y_1),\;...,\; (x_N,y_N)] ; \;Attribute \,Set \;A=[a_1,\;...,a_d]
DataSetD=[(x1,y1),...,(xN,yN)];AttributeSetA=[a1,...,ad]
Output:
c
o
n
t
i
n
u
o
u
s
v
a
r
i
a
b
l
e
w
i
t
h
t
h
r
e
s
h
o
l
d
t
.
continuous \; variable\; with \;threshold\; \red t.
continuousvariablewiththresholdt.
−
−
−
−
∗
∗
A
l
g
o
r
i
t
h
m
∗
∗
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
----\blue{**Algorithm**}------------------------------------------------------------
−−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
- 将离散型特征 a i a_i ai进行排序( a i a_i ai共有 V V V种取值)得到:{ a i 1 , a i 2 , . . . , a i V a_i^1,a_i^2,...,a_i^V ai1,ai2,...,aiV} , v = 1 , 2 , . . . , V ,\; v=1,2,..., V\\[2ex] ,v=1,2,...,V
- 选择划分点 t i t_i ti, D t i + = D_t{_i^+}= Dti+= { x n ∣ x n ( i ) > t i {\bf x_n}|{\bf x_n}^{(i)}>t_i xn∣xn(i)>ti}, D t i − = \;D_{t_i}^-= Dti−= { x n ∣ x n ( i ) ≤ t i {\bf x_n}|{\bf x_n}^{(i)} \leq t_i \\[2ex] xn∣xn(i)≤ti}
- t i ∗ ← a r g m i n t i ∈ ( a i v + a i v + 1 2 ∣ 1 ≤ v ≤ V − 1 ) i m p u r i t y ( D t + , D t − ) t^*_i \leftarrow \mathop{argmin} \limits_{t_i \,\in (\frac {a_i^v+a_i^{v+1}}{2}|1 \leq v \leq {V-1} )} \; impurity (D_t^+,D_t^-) \\[2ex] ti∗←ti∈(2aiv+aiv+1∣1≤v≤V−1)argminimpurity(Dt+,Dt−)
- 输出特征 a i a_i ai 和其划分点 t i ∗ t^*_i ti∗
−
−
−
−
∗
∗
A
l
g
o
r
i
t
h
m
∗
∗
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
----\blue{**Algorithm**}------------------------------------------------------------
−−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
1.32 Feauture selection ( Impurity )
1.32-1 信息增益 Information Gain
熵 (entropy)
对于离散型特征变量,
P
(
X
=
x
k
)
=
p
k
,
k
=
1
,
2
,
.
.
.
,
K
P(X=x_k)=p_k,\;k=1,2,...,K
P(X=xk)=pk,k=1,2,...,K
- 表示随机变量不确定性的度量
- 离散变量中, H ( X ) = − ∑ p k l o g p k ( d e f i n e 0 l o g 0 = 0 ) H({ X})=-\sum p_klog\,p_k\quad(define\; 0\,log0=0) H(X)=−∑pklogpk(define0log0=0)
- H ( x ) H(\bf x) H(x)越大,随机变量的不确定性就越大,样本纯度越低
- 对数往往以2或自然数e为底
- p = 0 p=0 p=0 或 p = 1 p=1 p=1时,随机变量完全没有不确定性。
- p = 0.5 p=0.5 p=0.5,熵最大,随机变量不确定性最大,样本纯度最低。
- 条件熵: H ( Y ∣ X ) = ∑ p k H ( Y ∣ X = x k ) H({ Y|X})=\sum p_kH(Y|X=x_k) H(Y∣X)=∑pkH(Y∣X=xk)
- 熵,条件熵 → 数据估计(特别是极大似然估计)→ 经验熵,条件经验熵
记样本的信息熵为
e
n
t
r
o
(
D
)
=
−
∑
k
=
1
K
p
k
l
o
g
2
k
entro(D)=-\sum_{k=1}^Kp_k\,log_2k
entro(D)=−k=1∑Kpklog2k
信息增益 (information gain)
- 熵与条件熵的差值称之为互信息 → 决策树中→训练数据中类 (lable)与特征 (attribute)的互信息
- 特征 a a a 对于训练数据 D D D的信息增益: g a i n ( D , a ) = e n t r o ( D ) − e n t r o ( D ∣ a ) gain(D,a)=entro(D)-entro(D|a) gain(D,a)=entro(D)−entro(D∣a)
- 表示由于特征 a a a而使得对于数据集 D D D进行分类的不确定减少的程度
- 信息增益越大的特征,具有更强的分类能力 → the bigger,the better
- 对于可取数值数目较多的特征有所偏好
记特征
a
a
a对于样本
D
D
D 的信息增益为
g
a
i
n
(
D
,
a
)
=
e
n
t
r
o
(
D
)
−
∑
v
=
1
V
∣
D
v
∣
∣
D
∣
e
n
t
r
o
(
D
v
)
gain(D,a)=entro(D)-\sum_{v=1}^{V} \frac{|D^v|}{|D|} entro \,(D^v)
gain(D,a)=entro(D)−v=1∑V∣D∣∣Dv∣entro(Dv)
1.32-2 信息增益率 Information Gain Ratio
- 矫正信息增益的偏好: ∣ a i ∣ |a_i| ∣ai∣ 大的。 例如,颜色这一特征有17个取值,分支后每个结点只有一两个样本,不具备泛化能力。
- 对于可取数值数目较少的特征有所偏好
- 特征 a a a 的取值越多,即 V V V越大,则 I V ( a ) IV(a) IV(a)往往越大
记特征
a
a
a对于样本
D
D
D的信息增益率为:
g
a
i
n
R
a
t
i
o
(
D
,
a
)
=
g
a
i
n
(
D
,
a
)
I
V
(
a
)
I
V
=
−
∑
v
=
1
V
∣
D
v
∣
∣
D
∣
l
o
g
2
∣
D
v
∣
∣
D
∣
gainRatio(D,a)=\frac{gain(D,a)}{IV(a)}\\[2ex]\\ IV=-\sum_{v=1}^V \frac{|D^v|}{|D|}log_2 \frac{|D^v|}{|D|}\\[2ex]\\
gainRatio(D,a)=IV(a)gain(D,a)IV=−v=1∑V∣D∣∣Dv∣log2∣D∣∣Dv∣
1.32-3 基尼指数 Gini Index
- 反映了从 D D D中随机抽取两个样本,其标记类别 (lable) 不一样的概率
- G i n i ( D ) Gini(D) Gini(D)越小, D D D 纯度越高 → \rightarrow → the smaller, the better
记数据集
D
D
D的基尼指数为
G
i
n
i
(
D
)
=
1
−
∑
v
=
1
V
p
k
2
Gini(D)=1-\sum_{v=1}^{V}{p_k}^2\\[2ex]
Gini(D)=1−v=1∑Vpk2
1.32-4 Regression Error
- 回归问题
- 二分
选择最优属性
a
∗
a_*
a∗和 分支阈值 branch criteria
s
∗
s_*
s∗
a
∗
,
s
∗
=
m
i
n
a
i
[
m
i
n
s
j
∑
x
n
∈
R
1
(
y
n
−
c
1
)
2
+
m
i
n
s
j
∑
x
n
∈
R
2
(
y
n
−
c
2
)
2
]
a^* ,s^*= \mathop{min} \limits_{a_i}\;[ \mathop{min} \limits_{s_j} \mathop{\sum}\limits_{{\bf x_n}\in R_1}(y_n-c_1)^2 +\mathop{min} \limits_{s_j} \mathop{\sum}\limits_{{\bf x_n}\in R_2}(y_n-c_2)^2]
a∗,s∗=aimin[sjminxn∈R1∑(yn−c1)2+sjminxn∈R2∑(yn−c2)2]
1.33 剪枝 Pruning
1.33-1 预剪枝
- 在每个结点划分前先进行估计
- 基于信息增益准则
- 留出验证法
- 划分后,并不能提升验证集的精准度,则禁止划分
- 决策树桩 decision stump;带来欠拟合风险
1.33-2 后剪枝
在生成决策树的时候, 我们往往考虑最小化其损失函数 [ in Lin’s PPT ]
a
r
g
m
i
n
a
l
l
p
o
s
s
i
b
l
e
G
E
r
r
i
n
(
G
)
+
λ
Ω
(
G
)
→
a
s
G
c
a
n
n
o
t
e
n
u
m
e
r
a
t
e
a
l
l
p
o
s
s
i
b
l
e
G
c
o
m
p
u
t
a
t
i
o
n
a
l
l
y
→
a
r
g
m
i
n
G
(
1
)
G
(
2
)
.
.
.
,
G
(
t
)
E
r
r
i
n
(
G
(
i
)
)
+
λ
Ω
(
G
(
i
)
)
\mathop{arg\,min} \limits_{all \;possible\; G} Err_{in}(G)+\lambda \Omega(G)\\[2ex]\\ \rightarrow as \;G \; can \; not\; enumerate \;all\; possible\; G\; computationally \\[2ex]\\ \rightarrow \mathop{arg\,min} \limits_{G^{(1)} \;G^{(2)}\;...,\; G^{(t)}} Err_{in}(G^{(i)})+\lambda \Omega(G^{(i)})\\[2ex]
allpossibleGargminErrin(G)+λΩ(G)→asGcannotenumerateallpossibleGcomputationally→G(1)G(2)...,G(t)argminErrin(G(i))+λΩ(G(i))
λ
≥
0
\lambda \geq0
λ≥0 是参数,
Ω
(
G
)
\Omega(G)
Ω(G)是该树的叶节点个数
G ( 0 ) = f u l l y − g r o w n t r e e G ( i ) = a r g m i n G E r r i n ( G ) s u c h t h a t G i s o n e − l e a f ( o r w e c a n s a y o n e − n o d e ) r e m o v e d f r o m G ( i − 1 ) G^{(0)}=fully-grown \; tree\\[2ex]\\ G^{(i)}=arg\,min_G\,Err_{in}(G) \;such\; that\; G\; is \; one-leaf\;(or \; we\; can\; say\; one-node\; )\; removed\; from\; G^{(i-1)}\\[2ex] G(0)=fully−growntreeG(i)=argminGErrin(G)suchthatGisone−leaf(orwecansayone−node)removedfromG(i−1)
- NP问题:不能遍历穷举所有的树再取最优
- 考虑:在生成完整的决策树之后,根据验证集上各个子树的预测精度表现,决定如何进行剪枝处理。
- 对树中所有非叶节点的结点(根结点和内部结点)进行逐一考察
- 自下向上,直至根节点
- 比预剪枝决策树往往保留了更多的分支
1.33-3 CART剪枝
为了便于理解,在后文中,我们定义树
T
T
T的损失函数为:
C
o
s
t
(
T
,
α
)
=
E
r
r
i
n
(
T
)
+
α
∣
T
∣
Cost(T,\alpha)=Err_{in}(T)+\alpha |T|
Cost(T,α)=Errin(T)+α∣T∣
定义内部结点的损失函数为
C
o
s
t
(
n
o
d
e
(
i
)
,
α
)
=
E
r
r
i
n
(
n
o
d
e
(
i
)
)
+
α
(
a
s
∣
n
o
d
e
(
i
)
∣
=
1
)
Cost(node^{(i)},\alpha)=Err_{in}(node^{(i)})+\alpha\; (\red{\, as\; |node^{(i)}|=1})
Cost(node(i),α)=Errin(node(i))+α(as∣node(i)∣=1)
以上图为例,
t
r
e
e
T
tree T
treeT表示已经生成的完整的树,共包含4个内部结点(1个根结点和3个叶结点)。需要注意的是,如果最终在根节点处进行剪枝处理,说明这棵树根本没有存在的必要,经过层层决策,带来的只是复杂度的增加)。
现在,我们选择结点
t
2
t_2
t2, 判断是否在当前结点进行剪枝处理(若进行剪枝处理,则结点
t
4
,
t
5
,
t
8
t_4,t_5,t_8
t4,t5,t8和
t
9
t_9
t9内的样本都向上退回到结点
t
2
t_2
t2内)。记以
t
2
t_2
t2为根结点的子树为
T
t
2
T_{t_2}
Tt2,以
t
2
t_2
t2为单结点(之一叶节点)的子树 ( 即对整树剪枝之后得到的子树 ) 为
T
−
T
t
2
T-T_{t_2}
T−Tt2。
对于原整树
T
t
1
T_{t_1}
Tt1来说,其损失函数为:
C
o
s
t
(
t
r
e
e
T
,
α
)
=
C
o
s
t
(
T
t
1
,
α
)
=
E
r
r
i
n
(
T
t
1
)
+
α
∣
T
t
1
∣
Cost(treeT,\alpha)=Cost(T_{t_1},\alpha)=Err_{in}(T_{t_1})+\alpha |T_{t_1}|
Cost(treeT,α)=Cost(Tt1,α)=Errin(Tt1)+α∣Tt1∣
对于被剪掉的子树
T
t
2
T_{t_2}
Tt2:
C
o
s
t
(
T
t
2
,
α
)
=
E
r
r
i
n
(
T
t
2
)
+
α
∣
T
t
2
∣
Cost(T_{t_2},\alpha)=Err_{in}(T_{t_2})+\alpha |T_{t_2}|
Cost(Tt2,α)=Errin(Tt2)+α∣Tt2∣
对于剪枝后的子树
T
−
T
t
2
T-T_{t_2}
T−Tt2:
C
o
s
t
(
T
−
T
t
2
,
α
)
=
E
r
r
i
n
(
T
−
T
t
2
)
+
α
∣
T
−
T
t
1
∣
Cost(T-T_{t_2},\alpha)=Err_{in}(T-T_{t_2})+\alpha |T-T_{t_1}|
Cost(T−Tt2,α)=Errin(T−Tt2)+α∣T−Tt1∣
判断是否进行剪枝处理,我们考虑的当然是剪枝之后的树和原来的树相比,损失函数有没有大幅度增加。在上例中,我们对 C o s t ( T − T t 2 , α ) Cost(T-T_{t_2},\alpha) Cost(T−Tt2,α)和 C o s t ( T t 1 , α ) Cost(T_{t_1},\alpha) Cost(Tt1,α)进行比较。
若剪枝之后,损失函数较原树增加,则不进行剪枝处理:
C
o
s
t
(
T
−
T
t
2
,
α
)
−
C
o
s
t
(
T
t
1
,
α
)
>
0
→
α
<
E
r
r
i
n
(
T
−
T
t
2
)
−
E
r
r
i
n
(
T
t
1
)
∣
T
t
1
∣
−
∣
T
−
T
t
2
∣
Cost(T-T_{t_2},\alpha)-Cost(T_{t_1},\alpha)>0\rightarrow\alpha<\frac{Err_{in}(T-T_{t_2}) - Err_{in}({T_{t_1}})}{|T_{t_1}|-|T-T_{t_2}|}
Cost(T−Tt2,α)−Cost(Tt1,α)>0→α<∣Tt1∣−∣T−Tt2∣Errin(T−Tt2)−Errin(Tt1)
若剪枝之后,损失函数跟原树相同,但是剪枝之后的树的复杂度减少,因而应该进行剪枝处理:
C
o
s
t
(
T
−
T
t
2
,
α
)
−
C
o
s
t
(
T
t
1
,
α
)
=
0
→
α
=
E
r
r
i
n
(
T
−
T
t
2
)
−
E
r
r
i
n
(
T
t
1
)
∣
T
t
1
∣
−
∣
T
−
T
t
2
∣
Cost(T-T_{t_2},\alpha)-Cost(T_{t_1},\alpha)=0\rightarrow\alpha=\frac{Err_{in}(T-T_{t_2}) - Err_{in}({T_{t_1}})}{|T_{t_1}|-|T-T_{t_2}|}
Cost(T−Tt2,α)−Cost(Tt1,α)=0→α=∣Tt1∣−∣T−Tt2∣Errin(T−Tt2)−Errin(Tt1)
若剪枝之后,损失函数反而减少,要进行剪枝处理:
C
o
s
t
(
T
−
T
t
2
,
α
)
−
C
o
s
t
(
T
t
1
,
α
)
<
0
→
α
>
E
r
r
i
n
(
T
−
T
t
2
)
−
E
r
r
i
n
(
T
t
1
)
∣
T
t
1
∣
−
∣
T
−
T
t
2
∣
Cost(T-T_{t_2},\alpha)-Cost(T_{t_1},\alpha)<0\rightarrow\alpha>\frac{Err_{in}(T-T_{t_2}) - Err_{in}({T_{t_1}})}{|T_{t_1}|-|T-T_{t_2}|}
Cost(T−Tt2,α)−Cost(Tt1,α)<0→α>∣Tt1∣−∣T−Tt2∣Errin(T−Tt2)−Errin(Tt1)
因此,如果
α
∈
(
0
,
E
r
r
i
n
(
T
−
T
t
2
)
−
E
r
r
i
n
(
t
1
)
∣
T
t
1
∣
−
∣
T
−
T
t
2
∣
\alpha \in (0,\frac{Err_{in}(T-T_{t_2}) - Err_{in}({t_1})}{|T_{t_1}|-|T-T_{t_2}|}
α∈(0,∣Tt1∣−∣T−Tt2∣Errin(T−Tt2)−Errin(t1)
)
)\\[2ex]
), 则不进行剪枝处理,当前整树就是最优的。
如果
α
∈
[
E
r
r
i
n
(
T
−
T
t
2
)
−
E
r
r
i
n
(
t
1
)
∣
T
t
1
∣
−
∣
T
−
T
t
2
∣
,
+
∞
\alpha \in [\frac{Err_{in}(T-T_{t_2}) - Err_{in}({t_1})}{|T_{t_1}|-|T-T_{t_2}|},\;+\infty
α∈[∣Tt1∣−∣T−Tt2∣Errin(T−Tt2)−Errin(t1),+∞
)
)\\[2ex]
), 则需要进行剪枝处理。
对
E
r
r
i
n
(
T
−
T
t
2
)
−
E
r
r
i
n
(
T
t
1
)
∣
T
t
1
∣
−
∣
T
−
T
t
2
∣
\frac{Err_{in}(T-T_{t_2}) - Err_{in}({T_{t_1}})}{|T_{t_1}|-|T-T_{t_2}|}\\[2ex]
∣Tt1∣−∣T−Tt2∣Errin(T−Tt2)−Errin(Tt1)进行化简,子树
T
−
T
t
2
T-T_{t_2}
T−Tt2与原树的损失函数之差,相当于结点 {
t
2
,
t
6
,
t
7
t_2,t_6,t_7
t2,t6,t7}与{
t
8
,
t
9
,
t
5
,
t
6
,
t
7
t_8,t_9,t_5,t_6,t_7
t8,t9,t5,t6,t7}的损失函数之差,进一步简化后为 {
t
2
t_2
t2}与 {
t
8
,
t
9
,
t
5
t_8,t_9,t_5
t8,t9,t5}的损失函数之差,此为结点
t
2
{t_2}
t2与以该点为根结点的子树的损失函数之差;而原树
T
t
1
T_{t_1}
Tt1和剪枝处理后的子树
T
−
T
t
2
T-T_{t_2}
T−Tt2的结点数目之差相当于被剪掉的那个树
T
t
2
T_{t_2}
Tt2的结点数目再减去一 ( 因为结点
t
2
t_2
t2在剪枝处理后,作为单结点(叶结点)仍保留在树中)。
E
r
r
i
n
(
T
−
T
t
2
)
−
E
r
r
i
n
(
t
1
)
=
E
r
r
i
n
(
n
o
d
e
t
2
)
−
E
r
r
i
n
(
T
t
2
)
∣
T
t
1
∣
−
∣
T
−
T
t
2
∣
=
∣
T
t
2
∣
−
1
Err_{in}(T-T_{t_2}) - Err_{in}({t_1})=Err_{in}(node_{t_2}) - Err_{in}(T_{t_2})\\[2ex]\\ |T_{t_1}|-|T-T_{t_2}|=|T_{t_2}|-1
Errin(T−Tt2)−Errin(t1)=Errin(nodet2)−Errin(Tt2)∣Tt1∣−∣T−Tt2∣=∣Tt2∣−1
不失一般性地,定义子树
T
t
(
i
)
T_t^{(i)}
Tt(i)(以
t
←
n
o
d
e
(
i
)
t \leftarrow node^{(i)}
t←node(i)为根结点的子树)损失函数为:
C
o
s
t
(
T
t
(
i
)
,
α
)
=
E
r
r
i
n
(
T
t
(
i
)
)
+
α
∣
T
t
(
i
)
∣
Cost(T_t^{(i)},\alpha )=Err_{in}(T_t^{(i)})+\alpha |T_t^{(i)}|
Cost(Tt(i),α)=Errin(Tt(i))+α∣Tt(i)∣
同样地,定义内部结点
i
i
i 内的损失函数为
C
o
s
t
(
n
o
d
e
(
i
)
,
α
)
=
E
r
r
i
n
(
n
o
d
e
(
i
)
)
+
α
,
(
a
s
∣
n
o
d
e
(
i
)
∣
=
1
)
Cost(node^{(i)},\alpha)=Err_{in}(node^{(i)})+\alpha \; ,\quad(\,\red{ as\; |node^{(i)}|=1})
Cost(node(i),α)=Errin(node(i))+α,(as∣node(i)∣=1)
当
α
\alpha
α一定时,将剪枝处理后整体的损失函数减少的程度定义如下;如果
g
i
g_i
gi过小,我们则认为相较于复杂程度的增加,该树的损失函数并没有明显改善(平均计算下来,被剪掉的部分里,每个结点消灭的“损失”很小),则应该进行剪枝处理。
g
(
k
)
=
E
r
r
i
n
(
n
o
d
e
t
(
k
)
)
−
E
r
r
i
n
(
T
t
(
k
)
)
∣
T
t
(
k
)
∣
−
1
g^{(k)}=\frac{Err_{in}(node_t^{(k)}) - Err_{in}(T_t^{(k)})}{|T_t^{(k)}|-1}\\[2ex]
g(k)=∣Tt(k)∣−1Errin(nodet(k))−Errin(Tt(k))
剪枝处理,可以概括为遍历和循环。
遍历指的是,在进行每次选结点的时候,要对当前树内所有的结点计算
g
t
g_t
gt,每次都选择
g
t
g_t
gt最小的结点进行剪枝处理。
循环指的是,在剪枝后剩下来的树中,反复迭代上述操作。
Input : a fully tree
T
(
1
)
w
i
t
h
i
n
n
e
r
n
o
d
e
s
t
1
,
t
2
,
t
3
,
.
.
.
T^{(1)} \; with \;inner\; nodes\; \red{t_1,t_2,t_3,...}
T(1)withinnernodest1,t2,t3,...
Output: the best pruning tree
T
∗
T^*
T∗
−
−
−
−
∗
∗
A
l
g
o
r
i
t
h
m
∗
∗
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
−
----\blue{**Algorithm**}------------------------------------------------------------
−−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
- generate sub-trees
- initialize k = 1 , α ( 1 ) = 0 k=1,\; \alpha^{(1)}=0 k=1,α(1)=0
- for all innner nodes
t
∈
t \in
t∈
T
(
1
)
T^{(1)}\\[2ex]
T(1) do
C o s t ( T t ( 1 ) , α ) = E r r i n ( T t ( 1 ) ) + α ∣ T t ( 1 ) ∣ Cost(T_{t}^{(1)},\alpha)=Err_{in}(T_t^{(1)})+\alpha\, |T_t^{(1)}|\\[2ex] Cost(Tt(1),α)=Errin(Tt(1))+α∣Tt(1)∣
C o s t ( n o d e ( 1 ) , α ) = E r r i n ( n o d e ( 1 ) ) + α Cost(node^{(1)},\alpha)=Err_{in}(node^{(1)})+\alpha\;\\[2ex] Cost(node(1),α)=Errin(node(1))+α
g t ( 1 ) = E r r i n ( n o d e ( 1 ) ) − E r r i n ( T t ( 1 ) ) ∣ T t ( 1 ) ∣ − ∣ n o d e ( 1 ) ∣ , g t ( 1 ) = ( g t 1 ( 1 ) , g t 2 ( 1 ) , . . . , ) g_t^{(1)}=\frac{Err_{in}(node^{(1)}) - Err_{in}(T_t^{(1)})}{|T_t^{(1)}|-|node^{(1)}|},\;g_t^{(1)}=(g_{t_1}^{(1)},g_{t_2}^{(1)},...,)\\[2ex] gt(1)=∣Tt(1)∣−∣node(1)∣Errin(node(1))−Errin(Tt(1)),gt(1)=(gt1(1),gt2(1),...,)
n o d e ∗ ( 1 ) = a r g m i n t g t ( 1 ) node^{(1)}_*=\mathop{arg\,min}\limits_{t} \, g_t^{(1)}\\[2ex] node∗(1)=targmingt(1)
t h e n \bf then\\[2ex,] then
T
(
2
)
=
T
(
1
)
−
T
n
o
d
e
∗
(
1
)
(
1
)
T^{(2)}=T^{(1)}-T^{(1)}_{node^{(1)}_*} \\[2ex]
T(2)=T(1)−Tnode∗(1)(1)
α
(
1
)
=
m
i
n
(
g
t
(
1
)
)
\quad \alpha^{(1)}=min (g_t^{(1)}) \\[2ex]
α(1)=min(gt(1))
-
k
=
k
+
1
k=k+1\\[2ex]
k=k+1
for all innner nodes t ∈ t \in t∈ T ( k ) T^{(k)}\\[2ex] T(k) do
C o s t ( T t ( k ) , α ) = E r r i n ( T t ( k ) ) + α ∣ T t ( k ) ∣ Cost(T_t^{(k)},\alpha)=Err_{in}(T_t^{(k)})+\alpha\, |T_t^{(k)}|\\[2ex] Cost(Tt(k),α)=Errin(Tt(k))+α∣Tt(k)∣
C o s t ( n o d e ( k ) , α ) = E r r i n ( n o d e ( k ) ) + α Cost(node^{(k)},\alpha)=Err_{in}(node^{(k)})+\alpha\;\\[2ex] Cost(node(k),α)=Errin(node(k))+α
g t ( k ) = E r r i n ( n o d e ( k ) ) − E r r i n ( T t ( k ) ) ∣ T t ( k ) ∣ − ∣ n o d e ( k ) ∣ , g t ( k ) = ( g t 1 ( k ) , g t 2 ( k ) , . . . , ) g_t^{(k)}=\frac{Err_{in}(node^{(k)}) - Err_{in}(T_t^{(k)})}{|T_t^{(k)}|-|node^{(k)}|},\; \;g_t^{(k)}=(g_{t_1}^{(k)},g_{t_2}^{(k)},...,)\\[2ex]\\[2ex] gt(k)=∣Tt(k)∣−∣node(k)∣Errin(node(k))−Errin(Tt(k)),gt(k)=(gt1(k),gt2(k),...,)
n o d e ∗ ( k ) = a r g m i n t g t ( k ) node^{(k)}_*=\mathop{arg\,min}\limits_{t} \, g_t^{(k)}\\[2ex] node∗(k)=targmingt(k)
t h e n \bf then\\[2ex,] then
T
(
k
+
1
)
=
T
(
k
)
−
T
n
o
d
e
∗
(
k
)
(
k
)
T^{(k+1)}=T^{(k)}-T^{(k)}_{node^{(k)}_*} \\[2ex]
T(k+1)=T(k)−Tnode∗(k)(k)
α
(
k
)
=
m
i
n
(
g
t
(
k
)
)
\quad \alpha^{(k)}=min (g_t^{(k)}) \\[2ex]
α(k)=min(gt(k))
- return {
α
(
k
)
,
T
(
k
)
\alpha^{(k)},T^{(k)}
α(k),T(k)},
α ( 1 ) ≤ α ( 2 ) ≤ α ( 3 ) ≤ . . . \alpha^{(1)} \leq \alpha^{(2)} \leq \alpha^{(3)} \leq ...\\[2ex] α(1)≤α(2)≤α(3)≤...
T ( 1 ) ⊇ T ( 2 ) ⊇ T ( 3 ) ⊇ . . . T^{(1)} \supseteq T^{(2)} \supseteq T^{(3)} \supseteq ...\\[2ex] T(1)⊇T(2)⊇T(3)⊇...
T ( 1 ) ← ( 0 , α ( 1 ) ) , T ( 2 ) ← [ α ( 1 ) , α ( 2 ) ) , . . . T^{(1)} \leftarrow (0,\alpha^{(1)}),\;T^{(2)} \leftarrow [\, \alpha^{(1)},\alpha^{(2)}),\quad... T(1)←(0,α(1)),T(2)←[α(1),α(2)),...
− − − − ∗ ∗ A l g o r i t h m ∗ ∗ − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − − ----\blue{**Algorithm**}------------------------------------------------------------ −−−−∗∗Algorithm∗∗−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
- 子树和内部节点的损失函数
- 交叉验证法选择最优子树
1.4 常见算法
1.41 CART
Classification:Gini-Index+CART 剪枝
Regression:OLS Regression Error+CART 剪枝
1.42 ID3
信息增益+?
1.43 C4.5
信息增益比+?