0


AdaBoost算法详解及python实现【Python机器学习系列(十八)】

文章目录


1. AdaBoost 算法简介

Boosting是机器学习的三大框架之一,其特点是,训练过程中的诸多弱模型,彼此之间有着强依赖关系。Boost也被称为增强学习或提升法。典型的代表算法是AdaBoost算法。AdaBoost算法的核心思想是:将关注点放在预测错误的样本上。

AdaBoost 算法可以概括如下:

①假设共有m个样本数据,首先根据需求划分好训练集数据,按照一般思路,训练出第一个弱模型

  1. G
  2. 1
  3. (
  4. x
  5. )
  6. G_1(x)
  7. G1​(x)。

②对第一个弱模型

  1. G
  2. 1
  3. (
  4. x
  5. )
  6. G_1(x)
  7. G1​(x),计算该弱模型的**分类错误率**(或者说带权错误率,但是因为第一次迭代训练是均等权重的,所以第一次迭代的带权错误率等于普通的分类错误率)。

通过计算的分类错误率来确定该弱模型的权重,并更新训练集数据的权值分布。
(这里涉及两个权重不要弄混,先是模型权重,再是样本数据权重)
记模型

  1. G
  2. 1
  3. (
  4. x
  5. )
  6. G_1(x)
  7. G1​(x)的权重为
  8. α
  9. 1
  10. \alpha_1
  11. α1​,则
  12. F
  13. 1
  14. (
  15. x
  16. )
  17. =
  18. 0
  19. +
  20. α
  21. 1
  22. G
  23. 1
  24. (
  25. x
  26. )
  27. F_1(x)=0+\alpha_1G_1(x)
  28. F1​(x)=01G1​(x)(因为是第一次迭代,所以上一次可以暂记为0)。

③开始第二次迭代,使用更新后的样本权重再次训练一个弱模型,然后将该弱模型与上一次训练的弱模型

  1. G
  2. 2
  3. (
  4. x
  5. )
  6. G_2(x)
  7. G2​(x),按照一定的规则得到的模型权重进行复合,
  8. F
  9. 2
  10. (
  11. x
  12. )
  13. =
  14. F
  15. 1
  16. (
  17. x
  18. )
  19. +
  20. α
  21. 2
  22. G
  23. 2
  24. (
  25. x
  26. )
  27. F_2(x)=F_1(x) + \alpha_2 G_2(x)
  28. F2​(x)=F1​(x)+α2G2​(x)。

遂得到模型

  1. F
  2. 2
  3. (
  4. x
  5. )
  6. F_2(x)
  7. F2​(x)。

这里的重点,就在于

  1. α
  2. 1
  3. α
  4. 2
  5. \alpha_1\alpha_2
  6. α1​,α2​等,这些模型的权重的确定。

④循环以上过程n次(从第二次开始,每次计算的模型错误率,是带权错误率)。
(n的值是自己指定的,希望的迭代次数)。
直到得到模型

  1. F
  2. n
  3. (
  4. x
  5. )
  6. =
  7. F
  8. n
  9. 1
  10. (
  11. x
  12. )
  13. +
  14. G
  15. n
  16. (
  17. x
  18. )
  19. F_n(x)=F_{n-1}(x)+G_n(x)
  20. Fn​(x)=Fn1​(x)+Gn​(x),即为AdaBoost算法的输出模型,此时的模型
  21. F
  22. n
  23. (
  24. x
  25. )
  26. F_n(x)
  27. Fn​(x)是一个强训练模型。

请添加图片描述


2. AdaBoost算法 逻辑详解

按照以上思路,下边开始针对其中涉及的细节进行详解。

2.1 数据

首先要面对的,是数据。假设样本数据集D中共有m个样本,并表示如下:

  1. D
  2. =
  3. {
  4. (
  5. x
  6. 1
  7. ,
  8. y
  9. 1
  10. )
  11. ,
  12. (
  13. x
  14. 2
  15. ,
  16. y
  17. 2
  18. )
  19. ,
  20. .
  21. .
  22. .
  23. ,
  24. (
  25. x
  26. m
  27. ,
  28. y
  29. m
  30. )
  31. }
  32. D=\{(x_1,y_1),(x_2,y_2),...,(x_m,y_m)\}
  33. D={(x1​,y1​),(x2​,y2​),...,(xm​,ym​)}

其中

  1. x
  2. i
  3. x_i
  4. xi​是特征向量,
  5. y
  6. i
  7. y_i
  8. yi​是标签。标签的取值可以是1和-1

AdaBoost算法每次训练模型的时候,使用的可以是从m个样本中抽样抽出的部分样本,但是预测的时候必须统一,测试集必须是固定的m个样本。


2.2 带权错误率

使用AdaBoost算法,每次训练完弱模型后,需要进一步计算出其带权错误率。
带权错误率的公式如下:

  1. ε
  2. j
  3. =
  4. i
  5. =
  6. 1
  7. m
  8. ω
  9. i
  10. j
  11. I
  12. {
  13. f
  14. j
  15. (
  16. x
  17. )
  18. y
  19. i
  20. }
  21. \varepsilon_j=\sum_{i=1}^m \omega_{ij}I\{f_j(x)≠y_i\}
  22. εj​=∑i=1m​ωijI{fj​(x)=yi​}

如何理解这个式子:其中

  1. I
  2. (
  3. )
  4. I()
  5. I()是指示函数,即,当括号内条件满足时值为1,当不满足条件时值为0

这里括号内的条件,即表示对某样本的分类不正确。可以看出,预测错误的样本越多,该值则越大。

  1. ω
  2. i
  3. j
  4. \omega_{ij}
  5. ωij​即第j次迭代中的第i个样本的权重。

在第一次迭代中第一次训练弱模型时,每个样本的初始权重是均等的,均为

  1. 1
  2. m
  3. \frac{1}{m}
  4. m1​。

即每个样本被选中的概率是均等的。AdaBoost算法首先基于该均等的权重训练一个简单的弱学习器。
且因为均等权重,在第一次迭代的输出的弱分类器的带权错误率,是刚好等于预测错误的个数在m个样本中所占的比重的。(即带权错误率等于普通的分类错误率)。


2.3 损失函数 与 确定样本权重

AdaBoost算法的损失函数为指数损失。

以第k次迭代为例,第k次迭代将得到模型

  1. F
  2. k
  3. (
  4. x
  5. )
  6. =
  7. F
  8. k
  9. 1
  10. (
  11. x
  12. )
  13. +
  14. α
  15. k
  16. G
  17. (
  18. x
  19. )
  20. F_k(x)=F_{k-1}(x)+\alpha_kG(x)
  21. Fk​(x)=Fk1​(x)+αkG(x),则
  22. F
  23. k
  24. (
  25. x
  26. )
  27. F_k(x)
  28. Fk​(x)的损失函数函数为:
  29. L
  30. o
  31. s
  32. s
  33. =
  34. i
  35. =
  36. 1
  37. m
  38. e
  39. y
  40. i
  41. F
  42. k
  43. (
  44. x
  45. i
  46. )
  47. Loss=\sum_{i=1}^me^{-y_iF_k(x_i)}
  48. Loss=∑i=1meyiFk​(xi​)

     经简单分析,可以看出,对于每个样本
     若预测正确,则指数为负,损失只增加

  1. 1
  2. e
  3. \frac{1}{e}
  4. e1​;

     若预测错误,则损失函数的损失会增加e。

 将该损失函数进行进一步展开得:

  1. L
  2. o
  3. s
  4. s
  5. =
  6. i
  7. =
  8. 1
  9. m
  10. e
  11. y
  12. i
  13. F
  14. k
  15. (
  16. x
  17. i
  18. )
  19. Loss=\sum_{i=1}^me^{-y_iF_k(x_i)}
  20. Loss=∑i=1meyiFk​(xi​)
  21. =
  22. i
  23. =
  24. 1
  25. m
  26. e
  27. y
  28. i
  29. (
  30. F
  31. k
  32. 1
  33. (
  34. x
  35. i
  36. )
  37. +
  38. α
  39. k
  40. G
  41. (
  42. x
  43. i
  44. )
  45. )
  46. =\sum_{i=1}^{m}e^{-y_i(F_{k-1}(x_i)+\alpha_kG(x_i))}
  47. =∑i=1meyi​(Fk1​(xi​)+αkG(xi​))
  48. =
  49. i
  50. =
  51. 1
  52. m
  53. e
  54. y
  55. i
  56. F
  57. k
  58. 1
  59. (
  60. x
  61. i
  62. )
  63. e
  64. y
  65. i
  66. α
  67. k
  68. G
  69. k
  70. (
  71. x
  72. i
  73. )
  74. =\sum_{i=1}^me^{-y_iF_{k-1}(x_i)}e^{-y_i\alpha_kG_k(x_i)}
  75. =∑i=1meyiFk1​(xi​)eyi​αkGk​(xi​)

因为

  1. L
  2. o
  3. s
  4. s
  5. Loss
  6. Loss,即该表达式整体,表示的是模型
  7. F
  8. k
  9. (
  10. x
  11. )
  12. F_k(x)
  13. Fk​(x)的损失,
  14. e
  15. y
  16. i
  17. α
  18. k
  19. G
  20. k
  21. (
  22. x
  23. i
  24. )
  25. e^{-y_i\alpha_kG_k(x_i)}
  26. eyi​αkGk​(xi​)表示的则是第
  27. k
  28. k
  29. k次迭代中,新训练弱模型,样本和模型都加权后的损失。
  30. e
  31. y
  32. i
  33. F
  34. k
  35. 1
  36. (
  37. x
  38. i
  39. )
  40. e^{-y_iF_{k-1}(x_i)}
  41. eyiFk1​(xi​)表示的则是第
  42. k
  43. 1
  44. k-1
  45. k1次迭代中得到的模型
  46. F
  47. k
  48. 1
  49. F_{k-1}
  50. Fk1​的损失。

鉴于AdaBoost算法是利用上一个弱分类器

  1. F
  2. k
  3. 1
  4. F_{k-1}
  5. Fk1​的准确率(或者说错误率) 模型权重来调整数据,以获得下一个分类器。继续观察该表达式,可以清晰地发现,模型
  6. F
  7. k
  8. F_k
  9. Fk​的损失,等于模型
  10. G
  11. k
  12. G_k
  13. Gk​乘以模型权重
  14. α
  15. k
  16. \alpha_k
  17. αk​后,并经过 以模型
  18. F
  19. k
  20. 1
  21. F_{k-1}
  22. Fk1​损失为度量尺度的样本权重的调节,后的损失。所以式子中的
  23. e
  24. y
  25. i
  26. F
  27. k
  28. 1
  29. (
  30. x
  31. i
  32. )
  33. e^{-y_iF_{k-1}(x_i)}
  34. eyiFk1​(xi​)即可以理解为样本权重
  35. ω
  36. k
  37. ,
  38. i
  39. \omega_{k,i}
  40. ωk,i​。

对于每一个样本,如果在上次迭代结果的模型

  1. F
  2. k
  3. 1
  4. F_{k-1}
  5. Fk1​中预测正确,则在第k次迭代中给予较小的样本权重;如果在上次迭代结果的模型
  6. F
  7. k
  8. 1
  9. F_{k-1}
  10. Fk1​中预测错误,则在第k次迭代的预测中给予较大的样本权重,这使得其在第k次迭代中预测的结果将拥有更大的话语权。如果再次预测错误将带来更大的损失。
  11. ω
  12. k
  13. ,
  14. i
  15. =
  16. e
  17. y
  18. i
  19. F
  20. k
  21. 1
  22. (
  23. x
  24. i
  25. )
  26. \omega_{k,i}=e^{-y_iF_{k-1}(x_i)}
  27. ωk,i​=eyiFk1​(xi​)这样的表示还尚不完美,因为要将其作为权重,就还需要进行归一化处理才好。

进一步将

  1. F
  2. k
  3. 1
  4. F_{k-1}
  5. Fk1​再展开可得到每次迭代的样本权重,与上次迭代样本权重之间的关系,并做归一化处理得:
  6. ω
  7. k
  8. ,
  9. i
  10. =
  11. ω
  12. k
  13. 1
  14. ,
  15. i
  16. e
  17. y
  18. i
  19. α
  20. k
  21. 1
  22. G
  23. k
  24. 1
  25. (
  26. x
  27. i
  28. )
  29. Z
  30. t
  31. \omega_{k,i}=\frac{\omega_{k-1,i e^{-y_i\alpha_{k-1}G_{k-1}(x_i)}}{Z_t}
  32. ωk,i​=Zt​ωk1,i​⋅eyi​αk1Gk1​(xi​)​

其中

  1. Z
  2. t
  3. Z_t
  4. Zt​是归一化因子。这里的
  5. Z
  6. t
  7. =
  8. e
  9. k
  10. 1
  11. (
  12. 1
  13. e
  14. k
  15. 1
  16. )
  17. Z_t=\sqrt{e_{k-1}(1-e_{k-1})}
  18. Zt​=ek1​(1ek1​)​,其中
  19. e
  20. k
  21. 1
  22. e_{k-1}
  23. ek1​是第k-1次迭代分类的带权错误率。

可以看到该表达式中还有模型权重

  1. α
  2. k
  3. 1
  4. \alpha_{k-1}
  5. αk1​需要进一步确定。

2.3 确定模型权重

模型权重的确定这一环节,涉及了较为麻烦的推导。这里只讨论逻辑,具体推导过程不再细究。
以第k次迭代为例,第k次迭代将得到模型

  1. F
  2. k
  3. (
  4. x
  5. )
  6. =
  7. F
  8. k
  9. 1
  10. (
  11. x
  12. )
  13. +
  14. α
  15. k
  16. G
  17. (
  18. x
  19. )
  20. F_k(x)=F_{k-1}(x)+\alpha_kG(x)
  21. Fk​(x)=Fk1​(x)+αkG(x),我们需要确定的是
  22. α
  23. k
  24. \alpha_k
  25. αk​的值。

以使得AdaBoost算法的损失函数Loss最小为目标,经过一系列麻烦的推导,最终得到

  1. α
  2. k
  3. =
  4. 1
  5. 2
  6. log
  7. 1
  8. e
  9. k
  10. e
  11. k
  12. \alpha_k=\frac{1}{2}\log{\frac{1-e_k}{e_k}}
  13. αk​=21logek1ek​​

根据该表达式不难看出,分类误差率越大,则对应的弱分类器权重系数也就越小。
​___

2.4 输出模型

最终模型的表达式如下所示:

  1. F
  2. n
  3. (
  4. x
  5. )
  6. =
  7. s
  8. i
  9. g
  10. n
  11. (
  12. k
  13. =
  14. 1
  15. m
  16. α
  17. k
  18. G
  19. k
  20. (
  21. x
  22. )
  23. )
  24. F_n(x)=sign(\sum_{k=1}^m\alpha_kG_k(x))
  25. Fn​(x)=sign(∑k=1m​αkGk​(x))

这里使用了符号函数sign,即若值大于0则表示标签1,小于0则表示标签-1。


3.AdaBoost算法的python实现

首先生成两组高斯分布的数据,用于模型训练和效果展示。

  1. import numpy as np
  2. from matplotlib import pyplot as plt
  3. from sklearn.datasets import make_gaussian_quantiles
  4. # 符合高斯分布,均值默认为0,方差为2,200个样本,2个特征,标签有2类,打乱
  5. x1,y1 = make_gaussian_quantiles(
  6. cov=2,
  7. n_samples=200,
  8. n_features=2,
  9. n_classes=2,
  10. shuffle=True,
  11. random_state=1)# 满足高斯分布,两个特征,均值都为3,方差为1.5,300个样本数据,标签也有两个类别,打乱
  12. x2,y2 = make_gaussian_quantiles(
  13. mean=(3,3),
  14. cov=1.5,
  15. n_samples=300,
  16. n_features=2,
  17. n_classes=2,
  18. shuffle=True,
  19. random_state=1)# 水平拼接:x1, x2
  20. X = np.vstack((x1,x2))# 垂直拼接:标签值
  21. y = np.hstack((y1,y2))

得到了有500个样本的数据集,该数据集有两个特征,标签取值有两种。特征数据为X,标签数据为y。
在这里插入图片描述


做数据可视化展示如下:

  1. # 可视化
  2. plt.scatter(X[:,0],X[:,1],c=y)
  3. plt.show()

数据分布图像如下图所示:
在这里插入图片描述


然后训练模型:

  1. # 基础模型 使用决策树分类器作为基础模型from sklearn.tree import DecisionTreeClassifier
  2. # 导入集成模型AdaBoostClassifierfrom sklearn.ensemble import AdaBoostClassifier
  3. # 实例化弱模型 设置最大深度为2
  4. weak_classifier = DecisionTreeClassifier(max_depth=2)# 集成模型 每次训练随机抽取300个样本,学习率为0.8
  5. clf = AdaBoostClassifier(base_estimator=weak_classifier,algorithm="SAMME",n_estimators=300,learning_rate=0.8)
  6. clf.fit(X,y)

为了更直观地展示模型在每个点处的效果,接下来我们绘制等高线图来呈现模型效果。
首先找出两个特征x1和x2的最小值和最大值,然后在原来的基础上分别减一、加一,来构建网格化数据。

  1. x1_min = X[:,0].min()-1
  2. x1_max = X[:,0].max()+1
  3. x2_min = X[:,1].min()-1
  4. x2_max = X[:,1].max()+1
  5. x1_new,x2_new = np.meshgrid(np.arange(x1_min,x1_max),np.arange(x2_min,x2_max))

做预测:

  1. y_t = clf.predict(np.c_[x1_new.ravel(),x2_new.ravel()])

模型预测结果如下:
在这里插入图片描述
绘制等高线图,并填充色彩:

  1. y_t = y_t.reshape(x1_new.shape)
  2. plt.contourf(x1_new,x2_new,y_t)
  3. plt.scatter(X[:,0],X[:,1],c=y)
  4. plt.show()

输出图像效果如下:
在这里插入图片描述
如果对等高线图的绘制存在疑问,欢迎点击博客进行学习:实现 等高线图 - 基于python-matplotlib


本次分享就到这里,小啾感谢您的关注与支持!
🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ

本专栏更多好文欢迎点击下方连接:

1.初识机器学习前导内容_你需要知道的基本概念罗列_以PY为工具 【Python机器学习系列(一)】

2.sklearn库数据标准预处理合集_【Python机器学习系列(二)】

3.K_近邻算法_分类Ionosphere电离层数据【python机器学习系列(三)】

4.python机器学习 一元线性回归 梯度下降法的实现 【Python机器学习系列(四)】

5.sklearn实现一元线性回归 【Python机器学习系列(五)】

6.多元线性回归_梯度下降法实现【Python机器学习系列(六)】

7.sklearn实现多元线性回归 【Python机器学习系列(七)】

8.sklearn实现多项式线性回归_一元/多元 【Python机器学习系列(八)】

9.逻辑回归原理梳理_以python为工具 【Python机器学习系列(九)】

10.sklearn实现逻辑回归_以python为工具【Python机器学习系列(十)】

11.决策树专题_以python为工具【Python机器学习系列(十一)】

12.文本特征提取专题_以python为工具【Python机器学习系列(十二)】

13.朴素贝叶斯分类器_以python为工具【Python机器学习系列(十三)】

14.SVM 支持向量机算法(Support Vector Machine )【Python机器学习系列(十四)】

15.PCA主成分分析算法专题【Python机器学习系列(十五)】

16.机器学习模型性能度量详解 【Python机器学习系列(十六)】

17.集成学习之随机森林案例专题【Python机器学习系列(十七)】

18.AdaBoost算法详解及python实现【Python机器学习系列(十八)】


本文转载自: https://blog.csdn.net/weixin_48964486/article/details/126633593
版权归原作者 侯小啾 所有, 如有侵权,请联系我们删除。

“AdaBoost算法详解及python实现【Python机器学习系列(十八)】”的评论:

还没有评论