这篇博客主要是对Adaboost算法的论文精度,包括翻译以及自己的一些基本理解,如果对原论文不感兴趣,只是想快速理解与应用,可以参考另外一篇集成学习—Adaboost(理解与应用)
Adaboost 是Yoav Freund和Robert E. Schapire在1995年的the Second European Conference on Computational Learning Theory首次提出(详见Proceedings of the Second European Conference on Computational Learning Theory, Barcelona, March, 1995),正式发表是在1997年的《Journal of Computer and System Sciences》(IF:1.129,2018),论文详见A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting[J]. Journal of Computer and System Sciences, 1997, 55(1):119-139.
文章分为五个大的部分:
介绍 :文章的大致内容、行文布局和主要结论;
在线分配算法及其分析 :给出算法
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) ,分析了
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 损失的界,这个界是由最优的单个策略的损失以及与
N
N
N 有关的部分组成,并给出收敛速度;
应用 :将上述分析运用到学习器中,并举了一些实际的例子;
Boosting :首先回顾PAC学习,然后由在线分配算法派生出了新的boosting算法Adaboost,与
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 对比给出了分析,然后给出了算法的误差上界,说明了训练误差是随着迭代次数指数级下降,以及给出了泛化误差与经验误差之间的gap,还有它的VC维,然后用贝叶斯最优决策规则解释,得到相同的结果,最后通过改进最后输出的假设的阈值函数,将误差的上界缩小到原来的
1
/
2
1/2
1 / 2 ;
对于多分类和回归的Boosting :通过改进误差计算方法,用伪损失函数替代之前的损失函数,并使最后的预测标签的弱假设的权值之和最大化,得到可以处理多分类问题的扩展版本AdaBoost.M1 ;通过引入标签权重函数,改进伪损失函数,最终使弱假设值的加权平均值最大化,从而得到可以处理多分类问题的扩展版本AdaBoost.M2 ;将给定的回归问题简化为一个二分类问题,然后应用AdaBoost,得到了可以用于回归问题的扩展版本AdaBoost.R ,并且分别由三个定理分别给出了这三个版本的误差的上界。
1、介绍
首先用赌马的例子来引出在线分配模型(on-line allocation model)。
即:分配器
A
A
A 有
N
N
N 个选择或者策略,记为
1
,
…
,
N
1,\dots,N
1 , … , N ,在每个时间节点
t
=
1
,
2
,
…
,
T
t=1,2,\dots,T
t = 1 , 2 , … , T ,分配器
A
A
A 在这些策略上决定分布
p
t
p^t
p t ,也就是
p
i
t
⩾
0
p_i^t\geqslant0
p i t ⩾ 0 是分配在策略
i
i
i 上的一个数量,且满足
∑
i
=
1
N
p
i
t
=
1
\sum_{i=1}^Np_i^t=1
∑ i = 1 N p i t = 1 。所有的策略
i
i
i 都有一个由环境决定的损失
l
i
t
\mathscr{l}_i^t
l i t 。因此分配器
A
A
A 的损失为
∑
i
=
1
N
p
i
t
l
i
t
=
p
t
l
t
\sum_{i=1}^Np_i^t\mathscr{l}_i^t=p^t\mathscr{l}^t
∑ i = 1 N p i t l i t = p t l t ,即关于
A
A
A 的分配规则的策略的平均损失,称为混合损失 。在本文中假设任何策略的损失都是有限的,即
l
i
t
∈
[
0
,
1
]
\mathscr{l}_i^t\in [0,1]
l i t ∈ [ 0 , 1 ] 。算法
A
A
A 的目标就是使其累积损失相对于最优策略的损失最小化 ,即最小化净损失
L
A
−
min
i
L
i
L_A-\min_iL_i
L A − i min L i 其中
L
A
=
∑
t
=
1
T
p
t
⋅
l
t
L_A=\sum_{t=1}^Tp^t\cdot\mathscr{l}^t
L A = ∑ t = 1 T p t ⋅ l t 是算法
A
A
A 在前
T
T
T 次实验中的总累计损失,且
L
i
=
∑
t
=
1
T
l
t
L_i=\sum_{t=1}^T\mathscr{l}^t
L i = ∑ t = 1 T l t 是策略
i
i
i 的累计损失。
为了得到最小化的净损失(net loss),采用weighted majority算法,并给出了一个上界。再由赌马的例子讲解如何选择好的策略以及如何组织这些策略,由此用在线分配模型的思想来得到新的提升(boosting)算法。
即:给定训练集
{
(
x
1
,
y
1
)
,
…
,
(
x
N
,
y
N
)
}
\{(x_1,y_1),\dots,(x_N,y_N)\}
{ ( x 1 , y 1 ) , … , ( x N , y N ) } ,算法一共进行
T
T
T 轮,在第
t
(
t
=
1
,
…
,
T
)
t\ (t=1,\dots,T)
t ( t = 1 , … , T ) 轮中,提升器(booster)会在样本集中设计一个分布
D
t
D_t
D t ,并且关于这个分布
D
t
D_t
D t 要求一个低误差
ϵ
t
\epsilon_t
ϵ t 的弱假设
h
t
h_t
h t ,即
ϵ
t
=
P
r
i
∼
D
t
[
h
t
(
x
i
)
≠
y
i
]
\epsilon_t=Pr_{i\sim D_t}[h_t(x_i)\neq y_i]
ϵ t = P r i ∼ D t [ h t ( x i ) = y i ] 。由此,分布
D
t
D_t
D t 指定了当前这轮中每个样本的相对重要性,在
T
T
T 轮之后,提升器必须将这些弱假设合并成一个预测规则。
该算法不需要事先知道弱假设的精度。相反,它适应这些精度,并产生weighted majority假设,其中每个弱假设的权重是其精度的函数。然后证明了在二分类问题中,最后假设的误差被
e
x
p
(
−
2
∑
t
=
1
T
γ
t
2
)
exp(-2\sum_{t=1}^T\gamma_t^2)
e x p ( − 2 ∑ t = 1 T γ t 2 ) 界住,其中
ϵ
t
=
1
2
−
γ
t
\epsilon_t={1\over 2}-\gamma_t
ϵ t = 2 1 − γ t 是第
t
t
t 个弱假设的误差,
γ
t
\gamma_t
γ t 度量了第
t
t
t 个弱假设相对于随机猜测的精度。因此,这个界告诉我们如果能够始终如一地找到比随机猜测稍好一点的弱假设,那么最终假设的误差将以指数级速度下降,所以当任何一个弱假设得到改进时,最终假设的精度的界限就会提高。这与以前的改进算法形成了鲜明的对比,以前算法的性能边界只依赖于最不精确的弱假设的准确性。最后给出了boosting算法的两个扩展,即对于多分类问题以及回归问题。
2、在线分配算法及其分析
作者提出了在线分配问题的算法
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) ,该算法及其分析是对Littlestone和Warmuth的weighted majority算法的直接推广。算法的伪代码如下:
这里的分析主要模仿了Littlestone和Warmuth给出的分析。主要的思想是获得
∑
i
=
1
N
w
i
T
+
1
\sum_{i=1}^Nw_i^{T+1}
∑ i = 1 N w i T + 1 的上下界,合起来就意味着这个算法误差的上界。
引理1 对任意损失向量序列
l
1
,
…
,
l
T
\mathscr{l}^1,\dots,\mathscr{l}^T
l 1 , … , l T
l
n
(
∑
i
=
1
N
w
i
T
+
1
)
⩽
−
(
1
−
β
)
L
H
e
d
g
e
(
β
)
ln(\sum_{i=1}^Nw_i^{T+1})\leqslant -(1-\beta)L_{\bf{Hedge}(\beta)}
l n ( i = 1 ∑ N w i T + 1 ) ⩽ − ( 1 − β ) L H e d g e ( β )
扫描二维码关注公众号,回复:
8692899 查看本文章
其中
L
H
e
d
g
e
(
β
)
=
∑
t
=
1
T
p
t
⋅
l
t
L_{\bf{Hedge}(\beta)}=\sum_{t=1}^Tp^t\cdot \mathscr{l}^t
L H e d g e ( β ) = ∑ t = 1 T p t ⋅ l t 为混合损失。因此就有
L
H
e
d
g
e
(
β
)
⩽
−
l
n
(
∑
i
=
1
N
w
i
T
+
1
)
1
−
β
L_{\bf{Hedge}(\beta)}\leqslant {-ln(\sum_{i=1}^Nw_i^{T+1})\over 1-\beta}
L H e d g e ( β ) ⩽ 1 − β − l n ( ∑ i = 1 N w i T + 1 )
由权重更新公式
w
i
t
+
1
=
w
i
t
⋅
β
l
i
t
w_i^{t+1}=w_i^t\cdot \beta^{\mathscr{l}_i^t}
w i t + 1 = w i t ⋅ β l i t 可以得到
w
i
T
+
1
=
w
i
1
∏
t
=
1
T
β
l
i
t
=
w
i
1
β
L
i
w_i^{T+1}=w_i^{1}\prod_{t=1}^T\beta^{\mathscr{l}_i^t}=w_i^{1}\beta^{L_i}
w i T + 1 = w i 1 t = 1 ∏ T β l i t = w i 1 β L i
定理2 对任意损失向量序列
l
1
,
…
,
l
T
\mathscr{l}^1,\dots,\mathscr{l}^T
l 1 , … , l T 以及任意的
i
∈
{
1
,
…
,
N
}
i\in \{1,\dots,N\}
i ∈ { 1 , … , N } ,有
L
H
e
d
g
e
(
β
)
⩽
−
l
n
(
w
i
1
)
−
L
i
l
n
β
1
−
β
(7)
L_{\bf{Hedge}(\beta)}\leqslant {-ln(w_i^{1})-L_iln\beta \over 1-\beta}\tag{7}
L H e d g e ( β ) ⩽ 1 − β − l n ( w i 1 ) − L i l n β ( 7 ) 更一般地,对任意的非空集合
S
⊆
{
1
,
…
,
N
}
S\subseteq\{1,\dots,N\}
S ⊆ { 1 , … , N } ,有
L
H
e
d
g
e
(
β
)
⩽
−
l
n
(
∑
i
∈
S
w
i
1
)
−
(
l
n
β
)
max
i
∈
S
L
i
1
−
β
(8)
L_{\bf{Hedge}(\beta)}\leqslant {-ln(\sum_{i\in S}w_i^{1})-(ln\beta)\max_{i\in S}L_i \over 1-\beta}\tag{8}
L H e d g e ( β ) ⩽ 1 − β − l n ( ∑ i ∈ S w i 1 ) − ( l n β ) max i ∈ S L i ( 8 )
(7)式表明
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 算法不会比最佳策略
i
i
i 差太多。损失差取决于
β
\beta
β 的选择以及每个策略的初始权重
w
i
1
w_i^1
w i 1 ,如果权重相等,即
w
i
1
=
1
N
w_i^1={1\over N}
w i 1 = N 1 ,则这个界变为
L
H
e
d
g
e
(
β
)
⩽
min
i
L
i
l
n
(
1
/
β
)
+
l
n
N
1
−
β
(9)
L_{\bf{Hedge}(\beta)}\leqslant {\min_iL_iln({1/ \beta})+lnN \over 1-\beta}\tag{9}
L H e d g e ( β ) ⩽ 1 − β min i L i l n ( 1 / β ) + l n N ( 9 ) 因为它只依赖于N的对数,所以这个界限是即使对于非常多的策略也是合理的。
(8)式表示策略为无限时候的界,可以用上确界替代最大值,无穷集合用整数集替代,则上式变为
L
H
e
d
g
e
(
β
)
⩽
c
min
i
L
i
+
a
l
n
N
L_{\bf{Hedge}(\beta)}\leqslant c{\min_iL_i+alnN}
L H e d g e ( β ) ⩽ c i min L i + a l n N 其中
c
=
l
n
(
1
/
β
)
/
(
1
−
β
)
,
a
=
1
/
(
1
−
β
)
c=ln(1/\beta)/(1-\beta),a=1/(1-\beta)
c = l n ( 1 / β ) / ( 1 − β ) , a = 1 / ( 1 − β ) 。借鉴Vovk的分析可以证明达到了
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 的常数
c
c
c 和
a
a
a 是最优的。
定理3 令
B
B
B 为任意策略数的在线分配问题的算法,假设存在正实数
c
c
c 和
a
a
a ,使得对任意数量的策略
N
N
N 以及任意损失向量序列
l
1
,
…
,
l
T
\mathscr{l}^1,\dots,\mathscr{l}^T
l 1 , … , l T ,有
L
B
⩽
c
min
i
L
i
+
a
l
n
N
L_B\leqslant c\min_iL_i+alnN
L B ⩽ c i min L i + a l n N 则对所有的
β
∈
(
0
,
1
)
\beta\in (0,1)
β ∈ ( 0 , 1 ) ,
c
⩾
l
n
(
1
/
β
)
1
−
β
c\geqslant{ln(1/\beta)\over 1-\beta}
c ⩾ 1 − β l n ( 1 / β ) 或者
a
⩾
1
1
−
β
a\geqslant {1\over 1-\beta}
a ⩾ 1 − β 1
至此,分析了在给定
β
\beta
β 下的
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 以及证明了在任选的
β
\beta
β 下的合理的界。在实际操作中,我们往往希望选择
β
\beta
β 来最大限度地利用我们可能拥有的关于当前特定问题的任何先验知识。下面的引理对于使用上面推到的界来选择
β
\beta
β 十分有用。
引理4 假设
0
⩽
L
⩽
L
~
,
0
<
R
⩽
R
~
0\leqslant L\leqslant \tilde{L},0< R\leqslant \tilde{R}
0 ⩽ L ⩽ L ~ , 0 < R ⩽ R ~ ,令
β
=
g
(
L
~
/
R
~
)
\beta=g(\tilde{L}/\tilde{R})
β = g ( L ~ / R ~ ) ,其中
g
(
z
)
=
1
/
(
1
+
2
/
z
)
g(z)=1/(1+\sqrt{2/z})
g ( z ) = 1 / ( 1 + 2 / z
) ,则
−
L
l
n
β
+
R
1
−
β
⩽
L
+
2
L
~
R
~
+
R
{-Lln\beta+R\over1-\beta} \leqslant L+\sqrt{2\tilde{L}\tilde{R}}+R
1 − β − L l n β + R ⩽ L + 2 L ~ R ~
+ R
这个引理可以用来求解上述所有的界因为他们全都是引理中不等式的形式。例如(9)式重若事先知道对于一个最好策略的损失的先验上界为
L
~
\tilde{L}
L ~ ,则(9)式变为
L
H
e
d
g
e
(
β
)
⩽
min
i
L
i
+
2
L
~
l
n
N
+
l
n
N
(11)
L_{\bf{Hedge}(\beta)}\leqslant {\min_iL_i+\sqrt{2\tilde{L}lnN}+lnN }\tag{11}
L H e d g e ( β ) ⩽ i min L i + 2 L ~ l n N
+ l n N ( 1 1 ) 其中
β
=
g
(
L
~
/
l
n
N
)
\beta=g(\tilde{L}/lnN)
β = g ( L ~ / l n N ) 。如果事先知道试验的次数
T
T
T ,则可以令
L
~
=
T
\tilde{L}=T
L ~ = T 作为这个上界。(因为前面假设了任何策略的损失都是有限的,在0到1之间)
将上式左右两边同时处以
T
T
T ,则得到了一个显式的界,这个界以
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 的每次平均损失接近最佳策略的平均损失的速率。
L
H
e
d
g
e
(
β
)
T
⩽
min
i
L
i
T
+
2
L
~
l
n
N
T
+
l
n
N
T
{L_{\bf{Hedge}(\beta)}\over T}\leqslant {{\min_iL_i\over T}+{\sqrt{2\tilde{L}lnN}\over T}+{lnN\over T} }
T L H e d g e ( β ) ⩽ T min i L i + T 2 L ~ l n N
+ T l n N 因为
L
~
⩽
T
\tilde{L}\leqslant T
L ~ ⩽ T ,这就给出了一个最差的收敛速率
O
(
(
l
n
N
)
/
T
)
O(\sqrt{(lnN)/T})
O ( ( l n N ) / T
) 。如果
L
~
\tilde{L}
L ~ 接近于零,则这个收敛会更快,甚至是
O
(
(
l
n
N
)
/
T
)
O({(lnN)/T})
O ( ( l n N ) / T ) 。
引理4也能应用到定理2中给出的其他界中,得到类似的结论。(11)式给出的界,在损失是预测和结果的函数,且该函数具有特殊形式的特殊情况下(例4),可以进行改进。然而,一般情况下,平方根项
2
L
~
l
n
N
\sqrt{2\tilde{L}lnN}
2 L ~ l n N
的改进不可能超过一个常数因子。这是CesaBianchi等人给出的下界的推论,他们分析了一个在线预测问题,可以看作是在线分配模型的一个特例。
3、应用
给定一个决策空间
Δ
\Delta
Δ ,一个输出空间
Ω
\Omega
Ω ,以及一个有界的损失函数
λ
:
Δ
×
Ω
→
[
0
,
1
]
\lambda:\Delta\times\Omega\to[0,1]
λ : Δ × Ω → [ 0 , 1 ] 。在每一时间
t
t
t ,学习算法选择一个决策
δ
t
∈
Δ
\delta^t\in\Delta
δ t ∈ Δ ,得到一个输出结果
ω
t
∈
Ω
\omega^t\in\Omega
ω t ∈ Ω ,并且损失记为
λ
(
δ
t
,
ω
t
)
\lambda(\delta^t,\omega^t)
λ ( δ t , ω t ) 。更一般地,让学习器从决策空间中选择一个分布
D
t
\mathscr{D}^t
D t ,这样根据这个分布学习器会得到一个随机选择的决策的期望损失,记这个期望损失为
Λ
(
D
t
,
ω
t
)
=
E
δ
∼
D
[
λ
(
δ
,
ω
)
]
\Lambda(\mathscr{D}^t,\omega^t)=E_{\delta\sim\mathscr{D}}[\lambda(\delta,\omega)]
Λ ( D t , ω t ) = E δ ∼ D [ λ ( δ , ω ) ] 为了确定这个分布
D
t
\mathscr{D}^t
D t ,假设学习器可以访问
N
N
N 个专家。在时间
t
t
t ,专家
i
i
i 在
Δ
\Delta
Δ 上产生自己的分布
E
i
t
\mathscr{E}_i^t
E i t ,并且损失为
Λ
(
E
i
t
,
ω
t
)
\Lambda(\mathscr{E}_i^t,\omega^t)
Λ ( E i t , ω t ) 。
利用第二部分中提到的
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 算法,把每个专家当做是一种策略,在每个时间节点,
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 在专家集合上产生一个分布
p
t
p^t
p t ,这个集合用来构建联合分布
D
t
=
∑
i
=
1
N
p
i
t
E
i
t
\mathscr{D}^t=\sum_{i=1}^Np_i^t\mathscr{E}_i^t
D t = i = 1 ∑ N p i t E i t 对任意输出
ω
t
\omega^t
ω t ,
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 的损失为
Λ
(
D
t
,
ω
t
)
=
∑
i
=
1
N
p
i
t
Λ
(
E
t
,
ω
t
)
\Lambda(\mathscr{D}^t,\omega^t)=\sum_{i=1}^Np_i^t\Lambda(\mathscr{E}^t,\omega^t)
Λ ( D t , ω t ) = i = 1 ∑ N p i t Λ ( E t , ω t ) 如果定义
l
i
t
=
Λ
(
E
t
,
ω
t
)
\mathscr{l}_i^t=\Lambda(\mathscr{E}^t,\omega^t)
l i t = Λ ( E t , ω t ) ,则学习器的损失为
p
t
l
t
p^t\mathscr{l}^t
p t l t ,也就是第二节中所说的混合损失。
因此,由(11)式可以将第二节的分析应用到这里,就得到以下定理:
定理5 对任意损失函数
λ
\lambda
λ 、任意的专家集合以及任意的输出序列,
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 的期望损失上界为:
∑
t
=
1
T
Λ
(
D
t
,
ω
t
)
⩽
min
i
∑
t
=
1
T
Λ
(
E
t
,
ω
t
)
+
2
L
~
l
n
N
+
l
n
N
\sum_{t=1}^T\Lambda(\mathscr{D}^t,\omega^t)\leqslant \min_i\sum_{t=1}^T\Lambda(\mathscr{E}^t,\omega^t)+\sqrt{2\tilde{L}lnN}+lnN
t = 1 ∑ T Λ ( D t , ω t ) ⩽ i min t = 1 ∑ T Λ ( E t , ω t ) + 2 L ~ l n N
+ l n N 其中
L
~
⩽
T
\tilde{L}\leqslant T
L ~ ⩽ T 是在最优专家的期望损失上设定的上界,
β
=
g
(
L
~
/
l
n
N
)
\beta=g(\tilde{L}/lnN)
β = g ( L ~ / l n N )
例1 是
k
k
k 元预测问题,定理2指出,学习算法的期望错误数最多将以
O
(
T
l
n
N
)
O(\sqrt{T ln N})
O ( T l n N
) 超过最佳专家的期望错误数,如果能够提前限制最佳专家的损失,则错误数可能会少得多。
例2 是剪刀石头布的问题,结果表明,在重复游戏中,算法所丢失的期望回合数将很快收敛到最好的专家所丢失的期望回合数。
例3 是剪刀石头布的问题的升级讨论,说明
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 算法不会比使用最优混合策略的算法差太多。
例4 是欧式空间
R
n
\mathbb{R}^n
R n 中单位球内的距离,同样可以利用这个方法得到一个上界。
4、Boosting
这部分主要是讲如何改进第二节中的算法来提升弱学习算法的性能。
PAC学习模型
先简要回顾PAC学习模型。设
X
X
X 为定义域,布尔函数
c
:
X
→
{
0
,
1
}
c:X\to\{0,1\}
c : X → { 0 , 1 } ,概念类
C
\mathscr{C}
C 是一些概念的集合(概念是从样本空间到标记空间的映射),学习器可以得到一些形如
(
x
,
c
(
x
)
)
(x,c(x))
( x , c ( x ) ) 的带标签的样本,其中
x
x
x 是根据一些在
X
X
X 上固定但是未知的任意分布
D
\mathscr{D}
D 来随机选取的,
c
∈
C
c\in\mathscr{C}
c ∈ C 是目标概念。经过一段时间后,学习器必须输出一个假设
h
:
X
→
[
0
,
1
]
h:X\to[0,1]
h : X → [ 0 , 1 ] ,这个
h
(
x
)
h(x)
h ( x ) 值可以视为
x
x
x 的标签的随机预测,即以概率
h
(
x
)
h(x)
h ( x ) 为1,概率
1
−
h
(
x
)
1-h(x)
1 − h ( x ) 为0。
h
(
x
)
h(x)
h ( x ) 的期望误差为
E
x
∼
D
(
∣
h
(
x
)
−
c
(
x
)
∣
)
E_{x\sim\mathscr{D}}(|h(x)-c(x)|)
E x ∼ D ( ∣ h ( x ) − c ( x ) ∣ ) ,如果
h
(
x
)
h(x)
h ( x ) 被解释为一个随机预测,那么这只是一个不正确预测的概率。
强PAC学习算法是这样,给定
ϵ
,
δ
>
0
\epsilon,\delta>0
ϵ , δ > 0 以及一些随机样本,以概率
1
−
δ
1-\delta
1 − δ 输出一个假设,它的错误率最多为
ϵ
\epsilon
ϵ 。此外,运行时间必须是
1
/
ϵ
,
1
/
δ
1/\epsilon,1/\delta
1 / ϵ , 1 / δ 以及其他参数的多项式(即所接收样本的“大小”,以及目标概念的“大小”或“复杂性”)。一个弱PAC学习算法满足同样的条件,但是
ϵ
⩾
1
/
2
−
γ
\epsilon\geqslant1/2-\gamma
ϵ ⩾ 1 / 2 − γ ,其中
γ
\gamma
γ 要么是一个常数,要么随着
1
/
p
1/p
1 / p 减小,这里
p
p
p 是相关参数的多项式。
Schapire[22]表明,任何弱学习算法都可以有效地转化或“增强”为强学习算法。后来,Freund[10,11]提出了一种比Schapire的算法更有效的“多数增强”(boost-by-majority)算法。这两种算法的工作原理都是将给定的弱学习算法多次调用弱学习算法,每次在定义域
X
X
X 中呈现不同的分布,最后将生成的所有假设组合成一个假设。直观的想法是改变定义域
X
X
X 中的分布,以增加空间中“较难”部分的概率,从而迫使较弱的学习器生成在这些部分出错较少的新假设。
多数增强算法的一个重要的、实际的不足之处在于,它要求弱学习算法的偏差
γ
\gamma
γ 必须提前知道。这种最坏情况下的偏差不仅在实践中通常是未知的,而且弱学习算法所能达到的偏差在不同的分布中也会有很大的差异。遗憾的是,多数增强算法不能利用弱学习算法计算的假设,其误差显著小于假定的最坏情况偏差
1
/
2
−
γ
1/2-\gamma
1 / 2 − γ 。
在本节中,作者提出了一种新的boosting算法,它是由第二节的在线分配算法派生而来的。这种新算法的效率几乎与多数增强算法相同。然而,与多数增强不同的是,新理论生成的最终假设的准确性依赖于弱学习算法返回的所有假设的准确性 ,因此能够更充分地利用弱学习算法的能力。同时,该算法为处理常由神经网络和其他学习算法产生的实值假设提供了一种简洁的方法。
新的boosting算法
基本的学习框架 为:学习器根据一些
X
×
Y
X\times Y
X × Y 上固定的但是未知的分布
P
\mathscr{P}
P 获得一些样本
(
x
i
,
y
i
)
(x_i,y_i)
( x i , y i ) ,其中
Y
Y
Y 是一组可能的标签。算法的目标是给定样本
x
x
x 就学习出一个预测的标签
y
y
y 。先从简单的情况开始,标签
Y
Y
Y 只包含两个可能的情况,即
Y
=
{
0
,
1
}
Y=\{0,1\}
Y = { 0 , 1 } 。Freund [11]描述了boosting应用的两种框架:通过过滤增强和通过采样增强。在本文中,作者使用了采样增强框架,这是分析“批量”学习的自然框架,即,使用存储在计算机内存中的固定训练集学习。假设给定
N
N
N 个样本的训练集,其中
(
x
1
,
y
1
)
,
…
,
(
x
N
,
y
N
)
(x_1,y_1),\dots,(x_N,y_N)
( x 1 , y 1 ) , … , ( x N , y N ) 是根据分布
P
\mathscr{P}
P 从
X
×
Y
X\times Y
X × Y 随机抽取的。使用boosting来找到一个假设
h
f
h_f
h f ,这个假设与大多数样本是一致的,即
h
f
(
x
i
)
=
y
i
h_f(x_i)=y_i
h f ( x i ) = y i 对大多数的
1
⩽
i
⩽
N
1\leqslant i\leqslant N
1 ⩽ i ⩽ N 成立。一般来说,过拟合可以通过限制假设让它更简单来避免。新的boosting算法如下图,算法的目标是找到一个最终的假设,它的误差相对于在训练集中给定的分布
D
D
D 中是较低的。与
X
×
Y
X\times Y
X × Y 上并且自然生成的分布
P
\mathscr{P}
P 不同的是,这个分布
D
D
D 只是在训练集的样本上而且被学习器控制。通常来说,这个分布会设置成均匀分布,即
D
(
i
)
=
1
/
N
D(i)=1/N
D ( i ) = 1 / N 。算法包含了训练集上的一系列权重
w
t
w^t
w t 。在第
t
t
t 次迭代中通过标准化这些权重来计算分布
p
t
p^t
p t ,这些分布用来生成弱学习器,而这些弱学习器又用来生成假设
h
t
h_t
h t 。利用这个新的假设
h
t
h_t
h t ,boosting算法产生下一个权重向量
w
t
+
1
w^{t+1}
w t + 1 ,然后重复这个过程。经过
T
T
T 轮的迭代,最后的假设
h
f
h_f
h f 就是输出的结果,它用加权多数投票来结合了
T
T
T 个弱学习器的输出。
我们称这个算法叫做Adaboost是因为它不像之前的算法,它自动调整了由弱学习器返回的弱假设的误差。如果弱学习器是一个PAC弱学习算法,那对所有的
t
t
t 有
ε
t
⩽
1
/
2
−
γ
\varepsilon_t\leqslant 1/2-\gamma
ε t ⩽ 1 / 2 − γ (假设样本是由一些
c
∈
C
c\in\mathscr{C}
c ∈ C 根据
y
i
=
c
(
x
i
)
y_i=c(x_i)
y i = c ( x i ) 适当生成的)。但是这样的误差上界不必提前知道,这个结论对所有的
ϵ
t
∈
[
0
,
1
]
\epsilon_t\in[0,1]
ϵ t ∈ [ 0 , 1 ] 成立,并且只依赖于那些在boosting过程中精确生成的分布上的弱学习器的性能 。
参数
β
t
\beta_t
β t 是
ε
t
\varepsilon_t
ε t 的函数,用来更新权重向量。更新规则减少了分配给假设预测良好的样本的概率,并增加了预测较差的样本的概率。注意Adaboost不像多数增强算法,它通过加和弱假设的概率预测来结合了这些弱假设 。
分析
对比图1和图2,
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 算法和Adaboost有明显的相似之处,这种相似性反映了在线分配模型与boosting问题之间惊人的“对偶”关系。另一个角度来说,可以把boosting问题直接映射或者简化为在线分配模型。在这种简化中,人们自然的期望可以将策略与弱假设对应起来,将实验(和相应的损失向量)与训练集中的样本对应起来,然而我们使用的简化是相反的:策略对应样本,实验对应弱假设。另一个相反的是损失函数的定义,在
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 中如果在
t
t
t 时刻第
i
i
i 个策略比较好,则它的损失也会比较小,然而在Adaboost中如果第
t
t
t 个假设关于第
i
i
i 个样本给出了一个差的预测,那么出现在第五步中权重更新的那个损失
l
i
t
=
1
−
∣
h
t
(
x
i
)
−
y
i
∣
\mathscr{l}_i^t=1-|h_t(x_i)-y_i|
l i t = 1 − ∣ h t ( x i ) − y i ∣ 会小。原因是在
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 中如果策略成功那么和策略有关的权重会增加,然而在Adaboost中如果样本很“难”那么和样本有关的权重会增加。
两个算法之间主要的差别是在Adaboost中参数
β
\beta
β 不再是前提固定的,而是在每次迭代中随着
ε
t
\varepsilon_t
ε t 而改变 。如果提前给定
ε
t
⩽
1
/
2
−
γ
\varepsilon_t\leqslant 1/2-\gamma
ε t ⩽ 1 / 2 − γ 对某些
γ
>
0
\gamma>0
γ > 0 和全部的
t
=
1
,
…
,
T
t=1,\dots,T
t = 1 , … , T 成立,那么就可以直接应用
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 算法以及它的分析:固定
β
\beta
β 为
1
−
γ
1-\gamma
1 − γ ,且令
l
i
t
=
1
−
∣
h
t
(
x
i
)
−
y
i
∣
\mathscr{l}_i^t=1-|h_t(x_i)-y_i|
l i t = 1 − ∣ h t ( x i ) − y i ∣ ,
h
f
h_f
h f 和AdaBoost中的一样,但所有假设
T
T
T 的权重相同。则
p
t
⋅
l
t
p^t\cdot l^t
p t ⋅ l t 恰好是分布
p
t
p^t
p t 上
h
t
h_t
h t 的精度 ,由假设,这个精度至少是
1
/
2
+
γ
1/2+\gamma
1 / 2 + γ (因为上面给定的
ε
t
⩽
1
/
2
−
γ
\varepsilon_t\leqslant 1/2-\gamma
ε t ⩽ 1 / 2 − γ )。此外,令
S
=
{
i
:
h
f
(
x
i
)
≠
y
i
}
S=\{i:h_f(x_i)\neq y_i\}
S = { i : h f ( x i ) = y i } ,直接可以得如果
i
∈
S
i\in S
i ∈ S 则由
h
f
h_f
h f 的定义以及
y
i
∈
{
0
,
1
}
y_i\in \{0,1\}
y i ∈ { 0 , 1 } 就有:
L
i
T
=
1
T
∑
t
=
1
T
l
i
t
=
1
−
1
T
∑
t
=
1
T
∣
y
i
−
h
t
(
x
i
)
∣
=
1
−
∣
y
i
−
1
T
∑
t
=
1
T
h
t
(
x
i
)
∣
⩽
1
/
2
\begin{aligned} {L_i\over T}&={1\over T}\sum_{t=1}^T\mathscr{l}_i^t\\ &=1-{1\over T}\sum_{t=1}^T|y_i-h_t(x_i)|\\ &=1-|y_i-{1\over T}\sum_{t=1}^Th_t(x_i)|\\ &\leqslant1/2 \end{aligned}
T L i = T 1 t = 1 ∑ T l i t = 1 − T 1 t = 1 ∑ T ∣ y i − h t ( x i ) ∣ = 1 − ∣ y i − T 1 t = 1 ∑ T h t ( x i ) ∣ ⩽ 1 / 2
因此,由定理2有
T
⋅
(
1
/
2
+
γ
)
⩽
∑
t
=
1
T
p
t
⋅
l
t
⩽
−
l
n
(
∑
i
∈
S
D
(
i
)
)
+
(
γ
+
γ
2
)
(
T
/
2
)
γ
\begin{aligned} T\cdot(1/2+\gamma)&\leqslant\sum_{t=1}^Tp^t\cdot l^t\\ &\leqslant {-ln(\sum_{i\in S}D(i))+(\gamma+\gamma^2)(T/2)\over \gamma} \end{aligned}
T ⋅ ( 1 / 2 + γ ) ⩽ t = 1 ∑ T p t ⋅ l t ⩽ γ − l n ( ∑ i ∈ S D ( i ) ) + ( γ + γ 2 ) ( T / 2 ) 因为
−
l
n
(
β
)
=
−
l
n
(
1
−
γ
)
⩽
γ
+
γ
2
-ln(\beta)=-ln(1-\gamma)\leqslant\gamma+\gamma^2
− l n ( β ) = − l n ( 1 − γ ) ⩽ γ + γ 2 对于
γ
∈
[
0
,
1
/
2
]
\gamma\in[0,1/2]
γ ∈ [ 0 , 1 / 2 ] 成立。这就意味着
h
f
h_f
h f 的误差
ε
=
∑
i
∈
S
D
(
i
)
\varepsilon=\sum_{i\in S}D(i)
ε = ∑ i ∈ S D ( i ) (因为
ε
=
P
r
i
∼
D
[
h
f
(
x
i
)
≠
y
i
]
\varepsilon=Pr_{i\sim D}[h_f(x_i)\neq y_i]
ε = P r i ∼ D [ h f ( x i ) = y i ] )最多为
e
−
T
γ
2
/
2
e^{-T\gamma^2/2}
e − T γ 2 / 2
这个boosting算法Adaboost在
H
e
d
g
e
(
β
)
\bf{Hedge}(\beta)
H e d g e ( β ) 的这个直接应用上有两个好处。第一,通过对
β
\beta
β 进行更精细的分析和选择,我们得到了一个误差
ε
\varepsilon
ε 的显著上界 ;其次,这个算法不需要预先知道弱学习器将生成的假设的精度 。相反地,它度量了每次迭代的
h
t
h_t
h t 的精度 ,并相应地设置参数。更新因子
β
t
\beta_t
β t 随着
ε
t
\varepsilon_t
ε t 的减小而减小,导致分布
p
t
p^t
p t 和
p
t
+
1
p^{t+1}
p t + 1 的差距也减小。
β
t
\beta_t
β t 的减小也带来权重
l
n
(
1
/
β
t
)
ln(1/\beta_t)
l n ( 1 / β t ) 的增加,这个权重和最后的假设
h
t
h_t
h t 有关。直观的感觉是:更准确的假设会导致生成的分布发生更大的变化,并对最终假设的结果产生更大的影响。
定理6 (证明略,详见论文原文,证明方法和引理1类似)假设弱学习器在被AdaBoost调用时,生成的假设误差为
ε
1
,
…
,
ε
T
\varepsilon_1,\dots,\varepsilon_T
ε 1 , … , ε T (定义如图2中的第三步),则由Adaboost最后的假设
h
f
h_f
h f 输出的误差
ε
=
P
r
i
∼
D
[
h
f
(
x
i
)
≠
y
i
]
\varepsilon=Pr_{i\sim D}[h_f(x_i)\neq y_i]
ε = P r i ∼ D [ h f ( x i ) = y i ] 的界为:
ε
⩽
2
T
∏
t
=
1
T
ε
t
(
1
−
ε
t
)
\varepsilon\leqslant 2^T\prod_{t=1}^T\sqrt{\varepsilon_t(1-\varepsilon_t)}
ε ⩽ 2 T t = 1 ∏ T ε t ( 1 − ε t )
定理6给出的误差的界还可以写成以下形式(因为
ε
=
1
/
2
−
γ
t
\varepsilon=1/2-\gamma_t
ε = 1 / 2 − γ t ):
ε
⩽
∏
t
=
1
T
1
−
4
γ
t
2
=
e
x
p
(
−
∑
t
=
1
T
K
L
(
1
/
2
∥
1
/
2
−
γ
t
)
)
⩽
e
x
p
(
−
2
∑
t
=
1
T
γ
t
2
)
\begin{aligned} \varepsilon&\leqslant \prod_{t=1}^T\sqrt{1-4\gamma_t^2}\\ &=exp(-\sum_{t=1}^TKL(1/2\|1/2-\gamma_t))\\ &\leqslant exp(-2\sum_{t=1}^T\gamma_t^2) \end{aligned}
ε ⩽ t = 1 ∏ T 1 − 4 γ t 2
= e x p ( − t = 1 ∑ T K L ( 1 / 2 ∥ 1 / 2 − γ t ) ) ⩽ e x p ( − 2 t = 1 ∑ T γ t 2 ) 其中
K
L
(
a
∥
b
)
=
a
l
n
(
a
/
b
)
+
(
1
−
a
)
l
n
(
(
1
−
a
)
/
(
1
−
b
)
)
KL(a\|b)=aln(a/b)+(1-a)ln((1-a)/(1-b))
K L ( a ∥ b ) = a l n ( a / b ) + ( 1 − a ) l n ( ( 1 − a ) / ( 1 − b ) ) 是Kullback-Leibler散度(相对熵)。(不等式的最后一步没看懂 )若所有假设的误差都等于
1
/
2
−
γ
1/2-\gamma
1 / 2 − γ ,则上式可以简化为
ε
⩽
(
1
−
4
γ
2
)
T
/
2
=
e
x
p
(
−
T
⋅
K
L
(
1
/
2
∥
1
/
2
−
γ
)
)
⩽
e
x
p
(
−
2
T
γ
2
)
(22)
\begin{aligned} \varepsilon&\leqslant (1-4\gamma^2)^{T/2}\\ &=exp(-T\cdot KL(1/2\|1/2-\gamma))\\ &\leqslant exp(-2T\gamma^2)\tag{22} \end{aligned}
ε ⩽ ( 1 − 4 γ 2 ) T / 2 = e x p ( − T ⋅ K L ( 1 / 2 ∥ 1 / 2 − γ ) ) ⩽ e x p ( − 2 T γ 2 ) ( 2 2 ) 这是切尔诺夫限的形式,在出现“头”的概率为
1
/
2
−
γ
1/2-\gamma
1 / 2 − γ 的随机抛掷硬币的
T
T
T 次实验中,出现“头”的次数少于
T
/
2
T/2
T / 2 的概率。这个界限与多数增强算法的界限一样有渐进性。(22)中,我们得到了boosting算法足够达到
h
f
h_f
h f 误差
ε
\varepsilon
ε 的迭代次数为
T
=
[
1
K
L
(
1
/
2
∥
1
/
2
−
γ
)
l
n
1
ε
]
⩽
[
1
2
γ
2
l
n
1
ε
]
\begin{aligned} T&=[{1\over KL(1/2\|1/2-\gamma)}ln{1\over \varepsilon}]\\ &\leqslant[{1\over 2\gamma^2}ln{1\over \varepsilon}] \end{aligned}
T = [ K L ( 1 / 2 ∥ 1 / 2 − γ ) 1 l n ε 1 ] ⩽ [ 2 γ 2 1 l n ε 1 ]
注意这里这个由假设生成的误差并不是一致的,定理6说明的是结合了所有弱假设的最终的误差。以往boosting算法的误差界只依赖于最弱假设的最大误差,而忽略了误差较小假设的优势。这一优势似乎与boosting的实际应用非常相关,因为有人预计,随着输入到弱学习器的分布越来越远离目标分布,学习算法的误差会增加。
泛化误差
现在主要讨论训练集之外的最终误差。定理6保证了样本上
h
f
h_f
h f 的误差很小,但我们感兴趣的是
h
f
h_f
h f 的泛化误差,即在整个样本空间
X
X
X 上的表现
ε
g
=
P
r
(
x
,
y
)
∼
P
[
h
f
(
x
)
≠
y
]
\varepsilon_\mathrm{g}=Pr_{(x,y)\sim\mathscr{P}}[h_f(x)\neq y]
ε g = P r ( x , y ) ∼ P [ h f ( x ) = y ] 。为了使得
ε
g
\varepsilon_\mathrm{g}
ε g 在训练集上接近经验误差
ε
^
\hat\varepsilon
ε ^ ,必须以某种方式限制
h
f
h_f
h f 的选择。一种自然的方法就是限制弱学习器让他们从一些简单的函数集中选择他们的假设并且限制弱假设结合成
h
f
h_f
h f 的次数
T
T
T 。弱假设集合的选择是针对当前学习问题的,应该反映我们对未知概念性质的认识。至于次数
T
T
T 的选择,可以设计各种通用的方法。一个比较广泛的做法就是用概念集合的VC维(Vapnik-Chervonenkis Dimension)的上界。这个方法有时称为“结构风险最小化”。
定理7(Vapnik) 令
H
H
H 为定义域
X
X
X 上的二值函数的集合,
d
d
d 表示
H
H
H 的VC维,
P
\mathscr{P}
P 为
X
×
{
0
,
1
}
X\times\{0,1\}
X × { 0 , 1 } 上的分布。对
h
∈
H
h\in H
h ∈ H ,关于
P
\mathscr{P}
P 的泛化误差定义为
ε
g
(
h
)
≐
P
r
(
x
,
y
)
∼
P
[
h
(
x
)
≠
y
]
\varepsilon_\mathrm{g}(h)\doteq Pr_{(x,y)\sim\mathscr{P}}[h(x)\neq y]
ε g ( h ) ≐ P r ( x , y ) ∼ P [ h ( x ) = y ]
S
=
{
(
x
1
,
y
1
)
,
…
,
(
x
N
,
y
N
)
}
S=\{(x_1,y_1),\dots,(x_N,y_N)\}
S = { ( x 1 , y 1 ) , … , ( x N , y N ) } 是根据分布
P
\mathscr{P}
P 从
X
×
{
0
,
1
}
X\times\{0,1\}
X × { 0 , 1 } 上抽出来的
N
N
N 个独立的随机样本(训练集),
h
h
h 关于训练集
S
S
S 的经验误差定义为
ε
^
(
h
)
≐
∣
{
i
:
h
(
x
i
)
≠
y
}
∣
N
\hat\varepsilon(h)\doteq {|\{i:h(x_i)\neq y\}|\over N}
ε ^ ( h ) ≐ N ∣ { i : h ( x i ) = y } ∣ 则对于任意的
δ
>
0
\delta>0
δ > 0 ,有
P
⟮
∃
h
∈
H
:
∣
ε
^
(
h
)
−
ε
g
(
h
)
∣
>
2
d
(
l
n
2
N
/
d
+
1
)
+
l
n
9
/
δ
N
⟯
⩽
δ
P\bigg\lgroup\exist h\in H:|\hat\varepsilon(h)-\varepsilon_\mathrm{g}(h)|>2\sqrt{d(ln2N/d+1)+ln9/\delta\over N}\bigg\rgroup\leqslant\delta
P ⎩ ⎪ ⎪ ⎧ ∃ h ∈ H : ∣ ε ^ ( h ) − ε g ( h ) ∣ > 2 N d ( l n 2 N / d + 1 ) + l n 9 / δ
⎭ ⎪ ⎪ ⎫ ⩽ δ 这个概率是根据样本S的随机选择计算的。
令
θ
:
R
→
{
0
,
1
}
\theta:\mathbb{R}\to\{0,1\}
θ : R → { 0 , 1 } 定义为
θ
(
x
)
=
{
1
if
x
⩾
0
0
otherwise
\theta(x)= \begin{cases} 1 &\text{if } x\geqslant 0\\ 0 &\text{otherwise} \end{cases}
θ ( x ) = { 1 0 if x ⩾ 0 otherwise 对任意的函数集
H
H
H ,令
Θ
T
(
H
)
\Theta_T(H)
Θ T ( H ) 为所有函数的集合,这些函数定义为
T
T
T 个
H
H
H 里的函数的线性阈值,即
Θ
T
(
H
)
=
{
θ
(
∑
t
=
1
T
a
t
h
t
−
b
)
:
b
,
a
1
,
…
,
a
T
∈
R
;
h
1
,
…
,
h
T
∈
H
}
\Theta_T(H)=\{\theta(\sum_{t=1}^Ta_th_t-b):b,a_1,\dots,a_T\in\mathbb{R};h_1,\dots,h_T\in H\}
Θ T ( H ) = { θ ( t = 1 ∑ T a t h t − b ) : b , a 1 , … , a T ∈ R ; h 1 , … , h T ∈ H }
显然,如果所有由弱学习器生成的假设都属于集合
H
H
H ,则Adaboost最后的假设在
T
T
T 轮之后就属于
Θ
T
(
H
)
\Theta_T(H)
Θ T ( H ) 。因此,下一个定理利用弱假设集合给出了AdaBoost生成的最终假设集合的VC维的一个上界。
定理8 令
H
H
H 为VC维
d
⩾
2
d\geqslant2
d ⩾ 2 的二值函数的集合,则
Θ
T
(
H
)
\Theta_T(H)
Θ T ( H ) 的VC维最多为
2
(
d
+
1
)
(
T
+
1
)
l
o
g
2
(
e
(
T
+
1
)
)
2(d+1)(T+1) log_2(e(T+1))
2 ( d + 1 ) ( T + 1 ) l o g 2 ( e ( T + 1 ) ) (其中e是自然对数的底) 因此,如果由弱学习器产生的假设是从VC维
d
⩾
2
d\geqslant2
d ⩾ 2 的集合中选出,那么由Adaboost经过
T
T
T 轮迭代后生成的最后的假设属于VC维最多为
2
(
d
+
1
)
(
T
+
1
)
l
o
g
2
(
e
(
T
+
1
)
)
2(d+1)(T+1) log_2(e(T+1))
2 ( d + 1 ) ( T + 1 ) l o g 2 ( e ( T + 1 ) ) 的集合。 (证明借鉴了Baum和Haussler证明神经网络的思路,将AdaBoost的最终假设输出看作一个由两层前馈网络计算得到的函数,其中第一层的计算单元为弱假设,第二层的计算单元为结合弱假设的线性阈值函数,具体略)
令
h
f
T
h_f^T
h f T 表示Adaboost运行
T
T
T 次迭代之后生成的假设,利用定理7和定理8给出的界,通过组合观测到的
h
f
T
h_f^T
h f T 的经验误差,我们可以计算
h
f
T
h_f^T
h f T 对所有的
T
T
T 的泛化误差的上界。然后我们就可以选择假设
h
f
T
h_f^T
h f T 使得上界最小化。
虽然结构风险最小化是一种数学上合理的方法,但以这种方式生成的
ε
g
\varepsilon_\mathrm{g}
ε g 的上界可能大于实际值,因此所选择的迭代次数
T
T
T 可能远远小于最优值,导致性能较差。一种简单的替代方法是使用“交叉验证”,将一部分训练集放在生成
h
f
h_f
h f 的训练集之外,作为所谓的“验证”集,然后选择
T
T
T 的值使验证集上最终假设的误差最小。
贝叶斯解释
AdaBoost生成的最终假设与贝叶斯分析提出的假设密切相关。符号设定与前面类似,我们的目标是将一组取值为
{
0
,
1
}
\{0,1\}
{ 0 , 1 } 的假设
h
1
,
…
,
h
T
h_1,\dots,h_T
h 1 , … , h T 以最优的方式组合起来。给定样本
x
x
x 以及假设
h
t
(
x
)
h_t(x)
h t ( x ) ,贝叶斯最优的决策规则要求我们预测出最有可能的标签,即预测值为1如果
P
r
[
y
=
1
∣
h
1
(
x
)
,
…
,
h
T
(
x
)
]
>
P
r
[
y
=
0
∣
h
1
(
x
)
,
…
,
h
T
(
x
)
]
Pr[y=1|h_1(x),\dots,h_T(x)]>Pr[y=0|h_1(x),\dots,h_T(x)]
P r [ y = 1 ∣ h 1 ( x ) , … , h T ( x ) ] > P r [ y = 0 ∣ h 1 ( x ) , … , h T ( x ) ] 否则预测为0。
如果我们假设不同的假设的误差之间彼此独立,且与目标概念无关,那么这个法则尤其容易计算,也就是说,如果我们假设事件
h
t
(
x
)
≠
y
h_t(x)\neq y
h t ( x ) = y 条件独立于实际的标签
y
y
y 和其他所有假设的预测
h
1
(
x
)
,
…
,
h
t
−
1
(
x
)
,
h
t
+
1
(
x
)
,
,
…
,
h
T
(
x
)
h_1(x),\dots,h_{t-1}(x),h_{t+1}(x),,\dots,h_T(x)
h 1 ( x ) , … , h t − 1 ( x ) , h t + 1 ( x ) , , … , h T ( x ) 。在这个例子中,通过运用贝叶斯法则,我们可以用一种特别简单的形式重写贝叶斯最优决策法则,即预测值为1如果
P
r
[
y
=
1
]
∏
t
:
h
t
(
x
)
=
0
ε
t
∏
t
:
h
t
(
x
)
=
1
(
1
−
ε
t
)
>
P
r
[
y
=
0
]
∏
t
:
h
t
(
x
)
=
0
(
1
−
ε
t
)
∏
t
:
h
t
(
x
)
=
1
ε
t
Pr[y=1]\prod_{t:h_t(x)=0}\varepsilon_t\prod_{t:h_t(x)=1}(1-\varepsilon_t)>Pr[y=0]\prod_{t:h_t(x)=0}(1-\varepsilon_t)\prod_{t:h_t(x)=1}\varepsilon_t
P r [ y = 1 ] t : h t ( x ) = 0 ∏ ε t t : h t ( x ) = 1 ∏ ( 1 − ε t ) > P r [ y = 0 ] t : h t ( x ) = 0 ∏ ( 1 − ε t ) t : h t ( x ) = 1 ∏ ε t 否则预测为0,其中
ε
t
=
P
r
[
h
t
(
x
)
≠
y
]
\varepsilon_t=Pr[h_t(x)\neq y]
ε t = P r [ h t ( x ) = y ] 。我们在假设集上加上平凡假设
h
0
h_0
h 0 ,它的预测值恒为1,则我们可以用
ε
0
\varepsilon_0
ε 0 替代
P
r
[
y
=
0
]
Pr[y=0]
P r [ y = 0 ] 。对不等式两边取对数,重新排列各项,发现贝叶斯最优决策规则与AdaBoost生成的组合规则相同 。
如果不同假设的误差是相互依赖的,那么贝叶斯最优决策规则就会变得复杂得多。然而,在实践中,即使没有理由假设独立性,也常常使用上面描述的简单规则。(这有时被称为“朴素贝叶斯”)一个有趣的、更有原则的替代方法是使用算法AdaBoost来找到一个组合规则,根据定理6,这个组合规则保证了非平凡精度。
在本节中,我们将展示如何将定理6中给出的界改进为原来的界除以2 。这种改进的主要思想是将
h
f
h_f
h f 使用的“硬”
{
0
,
1
}
\{0,1\}
{ 0 , 1 } 值决策替换为“软”阈值(伪代码中最后输出的那步的阈值)。具体来说,令
r
(
x
)
=
∑
t
=
1
T
(
l
o
g
1
β
t
)
h
t
(
x
)
∑
t
=
1
T
l
o
g
1
β
t
r(x)={\sum_{t=1}^T(log{1\over\beta_t})h_t(x)\over\sum_{t=1}^Tlog{1\over\beta_t}}
r ( x ) = ∑ t = 1 T l o g β t 1 ∑ t = 1 T ( l o g β t 1 ) h t ( x ) 它是弱假设
h
t
h_t
h t 的加权平均。这里考虑的最后的假设的形式为
h
f
(
x
)
=
F
(
r
(
x
)
)
h_f(x)=F(r(x))
h f ( x ) = F ( r ( x ) ) ,其中
F
:
[
0
,
1
]
→
[
0
,
1
]
F:[0,1]\to[0,1]
F : [ 0 , 1 ] → [ 0 , 1 ] 。在图2给出的Adaboost版本中,
F
(
r
)
F(r)
F ( r ) 是一个硬阈值,即
r
⩾
1
/
2
r\geqslant1/2
r ⩾ 1 / 2 时等于1。在本节中我们使用取值在
[
0
,
1
]
[0,1]
[ 0 , 1 ] 之间的软阈值函数来替代。当
h
f
(
x
)
∈
[
0
,
1
]
h_f(x)\in[0,1]
h f ( x ) ∈ [ 0 , 1 ] 时,我们可以把
h
f
h_f
h f 解释为随机的假设,
h
f
(
x
)
h_f(x)
h f ( x ) 解释为预测为1的概率。则误差
E
i
∼
D
[
∣
h
f
(
x
i
)
−
y
i
∣
]
E_{i\sim D}[|h_f(x_i)-y_i|]
E i ∼ D [ ∣ h f ( x i ) − y i ∣ ] 就是不正确预测的概率。
定理9 (证明略)生成的假设误差
ε
1
,
…
,
ε
T
\varepsilon_1,\dots,\varepsilon_T
ε 1 , … , ε T 和定理6一样定义,改进后的最终假设定义为
h
f
(
x
)
=
F
(
r
(
x
)
)
h_f(x)=F(r(x))
h f ( x ) = F ( r ( x ) ) ,其中
F
F
F 满足对
r
∈
[
0
,
1
]
r\in[0,1]
r ∈ [ 0 , 1 ] :
F
(
1
−
r
)
=
1
−
F
(
r
)
且
F
(
r
)
⩽
1
2
(
∏
t
=
1
T
β
t
)
1
/
2
−
r
F(1-r)=1-F(r)\ \ \ \text{且\ \ } F(r)\leqslant{1\over2}(\prod_{t=1}^T\beta_t)^{1/2-r}
F ( 1 − r ) = 1 − F ( r ) 且 F ( r ) ⩽ 2 1 ( t = 1 ∏ T β t ) 1 / 2 − r 则
h
f
h_f
h f 的误差
ε
\varepsilon
ε 的界为
ε
⩽
2
T
−
1
∏
t
=
1
T
ε
t
(
1
−
ε
t
)
\varepsilon\leqslant2^{T-1}\prod_{t=1}^T\sqrt{\varepsilon_t(1-\varepsilon_t)}
ε ⩽ 2 T − 1 t = 1 ∏ T ε t ( 1 − ε t )
(例如s型函数
F
(
r
)
=
(
1
+
∏
t
=
1
T
β
t
2
r
−
1
)
−
1
F(r)=(1+\prod_{t=1}^T\beta_t^{2r-1})^{-1}
F ( r ) = ( 1 + ∏ t = 1 T β t 2 r − 1 ) − 1 就满足定理的条件)
5、对于多分类和回归的Boosting
令
Y
=
{
1
,
2
,
…
,
k
}
Y=\{1,2,\dots,k\}
Y = { 1 , 2 , … , k } 为可能的标签集,boosting算法最后给出一个假设
h
f
:
X
→
Y
h_f:X\to Y
h f : X → Y ,最后的误差就是分类错误的概率。AdaBoost的第一个扩展是最直接的,称为AdaBoost.M1 。弱学习器生成假设并将
k
k
k 各可能标签中的一个分配给每一个样本。我们要求每个弱假设的预测错误率小于
1
/
2
1/2
1 / 2 。给定了这些要求,作者证明了最后结合的假设的误差以指数下降,就像是二分类的情况。然而,从直觉上看,这对弱学习器的要求比预期的要高。在二分类
k
=
2
k=2
k = 2 中,随机猜测可能以
1
/
2
1/2
1 / 2 的概率猜对,但是当
k
>
2
k>2
k > 2 ,随机预测的正确概率仅仅只有
1
/
k
<
1
/
2
1/k<1/2
1 / k < 1 / 2 ,因此,我们要求弱学习器的精度要大于
1
/
2
1/2
1 / 2 显然要比只要求弱学习器比随机猜测好要更强。
事实上,当弱学习器的性能度量只考虑错误率时,这种困难是不可避免的,正如以下非正式示例所示:考虑这样一个学习问题
Y
=
{
0
,
1
,
2
}
Y =\{0, 1, 2\}
Y = { 0 , 1 , 2 } ,假设预测标签是否2很容易但预测标签是否0或1很难。那么只要标签是2就预测正确,其他情况就随机地在0和1之间猜一个的这种假设至少一半的时间是对的(显然比完全随机猜测达到的
1
/
3
1/3
1 / 3 的情况要好。另一方面,由于我们假设很难区分0和1标记的样本,因此将该学习器提高到任意精度是不可行的。
作为这个问题的一个更自然的例子,考虑OCR应用程序中手写数字的分类。对于弱学习器来说,可能很容易就能分辨出一个“7”的特定图像不是“0”,但很难确定它是“7”还是“9”。这里的部分问题是,尽管boosting算法可以将弱学习器的注意力集中在更难的例子上,但它无法迫使弱学习器区分可能特别难以区分的特定标签。
在第二个版本的多分类boosting中,作者试图通过扩展boosting算法和弱学习器之间的通信来克服这个困难。首先,我们允许弱学习器产生更多的富有表现力的假设,它的输出是一个向量
[
0
,
1
]
k
[0,1]^k
[ 0 , 1 ] k ,而不是在
Y
Y
Y 上的一个标签。直观地说,从技术上说,向量的第
y
y
y 个部分代表正确的标签是y的“相信”的程度。值比较大的部分(接近1)对应于那些被认为是可信的标签。相反,值比较小(接近0)的部分对应于那些不太可信的标签,那些有疑问的标签值在
1
/
2
1/2
1 / 2 附近。如果有几个标签被认为是可信的(或不可信的),那么它们都可以被赋大(或小)值。
在赋予弱学习算法更强的表达能力的同时,也对弱假设的性能提出了更复杂的要求。我们不使用通常的预测误差,而是要求弱假设相对于更复杂的误差度量(我们称之为伪损失)做得更好。这种伪损失因例子而异,也因每一次迭代而异。在每次迭代过程中,伪损失函数由boosting算法提供给弱学习器,并给出了样本的分布。通过对伪损失函数的处理,boosting算法可以使弱学习器集中在最难识别的标签上。boosting算法AdaBoost.M2 就是基于这些思想,如果每个弱假设的伪损失略好于随机猜测(关于提供给弱学习器的伪损失度量),则可以实现增强。
除了本文描述的两个扩展之外,我们还提到了另一种标准方法,即将给定的多分类问题转换为几个二分类问题,然后对每个二分类问题分别使用boosting。有几种实现这种转换的标准方法,其中最成功的一种是Dietterich和Bakiri所提倡的纠错输出编码方法。
最后还给出了boosting回归算法,这种情况下,
Y
=
[
0
,
1
]
Y=[0,1]
Y = [ 0 , 1 ] ,假设的错误率定义为
E
(
x
,
y
)
∼
P
[
(
h
(
x
)
−
y
)
2
]
E_{(x,y)\sim\mathscr{P}}[(h(x)-y)^2]
E ( x , y ) ∼ P [ ( h ( x ) − y ) 2 ] ,与AdaBoost.M2 使用类似的方法来提升弱回归算法的性能,我们把这个叫做AdaBoost.R 。
多分类问题扩展1
弱学习器的目标是在第
t
t
t 次迭代时建立一个分类误差
ε
t
≐
P
r
i
∼
p
t
[
h
t
(
x
i
)
≠
y
i
]
\varepsilon_t\doteq Pr_{i\sim p^t}[h_t(x_i)\neq y_i]
ε t ≐ P r i ∼ p t [ h t ( x i ) = y i ] 较小的假设
h
t
:
X
→
Y
h_t:X\to Y
h t : X → Y 。我们的扩展的boosting算法称为AdaBoost.M1 ,如图3所示,它和Adaboost有些微差别。主要的差别在于将二分类问题中的误差
∣
h
t
(
x
i
)
−
y
i
∣
|h_t(x_i)-y_i|
∣ h t ( x i ) − y i ∣ 改为
⌊
h
t
(
x
i
)
≠
y
i
⌋
\lfloor h_t(x_i)\neq y_i\rfloor
⌊ h t ( x i ) = y i ⌋ (伪损失,类似于示性函数),对任意断言
π
\pi
π ,定义
⌊
π
⌋
\lfloor\pi\rfloor
⌊ π ⌋ 为1如果
π
\pi
π 成立,否则为0。同样的,对于给定的样本
x
x
x ,最终假设
h
f
h_f
h f 现在输出标签
y
y
y ,使预测为这个标签的弱假设的权值之和最大化 。
对于二分类(
k
=
2
k = 2
k = 2 )问题,误差明显大于
1
/
2
1/2
1 / 2 的弱假设
h
h
h 与误差明显小于
1
/
2
1/2
1 / 2 的弱假设等值,因为
h
h
h 可以用
1
−
h
1-h
1 − h 替代。然而,对于
k
>
2
k > 2
k > 2 ,一个误差
ε
⩾
1
/
2
\varepsilon\geqslant1/2
ε ⩾ 1 / 2 的假设
h
t
h_t
h t 对于boosting算法来说是无用的。如果这样弱假设是由弱学习器得到的,我们的算法就会停止,只使用已经计算过的弱假设。
定理10 (证明将M1的设置简化为AdaBoost的实例化,然后应用定理6。具体略)假设弱学习算法在被AdaBoost.M1 调用时,产生误差为
ε
1
,
…
,
ε
T
\varepsilon_1,\dots,\varepsilon_T
ε 1 , … , ε T 的假设,其中
ε
t
\varepsilon_t
ε t 定义如图3所示。假设每个
ε
t
⩽
1
/
2
\varepsilon_t\leqslant1/2
ε t ⩽ 1 / 2 ,那么AdaBoost.M1 最终假设
h
f
h_f
h f 输出的误差
ε
=
P
r
t
∼
D
[
h
f
(
x
i
)
≠
y
i
]
\varepsilon= Pr_{t\sim D}[h_f(x_i)\neq y_i]
ε = P r t ∼ D [ h f ( x i ) = y i ] 的上界是
ε
⩽
2
T
∏
t
=
1
T
ε
t
(
1
−
ε
t
)
\varepsilon\leqslant2^T\prod_{t=1}^T\sqrt{\varepsilon_t(1-\varepsilon_t)}
ε ⩽ 2 T t = 1 ∏ T ε t ( 1 − ε t )
这个版本的boosting算法可能允许假设对每个
x
x
x 不仅仅是预测类别标签
h
(
x
)
∈
Y
h(x)\in Y
h ( x ) ∈ Y ,还生成了一个“信任度”
κ
(
x
)
∈
[
0
,
1
]
\kappa(x)\in[0,1]
κ ( x ) ∈ [ 0 , 1 ] 。学习器如果预测正确损失为
1
/
2
−
κ
(
x
)
/
2
1/2-\kappa(x)/2
1 / 2 − κ ( x ) / 2 否则为
1
/
2
+
κ
(
x
)
/
2
1/2+\kappa(x)/2
1 / 2 + κ ( x ) / 2 。
多分类问题扩展2
这种扩展要求在boosting算法和弱学习算法之间进行更详细的交流。这样做的好处是,它给了较弱的学习器更多的灵活性来做出预测。特别是它有时会有益于弱学习器最终假设的精度,即使弱假设不是以大于
1
/
2
1/2
1 / 2 的概率来预测正确的标签。
和之前描述的一样,弱学习器生成一个形如
h
:
X
×
Y
→
[
0
,
1
]
h:X\times Y\to [0,1]
h : X × Y → [ 0 , 1 ] 的假设,粗略地说,
h
(
x
,
y
)
h(x,y)
h ( x , y ) 度量了人们认为
y
y
y 是关于样本
x
x
x 的正确标签的程度。如果对于给定的
x
x
x ,
h
(
x
,
y
)
h(x, y)
h ( x , y ) 对于所有的
y
y
y 都达到相同的值,那么我们说这个假设对样本
x
x
x 没有提供信息。我们将看到,任何此类信息都可能对增强算法有用。另一方面,任何对严格相等的偏离都有潜在的信息量,因为它预测一些标签比其他标签更可信,这样的信息对于boosting算法来说可能是很有用的。
下面,我们通过定义一个用来度量弱假设好坏的伪损失来形式化弱学习器的目标。为了激发我们的定义,我们首先考虑以下设置。对于一个固定的训练样本
(
x
i
,
y
i
)
(x_i, y_i)
( x i , y i ) ,我们使用给定的假设
h
h
h 来回答
k
−
1
k-1
k − 1 个二元问题。对于每一个不正确的标签
y
≠
y
i
y\neq y_i
y = y i ,我们提出以下问题:“谁才是
x
i
x_i
x i 的标签:
y
i
y_i
y i 还是
y
y
y ?”,换句话说,我们要求将正确的标签
y
i
y_i
y i 从错误的标签
y
y
y 中区分出来。
暂时假设
h
h
h 只取
{
0
,
1
}
\{0,1\}
{ 0 , 1 } 中的值。如果
h
(
x
i
,
y
)
=
0
h(x_i, y)=0
h ( x i , y ) = 0 且
h
(
x
i
,
y
i
)
=
1
h(x_i, y_i)=1
h ( x i , y i ) = 1 ,我们将
h
h
h 对上述问题的答案解释为
y
i
y_i
y i 。同样,如果
h
(
x
i
,
y
)
=
1
h(x_i, y)=1
h ( x i , y ) = 1 且
h
(
x
i
,
y
i
)
=
0
h(x_i, y_i)=0
h ( x i , y i ) = 0 ,那么答案是
y
y
y 。如果
h
(
x
i
,
y
)
=
h
(
x
i
,
y
i
)
h(x_i, y)=h(x_i, y_i)
h ( x i , y ) = h ( x i , y i ) ,则从这两个答案中等概率的随机选出一个。
在更一般的情况下,
h
h
h 取
[
0
,
1
]
[0,1]
[ 0 , 1 ] 中的值,我们将
h
(
x
,
y
)
h(x, y)
h ( x , y ) 解释为上述过程的随机决策。也就是说,我们首先选择一个随机位
b
(
x
,
y
)
b(x, y)
b ( x , y ) 它是以概率
h
(
x
,
y
)
h(x, y)
h ( x , y ) 为1,否则为0。然后我们将上述过程应用于随机选择的二元函数
b
b
b 。上述问题选择错误答案
y
y
y 的概率是
P
r
[
b
(
x
i
,
y
i
)
=
0
∧
b
(
x
i
,
y
)
=
1
]
+
1
2
P
r
[
b
(
x
i
,
y
i
)
=
b
(
x
i
,
y
)
]
=
1
2
(
1
−
h
(
x
i
,
y
i
)
+
h
(
x
i
,
y
)
)
Pr[b(x_i, y_i)=0\land b(x_i,y)=1]+{1\over 2}Pr[b(x_i, y_i)= b(x_i,y)]={1\over 2}(1-h(x_i,y_i)+h(x_i,y))
P r [ b ( x i , y i ) = 0 ∧ b ( x i , y ) = 1 ] + 2 1 P r [ b ( x i , y i ) = b ( x i , y ) ] = 2 1 ( 1 − h ( x i , y i ) + h ( x i , y ) ) 如果所有
k
−
1
k-1
k − 1 个问题的答案都被认为是同等重要的,那么将假设的损失定义为所有
k
−
1
k-1
k − 1 个问题错误答案概率的平均值是很自然的:
1
k
−
1
∑
y
≠
y
i
1
2
(
1
−
h
(
x
i
,
y
i
)
+
h
(
x
i
,
y
)
)
=
1
2
(
1
−
h
(
x
i
,
y
i
)
+
1
k
−
1
∑
y
≠
y
i
h
(
x
i
,
y
)
)
{1\over k-1}\sum_{y\neq y_i}{1\over 2}(1-h(x_i,y_i)+h(x_i,y))={1\over 2}(1-h(x_i,y_i)+{1\over k-1}\sum_{y\neq y_i}h(x_i,y))
k − 1 1 y = y i ∑ 2 1 ( 1 − h ( x i , y i ) + h ( x i , y ) ) = 2 1 ( 1 − h ( x i , y i ) + k − 1 1 y = y i ∑ h ( x i , y ) )
给不同的问题赋予不同程度的重要性的一种自然方法是给每个问题分配一个权重。因此,对于每个
x
i
x_i
x i 和不正确的标签
y
≠
y
i
y\neq y_i
y = y i ,我们分配一个权值
q
(
i
,
y
)
q(i, y)
q ( i , y ) ,这个权值与区分标签
y
y
y 和正确标签
y
i
y_i
y i 的问题相关联。然后用
q
(
i
,
y
)
q(i, y)
q ( i , y ) 加权平均代替上式中的平均值,得到的公式为训练样本
i
i
i 关于
q
q
q 的伪损失
h
h
h :
p
l
o
s
s
q
(
h
,
i
)
≐
1
2
(
1
−
h
(
x
i
,
y
i
)
+
∑
y
≠
y
i
q
(
i
,
y
)
h
(
x
i
,
y
)
)
ploss_q(h,i)\doteq{1\over2}(1-h(x_i,y_i)+\sum_{y\neq y_i}q(i,y)h(x_i,y))
p l o s s q ( h , i ) ≐ 2 1 ( 1 − h ( x i , y i ) + y = y i ∑ q ( i , y ) h ( x i , y ) ) 函数
q
=
{
1
,
…
,
N
}
×
Y
→
[
0
,
1
]
q=\{1,\dots,N\}\times Y\to[0,1]
q = { 1 , … , N } × Y → [ 0 , 1 ] 称为标签权重函数,它为训练集中的每个样本
i
i
i 在上面定义的
k
−
1
k-1
k − 1 个辨别问题中分配一个概率分布。所以,对于所有的
i
i
i ,
∑
y
≠
y
i
q
(
i
,
y
)
=
1
\sum_{y\neq y_i}q(i,y)=1
∑ y = y i q ( i , y ) = 1 。弱学习器的目标就是在给定分布
D
D
D 和权重函数
q
q
q 后最小化期望伪损失:
p
l
o
s
s
D
,
q
(
h
)
:
=
E
i
∼
D
[
p
l
o
s
s
q
(
h
,
i
)
]
ploss_{D,q}(h):=E_{i\sim D}[ploss_q(h,i)]
p l o s s D , q ( h ) : = E i ∼ D [ p l o s s q ( h , i ) ]
正如我们所看到的,通过操纵样本上的分布和标签权重函数
q
q
q ,我们的增强算法有效地令弱学习器不仅关注比较难的样本,还关注最难消除的不正确的类别标签。相反,这种伪损失度量可能会使弱学习器更容易获得较弱的优势。例如,如果一个弱学习器能够简单地确定一个特定的样本不属于某个类(即使它不知道其余的类中哪个是正确的类),那么,根据
q
q
q ,这可能足以获得一个较弱的优势。
本节的主要结果——定理11表明,弱学习器如果它可以持续产生伪损失小于
1
/
2
1/2
1 / 2 的弱假设,那么它是可以提升的。注意,伪损失
1
/
2
1/2
1 / 2 可以通过任意不含信息的假设平凡地实现。此外,伪损失
ε
>
1
/
2
\varepsilon>1/2
ε > 1 / 2 的弱假设对提升也是有利的,因为它可以用
1
−
ε
<
1
/
2
1-\varepsilon<1/2
1 − ε < 1 / 2 的假设
1
−
h
1-h
1 − h 替代。
例5 是一个简单的例子说明了伪损失的作用,即找到一个伪损失小的假设要比找到一个预测误差小的假设容易得多。
另外,我们使用预测误差(定理10)进行boosting的理论界要强于伪损失(定理11)的理论界。[12]的经验测试表明,当弱学习器使用非常严格的假设时,伪损失通常更成功。然而,对于较强的弱学习器,如决策树学习算法,使用伪损失和预测误差之间几乎没有区别。
AdaBoost.M2 算法如图4所示。每个样本
i
i
i 和每个标签
y
∈
Y
−
{
y
i
}
y\in Y-\{y_i\}
y ∈ Y − { y i } 的权重为
w
i
,
y
t
w^t_{i,y}
w i , y t 。分布
D
t
D_t
D t 和标签权重函数
q
t
q_t
q t 必须提供给弱学习器,这两个都是使用权重向量
w
t
w^t
w t 计算的,如步骤1所示。弱学习器的目标是最小化伪损失
ε
t
\varepsilon_t
ε t ,如步骤3所定义。权重的更新如步骤5所示。对于给定的样本
x
x
x ,最终假设
h
f
h_f
h f 输出标签
y
y
y ,使弱假设值
h
t
(
x
,
y
)
h_t(x, y)
h t ( x , y ) 的加权平均值最大化。
定理11 (证明思路类似定理10。具体略)假设弱学习算法在被AdaBoost.M2 调用时,产生伪误差为
ε
1
,
…
,
ε
T
\varepsilon_1,\dots,\varepsilon_T
ε 1 , … , ε T 的假设,其中
ε
t
\varepsilon_t
ε t 定义如图4所示。那么AdaBoost.M2 最终假设
h
f
h_f
h f 输出的误差
ε
=
P
r
t
∼
D
[
h
f
(
x
i
)
≠
y
i
]
\varepsilon= Pr_{t\sim D}[h_f(x_i)\neq y_i]
ε = P r t ∼ D [ h f ( x i ) = y i ] 的上界是
ε
⩽
(
k
−
1
)
2
T
∏
t
=
1
T
ε
t
(
1
−
ε
t
)
\varepsilon\leqslant(k-1)2^T\prod_{t=1}^T\sqrt{\varepsilon_t(1-\varepsilon_t)}
ε ⩽ ( k − 1 ) 2 T t = 1 ∏ T ε t ( 1 − ε t )
虽然这里省略了细节,但AdaBoost.M2 的边界,可以通过类似于4.5节所述的方式减小一半。
boosting回归算法
这里的标签空间为
Y
=
[
0
,
1
]
Y=[0,1]
Y = [ 0 , 1 ] ,学习器根据分布
P
\mathscr{P}
P 得到随机选取的样本
(
x
,
y
)
(x,y)
( x , y ) ,它的目标是找到一个假设
h
:
X
→
Y
h:X\to Y
h : X → Y ,这个假设在给定
x
x
x 值后预测出可能的合适的
y
y
y 值。具体来说,学习器试图去找到一个
h
h
h ,它有较小的均方误差(MSE):
E
(
x
,
y
)
∼
P
[
(
h
(
x
)
−
y
)
2
]
E_{(x,y)}\sim\mathscr{P}[(h(x)-y)^2]
E ( x , y ) ∼ P [ ( h ( x ) − y ) 2 ] 作者的boosting方法可以应用于任何合理的有界误差度量,但为了具体起见,我们在这里只讨论均方误度量。
按照对分类问题的方法,我们假设学习器已经获得了一个根据分布
P
\mathscr{P}
P 的训练集
(
x
1
,
y
1
)
,
…
,
(
x
N
,
y
N
)
(x_1, y_1),\dots,(x_N, y_N)
( x 1 , y 1 ) , … , ( x N , y N ) 的样本,我们只关注经验MSE的最小化:
1
N
∑
i
=
1
N
(
h
(
x
i
)
−
y
i
)
2
{1\over N}\sum_{i=1}^N(h(x_i)-y_i)^2
N 1 i = 1 ∑ N ( h ( x i ) − y i ) 2 利用泛化误差那部分的技巧,真实的MSE可以和经验MSE联系起来。
在这个背景下,为了得到一个boosting算法,我们将给定的回归问题简化为一个二分类问题,然后应用AdaBoost。正如在定理10和定理11的证明中使用的简化一样,我们用弯弯在简化的(AdaBoost)空间中标记所有变量。对训练集的每个样本
(
x
i
,
y
i
)
(x_i, y_i)
( x i , y i ) ,我们对所有
y
∈
[
0
,
1
]
y\in[0, 1]
y ∈ [ 0 , 1 ] 通过一对
(
i
,
y
)
(i,y)
( i , y ) 定义了一个连续的索引样本:相应的样本是
x
~
i
,
y
=
(
x
i
,
y
)
\tilde{x}_{i,y} = (x_i, y)
x ~ i , y = ( x i , y ) ,标签是
y
~
i
,
y
=
⌊
y
⩾
y
i
⌋
\tilde{y}_{i,y}= \lfloor y\geqslant y_i\rfloor
y ~ i , y = ⌊ y ⩾ y i ⌋ 。(回想一下
⌊
π
⌋
=
1
\lfloor\pi\rfloor=1
⌊ π ⌋ = 1 如果断言
π
\pi
π 成立,否则为0。)虽然显式地得到一个无限大的训练集显然是不可行的,但是我们将在后面看到如何有效地实现这种方法。此外,虽然第4节的结果只处理有限的训练集,但对无限的训练集的扩展是直接的。
因此,非正式地,每个样本
(
x
i
,
y
i
)
(x_i, y_i)
( x i , y i ) 被映射到一个二值问题的无限集合中,每个
y
∈
Y
y\in Y
y ∈ Y 对应一个问题,每个形式都是:“正确的标签
y
i
y_i
y i 比
y
y
y 大还是小?”。类似的方式,每个假设
h
:
X
→
Y
h:X\to Y
h : X → Y 通过以下规则被简化为一个二值假设
h
:
X
×
Y
→
{
0
,
1
}
h:X\times Y\to\{0,1\}
h : X × Y → { 0 , 1 } :
h
~
(
x
,
y
)
=
⌊
y
⩾
h
(
x
)
⌋
\tilde{h}(x,y)=\lfloor y\geqslant h(x)\rfloor
h ~ ( x , y ) = ⌊ y ⩾ h ( x ) ⌋ 所以
h
~
\tilde{h}
h ~ 尝试以一个自然的方式用估计值
h
(
x
)
h(x)
h ( x ) 来回答这些二值问题。
最后,类似于分类问题那样,假定在训练集上给定了分布
D
D
D ,通常来说给的是均匀分布,即
D
(
i
)
=
1
/
N
D(i)=1/N
D ( i ) = 1 / N ,在简化的模型中,这个分布通过一对
(
i
,
y
)
(i,y)
( i , y ) 被映射到
D
~
\tilde{D}
D ~ ,这样的方式在简化空间中的分类误差最小化等价于原来问题的MSE的最小化。为了实行,我们定义
D
~
(
i
,
y
)
=
D
(
i
)
∣
y
−
y
i
∣
Z
\tilde{D}(i,y)={D(i)|y-y_i|\over Z}
D ~ ( i , y ) = Z D ( i ) ∣ y − y i ∣ 其中
Z
Z
Z 是归一化常数
Z
=
∑
i
=
1
N
D
(
i
)
∫
0
1
∣
y
−
y
i
∣
d
y
Z=\sum_{i=1}^ND(i)\int_0^1|y-y_i|dy
Z = i = 1 ∑ N D ( i ) ∫ 0 1 ∣ y − y i ∣ d y 直接推出
1
/
4
⩽
Z
⩽
1
/
2
1/4\leqslant Z\leqslant 1/2
1 / 4 ⩽ Z ⩽ 1 / 2
若直接计算关于密度
D
~
\tilde{D}
D ~ 的二值误差
h
~
\tilde{h}
h ~ ,可以发现,它直接和均方误差是成比例的:
∑
i
=
1
N
∫
0
1
∣
y
~
i
,
y
−
h
~
(
x
~
i
.
y
)
∣
D
~
(
i
.
y
)
d
y
=
1
Z
∑
i
=
1
N
D
(
i
)
∣
∫
y
i
h
(
x
i
)
∣
y
−
y
i
∣
d
y
∣
=
1
2
Z
∑
i
=
1
N
D
(
i
)
(
h
(
x
i
)
−
y
i
)
2
\begin{aligned} \sum_{i=1}^N\int_0^1|\tilde{y}_{i,y}-\tilde{h}(\tilde{x}_{i.y})|\tilde{D}(i.y)dy&={1\over Z}\sum_{i=1}^ND(i)\bigg|\int_{y_i}^{h(x_i)}|y-y_i|dy\bigg|\\ &={1\over 2Z}\sum_{i=1}^ND(i)({h(x_i)}-{y_i})^2 \end{aligned}
i = 1 ∑ N ∫ 0 1 ∣ y ~ i , y − h ~ ( x ~ i . y ) ∣ D ~ ( i . y ) d y = Z 1 i = 1 ∑ N D ( i ) ∣ ∣ ∣ ∣ ∫ y i h ( x i ) ∣ y − y i ∣ d y ∣ ∣ ∣ ∣ = 2 Z 1 i = 1 ∑ N D ( i ) ( h ( x i ) − y i ) 2 比例常数是
1
/
(
2
Z
)
∈
[
1
,
2
]
1/(2Z)\in[1,2]
1 / ( 2 Z ) ∈ [ 1 , 2 ]
为了解决这个问题,我们得到了如图5所示的回归boosting程序AdaBoost.R 。按照简化的规定,AdaBoost.R 对每个样本
i
i
i 以及标签
y
∈
Y
y\in Y
y ∈ Y 都有一个权重
w
i
,
y
t
w_{i,y}^t
w i , y t ,初始权重函数
w
1
w^1
w 1 就是上述定义的密度
D
~
\tilde{D}
D ~ 。通过归一化权重
w
t
w^t
w t ,第1步中定义了密度
p
t
p^t
p t 并且在第2步中传给弱学习器。弱学习器的目标就是找到一个假设
h
t
:
X
→
Y
h_t:X\to Y
h t : X → Y 是的在第3步中的损失
ε
t
\varepsilon_t
ε t 最小。最后在第5步,根据简化模型的规则更新权重。
第3步中定义的
ε
t
\varepsilon_t
ε t 直接由上面的简化得到:它其实就是在简化空间中的分类误差
h
~
f
\tilde{h}_f
h ~ f 。注意,与AdaBoost.M2 类似,AdaBoost.R 不仅改变了示例之间的分布
(
x
i
,
y
i
)
(x_i, y_i)
( x i , y i ) ,而且对每个样本的假设所遭受的损失的定义进行了一轮又一轮的修改。因此,尽管我们的最终目标是使均方误差最小化,但较弱学习器必须能够处理比MSE更复杂的损失函数。
最后的假设
h
f
h_f
h f 也是和简化的一致,每一个简化的弱假设
h
~
f
(
x
,
y
)
\tilde{h}_f(x,y)
h ~ f ( x , y ) 都是
y
y
y 的非增函数,因此,在简化空间中由Adaboost生成的最后的假设
h
~
f
\tilde{h}_f
h ~ f ,作为这些假设的加权和的一个阈值,也是
y
y
y 的一个非增函数。因为
h
~
f
\tilde{h}_f
h ~ f 的输出是二值的,这意味着对每个
x
x
x 存在
y
y
y 的一个值,使得对所有的
y
′
<
y
y'<y
y ′ < y 有
h
~
f
(
x
,
y
′
)
=
0
\tilde{h}_f(x,y')=0
h ~ f ( x , y ′ ) = 0 ,对所有的
y
′
>
y
y'>y
y ′ > y 有
h
~
f
(
x
,
y
′
)
=
1
\tilde{h}_f(x,y')=1
h ~ f ( x , y ′ ) = 1 。这就是正如图中定义的给定
h
f
(
x
)
h_f(x)
h f ( x ) 后
y
y
y 的值。注意
h
f
h_f
h f 实际计算的是弱假设的加权中位数。
首先,似乎不可能在一组不可数的点上保持
w
i
.
y
t
w_{i.y}^t
w i . y t 的权重。然而,仔细观察可以发现,当
w
i
.
y
t
w_{i.y}^t
w i . y t 被看作是
y
y
y 的函数时,它是一个分段线性函数。对于
t
=
1
t=1
t = 1 ,
w
i
.
y
t
w_{i.y}^t
w i . y t 有两个线性部分,第5步的每次更新都可能在
h
t
(
x
i
)
h_t(x_i)
h t ( x i ) 处将其中一个部分一分为二。初始化、存储和更新这样的分段线性函数都是简单的操作。此外,图中出现的积分可以显式求值,因为它们只涉及分段线性函数的积分。
下面的定理描述了AdaBoost.R 的性能保证。这个证明由上面描述的简化和定理6的直接应用得到。
定理12 (证明略)假设弱学习算法在被AdaBoost.R 调用时,产生误差为
ε
1
,
…
,
ε
T
\varepsilon_1,\dots,\varepsilon_T
ε 1 , … , ε T 的假设,其中
ε
t
\varepsilon_t
ε t 定义如图5所示。那么AdaBoost.M2 最终假设
h
f
h_f
h f 输出的均方误差
ε
=
E
i
∼
D
[
(
h
f
(
x
i
)
−
y
i
)
2
]
\varepsilon= E_{i\sim D}[(h_f(x_i)- y_i)^2]
ε = E i ∼ D [ ( h f ( x i ) − y i ) 2 ] 的上界是
ε
⩽
2
T
∏
t
=
1
T
ε
t
(
1
−
ε
t
)
\varepsilon\leqslant2^T\prod_{t=1}^T\sqrt{\varepsilon_t(1-\varepsilon_t)}
ε ⩽ 2 T t = 1 ∏ T ε t ( 1 − ε t )
这个设置的一个不幸的性质是没有简单的方法来生成一个损失为
1
/
2
1/2
1 / 2 的假设,这与我们在算法AdaBoost.M1 中遇到的情况类似,解决这个问题的一个办法可能是允许来自更一般的函数类的弱假设,一个简单的概括是允许由两个函数
h
:
X
→
[
0
,
1
]
h:X\to[0,1]
h : X → [ 0 , 1 ] 和
κ
:
X
→
[
0
,
1
]
\kappa:X\to[0,1]
κ : X → [ 0 , 1 ] 定义的弱假设,其中这两个函数将信心指数与
h
h
h 的每一个预测联系起来。与这对函数相关的简化的假设是:
h
~
(
x
,
y
)
=
{
(
1
+
κ
(
x
)
)
/
2
if
h
(
x
)
⩾
y
(
1
−
κ
(
x
)
)
/
2
otherwise
\tilde{h}(x,y)= \begin{cases} (1+\kappa(x))/2 &\text{if } h(x)\geqslant y\\ (1-\kappa(x))/2 &\text{otherwise} \end{cases}
h ~ ( x , y ) = { ( 1 + κ ( x ) ) / 2 ( 1 − κ ( x ) ) / 2 if h ( x ) ⩾ y otherwise 这些假设的使用方法与前面定义的假设相同,并且可以使用算法AdaBoost.R 的细微变化来提高这些更一般的弱学习器的准确性(细节省略)。这种变体的优点是任何
κ
(
x
)
=
0
\kappa(x)=0
κ ( x ) = 0 的假设都有
1
/
2
1/2
1 / 2 的伪损失,而且对假设的轻微偏离可以用来编码非常弱的预测。
这里的这个boosting方法可以应用在任何合理的有界损失函数
L
:
Y
×
X
→
[
0
,
1
]
L:Y\times X\to [0,1]
L : Y × X → [ 0 , 1 ] ,这里的
L
(
y
′
,
y
)
L(y',y)
L ( y ′ , y ) 衡量了观测标签
y
y
y 和预测标签
y
′
y'
y ′ 之间的差异程度。为了修改算法AdaBoost.R 来处理这样的损失函数,我们只需要在初始化的时候用
∣
∂
L
(
y
,
y
i
)
/
∂
y
∣
|\partial L(y,y_i)/\partial y|
∣ ∂ L ( y , y i ) / ∂ y ∣ 来替代
∣
y
−
y
i
∣
|y-y_i|
∣ y − y i ∣ ,算法其余部分都不用变,分析所需的修改非常简单。
参考资料:
Freund Y , Schapire R E . A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting[J]. Journal of Computer and System Sciences, 1997, 55(1):119-139.