【 Adaboost算法】机器学习实例推导计算+公式详细过程（入门必备）

Bertha 。 2022-04-04 06:16 657阅读 0赞

> > > # 机器学习 【Adaboost算法】 #

https://blog.csdn.net/weixin\_41194171/article/details/85014669

## 一．Adaboost原理： ##

Adaboost算法基本原理就是将多个弱分类器组合成一个强分类器。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70]

## 二．Adaboost弱分类器 ##

Adaboost一般使用单层决策树作为其弱分类器。单层决策树只有一个决策点（与CART树类似），通过阈值将数据二分。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70 1]

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

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

## 四．算法流程 ##

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

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

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

#### 2.训练弱分类器。 ####

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

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

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

## 五．Adaboost公式推导 ##

给定一个训练数据集T=\{(x1,y1), (x2,y2)…(xN,yN)\}，其中实例![在这里插入图片描述][20181215131156828.png]，而实例空间![在这里插入图片描述][20181215131215940.png]，yi属于标记集合\{-1,+1\}，

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

每一个训练样本最开始时都被赋予相同的权值：1 / N。  
![在这里插入图片描述][20181215131236574.png]

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

（1）使用具有权值分布Dm的训练数据集学习，得到基本分类器（选取让误差率最低的阈值来设计基本分类器）：  
![在这里插入图片描述][20181215131440143.png]

（2） 计算Gm(x)在训练数据集上的分类误差率  
![在这里插入图片描述][2018121513150679.png]  
由上述式子可知，Gm(x)在训练数据集上的误差率em就是被Gm(x)**误分类样本的权值之和**。  
（3）计算Gm(x)的系数alpha，alpha m表示弱分类器权重，e表示数据误差率![在这里插入图片描述][20181215131549544.png]（log在python中用ln()更加准确，就是底数为e的对数函数。）  
由上述式子可知，em <= 1/2时，am >= 0，且am随着em的减小而增大，意味着分类误差率越小的基本分类器在最终分类器中的作用越大。

（4）更新训练数据权值（目的：得到样本的新的权值分布），用于下一轮迭代  
![在这里插入图片描述][20181215131618669.png]

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

其中，Zm是规范化因子，使得Dm+1成为一个概率分布：  
![在这里插入图片描述][20181215131808792.png]

### 3. 组合各个弱分类器 ###

![在这里插入图片描述][20181215131857230.png]  
得到强分类器，如下：

![在这里插入图片描述][20181215131924886.png]

## 六．Adaboost实例计算 ##

![在这里插入图片描述][20181215131938218.png]

求解过程：初始化训练数据的权值分布，令每个权值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。  
    ![在这里插入图片描述][20181215132247453.png]  
    用python中numpy类库计算：  
    **np.log((1 - 0.3) / 0.3) / 2) = 0.4236**

这个alpha1代表G1(x)在最终的分类函数中所占的权重，为0.4236。  
接着更新训练数据的权值分布，用于下一轮迭代：  
![在这里插入图片描述][2018121513245782.png]  
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  
    ![在这里插入图片描述][2018121513270261.png]

**当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)为负，负负得正，结果使得整个式子变大（样本权值变大），否则变小。

计算第一个弱分类器权重：  
![在这里插入图片描述][20181215151355503.png]

*  分类函数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）。

![在这里插入图片描述][20181215132956582.png]

很明显，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的系数：  
![在这里插入图片描述][20181215134312910.png]  
用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

![在这里插入图片描述][20181215134358265.png]

**当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

计算第二个弱分类器权重：  
![在这里插入图片描述][20181215151334967.png]

*  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.1060*3（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为0.1060*3），  
阈值v取5.5时误差率最低为0.0455*4（x > 5.5时取1，x < 5.5时取-1，则0 1 2 9分错，误差率为0.0455*4 = 0.1820），  
阈值v取8.5时误差率为0.1667*3（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为0.1667*3）。  
所以阈值v取5.5时误差率最低，故第三个基本分类器为：  
![在这里插入图片描述][20181215134454912.png]  
![在这里插入图片描述][20181215134519455.png]

此时，被误分类的样本是：0 1 2 9，这4个样本所对应的权值皆为0.0455，  
所以G3(x)在训练数据集上的误差率e3 = P(G3(xi)≠yi) = 0.0455 \* 4 = 0.1820。  
计算G3的系数：  
![在这里插入图片描述][20181215134651304.png]  
用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\*\*  
    ![在这里插入图片描述][20181215134821691.png]

**当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)；

![在这里插入图片描述][20181215135018427.png]  
![在这里插入图片描述][2018121513515654.png]  
此时，得到的第一个基本分类器sign(f1(x))在训练数据集上有3个误分类点（即6 7 8）。  
![在这里插入图片描述][20181215160951213.png]  
分类函数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)  
![在这里插入图片描述][20181215135557617.png]  
![在这里插入图片描述][20181215135536147.png]  
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）。  
![在这里插入图片描述][2018121516101794.png]  
\*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)。  
![在这里插入图片描述][20181215140250639.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70 2]  
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）。  
![在这里插入图片描述][20181215222732213.png]

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

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

![在这里插入图片描述][20181215140806855.png]  
![在这里插入图片描述][20181215161039198.png]

*  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。  
    结果全部预测正确。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70 3]

## 六.总结： ##

总的来说，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带入![在这里插入图片描述][20181215143158103.png]计算出弱分类器权重alpha。 #####

##### 4.将数据权重w，分类器权重alpha，真实值y，预测值G，带入![在这里插入图片描述][20181215143539745.png]计算出规范化因子Z #####

##### 5.更新数据权重。将数据权重w，分类器权重alpha，真实值y，预测值G带入![在这里插入图片描述][20181215143705803.png]计算出新的数据权重w。 #####

##### 6.将弱分类器权重alpha，预测值G带入![在这里插入图片描述][20181215145250915.png]计算出分类器权重。 #####

##### 7.依次迭代，计算出多个弱分类器权重。将多个分类器权重G带入![在这里插入图片描述][20181215151610424.png]求和。结果为正数，映射为+1，结果为负数，映射为-1。 #####

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

## 七、公式推导 ##

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

**加法模型公式**  
 f ( x ) = ∑ i = 1 m β i b ( x ; γ i ) f(x) = \\sum\_\{i=1\} ^ m \\beta\_i b(x;\\gamma\_i) f(x)=i=1∑mβib(x;γi)  
（10.1）式中，$ b(x;\\gamma\_i) $为基学习器， $ \\gamma\_i $为基学习器的参数， $ \\beta\_i $为基学习器的系数。

**损失函数**  
 L ( y , f ( x ) ) = m i n ∑ i = 1 m L \[ y i , ∑ i = 1 m β i b ( x ; γ i ) \] L(y, f(x)) = min \\quad \\sum\_\{i=1\} ^ m L \[y\_i, \\sum\_\{i=1\} ^ m \\beta\_i b(x;\\gamma\_i)\] L(y,f(x))=mini=1∑mL\[yi,i=1∑mβib(x;γi)\]

**前向分步算法推导**

1.初始化加法模型

f 0 ( x ) = 0 f\_0(x) = 0 f0(x)=0

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

f i ( x ) = f i − 1 ( x ) + β i b ( x ; γ i ) f\_i(x) = f\_\{i-1\}(x) + \\beta\_i b(x;\\gamma\_i) fi(x)=fi−1(x)\+βib(x;γi)

上式中， f i − 1 ( x ) f\_\{i-1\}(x) fi−1(x)为当前加法模型

3.通过风险最小化确定基分类器的参数 γ i \\gamma\_i γi

( β i , γ i ) = a r g m i n ∑ i = 1 m L ( y i , f i − 1 ( x i ) + β b ( i ; γ ) ) (\\beta\_i, \\gamma\_i) = argmin \\sum\_\{i=1\} ^ m L(y\_i, f\_\{i-1\}(x\_i) + \\beta b(i; \\gamma)) (βi,γi)=argmini=1∑mL(yi,fi−1(xi)\+βb(i;γ))

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

f ( x ) = ∑ i = 1 m β i b ( x ; γ i ) f(x) = \\sum\_\{i=1\} ^ m \\beta\_i b(x;\\gamma\_i) f(x)=i=1∑mβib(x;γi)

**前向分步正则化**

f i ( x ) = f i − 1 ( x ) + α β i b i ( x ) f\_i(x) = f\_\{i -1\}(x) + \\alpha \\beta\_i b\_i(x) fi(x)=fi−1(x)\+αβibi(x)  
上式中， α \\alpha α为学习率

**提升树公式**

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

f ( x ) = ∑ i = 1 m T ( X ; θ i ) f(x) = \\sum\_\{i=1\} ^ m T(X; \\theta\_i) f(x)=i=1∑mT(X;θi)

上式中， T ( X ; θ i ) T(X; \\theta\_i) T(X;θi)为决策树， θ i \\theta\_i θi为决策树参数，m为数的个数

**提升树算法**

*  采用前向分步算法。

1.初始化提升树  
 f 0 ( x ) = 0 f\_0(x) = 0 f0(x)=0

2.则第$ i $步的加法模型为  
 f i ( x ) = f i − 1 ( x ) + T ( x ; θ i ) f\_i(x) = f\_\{i-1\}(x) + T(x;\\theta\_i) fi(x)=fi−1(x)\+T(x;θi)

上式中， f i − 1 ( x ) f\_\{i-1\}(x) fi−1(x)为当前加法模型

3.通过风险最小化确定基分类器的参数 θ i \\theta\_i θi  
 θ i = a r g m i n ∑ i = 1 m L ( y i , f i − 1 ( x i ) + T ( x ; θ i ) ) \\theta\_i = argmin \\sum\_\{i=1\} ^ m L(y\_i, f\_\{i-1\}(x\_i) + T(x; \\theta\_i)) θi=argmini=1∑mL(yi,fi−1(xi)\+T(x;θi))

4.经过 i i i次循环得到加法模型  
 f ( x ) = ∑ i = 1 m T ( x ; θ i ) f(x) = \\sum\_\{i=1\} ^ m T(x;\\theta\_i) f(x)=i=1∑mT(x;θi)

**提升数回归任务**

1.平方损失函数

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

2.加法模型损失函数

L ( y , f i − 1 ( x ) + T ( x ; θ i ) ) = ( y − f i − 1 ( x ) − T ( x ; θ i ) ) 2 L(y, f\_\{i - 1\}(x) + T(x;\\theta\_i)) = (y - f\_\{i - 1\}(x) - T(x;\\theta\_i))^2 L(y,fi−1(x)\+T(x;θi))=(y−fi−1(x)−T(x;θi))2

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

**提升树正则化**

f i ( x ) = f i − 1 ( x ) + α T ( x ; θ i ) f\_i(x) = f\_\{i -1\}(x) + \\alpha T(x; \\theta\_i) fi(x)=fi−1(x)\+αT(x;θi)  
上式中， α \\alpha α为学习率

**GBDT梯度提升树算法流程**

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

f ( x ) = f ( x ) = ∑ i = 1 m T ( X ; θ i ) f(x) = f(x) = \\sum\_\{i=1\} ^ m T(X;\\theta\_i) \\quad f(x)=f(x)=i=1∑mT(X;θi)

**GBDT损失函数,拟合负梯度**

##  γ i m = − \[ ∂ L ( y i , f ( x i ) ) ∂ f ( x i ) \] f = f i − 1 \\gamma\_\{im\} = -\[\\frac\{\\partial L(y\_i,f(x\_i))\}\{\\partial f(x\_i)\}\]\_\{f = f\_\{i - 1\}\} \\quad γim=−\[∂f(xi)∂L(yi,f(xi))\]f=fi−1 ##

*  平方损失函数

L ( y i , f ( x i ) ) = 1 2 ( y i − f ( x i ) ) 2 L(y\_i, f(x\_i)) = \\frac\{1\}\{2\}(y\_i - f(x\_i))^2 \\quad L(yi,f(xi))=21(yi−f(xi))2

*  负梯度的值  
     y i − f i − 1 ( x i ) y\_i - f\_\{i - 1\}(x\_i) \\quad yi−fi−1(xi)
 *  初始化损失  
     f 0 ( x i ) = y ‾ f\_0(x\_i) = \\overline\{y\} \\quad f0(xi)=y

**GBDT分类任务**

*  初始化加法模型

f 0 ( x i ) = l o g ( 正 样 本 个 数 负 样 本 个 数 ) f\_0(x\_i) = log(\\frac\{正样本个数\}\{负样本个数\}) \\quad f0(xi)=log(负样本个数正样本个数)

*  log损失函数

L ( y i , f ( x i ) ) = y i l o g ( p i ) + ( 1 − y i ) l o g ( 1 − p i ) L(y\_i, f(x\_i)) = y\_i log(p\_i) + (1 - y\_i) log(1 - p\_i) \\quad L(yi,f(xi))=yilog(pi)\+(1−yi)log(1−pi)

p i = 1 1 + e − f ( x i ) p\_i = \\frac\{1\}\{1 + e^\{-f(x\_i)\}\} \\quad pi=1\+e−f(xi)1

*  负梯度值

y i − 1 1 + e − f i − 1 ( x i ) y\_i - \\frac\{1\}\{1 + e^\{- f\_\{i - 1\} (x\_i)\}\} \\quad yi−1\+e−fi−1(xi)1

\*\* AdaBoost分类 \*\*

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

T = ( x 1 , y 1 ) , ( x 2 , y 2 ) , ( x 3 , y 3 ) , … , ( x n , y n ) , y ∈ − 1 , + 1 T = \{(x\_1, y\_1), (x\_2, y\_2), (x\_3, y\_3), …, (x\_n, y\_n)\}, y \\in \{-1, +1\} \\quad T=(x1,y1),(x2,y2),(x3,y3),…,(xn,yn),y∈−1,\+1

1.初始化样本权重

D 1 = ( w 11 , w 12 , w 13 , … , w 1 N ) w 1 i = 1 N , i = 1 , 2 , 3 , … , N D\_1 = (w\_\{11\}, w\_\{12\},w\_\{13\}, …, w\_\{1N\}) w\_\{1i\} = \\frac\{1\}\{N\}, i = 1, 2, 3, …, N \\quad D1=(w11,w12,w13,…,w1N)w1i=N1,i=1,2,3,…,N

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

(1)使用具有权值分布 D m D\_m Dm的训练数据训练模型，得到弱学习器 G m ( x ) G\_m (x) Gm(x)

(2)计算 G m ( x ) G\_m (x) Gm(x)的分类误差率

e m = ∑ i = 1 N w m i I ( G m ( x i ) ≠ y i ) e\_m = \\sum\_\{i=1\} ^ N w\_\{mi\} I(G\_m (x\_i) \\not= y\_i) \\quad em=i=1∑NwmiI(Gm(xi)=yi)

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

α m = 1 2 l o g 1 − e m e m \\alpha\_m = \\frac\{1\}\{2\} log \\frac\{1 - e\_m\}\{e\_m\} \\quad αm=21logem1−em

(4)更新训练集的权值

D m + 1 = ( w m + 1 , 1 , … , w m + 1 , i , … , w m + 1 , N ) D\_\{m + 1\} = (w\_\{m + 1, 1\}, …, w\_\{m + 1, i\}, …, w\_\{m + 1, N\}) \\quad Dm\+1=(wm\+1,1,…,wm\+1,i,…,wm\+1,N)

w m + 1 , i = w m i Z m e x p ( − α m y i G m ( x i ) ) , i = 1 , 2 , 3 , … , N w\_\{m + 1, i\} = \\frac\{w\_\{mi\}\}\{Z\_m\} exp(-\\alpha\_m y\_i G\_m(x\_i)), i = 1, 2, 3, …,N \\quad wm\+1,i=Zmwmiexp(−αmyiGm(xi)),i=1,2,3,…,N

上式中， Z m Z\_m Zm是规范因子

Z m = ∑ i = 1 N w m i e x p ( − α m y i G m ( x i ) ) Z\_m = \\sum\_\{i=1\} ^ N w\_\{mi\} exp(-\\alpha\_m y\_i G\_m(x\_i)) \\quad Zm=i=1∑Nwmiexp(−αmyiGm(xi))

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

f ( x ) = ∑ m = 1 M α m G m ( x ) f(x) = \\sum\_\{m=1\} ^ M \\alpha\_m G\_m (x) \\quad f(x)=m=1∑MαmGm(x)

4.得到强分类器

G ( x ) = s i g n ( f ( x ) ) = s i g n \[ ∑ m = 1 M α m G m ( x ) \] G(x) = sign(f(x)) = sign\[\\sum\_\{m=1\} ^ M \\alpha\_m G\_m (x)\] G(x)=sign(f(x))=sign\[m=1∑MαmGm(x)\]

\*\* AdaBoost回归 \*\*

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

T = ( x 1 , y 1 ) , ( x 2 , y 2 ) , ( x 3 , y 3 ) , … , ( x n , y n ) , y ∈ R T = \{(x\_1, y\_1), (x\_2, y\_2), (x\_3, y\_3), …, (x\_n, y\_n)\}, y \\in R \\quad T=(x1,y1),(x2,y2),(x3,y3),…,(xn,yn),y∈R

1.初始化样本权重

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

(1)使用具有权值分布 D m D\_m Dm的训练数据训练模型，得到弱学习器 G m ( x ) G\_m (x) Gm(x)

(2)计算$ G\_m (x) $的回归误差率

e m = ∑ i = 1 N w m i ( y i − G m ) 2 E 2 m e\_m = \\sum\_\{i=1\} ^ N w\_\{mi\} \\frac\{(y\_i - G\_m)^2\}\{E\{2\}\_m\} \\quad em=i=1∑NwmiE2m(yi−Gm)2

上式中  
 E m = m a x ∣ y i − G m ∣ , i = 1 , 2 , 3 , … , N E\_m = max |y\_i - G\_m|, i = 1, 2, 3, …, N \\quad Em=max∣yi−Gm∣,i=1,2,3,…,N

(3)计算若学习器的系数 α m \\alpha\_m αm

α m = e m 1 − e m \\alpha\_m = \\frac\{e\_m\}\{1 - e\_m\} \\quad αm=1−emem

(4)更新训练集的权值

w m + 1 , i = w m i Z m α m 1 − e m i w\_\{m + 1, i\} = \\frac\{w\_\{mi\}\}\{Z\_m\} \\alpha^\{1 - e\_\{mi\}\}\_m \\quad wm\+1,i=Zmwmiαm1−emi

上式中， Z m Z\_m Zm是规范因子

Z m = ∑ i = 1 N w m i α m 1 − e m i Z\_m = \\sum\_\{i=1\} ^ N w\_\{mi\} \\alpha^\{1 - e\_\{mi\}\}\_m \\quad Zm=i=1∑Nwmiαm1−emi

4.得到强分类器

G ( x ) = ∑ m = 1 M ( l n ( 1 a m ) ) g ( x ) = \[ ∑ m = 1 M ( l n ( 1 a m ) ) \] g ( x ) 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)=m=1∑M(ln(am1))g(x)=\[m=1∑M(ln(am1))\]g(x)

上式中 g ( x ) g(x) g(x)是所有 α m G m ( x ) , m = 1 , 2 , 3 , … , M \\alpha\_m G\_m(x), m = 1, 2, 3,…, M αmGm(x),m=1,2,3,…,M 的中位数

> > > #### 欢迎大家交流学习，请留言 ####

参考资料:

https://blog.csdn.net/weixin\_41194171/article/details/85014669  
https://blog.csdn.net/px\_528/article/details/72963977  
https://blog.csdn.net/v\_july\_v/article/details/40718799

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70]: /images/20220404/816bed87d7ae4f5d92d72a3e3a4b7249.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70 1]: /images/20220404/f6c6d3dd0b0e4fb5b86f81961f5dd214.png
[20181215131156828.png]: https://img-blog.csdnimg.cn/20181215131156828.png
[20181215131215940.png]: /images/20220404/e2b3ca21fade41bc8e3a7d13eb20b2a9.png
[20181215131236574.png]: /images/20220404/80816c2c7969422289b9a5fbd6120b86.png
[20181215131440143.png]: /images/20220404/2b131bb0548149edae3514b463afbeb6.png
[2018121513150679.png]: /images/20220404/4506c1bdc37545d7acea0fa12306595a.png
[20181215131549544.png]: /images/20220404/d2155c70b72f4e169eae308af67f39bf.png
[20181215131618669.png]: /images/20220404/5c7375e6ac0a414ebd1b1a15b6cafd99.png
[20181215131808792.png]: /images/20220404/7b3d6bbe6fdc412c9a68bd0253b5c26e.png
[20181215131857230.png]: /images/20220404/6069324ec9e54466b85660aaca4e6c7a.png
[20181215131924886.png]: /images/20220404/fb2524f722d4420a9b5878d43b083ecf.png
[20181215131938218.png]: /images/20220404/1f346fbe043e4f12a1b71f640d86a66f.png
[20181215132247453.png]: /images/20220404/563adb4023324d02ba482d85c7cdca4a.png
[2018121513245782.png]: /images/20220404/ccaa5e1925f24b80b78f69cd4fc8cb5f.png
[2018121513270261.png]: /images/20220404/9fc14bf159f14aa09ba55cfa1f959143.png
[20181215151355503.png]: /images/20220404/8ad944a9313d45fe800892cddbcf1b98.png
[20181215132956582.png]: /images/20220404/9650f2406c6249938953c9cd49a99ada.png
[20181215134312910.png]: /images/20220404/03d425fd3b354af5a25018fb33bafa3a.png
[20181215134358265.png]: /images/20220404/79f3dc76157646c6837bc7d4e4146ed4.png
[20181215151334967.png]: /images/20220404/16048ff3c0f34c1b91f657f52788a1e0.png
[20181215134454912.png]: /images/20220404/ad630a3269b240948d639260f407f40f.png
[20181215134519455.png]: /images/20220404/27ce45f67894413d84530245d13336d9.png
[20181215134651304.png]: /images/20220404/b99d8c83785a4e3e880ca06d77193582.png
[20181215134821691.png]: /images/20220404/b40ace7a80b943a090c7286f4020ec10.png
[20181215135018427.png]: /images/20220404/fe1e667b903e4c43a497b9cf3bc2e4cc.png
[2018121513515654.png]: /images/20220404/82d19d1c42c44bbaa6bd83bbdf5dd46a.png
[20181215160951213.png]: /images/20220404/57ae43df57664507b18e3f471012e9c7.png
[20181215135557617.png]: /images/20220404/86254b06dd8d46e6ab82e7f015210ffa.png
[20181215135536147.png]: /images/20220404/66ac20382a214406a0d85c7b1891bc5a.png
[2018121516101794.png]: /images/20220404/7dc3cf12a2e0469a846a59fb4334e3ba.png
[20181215140250639.png]: /images/20220404/dd42c088ee894880b8715e2f786efca4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70 2]: /images/20220404/883b7970b2554ba098b80cf2d1e33424.png
[20181215222732213.png]: /images/20220404/dfac87b0f77e47039a2a2b64d341dd1d.png
[20181215140806855.png]: /images/20220404/32e798e35d0d446f8b779c192f3e66b1.png
[20181215161039198.png]: /images/20220404/311ddbf5896e4a988f1a50108b7c114a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTE5NDE3MQ_size_16_color_FFFFFF_t_70 3]: /images/20220404/8344198dc3034552b020cc1444bda895.png
[20181215143158103.png]: /images/20220404/601e6507eef349279de891f1353c1e10.png
[20181215143539745.png]: /images/20220404/2cf4d258b91449559f49a3bf429a7af4.png
[20181215143705803.png]: /images/20220404/53820cdb6b8047b893b92d54560dda5c.png
[20181215145250915.png]: /images/20220404/45be4a456cce4844a7dcaef350831cbc.png
[20181215151610424.png]: /images/20220404/945311f4e7eb443f98b49dd32a0b8f61.png