1. Adaboost 介绍
Adaboost 的原理是通过每次减少上一轮被正确分类的样本权值,提高被错误分类的样本权值,再进行本轮弱分类器的分类。
2. Adaboost 算法推导
2.1 权值更新
对于每个样本,定义为:
(
x
n
,
y
^
n
,
u
n
)
(x^{n},\hat{y}^{n},u^{n})
(xn,y^n,un)
表示每个样本的
(
f
e
a
t
u
r
e
,
l
a
b
e
l
,
权
重
)
(feature, label, 权重)
(feature,label,权重),一开始默认权重都为1。
假设每个弱分类器一开始都不是烂掉的,也不能完全拟合,即
0
<
ϵ
<
0.5
0< \epsilon < 0.5
0<ϵ<0.5 ,我们先定义第一个弱分类器的错误率为
ϵ
1
=
∑
n
u
1
n
δ
(
f
1
(
x
n
)
≠
y
^
n
)
z
1
\epsilon_{1} = \frac{\sum\limits_{n} {u_{1}^n} \delta(f_1(x^n) \neq \hat{y}^{n})}{z_{1}}
ϵ1=z1n∑u1nδ(f1(xn)=y^n)
其中
z
t
=
∑
n
u
t
n
z_t = \sum\limits_{n} u_t^{n}
zt=n∑utn
我们想调整
u
u
u 的权重,把错误分类的权重调大(乘
d
1
d_1
d1),把正确分类的权重调小(除
d
1
d_1
d1),使得刚刚的分类器分类之后的错误率很拉跨,即
ϵ
=
0.5
\epsilon = 0.5
ϵ=0.5。
ϵ
=
∑
f
1
(
x
n
)
≠
y
^
n
u
1
n
d
1
∑
f
1
(
x
n
)
≠
y
^
n
u
1
n
d
1
+
∑
f
1
(
x
n
)
=
y
^
n
u
1
n
d
1
=
0.5
\epsilon = \frac{\sum\limits_{f_1(x^n) \neq \hat{y}^{n}} {u_{1}^n}d_1} {\sum\limits_{f_1(x^n) \neq \hat{y}^{n}} {u_{1}^n}d_1 + \sum\limits_{f_1(x^n) = \hat{y}^{n}} \frac{{u_{1}^n}}{d_1}} = 0.5
ϵ=f1(xn)=y^n∑u1nd1+f1(xn)=y^n∑d1u1nf1(xn)=y^n∑u1nd1=0.5
∑
f
1
(
x
n
)
≠
y
^
n
u
1
n
d
1
=
∑
f
1
(
x
n
)
=
y
^
n
u
1
n
d
1
\sum\limits_{f_1(x^n) \neq \hat{y}^{n}} {u_{1}^n}d_1 = \sum\limits_{f_1(x^n) = \hat{y}^{n}} \frac{{u_{1}^n}}{d_1}
f1(xn)=y^n∑u1nd1=f1(xn)=y^n∑d1u1n
d
1
z
1
ϵ
1
=
1
d
1
z
1
(
1
−
ϵ
1
)
d_1 z_1 \epsilon{1} = \frac{1}{d_1} z_1 (1-\epsilon_{1})
d1z1ϵ1=d11z1(1−ϵ1)
d
1
=
1
−
ϵ
1
ϵ
1
d_1 = \sqrt{\frac{1-\epsilon_{1}}{\epsilon_{1}}}
d1=ϵ11−ϵ1
将这样的权值调整后的样本,放到第二个分类器上去分类。
u
2
n
=
u
1
n
d
1
=
u
1
n
e
x
p
(
α
1
)
u_{2}^{n} = u_{1}^{n} d_{1} = u_{1}^{n} exp(\alpha_{1})
u2n=u1nd1=u1nexp(α1)
u
2
n
=
u
1
n
d
1
=
u
1
n
e
x
p
(
−
α
1
)
u_{2}^{n} = \frac{u_{1}^{n}}{d_{1}} = u_{1}^{n} exp(-\alpha_{1})
u2n=d1u1n=u1nexp(−α1)
其中
α
1
=
l
n
(
d
1
)
=
1
2
l
n
(
1
−
ϵ
1
ϵ
1
)
\alpha_{1} = ln(d_1) = \frac{1}{2} ln(\frac{1-\epsilon_{1}}{\epsilon_{1}})
α1=ln(d1)=21ln(ϵ11−ϵ1)
结合两个式子,对于每个分类器的权重
u
t
u_t
ut 到
u
t
+
1
u_{t+1}
ut+1 都有:
u
t
+
1
n
=
u
t
n
e
x
p
(
−
y
^
n
f
t
(
x
n
)
α
t
)
u_{t+1}^{n} = u_{t}^{n} exp(-\hat{y}^{n} f_t(x^n) \alpha_{t})
ut+1n=utnexp(−y^nft(xn)αt)
把所有项都迭代起来:
u
t
+
1
n
=
∏
t
=
1
T
e
x
p
(
−
y
^
n
f
t
(
x
n
)
α
t
)
u_{t+1}^{n} = \prod \limits_{t=1}^{T} exp(-\hat{y}^{n} f_t(x^n) \alpha_{t})
ut+1n=t=1∏Texp(−y^nft(xn)αt)
z
t
+
1
=
∑
n
∏
t
=
1
T
e
x
p
(
−
y
^
n
f
t
(
x
n
)
α
t
)
=
∑
n
e
x
p
(
−
y
^
n
∑
t
=
1
T
f
t
(
x
n
)
α
t
)
z_{t+1} = \sum\limits_{n} \prod \limits_{t=1}^{T} exp(-\hat{y}^{n} f_t(x^n) \alpha_{t}) = \sum\limits_{n} exp(-\hat{y}^{n} \sum\limits_{t=1}^{T} f_t(x^n) \alpha_{t})
zt+1=n∑t=1∏Texp(−y^nft(xn)αt)=n∑exp(−y^nt=1∑Tft(xn)αt)
其中,这里的权值和还有一个收敛的性质:
z
1
=
N
z_1 = N
z1=N
z
t
=
z
t
−
1
ϵ
t
−
1
e
x
p
(
α
t
)
+
z
t
−
1
(
1
−
ϵ
t
−
1
)
e
x
p
(
−
α
t
)
=
2
z
t
−
1
(
1
−
ϵ
t
−
1
)
ϵ
t
−
1
=
N
∏
t
=
1
T
−
1
2
ϵ
t
(
1
−
ϵ
t
)
z_t = z_{t-1} \epsilon_{t-1}exp(\alpha_{t}) + z_{t-1} (1-\epsilon_{t-1}) exp(-\alpha_{t}) = 2z_{t-1}\sqrt{(1-\epsilon_{t-1} )\epsilon_{t-1}} = N \prod \limits_{t=1}^{T-1} 2\sqrt{\epsilon_{t}(1-\epsilon_{t})}
zt=zt−1ϵt−1exp(αt)+zt−1(1−ϵt−1)exp(−αt)=2zt−1(1−ϵt−1)ϵt−1=Nt=1∏T−12ϵt(1−ϵt)
2.2 集成分类器判别
如果采用 Uniform weight 的方法,我们可以简单的把每个分类器的分类简单加总起来,有:
H
(
x
)
=
s
i
g
n
(
∑
t
=
1
T
f
t
(
x
)
)
H(x) = sign(\sum\limits_{t=1}^{T} f_t(x))
H(x)=sign(t=1∑Tft(x))
这样是一种方法,但是不是最好的方法,因为每个分类器其实有好有坏,所以应该给它不同的权重。这里,我们可以发现,由
α
=
1
2
l
n
(
1
−
ϵ
ϵ
)
\alpha= \frac{1}{2} ln(\frac{1-\epsilon}{\epsilon})
α=21ln(ϵ1−ϵ) ,错误率
ϵ
\epsilon
ϵ 越低,
α
\alpha
α 越高。
Non-uniform weight:
H
(
x
)
=
s
i
g
n
(
∑
t
=
1
T
α
t
f
t
(
x
)
)
H(x) = sign(\sum\limits_{t=1}^{T} \alpha_{t} f_t(x))
H(x)=sign(t=1∑Tαtft(x))
接下来,我们要证明弱分类器越多,集成的强分类器的错误率是会越小的,我们设:
G
(
x
)
=
∑
t
=
1
T
α
t
f
t
(
x
)
G(x) = \sum\limits_{t=1}^{T} \alpha_{t} f_t(x)
G(x)=t=1∑Tαtft(x)
定义我们最后判别出来的强分类器的训练数据错误率为
1
n
∑
n
δ
(
H
(
x
n
)
≠
y
^
n
)
=
1
n
∑
n
δ
(
y
^
n
G
(
x
n
)
<
0
)
≤
1
n
∑
n
e
x
p
(
−
y
^
n
G
(
x
n
)
)
=
1
n
z
t
+
1
\frac{1}{n} \sum\limits_{n} \delta(H(x^n) \neq \hat{y}^n) = \frac{1}{n} \sum\limits_{n} \delta(\hat{y}^n G(x^n) < 0) \leq \frac{1}{n} \sum\limits_{n} exp(-\hat{y}^n G(x^n)) = \frac{1}{n} z_{t+1}
n1n∑δ(H(xn)=y^n)=n1n∑δ(y^nG(xn)<0)≤n1n∑exp(−y^nG(xn))=n1zt+1
根据2.1的性质,训练数据错误率上限是在不断地减小的,我们可以认为训练数据的错误率也是在不断地减小。这里我们可以认为 Adaboost 的目标函数(Objective function)是:
1
n
∑
n
e
x
p
(
−
y
^
n
G
(
x
n
)
)
=
1
n
∑
n
e
x
p
(
−
y
^
n
∑
t
=
1
T
α
t
f
t
(
x
)
)
\frac{1}{n} \sum\limits_{n} exp(-\hat{y}^n G(x^n)) = \frac{1}{n} \sum\limits_{n} exp(-\hat{y}^n \sum\limits_{t=1}^{T} \alpha_{t}f_t(x))
n1n∑exp(−y^nG(xn))=n1n∑exp(−y^nt=1∑Tαtft(x))
y
^
n
\hat{y}^n
y^n 与
G
(
x
)
G(x)
G(x) 相同符号的时候,希望
G
(
x
)
G(x)
G(x) 的绝对值越来越大。
有实验表明,即使训练数据的错误率为 0 了, G ( x ) G(x) G(x) 的绝对值还是会随弱分类器数量的增加而变大,说明样本会更清楚属于某一类,这样在测试的时候鲁棒性会变得更好。
3.另一个角度去看Adaboost
3.1 Gradient Boosting 算法过程
初始化 g0(x) = 0
For t=1 to T:
Find a function ft(x) and alpha[t] to improve gt-1(x)
gt-1(x) = sum(alpha[i] * fi(x)) (for i in range(1,t-1))
gt(x) = gt-1(x) + alpha[t] * ft(x)
Output: H(x) = sign(gt(x))
3.2 从 Gradient Boosting 的角度看 Adaboost
假设我们使用梯度下降法去更新 g t ( x ) g_t(x) gt(x) 的函数的时候,希望最小化损失函数,在Adaboost里,损失函数用的是指数损失函数,即:
L ( g ) = ∑ n l ( y ^ n , g ( x n ) ) = ∑ n e x p ( − y ^ n g ( x n ) ) L(g) = \sum\limits_{n} l(\hat{y}^n,g(x^n)) = \sum\limits_{n}exp(-\hat{y}^ng(x^n)) L(g)=n∑l(y^n,g(xn))=n∑exp(−y^ng(xn))
当
g
(
x
)
=
g
t
−
1
(
x
)
g(x) = g_{t-1}(x)
g(x)=gt−1(x) ,考虑更新当前的
g
(
x
)
g(x)
g(x)
g
t
(
x
)
←
g
t
−
1
(
x
)
−
η
∂
L
(
g
)
∂
g
∣
g
=
g
t
−
1
g_t(x) \leftarrow g_{t-1}(x) - \eta\frac{ \partial L(g) }{\partial g} \bigg|_{g = g_{t-1}}
gt(x)←gt−1(x)−η∂g∂L(g)∣∣∣∣g=gt−1
−
η
∂
L
(
g
)
∂
g
∣
g
=
g
t
−
1
=
−
η
∑
n
e
x
p
(
−
y
^
n
g
t
−
1
(
x
n
)
)
(
−
y
^
n
)
- \eta\frac{ \partial L(g) }{\partial g} \bigg|_{g = g_{t-1}} = - \eta \sum\limits_{n}exp(-\hat{y}^ng_{t-1}(x^n))(-\hat{y}^n)
−η∂g∂L(g)∣∣∣∣g=gt−1=−ηn∑exp(−y^ngt−1(xn))(−y^n)
我们之前有:
g
t
(
x
)
=
g
t
−
1
(
x
)
+
α
t
f
t
(
x
)
g_t(x) = g_{t-1}(x) + \alpha_{t}f_t(x)
gt(x)=gt−1(x)+αtft(x)
α
t
>
0
\alpha_{t} > 0
αt>0,如果
f
t
(
x
n
)
f_t(x^n)
ft(xn) 与
∑
n
e
x
p
(
−
y
^
n
g
t
−
1
(
x
n
)
)
(
y
^
n
)
\sum\limits_{n}exp(-\hat{y}^ng_{t-1}(x^n))(\hat{y}^n)
n∑exp(−y^ngt−1(xn))(y^n) 的更新方向越相同的话(每个函数都相当于是无穷多维得向量),那么就会使
g
t
(
x
)
g_t(x)
gt(x) 的 Loss 变得更小,所以我们希望找一个
f
t
(
x
n
)
f_t(x^n)
ft(xn),使得下面式子最大:
∑
n
e
x
p
(
−
y
^
n
g
t
−
1
(
x
n
)
)
(
y
^
n
)
f
t
(
x
n
)
\sum\limits_{n} exp(-\hat{y}^ng_{t-1}(x^n))(\hat{y}^n) f_t(x^n)
n∑exp(−y^ngt−1(xn))(y^n)ft(xn)
展开会发现:
e
x
p
(
−
y
^
n
g
t
−
1
(
x
n
)
)
=
e
x
p
(
−
y
^
n
∑
t
=
1
t
−
1
α
t
f
t
(
x
n
)
)
=
∏
t
=
1
T
−
1
e
x
p
(
−
y
^
n
f
t
(
x
n
)
α
t
)
=
u
t
n
exp(-\hat{y}^ng_{t-1}(x^n)) = exp(-\hat{y}^n\sum\limits_{t=1}^{t-1} \alpha_{t} f_t(x^n)) = \prod_{t=1}^{T-1} exp(-\hat{y}^{n} f_t(x^n) \alpha_{t}) = u_{t}^n
exp(−y^ngt−1(xn))=exp(−y^nt=1∑t−1αtft(xn))=t=1∏T−1exp(−y^nft(xn)αt)=utn
最后我们对损失函数求个偏导,即可发现就是 Adaboost 的参数
L ( g ) = ∑ n e x p ( − y ^ n ( g t − 1 ( x n ) + α t f t ( x n ) ) ) = ∑ n e x p ( − y ^ n g t − 1 ( x n ) ) e x p ( − y ^ n α t f t ( x n ) ) = ∑ f t ( x n ) ≠ y ^ n e x p ( − y ^ n g t − 1 ( x n ) ) e x p ( α t ) + ∑ f t ( x n ) = y ^ n e x p ( − y ^ n g t − 1 ( x n ) ) e x p ( − α t ) L(g) = \sum\limits_{n}exp(-\hat{y}^n(g_{t-1}(x^n) + \alpha_{t} f_{t}(x^n))) = \sum\limits_{n}exp(-\hat{y}^ng_{t-1}(x^n))exp(-\hat{y}^n\alpha_{t} f_{t}(x^n)) = \sum\limits_{f_t(x^n) \neq \hat{y}^{n}} exp(-\hat{y}^ng_{t-1}(x^n))exp(\alpha_{t}) + \sum\limits_{f_t(x^n) = \hat{y}^{n}} exp(-\hat{y}^ng_{t-1}(x^n))exp(-\alpha_{t}) L(g)=n∑exp(−y^n(gt−1(xn)+αtft(xn)))=n∑exp(−y^ngt−1(xn))exp(−y^nαtft(xn))=ft(xn)=y^n∑exp(−y^ngt−1(xn))exp(αt)+ft(xn)=y^n∑exp(−y^ngt−1(xn))exp(−αt)
∂ L ∂ α t = 0 \frac{\partial{L}}{\partial{\alpha_{t}}} = 0 ∂αt∂L=0
得到:
α t = 1 2 l n ( 1 − ϵ t ϵ t ) \alpha_{t} = \frac{1}{2} ln(\frac{1-\epsilon_{t}}{\epsilon_{t}}) αt=21ln(ϵt1−ϵt)
4.Adaboost 算法流程
大致的算法流程:根据上一步的权重,算出当前步的错误率,然后算出调整的系数
α
t
\alpha_t
αt 和 权重调整之后的总和
Z
t
Z_t
Zt,再把权重进行归一化算出概率。最后把每个样本在 每个分类器上的权重 * 该分类器分成的类别 加总,即是这个样本所识别出来的类型。(上文 2.2 有解释)