Wij权重怎么计算

机器学习 【Adaboost算法】

一．Adaboost原理：

Adaboost算法基本原理就是将多个弱分类器组合成一个强分类器。

二．Adaboost弱分类器

Adaboost一般使用单层决策树作为其弱分类器。单层决策树只有一个决策点（与CART树类似），通过阈值将数据二分。

三．Adaboost的数据权重和分类器权重

数据权重主要用于弱分类器寻找其分类误差最小的决策点，找到之后用这个最小误差计算出该弱分类器权重，弱分类器权重越大说明该弱分类器在最终决策时作用越大。

四．算法流程

具体说来，整个Adaboost 迭代算法就3步：

1.初始化训练数据权值。

如果有N个样本，则每一个训练样本最开始时都被赋予相同的权值：1/N。

2.训练弱分类器。

具体训练过程中，如果某个样本点已经被准确地分类，那么在构造下一个训练集中，它的权值就被降低；相反，如果某个样本点没有被准确地分类，那么它的权值就得到提高。然后，权值更新过的样本集被用于训练下一个分类器，整个训练过程如此迭代地进行下去。

3.将各个训练得到的多个弱分类器组合成一个强分类器。

各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，使其在最终的分类函数中起着较大的决策作用，而降低分类误差率大的弱分类器的权重，使其在最终的分类函数中起着较小的决策作用。换言之，误差率低的弱分类器在最终分类器中占的权重较大，否则较小。

五．Adaboost公式推导

给定一个训练数据集T={(x1,y1), (x2,y2)…(xN,yN)}，其中实例

，而实例空间

，yi属于标记集合{-1,+1}，

1. 初始化训练数据的权值分布。

每一个训练样本最开始时都被赋予相同的权值：1 / N。

2. 进行多轮迭代，用m = 1,2, …, M表示迭代的第多少轮

（1）使用具有权值分布Dm的训练数据集学习，得到基本分类器（选取让误差率最低的阈值来设计基本分类器）：

（2） 计算Gm(x)在训练数据集上的分类误差率

由上述式子可知，Gm(x)在训练数据集上的误差率em就是被Gm(x)误分类样本的权值之和。

（3）计算Gm(x)的系数alpha，alpha m表示弱分类器权重，e表示数据误差率

（log在python中用ln()更加准确，就是底数为e的对数函数。）

由上述式子可知，em <= 1/2时，am >= 0，且am随着em的减小而增大，意味着分类误差率越小的基本分类器在最终分类器中的作用越大。（4）更新训练数据权值（目的：得到样本的新的权值分布），用于下一轮迭代

使得误分样本的权值增大，正确分类样本的权值减小。因此AdaBoost方法能“重点关注”或“聚焦于”那些较难分对的样本上

其中，Zm是规范化因子，使得Dm+1成为一个概率分布：

3. 组合各个弱分类器

得到强分类器，如下：

六．Adaboost实例计算

求解过程：初始化训练数据的权值分布，令每个权值W1i = 1 / N = 0.1，其中，N = 10，i = 1,2, …, 10，然后分别对于m = 1,2,3, …等值进行迭代。

迭代过程1

对于m=1，在权值分布为D1（10个数据，每个数据的权值皆初始化为0.1）的训练数据上，经过计算可得：

阈值v取2.5时误差率为0.3（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为0.3），

阈值v取5.5时误差率最低为0.4（x < 5.5时取1，x > 5.5时取-1，则3 4 5 6 7 8皆分错，误差率0.6大于0.5，不可取。故令x > 5.5时取1，x < 5.5时取-1，则0 1 2 9分错，误差率为0.4），

阈值v取8.5时误差率为0.3（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为0.3）。

可以看到，无论阈值v取2.5，还是8.5，总得分错3个样本，故可任取其中任意一个如2.5，弄成第一个基本分类器为：

从而得到G1(x)在训练数据集上的

• 误差率:e1 = P(G1(xi)≠yi) = 3 * 0.1 = 0.3。
  
  用python中numpy类库计算：
  np.log((1 - 0.3) / 0.3) / 2) = 0.4236

这个alpha1代表G1(x)在最终的分类函数中所占的权重，为0.4236。

接着更新训练数据的权值分布，用于下一轮迭代：

Zm是规范化因子，使得Dm+1成为一个概率分布：

用python中numpy类库计算：

• 0.1 * np.exp(-0.4236 * 1 * 1) * 7 + 0.1 * np.exp(-0.4236 * -1 * 1) * 3 = 0.9165

当Y = 1 , G = 1 ,w = 0.1，
用python中numpy类库计算：

• (0.1 / 0.9165) * np.exp(-0.4236 * 1 * 1) = 0.0714 （用近似值计算，有损耗下边取0.0715计算）

当Y = 1 , G = -1 ,w = 0.1
用python中numpy类库计算：
np.exp(-0.4236 * 1 * -1) * (0.1 /0.9165) = 0.1666

即如果某个样本被分错了，则yi * Gm(xi)为负，负负得正，结果使得整个式子变大（样本权值变大），否则变小。

计算第一个弱分类器权重：

• 分类函数f1(x)= alpha1 * G1(x) = 0.4236 * G1(x)。

此时，得到的第一个基本分类器sign(f1(x))在训练数据集上有3个误分类点（即6 7 8）。

迭代过程2

对于m=2，在权值分布为D2 = (0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.1666, 0.1666, 0.1666, 0.0715)的训练数据上，经过计算可得：

阈值v取2.5时误差率为0.1666 * 3（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为0.1666*3），

阈值v取5.5时误差率最低为0.0715 * 4（x > 5.5时取1，x < 5.5时取-1，则0 1 2 9分错，误差率为0.0715 * 3 + 0.0715），

阈值v取8.5时误差率为0.0715 * 3（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为0.0715*3）。

很明显，G2(x)把样本“3 4 5”分错了，根据D2可知它们的权值为0.0715, 0.0715, 0.0715，所以G2(x)在训练数据集上的

• 误差率:e2 = P(G2(xi)≠yi) = 0.0715 * 3 = 0.2143。

计算G2的系数：

用python中numpy类库计算：

np.log((1 - 0.2143) / 0.2143) / 2 = 0.6496

Zm是规范化因子，使得Dm+1成为一个概率分布：

用python中numpy类库计算：

• 0.0715 * np.exp(-0.6496 * 1 ) * 3 + 0.0715 * np.exp(-0.6496 * -1) * 3 + 0.1666 * np.exp(-0.6496 * 1) * 3 + 0.0715 * np.exp(-0.6496 * 1) = 0.1667

当Y = 1 , G = 1 ,w = 0.0715
用python中numpy类库计算：

• (0.0715 / 0.8211) * np.exp(-0.6496 * -1 * 1) = 0.0455

当Y = -1 ,G = 1 ,w = 0.0715
用python中numpy类库计算：

• (0.0715 /0.8211) * np.exp(-0.6496 * -1 * 1) = 0.1667

Y = -1 ,G = 1 ,w = 0.1666

• (0.1666 /0.8211) * np.exp(-0.6496 * 1 * 1) = 0.106

计算第二个弱分类器权重：

• f2(x) = 0.4236 * G1(x) + 0.6496 * G2(x)

迭代过程3

对于m=3，在权值分布为D3 = (0.0455, 0.0455, 0.0455, 0.1667, 0.1667, 0.01667, 0.1060, 0.1060, 0.1060, 0.0455)的训练数据上，经过计算可得：

阈值v取2.5时误差率为0.10603（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为0.10603），

阈值v取5.5时误差率最低为0.04554（x > 5.5时取1，x < 5.5时取-1，则0 1 2 9分错，误差率为0.04554 = 0.1820），

阈值v取8.5时误差率为0.16673（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为0.16673）。

所以阈值v取5.5时误差率最低，故第三个基本分类器为：

此时，被误分类的样本是：0 1 2 9，这4个样本所对应的权值皆为0.0455，

所以G3(x)在训练数据集上的误差率e3 = P(G3(xi)≠yi) = 0.0455 * 4 = 0.1820。

计算G3的系数：

用python中numpy类库计算：

• np.log((1 - 0.182)/ 0.182) / 2 = 0.7514

Zm是规范化因子，使得Dm+1成为一个概率分布：

用python中numpy类库计算：

• 0.0455 * np.exp(-0.7514 * -1 ) * 3 + 0.1667 * np.exp(-0.7514 * 1) * 3 + 0.1060 * np.exp(-0.7514 * 1) * 3 + 0.0455 * np.exp(-0.7514 * -1) = 0.7717**

当Y = -1 , G = 1 ,w =0.0455
用python中numpy类库计算：

• np.exp(-0.7514 * 1 * -1) * (0.0455 / 0.7717)= 0.125

当Y = -1 , G = -1 ,w = 0.1667
用python中numpy类库计算：

• np.exp(-0.7514 * 1 * 1) * (0.1667 / 0.7717) = 0.102

当Y = 1 , G = 1 ,w = 0.1060
用python中numpy类库计算：

• np.exp(-0.7514 * 1 * 1) * (0.1060 / 0.7717) = 0.065

D4 = (0.125, 0.125,** 0.125**, 0.102, 0.102, 0.102, 0.065, 0.065, 0.065, 0.125)。被分错的样本“0 1 2 9”的权值变大，其它被分对的样本的权值变小。

计算第三个弱分类器权重：

f3(x)=0.4236G1(x) + 0.6496G2(x) + 0.7514G3(x)

此时，得到的第三个基本分类器sign(f3(x))在训练数据集上有0个误分类点。至此，整个训练过程结束

现在，咱们来总结下3轮迭代下来，各个样本权值和误差率的变化，如下所示（其中，样本权值D中加了下划线的表示在上一轮中被分错的样本的新权值）：

训练之前，各个样本的权值被初始化为D1 = (0.1, 0.1,0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1)；

第一轮迭代中，样本“6 7 8”被分错，对应的误差率为e1=P(G1(xi)≠yi) = 3*0.1 = 0.3，此第一个基本分类器在最终的分类器中所占的权重为a1 = 0.4236。第一轮迭代过后，样本新的权值为D2 = (0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.1666, 0.1666, 0.1666, 0.0715)；

此时，得到的第一个基本分类器sign(f1(x))在训练数据集上有3个误分类点（即6 7 8）。

分类函数f1(x)= a1*G1(x) = 0.4236G1(x)。第二轮迭代中，样本“3 4 5”被分错，对应的误差率为e2=P(G2(xi)≠yi) = 0.0715 * 3 = 0.2143，此第二个基本分类器在最终的分类器中所占的权重为a2 = 0.6496。第二轮迭代过后，样本新的权值为D3 = (0.0455, 0.0455, 0.0455, 0.1667, 0.1667, 0.1667, 0.1060, 0.1060, 0.1060, 0.0455)；

D2 = ( 0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.1666, 0.1666, 0.1666, 0.0715)

D3 = ( 0.0455, 0.0455, 0.0455, 0.1667, 0.1667, 0.1667, 0.1060, 0.1060, 0.1060, 0.0455)

此时，得到的第一个基本分类器sign(f1(x))在训练数据集上有3个误分类点（即3 4 5）。

*f2(x)=0.4236G1(x) + 0.6496G2(x)第三轮迭代中，样本“0 1 2 9”被分错，对应的误差率为e3 = P(G3(xi)≠yi) = 0.0455*4 = 0.1820，此第三个基本分类器在最终的分类器中所占的权重为a3 = 0.7514。第三轮迭代过后，样本新的权值为D4 = (0.125, 0.125, 0.125, 0.102, 0.102, 0.102, 0.065, 0.065, 0.065, 0.125)。

D4 = ( 0.125, 0.125, 0.125 , 0.102 , 0.102, 0.102, 0.065, 0.065, 0.065, 0.125)

此时，得到的第一个基本分类器sign(f1(x))在训练数据集上有4个误分类点（即0 1 2 9）。

• f3(x)=0.4236 * G1(x) + 0.6496 * G2(x)+0.7514 * G3(x)
  得到的第三个基本分类器sign(f3(x))在训练数据集上有0个误分类点。至此，整个训练过程结束

从上述过程中可以发现，如果某些个样本被分错，它们在下一轮迭代中的权值将被增大，同时，其它被分对的样本在下一轮迭代中的权值将被减小。就这样，分错样本权值增大，分对样本权值变小，而在下一轮迭代中，总是选取让误差率最低的阈值来设计基本分类器，所以误差率e（所有被Gm(x)误分类样本的权值之和）不断降低。

• G(x) = sign[f3(x)] = sign[ 0.4236 * G1(x) + 0.6496 * G2(x) + 0.7514 * G3(x) ]。
  带入预测G1,G2,G3值，组成一个强分类器。
  G1,G2,G3权重求和为正数，映射为+1。
  G1,G2,G3权重求和为负数，映射为-1。
  结果全部预测正确。

六.总结：

总的来说，adaboost就是把弱分类器组成一个强分类器的过程。每个分类器都有所侧重，若分类正确，降低权重，则下一个分类器不会太关注；若分类错误，调高权重，则给下一个分类器重点关注（重点关注没分对的数据，有种说法叫“你分不对的我来分”）。将每一个弱分类器叠加组成一个强分类器，强分类器计算结果映射到+1或-1，不断的提高预测准确率。

上述例子中，数据集中输入一个X值，会对应输出Y标签值（+1或-1）。而我们adaboost要做的是预测Y值。

1.初始化数据权重。（1 / N）

2.在数据边界点（Y值+1，-1连接处）找到阈值2.5，5.5，8.8，分别进行二分预测，计算误差率e。 （分错的个数 / 总个数）

3.将误差率e带入

计算出弱分类器权重alpha。

4.将数据权重w，分类器权重alpha，真实值y，预测值G，带入

计算出规范化因子Z

5.更新数据权重。将数据权重w，分类器权重alpha，真实值y，预测值G带入

计算出新的数据权重w。

6.将弱分类器权重alpha，预测值G带入

计算出分类器权重。

7.依次迭代，计算出多个弱分类器权重。将多个分类器权重G带入

求和。结果为正数，映射为+1，结果为负数，映射为-1。

8.预测全部正确，迭代结束。

七、公式推导

• boosting：是一种集成学习的方法。通过串行的方式将多个基学习器组合成一个强学习器。
• stacking：是一种集成学习的方法。对原始数据使用多种不同算法训练出基学习器，然后将这几个基学习器的预测结果作为新的训练集“喂给”新的学习器去预测。
• GDBT算法：梯度提升决策树。每一棵树学习到的是之前所有树的残差。
• AdaBoost算法：在模型学习的过程中，每个模型的预测结果存在正确和错误。该学习器更加关注靠前的基学习器预测存在错误的样本。

加法模型公式
$f(x) = \sum_{i=1} ^ m \beta_i b(x;\gamma_i)$
（10.1）式中，$ b(x;\gamma_i) $为基学习器， $ \gamma_i $为基学习器的参数， $ \beta_i $为基学习器的系数。

损失函数
$L(y, f(x)) = min \quad \sum_{i=1} ^ m L [y_i, \sum_{i=1} ^ m \beta_i b(x;\gamma_i)]$

前向分步算法推导

1.初始化加法模型

$f_0(x) = 0$

2.则第$ i $步的加法模型为

$f_i(x) = f_{i-1}(x) + \beta_i b(x;\gamma_i)$

上式中，$f_{i-1}(x)$为当前加法模型

3.通过风险最小化确定基分类器的参数$\gamma_i$

$(\beta_i, \gamma_i) = argmin \sum_{i=1} ^ m L(y_i, f_{i-1}(x_i) + \beta b(i; \gamma))$

4.经过$i$次循环得到加法模型

$f(x) = \sum_{i=1} ^ m \beta_i b(x;\gamma_i)$

前向分步正则化

$f_i(x) = f_{i -1}(x) + \alpha \beta_i b_i(x)$
上式中，$\alpha$为学习率

提升树公式

可以表示为决策树的加法模型

$f(x) = \sum_{i=1} ^ m T(X; \theta_i)$

上式中，$T(X; \theta_i)$为决策树，$\theta_i$为决策树参数，m为数的个数

提升树算法

• 采用前向分步算法。

1.初始化提升树
$f_0(x) = 0$

2.则第$ i $步的加法模型为
$f_i(x) = f_{i-1}(x) + T(x;\theta_i)$

上式中，$f_{i-1}(x)$为当前加法模型

3.通过风险最小化确定基分类器的参数$\theta_i$
$\theta_i = argmin \sum_{i=1} ^ m L(y_i, f_{i-1}(x_i) + T(x; \theta_i))$

4.经过$i$次循环得到加法模型
$f(x) = \sum_{i=1} ^ m T(x;\theta_i)$

提升数回归任务

1.平方损失函数

$L(y, f(x)) = (y - f(x))^2$

2.加法模型损失函数

$L(y, f_{i - 1}(x) + T(x;\theta_i)) = (y - f_{i - 1}(x) - T(x;\theta_i))^2$

3.令$\gamma = y - f_{i - 1}(x)$，则$\gamma$为当前模型拟合的残差。

提升树正则化

$f_i(x) = f_{i -1}(x) + \alpha T(x; \theta_i)$
上式中，$\alpha$为学习率

GBDT梯度提升树算法流程

• 初始化模型
• 拟合负梯度，得到每一轮的基学习器。
• 把所有基学习器叠加，最终得到模型。

$f(x) = f(x) = \sum_{i=1} ^ m T(X;\theta_i) \quad$

GBDT损失函数,拟合负梯度

$\gamma_{im} = -[\frac{\partial L(y_i,f(x_i))}{\partial f(x_i)}]_{f = f_{i - 1}} \quad$

• 平方损失函数

$L(y_i, f(x_i)) = \frac{1}{2}(y_i - f(x_i))^2 \quad$

• 负梯度的值
  $y_i - f_{i - 1}(x_i) \quad$
• 初始化损失
  $f_0(x_i) = \overline{y} \quad$

GBDT分类任务

• 初始化加法模型

$f_0(x_i) = log(\frac{正样本个数}{负样本个数}) \quad$

• log损失函数

$L(y_i, f(x_i)) = y_i log(p_i) + (1 - y_i) log(1 - p_i) \quad$

$p_i = \frac{1}{1 + e^{-f(x_i)}} \quad$

• 负梯度值

$y_i - \frac{1}{1 + e^{- f_{i - 1} (x_i)}} \quad$

** AdaBoost分类 **

• input：训练集：弱学习器为M个
• output：最终的强学习器$G(x)$

$T = {(x_1, y_1), (x_2, y_2), (x_3, y_3), …, (x_n, y_n)}, y \in {-1, +1} \quad$

1.初始化样本权重

$D_1 = (w_{11}, w_{12},w_{13}, …, w_{1N}) w_{1i} = \frac{1}{N}, i = 1, 2, 3, …, N \quad$

2.对于$m = 1, 2, 3, …, M$

(1)使用具有权值分布$D_m$的训练数据训练模型，得到弱学习器$G_m (x)$

(2)计算$G_m (x)$的分类误差率

$e_m = \sum_{i=1} ^ N w_{mi} I(G_m (x_i) \not= y_i) \quad$

(3)计算弱学习器的系数

$\alpha_m = \frac{1}{2} log \frac{1 - e_m}{e_m} \quad$

(4)更新训练集的权值

$D_{m + 1} = (w_{m + 1, 1}, …, w_{m + 1, i}, …, w_{m + 1, N}) \quad$

$w_{m + 1, i} = \frac{w_{mi}}{Z_m} exp(-\alpha_m y_i G_m(x_i)), i = 1, 2, 3, …,N \quad$

上式中，$Z_m$是规范因子

$Z_m = \sum_{i=1} ^ N w_{mi} exp(-\alpha_m y_i G_m(x_i)) \quad$

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

$f(x) = \sum_{m=1} ^ M \alpha_m G_m (x) \quad$

4.得到强分类器

$G(x) = sign(f(x)) = sign[\sum_{m=1} ^ M \alpha_m G_m (x)]$

** AdaBoost回归 **

• input：训练集：弱学习器为M个
• output：最终的强学习器$G(x)$

$T = {(x_1, y_1), (x_2, y_2), (x_3, y_3), …, (x_n, y_n)}, y \in R \quad$

1.初始化样本权重

$D_1 = (w_{11}, w_{12},w_{13}, …, w_{1N}) w_{1i} = \frac{1}{N}, i = 1, 2, 3, …, N \quad$

2.对于$m = 1, 2, 3, …, M$

(1)使用具有权值分布$D_m$的训练数据训练模型，得到弱学习器$G_m (x)$

(2)计算$ G_m (x) $的回归误差率

$e_m = \sum_{i=1} ^ N w_{mi} \frac{(y_i - G_m)^2}{E{2}_m} \quad$

上式中
$E_m = max |y_i - G_m|, i = 1, 2, 3, …, N \quad$

(3)计算若学习器的系数$\alpha_m$

$\alpha_m = \frac{e_m}{1 - e_m} \quad$

(4)更新训练集的权值

$w_{m + 1, i} = \frac{w_{mi}}{Z_m} \alpha^{1 - e_{mi}}_m \quad$

上式中，$Z_m$是规范因子

$Z_m = \sum_{i=1} ^ N w_{mi} \alpha^{1 - e_{mi}}_m \quad$

4.得到强分类器

$G(x) = \sum_{m=1} ^ M (ln(\frac{1}{a_m})) g(x) = [\sum_{m=1} ^ M (ln(\frac{1}{a_m}))] g(x) \quad$

上式中$g(x)$是所有$\alpha_m G_m(x), m = 1, 2, 3,…, M$