AdaBoost
AdaBoost（Adaptive Boosting）是一种Boosting算法，它通过迭代地训练弱分类器并将它们组合成一个强分类器来提高分类性能。
AdaBoost算法的特点是它能够自适应地调整样本的权重，使那些被错误分类的样本在后续的训练中得到更多的关注。
加法模型
AdaBoost算法的最终分类器是一个加法模型，即多个弱分类器的线性组合。数学表达式如下：
f ( x ) = ∑ m = 1 M α m G m ( x ) f(x) = \sum_{m=1}^{M} \alpha_m G_m(x) f(x)=m=1∑MαmGm(x)
其中， G m ( x ) G_m(x) Gm(x)是第m个弱分类器， α m \alpha_m αm 是第m个弱分类器的权重， M M M 是弱分类器的总数。
训练过程
-
初始化样本权重 ：在第一轮迭代中，所有样本的权重都相等，即每个样本的权重为 1 N \frac{1}{N} N1，其中N是样本总数。
-
训练弱分类器 ：在每一轮迭代中，使用当前的样本权重来训练一个弱分类器 G m ( x ) G_m(x) Gm(x)。
-
计算分类误差率 ：计算弱分类器 G m ( x ) G_m(x) Gm(x)在训练集上的分类误差率 ϵ m \epsilon_m ϵm，即被错误分类的样本数占总样本数的比例。
- 分类误差率范围确定: 0 < = ϵ m < = 0.5 0<=\epsilon_m<=0.5 0<=ϵm<=0.5
- 分类误差率计算公式为： ϵ m = ∑ i = 1 N w i ( m ) ⋅ I ( y i ≠ G m ( x i ) ) = ∑ y i ≠ G m ( x i ) w i ( m ) \epsilon_m ={\sum_{i=1}^{N} w_i^{(m)} \cdot \mathbb{I}(y_i \neq G_m(x_i))} = {\sum_{y_i \neq G_m(x_i)} w_i^{(m)}} ϵm=i=1∑Nwi(m)⋅I(yi=Gm(xi))=yi=Gm(xi)∑wi(m)
- I ( y i ≠ G m ( x i ) ) \mathbb{I}(y_i \neq G_m(x_i)) I(yi=Gm(xi))是一个指示函数（也称为指示变量），当样本i的真实标签 y i y_i yi 与弱分类器对样本i的预测 G m ( x i ) G_m(x_i) Gm(xi) 不相等，即样本被错误分类时，该函数的值为1；如果相等，即样本被正确分类时，该函数的值为0。
- ∑ y i ≠ G m ( x i ) w i ( m ) \sum_{y_i \neq G_m(x_i)} w_i^{(m)} ∑yi=Gm(xi)wi(m)对所有被第m个弱分类器错误分类的样本的权重进行累加。
-
计算弱分类器权重 ：根据分类误差率 ϵ m \epsilon_m ϵm 计算弱分类器的权重 α m \alpha_m αm。
-
分类误差率越大，权重越小；反之，分类误差率越小，权值越大。
-
权重的计算公式为：
α m = 1 2 ln ( 1 − ϵ m ϵ m ) \alpha_m = \frac{1}{2} \ln \left( \frac{1 - \epsilon_m}{\epsilon_m} \right) αm=21ln(ϵm1−ϵm)
- 1 − ϵ m 1−ϵ_m 1−ϵm 是第m个弱分类器在训练集上的正确率，即被正确分类的样本数占总样本数的比例。
- 对数函数 ln ( 1 − ϵ m ϵ m ) \ln \left( \frac{1 - \epsilon_m}{\epsilon_m} \right) ln(ϵm1−ϵm) 用于计算正确率与误差率的比值的自然对数。这个比值反映了弱分类器的性能，正确率越高，误差率越低，比值越大。
-
-
更新样本权重 ：根据弱分类器的预测结果更新样本权重。对于被正确分类的样本，权重降低；对于被错误分类的样本，权重提高。将样本权重的更新视为损失函数
更新公式为：
w i ( m + 1 ) = w i ( m ) ⋅ exp ( − α m ⋅ y i ⋅ G m ( x i ) ) Z m w_{i}^{(m+1)} =\frac {w_{i}^{(m)} \cdot \exp(-\alpha_m \cdot y_i \cdot G_m(x_i)) }{Z_m} wi(m+1)=Zmwi(m)⋅exp(−αm⋅yi⋅Gm(xi))
-
其中， w i ( m ) w_{i}^{(m)} wi(m) 是第m轮中第i个样本的权重， y i y_i yi 是第i个样本的真实标签， G m ( x i ) G_m(x_i) Gm(xi) 是第m个弱分类器对第i个样本的预测结果
-
Z m Z_m Zm是归一化因子，目的是把分子映射到0-1范围内。 Z m = ∑ i = 1 N w i ( m ) ⋅ exp ( − α m ⋅ y i ⋅ G m ( x i ) ) Z_m = \sum_{i = 1}^Nw_{i}^{(m)} \cdot \exp(-\alpha_m \cdot y_i \cdot G_m(x_i)) Zm=∑i=1Nwi(m)⋅exp(−αm⋅yi⋅Gm(xi))。
-
对于被正确分类的样本， y i ⋅ G m ( x i ) y_i \cdot G_m(x_i) yi⋅Gm(xi)同号，指数函数的值为 e − α m e^{-\alpha_m} e−αm 小于1，样本权重降低。
-
对于被错误分类的样本， y i ⋅ G m ( x i ) y_i \cdot G_m(x_i) yi⋅Gm(xi)异号，指数函数的值为 e α m e^{\alpha_m} eαm 大于1，样本权重提高。
-
上述公式也可以写成这样：
-
迭代：重复步骤2到6，直到达到指定的迭代次数M或总分类器的精度达到设定的阈值。
-
最终预测 ：在所有弱分类器训练完成后，AdaBoost算法通过加权多数表决来确定最终的分类结果。对于一个新样本x，最终的预测结果是所有弱分类器预测结果的加权和：
f ( x ) = ∑ m = 1 M α m G m ( x ) f(x) = \sum_{m=1}^{M} \alpha_m G_m(x) f(x)=m=1∑MαmGm(x)对于分类问题，最终的预测类别是使 f ( x ) f(x) f(x)最大化的类别。
例子
代码实现
python
import numpy as np
from sklearn.datasets import make_classification
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
# make_classification生成包含1000个样本和20个特征的模拟二分类数据集
X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=0, random_state=42)
y = np.where(y == 0, -1, 1) # 将标签转换为-1和1
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 1. 初始化样本权重
sample_weights = np.ones_like(y_train) / len(y_train)
# 设置参数
n_estimators = 50 # 弱分类器的数量
learning_rate = 1.0 # 学习率
# 初始化弱分类器列表
weak_classifiers = []
for m in range(n_estimators):
# 2. 训练弱分类器
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier(max_depth=1)
clf.fit(X_train, y_train, sample_weight=sample_weights)
y_pred = clf.predict(X_train)
# 3. 计算分类误差率
incorrect = np.sum(sample_weights * (y_train != y_pred))
error_rate = incorrect / np.sum(sample_weights)
# 如果误差率大于0.5，则拒绝这个分类器
if error_rate > 0.5:
continue
# 4. 计算弱分类器权重
alpha = np.log((1.0 - error_rate) / error_rate) / 2.0
# 更新弱分类器列表
weak_classifiers.append((clf, alpha))
# 5. 更新样本权重
sample_weights *= np.exp(-alpha * y_train * y_pred)
sample_weights /= np.sum(sample_weights) # 归一化权重
def predict(X, classifiers):
votes = np.zeros((X.shape[0],))
for clf, alpha in classifiers:
votes += alpha * clf.predict(X)
return np.sign(votes)
# 7.预测
train_pred = predict(X_train, weak_classifiers)
test_pred = predict(X_test, weak_classifiers)
# 计算准确率
train_accuracy = accuracy_score(y_train, train_pred)
test_accuracy = accuracy_score(y_test, test_pred)
print(f"Train Accuracy: {train_accuracy:.4f}")
print(f"Test Accuracy: {test_accuracy:.4f}")