Adaboost算法及其代码实现

Adaboost算法及其代码实现

算法概述

AdaBoost（adaptive boosting），即自适应提升算法。

Boosting 是一类算法的总称，这类算法的特点是通过训练若干弱分类器，然后将弱分类器组合成强分类器进行分类。

为什么要这样做呢？因为弱分类器训练起来很容易，将弱分类器集成起来，往往可以得到很好的效果。

俗话说，"三个臭皮匠，顶个诸葛亮"，就是这个道理。

这类 boosting 算法的特点是各个弱分类器之间是串行训练的，当前弱分类器的训练依赖于上一轮弱分类器的训练结果。

各个弱分类器的权重是不同的，效果好的弱分类器的权重大，效果差的弱分类器的权重小。

值得注意的是，AdaBoost 不止适用于分类模型，也可以用来训练回归模型。

这需要将弱分类器替换成回归模型，并改动损失函数。

$几个概念

强学习算法：正确率很高的学习算法；
弱学习算法：正确率很低的学习算法，仅仅比随机猜测略好。

弱分类器：通过弱学习算法得到的分类器， 又叫基本分类器；
强分类器：多个弱分类器按照权值组合而成的分类器。

$提升方法专注两个问题：

1.每一轮如何改变训练数据的权值或者概率分布：

Adaboost的做法是提高被分类错误的训练数据的权值，而提高被分类错误的训练数据的权值。

这样，被分类错误的训练数据会得到下一次弱学习算法的重视。

2.弱组合器如何构成一个强分类器

加权多数表决。

每一个弱分类器都有一个权值，该分类器的误差越小，对应的权值越大，因为他越重要。

算法流程

给定二分类训练数据集：
\(T = {(x_1, y_1), (x_2, y_2), ... , (x_n, y_n)}\)
和弱学习算法

目标：得到分类器\(G(x)\)

1.初始化权重分布：

一开始所有的训练数据都赋有同样的权值，平等对待。
\(D_1 = (w_{11}, w_{12}, ... , w_{1n})\), \(w_{1i} = \frac{1}{N}\), \(i = 1, 2, ... , N\)

2.权值的更新

设总共有M个弱分类器，m为第m个弱分类器， \(m = 1, 2, ... , M\)
(1)第m次在具有\(D_m\)权值分布的训练数据上进行学习，得到弱分类器\(G_m(x)\)。
这个时候训练数据的权值：\(D_m = (w_{m, 1}, w_{m, 2}, ... , w_{m, n})\), \(i = 1, 2, ... , N\)
(2)计算\(Gm(x)\)在该训练数据上的分类误差率：
注：I函数单位误差函数
分类误差率：\(e_m = \sum^{N}_{i = 1} w_i I (G_m(x_i) \neq y_i)\)
(3)计算\(G_(x)\)的系数：
\(\alpha_m = \frac 1 2 \ln \frac{1 - e_m}{e_m}\)
(4)更新训练数据的权值：
\(D_{m+1} = (w_{m+1, 1}, w_{m+1, 2}, ... , w_{m+1, n})\), \(i = 1, 2, ... , N\)
\(w_{m+1, i} = \frac{w_{m, i}}{Z_m}\exp(-\alpha_m y_i G_m(x_i))\), \(i = 1, 2, ... , N\)
其中：
\(Z_m = \sum^{N}_{i = 1} w_{m, i} \exp(-\alpha_m y_i G_m(x_i))\)
正确的分类：\(y_i G_m(x_i) = 1\)
错误的分类：\(y_i G_m(x_i) = -1\)

3.构建基本分类器的线性组合

弱分类器乘以权重
\(f(x) = \sum^{M}_{m = 1} \alpha_m G_m(x)\)
最终分类器
\(G_(x) = sign(f(x))\)

一个例子

表 1. 示例数据集
x 0 1 2 3 4 5
y 1 1 -1 -1 1 -1

第一轮迭代

1.a 选择最优弱分类器

第一轮迭代时，样本权重初始化为（0.167, 0.167, 0.167, 0.167, 0.167, 0.167）。

表1数据集的切分点有0.5, 1.5, 2.5, 3.5, 4.5

若按0.5切分数据，得弱分类器x < 0.5,则 y = 1; x > 0.5, 则 y = -1。此时错误率为2 * 0.167 =
0.334

若按1.5切分数据，得弱分类器x < 1.5,则 y = 1; x > 1.5, 则 y = -1。此时错误率为1 * 0.167 =
0.167

若按2.5切分数据，得弱分类器x < 2.5,则 y = 1; x > 2.5, 则 y = -1。此时错误率为2 * 0.167 =
0.334

若按3.5切分数据，得弱分类器x < 3.5,则 y = 1; x > 3.5, 则 y = -1。此时错误率为3 * 0.167 =
0.501

若按4.5切分数据，得弱分类器x < 4.5,则 y = 1; x > 4.5, 则 y = -1。此时错误率为2 * 0.167 =
0.334

由于按1.5划分数据时错误率最小为0.167，则最优弱分类器为x < 1.5,则 y = 1; x > 1.5, 则 y =
-1。

1.b 计算最优弱分类器的权重

alpha = 0.5 * ln((1 – 0.167) / 0.167) = 0.8047

1.c 更新样本权重

x = 0, 1, 2, 3, 5时，y分类正确，则样本权重为：

0.167 * exp(-0.8047) = 0.075

x = 4时，y分类错误，则样本权重为：

0.167 * exp(0.8047) = 0.373

新样本权重总和为0.075 * 5 + 0.373 = 0.748

规范化后，

x = 0, 1, 2, 3, 5时，样本权重更新为：

0.075 / 0.748 = 0.10

x = 4时, 样本权重更新为：

0.373 / 0.748 = 0.50

综上，新的样本权重为(0.1, 0.1, 0.1, 0.1, 0.5, 0.1)。

此时强分类器为G(x) = 0.8047 * G1(x)。G1(x)为x < 1.5,则 y = 1; x > 1.5, 则 y =
-1。则强分类器的错误率为1 / 6 = 0.167。

第二轮迭代

2.a 选择最优弱分类器

若按0.5切分数据，得弱分类器x > 0.5,则 y = 1; x < 0.5, 则 y = -1。此时错误率为0.1 * 4 =
0.4

若按1.5切分数据，得弱分类器x < 1.5,则 y = 1; x > 1.5, 则 y = -1。此时错误率为1 * 0.5 =
0.5

若按2.5切分数据，得弱分类器x > 2.5,则 y = 1; x < 2.5, 则 y = -1。此时错误率为0.1 * 4 =
0.4

若按3.5切分数据，得弱分类器x > 3.5,则 y = 1; x < 3.5, 则 y = -1。此时错误率为0.1 * 3 =
0.3

若按4.5切分数据，得弱分类器x < 4.5,则 y = 1; x > 4.5, 则 y = -1。此时错误率为2 * 0.1 =
0.2

由于按4.5划分数据时错误率最小为0.2，则最优弱分类器为x < 4.5,则 y = 1; x > 4.5, 则 y = -1。

2.b 计算最优弱分类器的权重

alpha = 0.5 * ln((1 –0.2) / 0.2) = 0.6931

2.c 更新样本权重

x = 0, 1, 5时，y分类正确，则样本权重为：

0.1 * exp(-0.6931) = 0.05

x = 4 时，y分类正确，则样本权重为：

0.5 * exp(-0.6931) = 0.25

x = 2,3时，y分类错误，则样本权重为：

0.1 * exp(0.6931) = 0.20

新样本权重总和为 0.05 * 3 + 0.25 + 0.20 * 2 = 0.8

规范化后，

x = 0, 1, 5时，样本权重更新为：

0.05 / 0.8 = 0.0625

x = 4时, 样本权重更新为：

0.25 / 0.8 = 0.3125

x = 2, 3时, 样本权重更新为：

0.20 / 0.8 = 0.250

综上，新的样本权重为(0.0625, 0.0625, 0.250, 0.250, 0.3125, 0.0625)。

此时强分类器为G(x) = 0.8047 * G1(x) + 0.6931 * G2(x)。G1(x)为x < 1.5,则 y = 1; x
> 1.5, 则 y = -1。G2(x)为x < 4.5,则 y = 1; x > 4.5, 则 y =
-1。按G(x)分类会使x=4分类错误，则强分类器的错误率为1 / 6 = 0.167。

第三轮迭代

3.a 选择最优弱分类器

若按0.5切分数据，得弱分类器x < 0.5,则 y = 1; x > 0.5, 则 y = -1。此时错误率为0.0625 +
0.3125 = 0.375

若按1.5切分数据，得弱分类器x < 1.5,则 y = 1; x > 1.5, 则 y = -1。此时错误率为1 * 0.3125 =
0.3125

若按2.5切分数据，得弱分类器x > 2.5,则 y = 1; x < 2.5, 则 y = -1。此时错误率为0.0625 * 2 +
0.250 + 0.0625 = 0.4375

若按3.5切分数据，得弱分类器x > 3.5,则 y = 1; x < 3.5, 则 y = -1。此时错误率为0.0625 * 3 =
0.1875

若按4.5切分数据，得弱分类器x < 4.5,则 y = 1; x > 4.5, 则 y = -1。此时错误率为2 * 0.25 =
0.5

由于按3.5划分数据时错误率最小为0.1875，则最优弱分类器为x > 3.5,则 y = 1; x < 3.5, 则 y =
-1。

3.b 计算最优弱分类器的权重

alpha = 0.5 * ln((1 –0.1875) / 0.1875) = 0.7332

3.c 更新样本权重

x = 2, 3时，y分类正确，则样本权重为：

0.25 * exp(-0.7332) = 0.1201

x = 4 时，y分类正确，则样本权重为：

0.3125 * exp(-0.7332) = 0.1501

x = 0, 1, 5时，y分类错误，则样本权重为：

0.0625 * exp(0.7332) = 0.1301

新样本权重总和为 0.1201 * 2 + 0.1501 + 0.1301 * 3 = 0.7806

规范化后，

x = 2, 3时，样本权重更新为：

0.1201 / 0.7806 = 0.1539

x = 4时, 样本权重更新为：

0.1501 / 0.7806 = 0.1923

x = 0, 1, 5时, 样本权重更新为：

0.1301 / 0.7806 = 0.1667

综上，新的样本权重为(0.1667, 0.1667, 0.1539, 0.1539, 0.1923, 0.1667)。

此时强分类器为G(x) = 0.8047 * G1(x) + 0.6931 * G2(x) + 0.7332 * G3(x)。G1(x)为x <
1.5,则 y = 1; x > 1.5, 则 y = -1。G2(x)为x < 4.5,则 y = 1; x > 4.5, 则
y = -1。G3(x)为x > 3.5,则 y = 1; x < 3.5, 则 y =
-1。按G(x)分类所有样本均分类正确，则强分类器的错误率为0 / 6 = 0。则停止迭代，最终强分类器为G(x) = 0.8047 * G1(x)
+ 0.6931 * G2(x) + 0.7332 * G3(x)。

代码实现

![](https://img2018.cnblogs.com/blog/1612966/202001/1612966-20200129225316188-817919185.png)

原文地址：https://www.cnblogs.com/hichens/p/12241908.html

时间： 2024-10-30 09:45:35

Adaboost算法及其代码实现的相关文章

Adaboost算法原理分析和实例+代码（简明易懂）

Adaboost算法原理分析和实例+代码(简明易懂) [尊重原创,转载请注明出处] http://blog.csdn.net/guyuealian/article/details/70995333     本人最初了解AdaBoost算法着实是花了几天时间,才明白他的基本原理.也许是自己能力有限吧,很多资料也是看得懵懵懂懂.网上找了一下关于Adaboost算法原理分析,大都是你复制我,我摘抄你,反正我也搞不清谁是原创.有些资料给出的Adaboost实例,要么是没有代码,要么省略很多步骤,让初学者

04-04 AdaBoost算法代码(鸢尾花分类)

目录 AdaBoost算法代码(鸢尾花分类) 一.导入模块 二.导入数据 三.构造决策边界 四.训练模型 4.1 训练模型(n_e=10, l_r=0.8) 4.2 可视化 4.3 训练模型(n_estimators=300, learning_rate=0.8) 4.4 训练模型(n_estimators=300, learning_rate=0.5) 4.5 训练模型(n_estimators=600, learning_rate=0.7) 更新.更全的<机器学习>的更新网站,更有pyth

Adaboost 算法的原理与推导——转载及修改完善

<Adaboost算法的原理与推导>一文为他人所写,原文链接: http://blog.csdn.net/v_july_v/article/details/40718799 另外此文大部分是摘录李航的<统计学笔记>一书,原书下载链接:http://vdisk.weibo.com/s/z4UjMcqGpoNTw?from=page_100505_profile&wvr=6 在根据文中推导是发现有计算错误以及省略的步骤,在下文将会进行说明. ------------------

AdaBoost算法详解与实战

[原创]Liu_LongPo 转载请注明出处 [CSDN]http://blog.csdn.net/llp1992 AdaBoost算法是基于单层决策树等弱分类算法的强学习分类算法.单层决策树算法也是一种分类算法,但是其分类效果较差,只根据一个特征进行数据划分,因此单层决策树算法被称为弱分类算法:而AdaBoost算法通过将多个弱分类算法串行训练而成,属于强分类算法. AdaBoost算法是boosting算法的一种,它所串联的弱分类器一般都是一致的,而且它训练是的关注点在于被之前分类器分错的数

《机器学习实战》AdaBoost算法的分析与实现

===================================================================== <机器学习实战>系列博客是博主阅读<机器学习实战>这本书的笔记也包含一些其他python实现的机器学习算法 github 源码同步:https://github.com/Thinkgamer/Machine-Learning-With-Python 算法实现均采用Python              如需转载请注明出处,谢谢 ========

【人脸检测——基于机器学习3】AdaBoost算法

简介 主要工作 AdaBoost算法的人脸检测算法包含的主要工作:(1)通过积分图快速求得Haar特征:(2)利用AdaBoost算法从大量的特征中选择出判别能力较强的少数特征用于人脸检测分类:(3)提出一个级联结构模型,将若干个弱分类器集成一个强分类器,其能够快速排除非人脸区域,提高算法的检测速度. 2. AdaBoost算法具体描述 AdaBoost算法的原理是通过逐级增强的方法将弱分类器组合成为分类效果较好的强分类器,具体来说: (1) 给定一个弱学习算法和一个训练集,其中是输入的训练样本

提升树之Adaboost算法的介绍

主要内容: 模型介绍 损失函数的介绍 Adaboost分类算法步骤 Adaboost回归算法步骤 Adaboost函数语法 提升树之Adaboost算法的应用——信用卡是否违约的识别 1.模型介绍 提升树算法与线性回归模型的思想类似,所不同的是该算法实现了多棵基础决策树??(??)的加权运算,最具代表的提升树为AdaBoost算法,即 2.损失函数的介绍 对于Adaboost算法而言,每一棵基础决策树都是基于前一棵基础决策树的分类结果对样本点设置不同的权重,如果在前一棵基础决策树中将某样本点预测

机器学习——Boosting算法与Adaboost算法

Boosting算法 关键点与难点在于如何修改数据 原理:将 含有m个数据的数据集 丢给一个弱学习器1分类,比如分对百分之60, 那么经过一定手段修改数据集,数据个数还是m个,将修改后的数据集扔给弱学习器2训练,学习器2把在学习器1中分错的那一部分又分对百分之三十. 再修改数据集,将修改后的数据集扔给弱学习器3训练,学习器3把在学习器1和2中分错的那一部分又分对百分之三十. 最后加权融合为一个强学习器. ...... ...... 如下图: 重点:修改数据集的方法 ①凡解(配图讲解,绝对可以懂)

Python实现各种排序算法的代码示例总结

Python实现各种排序算法的代码示例总结 作者:Donald Knuth 字体:[增加 减小] 类型:转载 时间:2015-12-11我要评论 这篇文章主要介绍了Python实现各种排序算法的代码示例总结,其实Python是非常好的算法入门学习时的配套高级语言,需要的朋友可以参考下 在Python实践中,我们往往遇到排序问题,比如在对搜索结果打分的排序(没有排序就没有Google等搜索引擎的存在),当然,这样的例子数不胜数.<数据结构>也会花大量篇幅讲解排序.之前一段时间,由于需要,我复习了