【机器学习笔记】——Bagging、Boosting、Stacking（RF / Adaboost / Boosting Tree / GBM / GBDT / XGBoost / LightGBM）

目 录

集成学习

概念

  首先，让我们先来了解一下，什么是集成学习（Ensemble Learning，写作银桑，读作昂桑）。集成学习由训练数据构建一组基分类器，然后通过对每个基分类器的预测进行投票来进行分类，对每个个体学习器的预测进行（加权）平均来进行回归，有时也被称为多分类器系统、基于委员会的学习等。如果把单个分类器比作一个决策者的话，集成学习的方法就相当于多个决策者共同进行一项决策。严格来说，集成学习并不算是一种分类器，而是一种分类器结合的方法。

• 集成学习将多个分类方法聚集在一起，以提高分类的准确率。通常一个集成分类器的分类性能会好于单个分类器

  对于二分类问题，假设基分类器的错误率为$ϵ$：
$$P(h_i(x̸=y))=ϵ$$

  通过投票我们得到集成学习的分类预测：
$$H(x)=sign\left(\sum _{i=1}^T{h}_i(x)\right)$$

  假设分类器的错误率相互独立，则由Hoeffding不等式有：
$$P(H(x̸=y))=\sum _{k=0}^{\lfloor T/2\rfloor }\left(\genfrac{}{}{0ex}{}{T}{k}\right)(1-ϵ{)}^k{ϵ}^{T-k}\le exp\left(-\frac{1}{2}T(1-2ϵ{)}^2\right)$$

  即随着集成中基分类器数目$T$增大，集成的错误率会指数级下降，最终趋于0。当然实际中个体学习器错误率独立的假设是不成立的

• 集成学习的很多理论研究都是针对弱分类器（精度略高于50%）进行的，但在实践中往往会使用较强的分类器

• 个体学习器要有一定的“准确性”，并且要有“多样性”。一般的，准确性很高之后，要增加多样性就需牺牲准确性。如何产生并结合“好而不同”的个体学习器，恰是集成学习研究的核心

  下面这个例子，图(a)中每个学习器只有67%的精度，但集成学习却达到了100%；图(b)中三个学习器完全一样，集成之后性能没有提高；图©中每个学习器只有33%的精度集成学习的效果更差。

思维导图

Bagging算法

概念

  Bagging算法（Bootstrap AGGregatING）是一种并行式集成算法。它基于自助采样法（Bootstrap sampling）采样出T个含有m个训练样本的采样集，然后基于每个采样集训练出一个基学习器，再将这些基学习器进行结合。

  算法的伪代码如下：

  从偏差-方差分解的角度看，降低一个估计的方差的方式是把多个估计平均起来，所以Bagging主要关注降低方差，因此它在不剪枝决策树、神经网络等易受样本扰动的学习器上效用更为明显。同时，Bagging并不能减小模型的偏差，所以应尽量选择偏差较小的基分类器，如未剪枝的决策树。

编程（分类）

  参考：https://github.com/vsmolyakov/experiments_with_python/blob/master/chp01/ensemble_methods.ipynb

  我们用iris数据集来看一下不同基分类器Bagging的效果

import itertools
import numpy as np

import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec

from sklearn import datasets

from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

from sklearn.ensemble import BaggingClassifier
from sklearn.model_selection import cross_val_score, train_test_split

from mlxtend.plotting import plot_learning_curves
from mlxtend.plotting import plot_decision_regions

np.random.seed(0)

  导入数据

iris = datasets.load_iris()
X, y = iris.data[:, 0:2], iris.target

X.shape, y.shape

((150, 2), (150,))

  设置基分类器和集成方法

# 配置基分类器的参数
clf1 = DecisionTreeClassifier(criterion='entropy', max_depth=1)    # 深度为1的决策树
clf2 = KNeighborsClassifier(n_neighbors=1)    # k=1的k近邻

# 每个Bagging有10个基分类器
bagging1 = BaggingClassifier(base_estimator=clf1, n_estimators=10, max_samples=0.8, max_features=0.8)
bagging2 = BaggingClassifier(base_estimator=clf2, n_estimators=10, max_samples=0.8, max_features=0.8)

  查看单个学习器和Bagging后的效果

label = ['Decision Tree(depth = 1)', 'K-NN(k = 1)', 'Bagging Tree', 'Bagging K-NN']
clf_list = [clf1, clf2, bagging1, bagging2]

fig = plt.figure(figsize=(10, 8))
gs = gridspec.GridSpec(2, 2)    # 创建 2x2 的画布
grid = itertools.product([0,1],repeat=2)    # 返回参数的笛卡尔积的元组，每个元素可以用 2 次

for clf, label, grd in zip(clf_list, label, grid):        
    scores = cross_val_score(clf, X, y, cv=3, scoring='accuracy')    # Array of scores of the estimator for each run of the cross validation.
    print("Accuracy: %.2f (+/- %.2f) [%s]" %(scores.mean(), scores.std(), label))
        
    clf.fit(X, y)
    ax = plt.subplot(gs[grd[0], grd[1]])
    fig = plot_decision_regions(X=X, y=y, clf=clf, legend=2)    # 绘制决策边界
    plt.title(label)

plt.show()

Accuracy: 0.63 (+/- 0.02) [Decision Tree(depth = 1)]
Accuracy: 0.70 (+/- 0.02) [K-NN(k = 1)]
Accuracy: 0.66 (+/- 0.02) [Bagging Tree]
Accuracy: 0.61 (+/- 0.02) [Bagging K-NN]

  可以发现决策树的集成有一定效果，而k近邻的效果反而变差了。这是因为k近邻是稳定学习器，不易受样本扰动影响。

  再来看看数据集的划分对训练结果的影响

#plot learning curves
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    
plt.figure()
plot_learning_curves(X_train, y_train, X_test, y_test, bagging1, print_model=False, style='ggplot')
plt.show()

  虽然每次结果有较大的差异，但是我们还是能得到一些结论：对于给定的划分比例，模型在训练集上的错分率基本在30%上下，而在测试集上，当训练集较小时，模型在测试集上表现很差，当训练集比例逐渐增加时，模型在测试集上的表现慢慢变好，一般在训练集占到80%左右时，模型在训练集和测试集上都能取得较好的表现

  接下来我们看一下学习器的个数对bagging效果的影响

#Ensemble Size
num_est = np.concatenate(([1],np.arange(5,105,5)))
bg_clf_cv_mean = []
bg_clf_cv_std = []

for n_est in num_est:    
    bg_clf = BaggingClassifier(base_estimator=clf1, n_estimators=n_est, max_samples=0.8, max_features=0.8)
    scores = cross_val_score(bg_clf, X, y, cv=3, scoring='accuracy')
    bg_clf_cv_mean.append(scores.mean())
    bg_clf_cv_std.append(scores.std())
    

plt.figure()
# 绘制误差棒图，横轴为num_est，纵轴为scores.mean()，误差为scores.std()
(_, caps, _) = plt.errorbar(num_est, bg_clf_cv_mean, yerr=bg_clf_cv_std, c='blue', fmt='-o', capsize=5)
for cap in caps:
    cap.set_markeredgewidth(1)                                                           
plt.ylabel('Accuracy'); plt.xlabel('Ensemble Size'); plt.title('Bagging Tree Ensemble');
plt.show()

  基于交叉验证的结果，我们可以看到在基分类器数量达到20后，集成的效果不再有明显的提升

随机森林

  随机森林（Random Forest, RF）可以看成是改进的Bagging算法，它可以更好地解决决策树的过拟合问题。随机森林以CART树作为基分类器，对比决策树的Bagging，它有一个明显的特点——随机选择特征，对于普通的决策树，我们会在每个节点在当前的所有特征（假设有n个）中寻找最优特征，而随机森林的决策树会在每个节点在随机选取的特征集合（推荐$n_{rf}={\log }_{2}n$）中寻找最优特征。这样做的好处是如果训练集中的几个特征对输出的结果有很强的预测性，那么这些特征会被每个决策树所应用，这样会导致树之间具有相关性，这样并不会减小模型的方差，但同时随机森林会不可避免的增加偏差。

  RF的主要优点有：

1. 训练可以高度并行化，对于大数据时代的大样本训练速度有优势。个人觉得这是的最主要的优点。

2. 由于可以随机选择决策树节点划分特征，这样在样本特征维度很高的时候，仍然能高效的训练模型。

3. 在训练后，可以给出各个特征对于输出的重要性

4. 由于采用了随机采样，训练出的模型的方差小，泛化能力强。

5. 相对于Boosting系列的Adaboost和GBDT， RF实现比较简单。

6. 对部分特征缺失不敏感。

  RF的主要缺点有：

1. 在某些噪音比较大的样本集上，RF模型容易陷入过拟合。

2. 取值划分比较多的特征容易对RF的决策产生更大的影响，从而影响拟合的模型的效果。

扩展

  RF还有很多变种，其目的都是为了进一步降低方差。

Extremely randomized Trees

  Extremely randomized Trees（以下简称Extra Trees）放弃了Boostrap sampling的方式，而选择使用原始数据集，而且在特征选择时更加暴力的随机选择一个特征直接作为最优特征

*Totally Random Trees Embedding

  参考：http://www.cnblogs.com/pinard/p/6156009.html

  Totally Random Trees Embedding(以下简称 TRTE)是一种非监督学习的数据转化方法。它将低维的数据集映射到高维，从而让映射到高维的数据更好的运用于分类回归模型。我们知道，在支持向量机中运用了核方法来将低维的数据集映射到高维，此处TRTE提供了另外一种方法。

  TRTE在数据转化的过程也使用了类似于RF的方法，建立T个决策树来拟合数据。当决策树建立完毕以后，数据集里的每个数据在T个决策树中叶子节点的位置也定下来了。比如我们有3颗决策树，每个决策树有5个叶子节点，某个数据特征xx划分到第一个决策树的第2个叶子节点，第二个决策树的第3个叶子节点，第三个决策树的第5个叶子节点。则x映射后的特征编码为(0,1,0,0,0, 0,0,1,0,0, 0,0,0,0,1), 有15维的高维特征。这里特征维度之间加上空格是为了强调三颗决策树各自的子编码。

  映射到高维特征后，可以继续使用监督学习的各种分类回归算法了。

*Isolation Forest

  Isolation Forest（以下简称IForest）是一种异常点检测的方法。它也使用了类似于RF的方法来检测异常点。

  对于在T个决策树的样本集，IForest也会对训练集进行随机采样,但是采样个数不需要和RF一样，对于RF，需要采样到采样集样本个数等于训练集个数。但是IForest不需要采样这么多，一般来说，采样个数要远远小于训练集个数？为什么呢？因为我们的目的是异常点检测，只需要部分的样本我们一般就可以将异常点区别出来了。

  对于每一个决策树的建立， IForest采用随机选择一个划分特征，对划分特征随机选择一个划分阈值。这点也和RF不同。

  另外，IForest一般会选择一个比较小的最大决策树深度max_depth,原因同样本采集，用少量的异常点检测一般不需要这么大规模的决策树。

  对于异常点的判断，则是将测试样本点$x$拟合到$T$颗决策树。计算在每颗决策树上该样本的叶子节点的深度$h_t(x)$，从而可以计算出平均高度$h(x)$。此时我们用下面的公式计算样本点xx的异常概率:

$$s(x,m)=2^{-\frac{h(x)}{c(m)}}$$

  其中，m为样本个数。$c(m)$的表达式为：

$$c(m)=2\ln (m-1)+\xi -2\frac{m-1}{m}$$

$\xi$为欧拉常数，$s(x,m)$的取值范围是$[0,1]$，取值越接近于1，则是异常点的概率也越大。

编程（分类）

import time

# DecisionTree
clf3 = DecisionTreeClassifier(criterion='entropy', max_depth=2)

# Tree Bagging
tree_bagging = BaggingClassifier(base_estimator=clf3, n_estimators=100)

# Random Forest
random_forest = RandomForestClassifier(n_estimators=100, criterion='entropy', max_depth = 2)

label = ['Decision Tree', 'Tree Bagging', 'Random Forest']
clf_list = [clf3, tree_bagging, random_forest]

fig = plt.figure(figsize=(15, 4))
gs = gridspec.GridSpec(1, 3)
grid = itertools.product([0], [0, 1, 2])

for clf, label, grd in zip(clf_list, label, grid):
    b = time.time()
    scores = cross_val_score(clf, X, y, cv=3, scoring='accuracy')
    runtime = time.time() - b
    print("Accuracy: %.2f (+/- %.2f) [%s] Runtime: %.2f s" %(scores.mean(), scores.std(), label, runtime))
        
    clf.fit(X, y)
    ax = plt.subplot(gs[grd[0], grd[1]])
    fig = plot_decision_regions(X=X, y=y, clf=clf, legend=2)
    plt.title(label)

plt.show()

Accuracy: 0.63 (+/- 0.04) [Decision Tree] Runtime: 0.01 s
Accuracy: 0.77 (+/- 0.03) [Tree Bagging] Runtime: 0.40 s
Accuracy: 0.76 (+/- 0.04) [Random Forest] Runtime: 0.36 s

  从结果可以看到随机森林的运行速度比Tree Bagging要快一点，这是因为在选择最优特征时，随机森林并没有从全部特征中进行选择

rf_label = ['DecisionTree','1 Trees','5 Trees','10 Trees','20 Trees','100 Trees']

random_forest1 = RandomForestClassifier(n_estimators=1, criterion='entropy', max_depth = 2)
random_forest5 = RandomForestClassifier(n_estimators=5, criterion='entropy', max_depth = 2)
random_forest10 = RandomForestClassifier(n_estimators=10, criterion='entropy', max_depth = 2)
random_forest20 = RandomForestClassifier(n_estimators=20, criterion='entropy', max_depth = 2)
random_forest100 = RandomForestClassifier(n_estimators=100, criterion='entropy', max_depth = 2)

clf_list = [clf3, random_forest1, random_forest5, random_forest10, random_forest20, random_forest100]

fig = plt.figure(figsize=(15, 8))
gs = gridspec.GridSpec(2, 3)
grid = itertools.product([0, 1], [0, 1, 2])

for clf, label, grd in zip(clf_list, rf_label, grid):
    scores = cross_val_score(clf, X, y, cv=3, scoring='accuracy')
    print("Accuracy: %.2f (+/- %.2f) [%s]" %(scores.mean(), scores.std(), label))
        
    clf.fit(X, y)
    ax = plt.subplot(gs[grd[0], grd[1]])
    fig = plot_decision_regions(X=X, y=y, clf=clf, legend=2)
    plt.title(label)

plt.show()

Accuracy: 0.63 (+/- 0.04) [DecisionTree]
Accuracy: 0.59 (+/- 0.08) [1 Trees]
Accuracy: 0.69 (+/- 0.02) [5 Trees]
Accuracy: 0.71 (+/- 0.06) [10 Trees]
Accuracy: 0.74 (+/- 0.04) [20 Trees]
Accuracy: 0.79 (+/- 0.02) [100 Trees]

  可以看到随着树的增加，随机森林的决策边界越来越光滑，精度越来越高。而且当树为1个时随机森林色精度是比决策树要差的，这很容易理解，有可能重要的特征被排除在外了，所以同样是一棵树，随机森林分类效果更差。我们再通过误差棒图看一下决策树数量对精度的影响

num_est = np.concatenate(([1],np.arange(5,105,5)))
rf_clf_cv_mean = []
rf_clf_cv_std = []

for n_est in num_est:    
    rf_clf = RandomForestClassifier(n_estimators=n_est, criterion='entropy', max_depth = 2)
    scores = cross_val_score(rf_clf, X, y, cv=3, scoring='accuracy')
    rf_clf_cv_mean.append(scores.mean())
    rf_clf_cv_std.append(scores.std())
    

plt.figure()
(_, caps, _) = plt.errorbar(num_est, rf_clf_cv_mean, yerr=rf_clf_cv_std, c='blue', fmt='-o', capsize=5)
for cap in caps:
    cap.set_markeredgewidth(1)                                                           
plt.ylabel('Accuracy')
plt.xlabel('Trees Number')
plt.show()

  可以看到随着树的数量增加，随机森林一开始有明显的提升，但是当树到达10个后就基本趋于稳定了

  下面我们比较一下随着学习器的增加，Tree Bagging和Random Forest的差异

num_est = np.concatenate(([1],np.arange(10,1005,10)))
bg_arr = []
rf_arr = []

for n_est in num_est:    
    rf_clf = RandomForestClassifier(n_estimators=n_est, criterion='entropy', max_depth = 2)
    rf_scores = cross_val_score(rf_clf, X, y, cv=3, scoring='accuracy')
    rf_arr.append(rf_scores.mean())
    
    bg_clf = BaggingClassifier(base_estimator=clf3, n_estimators=n_est, max_samples=0.8, max_features=0.8)
    bg_scores = cross_val_score(bg_clf, X, y, cv=3, scoring='accuracy')
    bg_arr.append(bg_scores.mean())
    

plt.figure()
plt.plot(num_est, bg_arr,  color='blue', label='Bagging')
plt.plot(num_est, rf_arr, color='red', label='Random Forest')
plt.legend()
plt.ylabel('Accuracy')
plt.xlabel('Learner Number')
plt.show()

  可以看到Bagging和随机森林有相似的收敛性，但是随着个体学习器数量的增加，随机森林的泛化性能要更好。

为什么说Bagging通过减小方差来提升精度

  因为Bagging是同质集成并且数据集也相同，因此各个学习器的偏差$bias(h_t(x))$和方差$Var(h_t(x))$近似相等，但是各个学习器并不是独立的，于是
$$bias(H(x))=bias\left(\frac{1}{T}\sum _{t=1}^T{h}_t(x)\right)=bias(h_t(x))$$

$$Var(H(x))=Var\left(\frac{1}{T}\sum _{t=1}^T{h}_t(x)\right)=\frac{1}{T}Var(h_t(x))$$

所以Bagging不能降低偏差，而是会降低方差（因为学习器之间的相关性，方差不会下降到$\frac{1}{T}Var(h_t(x))$），如果各个学习器完全相同，即有$\frac{1}{T}{\sum }_{t=1}^T{h}_t(x)=h_t(x)$，那么方差也不会降低，这也就是为什么要求学习器之间要有“多样性”。随机森林通过随机选取特征的方式降低了各决策树的相关性，使得方差进一步降低。

Boosting

  不同于bagging方法，boosting方法通过分步迭代（stage-wise）的方式来构建模型，在迭代的每一步构建的弱学习器都是为了弥补已有模型的不足。Boosting算法先从初始训练集训练出一个基学习器，再根据基学习器的表现对训练样本进行调整，使得先前基学习器做错的训练样本在后续受到更多关注，然后基于调整后的样本分布来训练下一个基学习器；如此重复进行，直至基学习器数目达到事先指定的值T，最终将这T个基学习器进行加权。从偏差—方差分解的角度看，Boosting主要关注降低偏差，因此Boosting能基于泛化性能相当弱的学习器构建出很强的集成。下图以Adaboost分类为例简要说明了Boosting的机制

Adaboost

  Boosting算法最著名的代表是Adaboost（Adaptive Boosting）算法。Adaboost不改变所给的训练数据，而不断改变训练数据的权值分布，使得训练数据在基本分类器的学习中起不同的作用，然后利用基本分类器的线性组合构建最终的分类器。Adaboost的二类分类算法的描述如下图所示，其中 y i ∈ { − 1 , + 1 } y_i\in\{-1,+1\} yi​∈{ −1,+1}，$i=1,2,...,m$，$f$是真实函数，${\mathcal{D}}_t$是调整后用于进行第$t$次训练的样本分布，$h_t$ 是基于分布${\mathcal{D}}_t$从数据集$D$中训练出的分类器，${ϵ}_t$是$h_t$误差的估计，${\alpha }_t$是分类器$h_t$的权重，$Z_t$是规范化因子，以确保${\mathcal{D}}_{t+1}$是一个分布，$t=1,2,...,T$。

  Adaboost是一种比较有特点的算法，可以总结如下：

1. 每次迭代改变的是样本的分布，而不是重复采样（re weight)。

2. 样本分布的改变取决于样本是否被正确分类：总是分类正确的样本权值低，总是分类错误的样本权值高（通常是边界附近的样本）。

3. 最终的结果是弱分类器的加权组合，权值表示该弱分类器的性能。

  我们通过一个例子来感受一下Adaboost的机制

实例

  我们有如下数据集，其中有红色圆形和绿色三角形共10个样本，希望建立一个分类器，能判断出任意位置样本属于哪一类，我们指定基学习器个数$T$为3

  我们初始化样本权值分布${\mathcal{D}}_1=0.1,0.1,\cdots ,0.1$，并基于该分布从训练集中训练出分类器$h_1$（理论上$h_1$应使分类错误率达到最小，这里仅用一条线代表分类结果，并未给出这条线是怎么得到的，但是不代表这条线是随意做出的），之后估计$h_1$的误差${ϵ}_1$，确定$h_1$的权重${\alpha }_1$，并更新样本的权值分布

  重复上面操作依次训练出基学习器$h_2$、$h_3$，此时基学习器个数达到我们预先指定的值。可以按照基学习器的权重给出输出公式。并据此预测其他样本的分类

  每个区域是属于哪个类别，由这个区域所在分类器的权值综合决定。比如左下角的区域的样本，属于绿色分类区的权重为$h_1$中的0.42和$h_2$ 中的0.65，其和为1.07；属于红色分类区域的权重为$h_3$中的0.92；属于红色分类区的权重小于属于绿色分类区的权值，因此左下角属于绿

  从结果中看，即使简单的分类器，组合起来也能获得很好的分类效果。

模型推导

  Adaboost算法有多种推导方式，一种比较容易理解的是基于“加性模型”，即基学习器的线性组合

$$H(x)=\sum _{t=1}^T{\alpha }_t{h}_t(x)$$

来最小化指数损失函数

$$Loss(H|\mathcal{D})={\mathbb{E}}_{\mathcal{D}}[e^{-yH(x)}]=e^{-H(x)}P(y=1|x)+e^{H(x)}P(y=-1|x)$$

---

●什么是前向分步算法（forward stagewise algorithm）？

  前向分步算法是求解加法模型损失函数（${\sum }_{i=1}^{N}Loss(y_i,\alpha h(x_i))$）最小化的一种算法，简单来说就是在每一次学习一个基学习器，然后逐步逼近目标函数：

$$\begin{array}{lclcc}{f}_0(x)& =& 0& & \\ f_1(x)& =& f_0(x)+{\alpha }_1{h}_1(x)& =& {\alpha }_1{h}_1(x)\\ f_2(x)& =& f_1(x)+{\alpha }_2{h}_2(x)& =& {\alpha }_1{h}_1(x)+{\alpha }_2{h}_2(x)\\ \cdots & & & & \\ f_M(x)& =& f_{M-1}(x)+{\alpha }_M{h}_M(x)& =& {\sum }_{m=1}^M{\alpha }_m{h}_m(x)\end{array}$$

---

●为什么是指数损失函数？

  指数损失函数对$H(x)$求偏导得

$$\frac{\partial Loss(H|\mathcal{D})}{\partial H(x)}=-e^{-H(x)}P(y=1|x)+e^{H(x)}P(y=-1|x)$$

令偏导数为0有

$$H(x)=\frac{1}{2}\ln \frac{P(y=1|x)}{P(y=-1|x)}$$

于是有

s i g n ( H ( x ) ) = s i g n ( 1 2 ln ⁡ P ( y = 1 ∣ x ) P ( y = − 1 ∣ x ) ) = { 0 if  P ( y = 1 ∣ x ) &gt; P ( y = − 1 ∣ x ) 1 if  P ( y = 1 ∣ x ) &lt; P ( y = − 1 ∣ x ) = arg ⁡ max ⁡ y ∈ { + 1 , − 1 } P ( y ∣ x ) \begin{aligned} sign\left(H(x)\right) &amp; = sign\left(\frac{1}{2} \ln \frac{P(y = 1 |x)}{P(y = -1 |x)}\right) \\ &amp; = \begin{cases} 0&amp; \text{if } P(y = 1 |x) \gt P(y = -1 |x)\\ 1&amp; \text{if } P(y = 1 |x) \lt P(y = -1 |x) \end{cases} \\ &amp; = \mathop{\arg\max}_{y \in \{+1,-1\}} P(y | x) \end{aligned} sign(H(x))​=sign(21​lnP(y=−1∣x)P(y=1∣x)​)={ 01​if P(y=1∣x)>P(y=−1∣x)if P(y=1∣x)<P(y=−1∣x)​=argmaxy∈{ +1,−1}​P(y∣x)​

过程中忽略了$P(y=1|x)=P(y=-1|x)$的情况，另外西瓜书中对于概率的写法是$P(f(x)=y|x)$，其中$f$是真实函数。从结果可知，$sign\left(H(x)\right)$达到了贝叶斯最优错误率（$ifP({\omega }_1|x)>P({\omega }_1|x),thenx\in {\omega }_1,elsex\in {\omega }_2$），即最小化指数损失函数等价于分类错误率最小化。因此我们可以用它替代0/1损失函数作为最优目标。有了以上结论，我们便可以进行算法的推导。

---

●推导过程

  在算法的第$t$次循环中，我们基于分布${\mathcal{D}}_t$产生了基分类器$h_t(x)$和分类器权重${\alpha }_t$，那么它们应该使得$H_t(x)={\sum }_{k=1}^t{\alpha }_k{h}_k(x)$最小化损失函数

$$\begin{array}{rl}Loss(H_t(x)|{\mathcal{D}}_t)& =Loss(\sum _{k=1}^t{\alpha }_k{h}_k(x)|{\mathcal{D}}_k)\\ & =Loss(H_{t-1}(x)+{\alpha }_t{h}_t(x)|{\mathcal{D}}_k)\\ & ={\mathbb{E}}_{{\mathcal{D}}_t}{e}^{-y(H_{t-1}(x)+{\alpha }_t{h}_t(x))}\\ & =\sum _{i=1}^N{e}^{-y_i{H}_{t-1}(x_i)}{e}^{-y_i{\alpha }_t{h}_t(x_i)}\end{array}$$

我们令$w_{t,i}=e^{-y_i{H}_{t-1}(x_i)}$，显然，$w_{t,i}$与${\alpha }_t$和$h_t$无关，所以与最小化损失也无关，于是有

$$Loss(H_t(x)|{\mathcal{D}}_t)=\sum _{i=1}^N{w}_{t,i}{e}^{-y_i{\alpha }_t{h}_t(x_i)}$$

设$h_t^{\ast }$和${\alpha }_t^{\ast }$是满足要求的分类器和分类器权重，即

$$(h_t^{\ast },{\alpha }_t^{\ast })={\mathrm{argmin}}_{{\alpha }_t,h_t}Loss(H_t(x)|{\mathcal{D}}_t)={\mathrm{argmin}}_{{\alpha }_t,h_t}\sum _{i=1}^N{w}_{t,i}{e}^{-y_i{\alpha }_t{h}_t(x_i)}$$

对任意${\alpha }_t>0$，考虑

$$h_t^{\ast }(x)={\mathrm{argmin}}_{h_t}\sum _{i=1}^N{w}_{t,i}I(h_t(x_i)̸=y_i)$$

这意味着$h_t^{\ast }(x)$是使第t轮加权训练数据分类误差最小的基本分类器，即为所求。再求${\alpha }_t^{\ast }$

$$Loss(H_t(x)|{\mathcal{D}}_t)=\sum _{i=1}^N{w}_{t,i}{e}^{-y_i{\alpha }_t{h}_t^{\ast }(x_i)}=\sum _{h_t^{\ast }(x_i)̸=y_i}{w}_{t,i}{e}^{{\alpha }_t}+\sum _{h_t^{\ast }(x_i)=y_i}{w}_{t,i}{e}^{-{\alpha }_t}$$

损失函数对${\alpha }_t$求偏导得

$$\frac{\partial Loss(H_t(x)|{\mathcal{D}}_t)}{\partial {\alpha }_t}=-\sum _{h_t^{\ast }(x_i)̸=y_i}{w}_{t,i}{e}^{{\alpha }_t}+\sum _{h_t^{\ast }(x_i)=y_i}{w}_{}$$