张小贤的平凡之路---机器学习之集成学习---周志华《机器学习》

最新推荐文章于 2024-09-01 15:53:42 发布

CSU张小贤

最新推荐文章于 2024-09-01 15:53:42 发布

阅读量299

点赞数

分类专栏：机器学习

机器学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

集成学习

集成学习的概念

123

1. AdaBoost简介

Boosting, 也称为增强学习或提升法，是一种重要的集成学习技术，能够将预测精度仅比随机猜度略高的弱学习器增强为预测精度高的强学习器，这在直接构造强学习器非常困难的情况下，为学习算法的设计提供了一种有效的新思路和新方法。从某种程度上来说，Boosting并不是某一种学习算法，而是一种框架。

AdaBoost是英文"Adaptive Boosting"（自适应增强）的缩写，它的自适应在于：前一个基本分类器被错误分类的样本的权值会增大，而正确分类的样本的权值会减小，并再次用来训练下一个基本分类器。同时，在每一轮迭代中，加入一个新的弱分类器，直到达到某个预定的足够小的错误率或达到预先指定的最大迭代次数才确定最终的强分类器。

AdaBoost 算法的基本步骤：

首先，是初始化训练数据的权值分布 $D_{1}$ 。假设有 $N$ 个训练样本数据，则每一个训练样本最开始时，都被赋予相同的权值： $w_{1}=\frac{1}{N}$ 。
然后，训练弱分类器 $h_{i}$ 。具体训练过程中是：如果某个训练样本点，被弱分类器 $h_{i}$ 准确地分类，那么在构造下一个训练集中，它对应的权值要减小；相反，如果某个训练样本点被错误分类，那么它的权值就应该增大。权值更新过的样本集被用于训练下一个分类器，整个训练过程如此迭代地进行下去。
最后，将各个训练得到的弱分类器组合成一个强分类器。各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，使其在最终的分类函数中起着较大的决定作用，而降低分类误差率大的弱分类器的权重，使其在最终的分类函数中起着较小的决定作用。换而言之，误差率低的弱分类器在最终分类器中占的权重较大，否则较小。

2. 针对二分类问题的AdaBoost算法实现过程

2.1 算法流程

首先，初始化训练数据的权重分布。每一个训练样本最开始时都被赋予相同的权值： $w_{i}=\frac{1}{N}$ ，这样训练样本集的初始权重分布 $D_{1}(i)$ :
$D_{1}(i)=(w_{1},w_{2},\cdots,w_{N})=(\frac{1}{N},\cdots,\frac{1}{N})$
迭代 $T$ 次以获得样本权值：
- 选取一个当前误差率最低的弱分类器 $h$ 作为第 $t$ 个基本分类器 $H_{t}$ ，并计算弱分类器 $h_{t}:X\rightarrow \{-1,1\}$ ，该弱分类器在分布 $D_{t}$ 上的误差为：
  $e_{t}=P(H_{t}(x_{i}) \neq y_{i})=\sum\limits_{i=1}^{N}w_{ti}I(H_{t}(x_{i})\neq y_{i})$
  (可知 $H_{t}(x)$ 在训练数据集上的误差率 $e_{t}$ 就是被 $H_{t}(x)$ 误分类样本的权值之和)
- 计算该弱分类器在最终分类器中所占的权重（弱分类器权重用 $\alpha$ 表示）：
  $\alpha_{t}=\frac{1}{2}ln(\frac{1-e_{t}}{e_{t}})$
- 更新训练样本的权值分布 $D_{t-1}$ :
  $D_{t+1}=\frac{D_{t}(i)exp(-\alpha_{t}y_{i}H_{t}(x_{i}))}{Z_{t}}$
  其中 $Z_{t}$ 为归一化常数 $Z_{t}=2\sqrt{e_{t}(1-e_{t})}$
最后，按弱分类器权重 $\alpha_{t}$ 组合各个弱分类器，即：
$f(x)=\sum\limits_{t=1}^{T}\alpha_{t}H_{t}(x)$
通过符号函数 $s i g n$ 的作用，得到一个强分类器为:
$H_{f}=sign(f(x))=sign(\sum\limits_{t=1}^{T}\alpha_{t}H_{t}(x))$
注：
因为权重更新依赖于 $\alpha$ ，而 $\alpha$ 又依赖于误差率 $e$ ，所以我们可以直接将权值更新公式用 $e$ 表示。样本权值更新公式： $D_{t+1}=\frac{D_{t}(i)exp(-\alpha_{t}y_{i}H_{t}(x_{i}))}{Z_{t}}$ ，其中 $Z_{t}=2\sqrt{e_{t}(1-e_{t})}$
当样本分错时， $y_{i}H_{t}(x_{i})=-1$
$D_{t+1}(i)=\frac{D_{t}(i)}{Z_{t}}exp(\alpha_{1})=\frac{D_{t}(i)}{Z_{t}}exp(\frac{1}{2}ln(\frac{1-e_{t}}{e_{t}}))=\frac{D_{t}(i)}{Z_{t}}\sqrt{\frac{1-e_{t}}{e_{t}}}\\=\frac{D_{t}(i)}{2\sqrt{e_{t}(1-e_{t})}}\sqrt{\frac{1-e_{t}}{e_{t}}}=\frac{D_{t}(i)}{2e_{t}}$
当样本分对时， $y_{i}H_{t}(x_{i})=1$
$D_{t+1}(i)=\frac{D_{t}(i)}{Z_{t}}exp(-\alpha_{1})=\frac{D_{t}(i)}{Z_{t}}exp(-\frac{1}{2}ln(\frac{1-e_{t}}{e_{t}}))=\frac{D_{t}(i)}{Z_{t}}\sqrt{\frac{e_{t}}{1-e_{t}}}\\=\frac{D_{t}(i)}{2\sqrt{e_{t}(1-e_{t})}}\sqrt{\frac{e_{t}}{1-e_{t}}}=\frac{D_{t}(i)}{2(1-e_{t})}$
$Z_{t}=\sum\limits_{i}D_{t}(i)exp(-\alpha_{t}y_{i}h_{t}(x_{i})) =\sum\limits_{y_{i}\neq h_{t}(x_{i})}D_{t}(i)exp(\alpha_{t})+\sum\limits_{y_{i}= h_{t}(x_{i})}D_{t}(i)exp(-\alpha_{t})\\=e_{t}e^{\alpha_{t}}+(1-e_{t})e^{-\alpha_{t}}=2\sqrt{e_{t}(1-e_{t})}$

3. 对 AdaBoost 提升方法来说，在每一轮如何改变训练数据的权值或概率分布？

提高那些被前一轮弱分类器错误分类样本的权值，而降低那些被正确分类样本的权值。采取这种操作可以使那些没有得到准确分类的数据由于其权值的加大而受到后一轮的弱分类器的更多关注。

4. AdaBoost 如何将弱分类器组合成一个强分类器？

采取加权多数表决的方法。加大分类误差率小的弱分类器的权值，使其在表决中起较大的作用；减小分类误差率大的弱分类器的权值，使其在表决中起较小的作用。

5. Boosting 和 Bagging (Bootstrap aggregating) 的区别？

1）样本选择上

$\textbf{Bagging}$ ：训练集是在原始集中有放回选取的，从原始集中选出的各轮训练集之间是独立的。

$\textbf{Boosting}$ ：每一轮的训练集不变，只是训练集中每个样例在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整。

2）样例权重

$\textbf{Bagging}$ ：使用均匀取样，每个样例的权重相等

$\textbf{Boosting}$ ：根据错误率不断调整样例的权值，错误率越大则权重越大。

3）预测函数

$\textbf{Bagging}$ ：所有预测函数的权重相等。

$\textbf{Boosting}$ ：每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重。

3）并行计算

$\textbf{Bagging}$ ：各个预测函数可以并行生成

$\textbf{Boosting}$ ：各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。

这两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果，将不同的分类算法套入到此类算法框架中一定程度上会提高了原单一分类器的分类效果，但是也增大了计算量。下面是将决策树与这些算法框架进行结合所得到的新的算法：

Bagging + 决策树 = 随机森林
AdaBoost + 决策树 = 提升树
Gradient Boosting + 决策树 = GBDT

6. 实例求解

给定如表所示的训练样本，弱分类器采用平行于坐标轴的直线，用AdaBoost算法实现强分类过程：

样本序号	1	2	3	4	5	6	7	8	9	10
样本点 $X$	(1,5)	(2,2)	(3,1)	(4,6)	(6,6)	(6,8)	(7,9)	(8,8)	(9,9)	(10,2)
类别 $Y$	1	1	-1	-1	1	-1	1	1	-1	-1

6.1 MATLAB程序

function kind = wcH1(X,entroy)
%h1弱分类器
X1=X(1);
X2=X(2);
if X1<entroy
    kind=1;
else
    kind=-1;
end
end

function kind = wcH2(X,entroy)
%h2弱分类器
X1=X(1);
X2=X(2);
if X1<entroy
    kind=1;
else
    kind=-1;
end
end

function kind = wcH3(X,entroy)
%h3弱分类器
X1=X(1);
X2=X(2);
if X2<entroy
    kind=-1;
else
    kind=1;
end
end

clc,clear all;
%% 训练样本数据
xData=[1 5;2 2;3 1;4 6;6 6;6 8;7 9;8 8;9 9;10 2] %样本数据点，对应编号为1,2,...10
Y=[1 1 -1 -1 1 -1 1 1 -1 -1]';                             %对应的样本类别，用1和-1表示
xNum=1:10;                                                      %编号
format rat
 %% 绘制样本分布图
L1=find(Y==1);
x=xData(L1,1);y=xData(L1,2);
plot(x,y,'b+','LineWidth',3,'MarkerSize',12);
hold on;
L2=find(Y==-1);
x=xData(L2,1);y=xData(L2,2);
plot(x,y,'ro','LineWidth',3,'MarkerSize',12);
xlabel('X1');ylabel('X2');axis([0 10 0 10])
%% ***********************************初试过程************************************
H1=zeros(10,1);H2=H1;H3=H1
for i=1:10
    X=xData(i,:);
    H1(i) = wcH1( X,2.5 );%弱分类器h1
    H2(i) = wcH2( X,8.5 );%弱分类器h2
    H3(i) = wcH3( X,6.5 );%弱分类器h3
end
errDataH1=find(H1~=Y);%找到被h1错分的样本点的序号
errDataH2=find(H2~=Y);%找到被h2错分的样本点的序号
errDataH3=find(H3~=Y);%找到被h3错分的样本点的序号
accDataH1=find(H1==Y);%找到被h1正确分的样本点的序号
accDataH2=find(H2==Y);%找到被h2正确分的样本点的序号
accDataH3=find(H3==Y);%找到被h3正确分的样本点的序号
errDataAll=[errDataH1,errDataH2,errDataH3];
accDataAll=[accDataH1,accDataH2,accDataH3];
N=10;
D1=zeros(10,1)+1/N       % 初始化权值分布
%% ***********************************第一次迭代***********************************
err1=sum(D1(errDataH1,:));%所有被错分类的样本点的权值之和即为误差率
err2=sum(D1(errDataH2,:));%所有被错分类的样本点的权值之和即为误差率
err3=sum(D1(errDataH3,:));%所有被错分类的样本点的权值之和即为误差率
errAll=[err1,err2,err3];
[minErr,minIndex]=min(errAll);
%根据误差率e1计算H1的系数：
a1=0.5*log((1-minErr)/minErr)
minErrData=errDataAll(:,minIndex);
minAccData=accDataAll(:,minIndex);
D2=D1;
for i=minAccData'
    D2(i)=D2(i)/(2*(1-minErr));
end
for i=minErrData'
     D2(i)=D2(i)/(2*minErr);
end
D2
%分类函数
f1=a1.*H1;
kindFinal=sign(f1)%此时强分类器的分类结果
%% ***********************************第二次迭代***********************************
err1=sum(D2(errDataH1,:));%所有被错分类的样本点的权值之和即为误差率
err2=sum(D2(errDataH2,:));%所有被错分类的样本点的权值之和即为误差率
err3=sum(D2(errDataH3,:));%所有被错分类的样本点的权值之和即为误差率
errAll=[err1,err2,err3];
[minErr,minIndex]=min(errAll);
% 根据误差率e2计算H2的系数：
a2=0.5*log((1-minErr)/minErr)
minErrData=errDataAll(:,minIndex);
minAccData=accDataAll(:,minIndex);
D3=D2;
for i=minAccData'
    D3(i)=D3(i)/(2*(1-minErr));
end
for i=minErrData'
     D3(i)=D3(i)/(2*minErr);
end
D3
% 分类函数
f2=a1.*H1+a2*H2;
kindFinal=sign(f2)%此时强分类器的分类结果
%% ***********************************第三次迭代***********************************
err1=sum(D3(errDataH1,:));%所有被错分类的样本点的权值之和即为误差率
err2=sum(D3(errDataH2,:));%所有被错分类的样本点的权值之和即为误差率
err3=sum(D3(errDataH3,:));%所有被错分类的样本点的权值之和即为误差率
errAll=[err1,err2,err3];
[minErr,minIndex]=min(errAll);
% 根据误差率e3计算G3的系数：
a3=0.5*log((1-minErr)/minErr)
minErrData=errDataAll(:,minIndex);
minAccData=accDataAll(:,minIndex);
D4=D3;
for i=minAccData'
    D4(i)=D4(i)/(2*(1-minErr));
end
for i=minErrData'
     D4(i)=D4(i)/(2*minErr);
end
D4
% 分类函数
f3=a1.*H1+a2*H2+a3*H3;
kindFinal=sign(f3)%此时强分类器的分类结果

7. AdaBoost优缺点

7.1 优点

Adaboost提供一种框架，在框架内可以使用各种方法构建子分类器。可以使用简单的弱分类器，不用对特征进行筛选。
Adaboost算法不需要弱分类器的先验知识，最后得到的强分类器的分类精度依赖于所有弱分类器。无论是应用于人造数据还是真实数据，Adaboost都能显著的提高学习精度。
Adaboost算法不需要预先知道弱分类器的错误率上限，且最后得到的强分类器的分类精度依赖于所有弱分类器的分类精度，可以深挖分类器的能力。Adaboost可以根据弱分类器的反馈，自适应地调整假定的错误率，执行的效率高。
Adaboost对同一个训练样本集训练不同的弱分类器，按照一定的方法把这些弱分类器集合起来，构造一个分类能力很强的强分类器，即“三个臭皮匠赛过一个诸葛亮”。