三种集成学习范式详解：Boosting、Bagging、Stacking

早起星人

已于 2025-02-26 16:13:30 修改

阅读量1.3k

点赞数 12

文章标签：集成学习 boosting 机器学习

于 2024-06-16 23:02:21 首次发布

本文链接：https://blog.csdn.net/weixin_41174300/article/details/139728125

版权

集成学习是机器学习中一个非常强大的范式，通过结合多个模型的预测来提升整体的预测效果。主要的集成学习方法包括Boosting、Bagging和Stacking，每种方法都有其独特的策略和优点。本文将详细介绍这三种集成学习方法，包括它们的数学原理、具体的算法实现，以及应用场景。

1. Boosting

概述

Boosting是一种可以将多个弱学习器组合成强学习器的技术。其核心思想是按顺序训练模型，其中每一个模型都尝试纠正前一个模型的错误。最著名的Boosting算法包括AdaBoost和Gradient Boosting。

1.1. AdaBoost：

初始化训练数据的权重分布 $D_1(i) = 1/n$ ，其中 $n$ 是样本数。
对于每一个学习器 $\dots, T$ :
- 训练一个弱学习器 $h_t$ 。
- 计算错误率 $\epsilon_t = \sum_{i=1}^n D_t(i) [y_i \neq h_t(x_i)]$ 。
- 计算学习器权重 $\alpha_t = \frac{1}{2} \ln \left(\frac{1 - \epsilon_t}{\epsilon_t}\right)$ 。
- 更新数据权重 $D_{t+1}(i) = \frac{D_t(i) \exp(-\alpha_t y_i h_t(x_i))}{Z_t}$ ，其中 $Z_t$ 是规范化因子。
最终模型为 $\text{sign}(\sum_{t=1}^T \alpha_t h_t(x))$ 。

Python实现

使用scikit-learn的AdaBoost分类器：

from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 创建数据
X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# AdaBoost模型
model = AdaBoostClassifier(n_estimators=50, random_state=42)
model.fit(X_train, y_train)

# 预测
predictions = model.predict(X_test)

1.2. Gradient Boosting

数学公式

对于给定的损失函数 $L (y, F (x))$ ，Gradient Boosting 方法更新模型 $F$ 如下：

计算损失函数对于当前模型预测的负梯度（残差） $r_{im} = -\left[\frac{\partial L(y_i, F(x_i))}{\partial F(x_i)}\right]_{F(x) = F_{m-1}(x)}$ 。
拟合这个残差 $r_{im}$ 与新的弱学习器 $h_m(x)$ 。
更新模型 $F_m(x) = F_{m-1}(x) + \nu h_m(x)$ ，其中 $\nu$ 是学习率。

python实例

from sklearn.ensemble import GradientBoostingClassifier

gbc = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)
gbc.fit(X_train, y_train)
predictions = gbc.predict(X_test)

1.3. XGBoost (Extreme Gradient Boosting)

数学公式

XGBoost 在 Gradient Boosting 的基础上添加了正则化项，其目标函数 $\mathcal{L}$ 如下：
$\mathcal{L}^{(t)} = \sum_{i=1}^n l(y_i, \hat{y}_i^{(t-1)} + f_t(x_i)) + \Omega(f_t)$
其中， $\Omega(f) = \gamma T + \frac{1}{2} \lambda \|w\|^2$ 为正则化项， $T$ 是树的数量， $w$ 是叶节点权重。

Python实例

import xgboost as xgb

xgb_model = xgb.XGBClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)
xgb_model.fit(X_train, y_train)
predictions = xgb_model.predict(X_test)

XGBoost 和 GBDT区别和联系

XGBoost (Extreme Gradient Boosting) 和 GBDT (Gradient Boosting Decision Trees) 都是基于梯度提升的集成学习方法，用于提升模型的预测性能。尽管它们有许多相似之处，但XGBoost引入了许多优化和增强功能，使其在许多实际应用中表现更好。以下是详细的区别和联系：

联系

基于梯度提升：两者都使用梯度提升框架，通过迭代地训练决策树来减小预测误差。
损失函数最小化：两者都通过最小化损失函数来提高模型性能，利用梯度下降法逐步逼近最优解。
决策树基学习器：两者都使用决策树作为基学习器，但具体实现有所不同。

区别

1. 训练效率和速度

XGBoost：
- XGBoost在速度和效率上进行了大量优化。例如，它通过并行处理来加快树的构建过程，使用更高效的内存管理技术，并实现了更快的排序算法。
- XGBoost利用分块结构来支持并行计算，从而大大提升训练速度。
GBDT：
- 传统的GBDT没有进行这些针对速度和效率的优化，因此在处理大规模数据时相对较慢。

2. 正则化

XGBoost：
- XGBoost引入了正则化项，以控制模型复杂度，防止过拟合。它在目标函数中加入了L1和L2正则化项：
  $\text{Obj}(\theta) = \sum_{i} l(y_i, \hat{y}_i) + \sum_{k} \Omega(f_k)$
  其中， $\Omega(f_k) = \gamma T + \frac{1}{2} \lambda \|w\|^2$ ， $T$ 是树的叶子节点数， $w$ 是叶子节点的权重。
- 这种正则化能够有效控制模型的复杂度，提升泛化能力。
GBDT：
- 传统的GBDT不包含显式的正则化项，因此在防止过拟合方面可能表现较差。

3. 剪枝和树的构建

XGBoost：
- 使用最大增益剪枝（Max Depth Pruning）策略，通过计算每个分裂点的增益来决定是否继续分裂。
- XGBoost在每个树的构建过程中会进行后剪枝，以减少不必要的复杂度。
GBDT：
- 传统的GBDT通常使用贪心算法在构建过程中进行前剪枝（Pre-Pruning），通过设置最大深度、最小样本分裂数等参数来控制树的大小。

4. 缺失值处理

XGBoost：
- 具备原生的缺失值处理功能，能够自动处理缺失值，并在分裂过程中智能地找到缺失值的最优填补方向。
GBDT：
- 传统的GBDT不具备自动处理缺失值的功能，需要在预处理步骤中处理缺失值。

5. 支持并行和分布式计算

XGBoost：
- 设计之初就考虑了分布式计算，能够在多台机器上并行训练。
- 支持通过MPI、YARN等分布式框架进行训练。
GBDT：
- 传统的GBDT通常不支持分布式计算，仅适用于单机环境。

实现和使用示例

以下是XGBoost和GBDT在Python中的简单实现示例：

XGBoost

import xgboost as xgb
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# 加载数据集
boston = load_boston()
X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2, random_state=42)

# 转换为DMatrix格式
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

# 设置参数
params = {
    'objective': 'reg:squarederror',
    'max_depth': 3,
    'eta': 0.1,
    'subsample': 0.8,
    'colsample_bytree': 0.8
}

# 训练模型
bst = xgb.train(params, dtrain, num_boost_round=100)

# 预测
y_pred = bst.predict(dtest)
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')

GBDT

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# 加载数据集
boston = load_boston()
X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2, random_state=42)

# 训练模型
gbdt = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, subsample=0.8, random_state=42)
gbdt.fit(X_train, y_train)

# 预测
y_pred = gbdt.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')

总结

联系：

都是基于梯度提升框架，通过迭代训练决策树来提高模型性能。
都使用损失函数最小化来优化模型。

区别：

训练效率和速度：XGBoost进行了大量优化，训练速度更快。
正则化：XGBoost引入了L1和L2正则化，控制模型复杂度。
剪枝和树的构建：XGBoost使用最大增益剪枝，传统GBDT使用前剪枝。
缺失值处理：XGBoost具备原生的缺失值处理功能。
支持并行和分布式计算：XGBoost支持分布式计算，传统GBDT通常不支持。

通过以上详细解释，展示了XGBoost和GBDT在原理、实现和应用方面的区别和联系。

Gradient Boosting (GBoost) 和 AdaBoost的区别和联系

Gradient Boosting (GBoost) 和 AdaBoost 都是提升（Boosting）方法中的代表算法，用于提高弱学习器（例如决策树）的性能。尽管它们都是提升方法，有许多相似之处，但在具体实现和工作原理上存在显著差异。

联系

提升的思想：两者都属于提升方法，通过组合多个弱学习器来提高模型的预测能力。
迭代训练：都采用迭代训练的方式，每一轮基学习器的训练都依赖于前一轮的结果。
加权投票：通过加权投票或加权平均的方式将多个弱学习器的结果组合起来，以得到最终的预测结果。

区别

1. 训练方式

AdaBoost:
- 在每一轮中，AdaBoost会根据上轮模型的错误率调整训练样本的权重，错误样本的权重会增加，而正确样本的权重会减少。
- 每个弱学习器的权重是基于其在训练数据上的表现来确定的。
- 具体公式如下：
  $w_{i+1} = w_i \cdot \exp(\alpha_t \cdot I(y_i \ne h_t(x_i)))$
  其中， $\alpha_t$ 是第 $t$ 个弱学习器的权重， $I(y_i \ne h_t(x_i))$ 是指示函数，表示样本 $i$ 是否被正确分类。
Gradient Boosting:
- 通过拟合残差（残差是实际值与预测值之间的差异）来逐步改善模型的预测。
- 每一轮中，弱学习器是通过拟合前一轮模型的残差来训练的。
- 具体公式如下：
  $F_{m}(x) = F_{m-1}(x) + \alpha_m h_m(x)$
  其中， $\alpha_m$ 是学习率， $h_m(x)$ 是第 $m$ 个弱学习器拟合的残差。

2. 损失函数

AdaBoost:
- 主要基于指数损失函数：
  $\exp(-y F(x))$
- 通过加权调整的方式来优化模型。
Gradient Boosting:
- 可用于多种损失函数，包括回归问题中的均方误差和分类问题中的对数损失等：
  $\sum_{i=1}^N l(y_i, F(x_i))$
- 通过梯度下降法来优化损失函数，逐步减少预测误差。

3. 弱学习器权重的更新

AdaBoost:
- 每个弱学习器的权重根据其分类错误率来计算。
- 错误率高的弱学习器权重低，反之亦然。
Gradient Boosting:
- 每个弱学习器对残差的拟合程度决定其对最终模型的贡献。
- 通过梯度下降来优化整体模型。

具体实现步骤

AdaBoost

初始化样本权重：所有样本权重初始相等。
迭代训练弱学习器：
- 在每一轮迭代中，根据样本权重训练弱学习器。
- 计算弱学习器的错误率和权重。
- 更新样本权重，使错误分类的样本权重增加，正确分类的样本权重减少。
加权组合弱学习器：最终模型是所有弱学习器的加权组合。

Gradient Boosting

初始化模型：初始模型通常为一个简单的常数模型。
迭代训练弱学习器：
- 在每一轮迭代中，计算当前模型的残差。
- 训练弱学习器拟合残差。
- 更新模型，通过将当前模型与弱学习器的预测结果按学习率进行加权组合。
组合所有弱学习器：最终模型是所有弱学习器的累加。

示例代码

AdaBoost

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

# 基础分类器
base_clf = DecisionTreeClassifier(max_depth=1)
# AdaBoost 分类器
ada_clf = AdaBoostClassifier(base_estimator=base_clf, n_estimators=50, learning_rate=1.0)

# 训练
ada_clf.fit(X_train, y_train)

# 预测
y_pred = ada_clf.predict(X_test)

Gradient Boosting

from sklearn.ensemble import GradientBoostingClassifier

# Gradient Boosting 分类器
gboost_clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)

# 训练
gboost_clf.fit(X_train, y_train)

# 预测
y_pred = gboost_clf.predict(X_test)

总结

联系：

都是提升方法，通过组合多个弱学习器来提高模型性能。
都使用迭代训练方式，每一轮训练依赖前一轮的结果。

区别：

AdaBoost通过调整样本权重来改进模型，基于指数损失函数。
Gradient Boosting通过拟合残差来改进模型，可以使用多种损失函数，并通过梯度下降来优化模型。

各自使用的场景

XGBoost、GBDT（Gradient Boosting Decision Trees）、和 AdaBoost 都是广泛使用的提升方法，各自适用于不同的任务和场景。以下是对每种方法适用任务的详细解释：

1. XGBoost

特点：

高效的实现：包括并行处理、分布式计算。
强大的正则化：包括L1和L2正则化，控制模型复杂度，防止过拟合。
自动处理缺失值。
灵活性高：支持多种目标函数和自定义目标函数。

适用任务：

大规模数据：由于其高效实现和支持并行、分布式计算，XGBoost非常适合处理大规模数据集。
结构化数据：在 Kaggle 和其他数据科学竞赛中，XGBoost常被用于结构化数据（如表格数据）中的分类和回归任务。
预测准确性要求高：XGBoost因其复杂度控制和多种优化技术，通常能提供高准确性的预测结果。
缺失值较多的数据：由于其自动处理缺失值的能力，XGBoost适用于含有较多缺失值的数据集。

具体任务示例：

销售预测、客户流失预测、信用评分、推荐系统、基因表达数据分析等。

2. GBDT (Gradient Boosting Decision Trees)

特点：

基于梯度提升的集成方法，通过逐步减少残差来提升模型性能。
支持多种损失函数。
较简单的实现，不具备XGBoost的高级优化。

适用任务：

中小规模数据：GBDT在处理中小规模数据集时表现良好，虽然没有XGBoost高效，但仍能提供准确的预测。
分类和回归任务：适用于各种分类和回归任务。
模型可解释性要求较高：由于GBDT模型较简单，易于解释和分析。
时间和计算资源受限的场景：GBDT实现相对简单，不需要复杂的计算资源，适合资源受限的场景。

具体任务示例：

信用评分、客户流失预测、市场营销响应预测、房价预测等。

3. AdaBoost

特点：

通过调整样本权重来提升弱学习器的性能。
简单高效，易于实现。
容易过拟合，特别是对噪声数据敏感。

适用任务：

中小规模数据：适合处理中小规模数据集，在这些数据集上能快速迭代和调整。
二分类任务：虽然可以扩展到多分类任务，但AdaBoost在二分类任务中表现最佳。
噪声较少的数据：由于对噪声数据敏感，适合处理噪声较少的数据集。
需要快速模型构建和验证的场景：由于实现简单，可以快速构建和验证模型。

具体任务示例：

人脸检测、文本分类、信用评分、欺诈检测等。

综述

XGBoost：适用于大规模数据、结构化数据和高准确性要求的任务。适合需要处理缺失值较多的数据。
GBDT：适用于中小规模数据、需要模型可解释性和资源受限的场景。
AdaBoost：适用于中小规模数据、噪声较少的数据和二分类任务，适合快速模型验证。

通过了解这些算法的特点和适用任务，可以根据具体的应用场景选择最合适的提升方法，从而获得最佳的模型性能和效率。

2. Bagging

概述

Bagging（Bootstrap Aggregating）通过并行训练多个模型，并对其预测结果进行平均或多数投票，以减少方差。每个模型都在原始数据集的一个随机子集（bootstrap样本）上训练。著名的Bagging方法是随机森林。

数学原理

Bagging的核心是对训练集进行多次随机采样，构建多个独立的学习器，然后综合这些学习器的预测结果。具体算法如下：

从原始数据集中用Bootstrap方法随机抽取n个样本。
训练一个基学习器。
重复步骤1和2 K次。
通过平均（回归问题）或多数投票（分类问题）来综合所有学习器的预测结果。

Python实现

使用scikit-learn的随机森林：

from sklearn.ensemble import RandomForestClassifier

# 随机森林模型
forest = RandomForestClassifier(n_estimators=100, random_state=42)
forest.fit(X_train, y_train)

# 预测
predictions = forest.predict(X_test

)

a. Extra Trees (Extremely Randomized Trees)

数学原理

与随机森林类似，但在每个分裂点使用随机阈值，而不是寻找最佳分裂。这可以写成：

随机选择特征。
对于每个特征，使用随机阈值分裂节点。

这种方法增加了模型多样性，可以减少过拟合的风险。

Python实例

from sklearn.ensemble import ExtraTreesClassifier

etc = ExtraTreesClassifier(n_estimators=100, random_state=42)
etc.fit(X_train, y_train)
predictions = etc.predict(X_test)

3. Stacking

概述

Stacking通过堆叠不同的模型，使用一个新的模型来综合这些模型的输出。基本思想是用前一层的多个基学习器的预测结果作为输入，通过一个新的学习器来进行最终的预测。

数学原理

Stacking通常涉及两层模型：第一层由多个基学习器组成，第二层是一个元学习器，用于综合第一层的输出。具体步骤如下：

训练多个不同的模型。
使用这些模型的预测结果作为新的特征。
使用这些新特征训练一个新的模型（元学习器），以进行最终预测。

Python实现

使用scikit-learn的Stacking：

from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

# 定义基学习器
estimators = [
    ('rf', RandomForestClassifier(n_estimators=10, random_state=42)),
    ('svr', SVC(random_state=42))
]

# Stacking模型
stacking_model = StackingClassifier(estimators=estimators, final_estimator=LogisticRegression())
stacking_model.fit(X_train, y_train)

# 预测
predictions = stacking_model.predict(X_test)

a. Stacking with Non-linear Meta-learners

数学公式

在第一层的基学习器训练完成后，它们的预测结果 ( Z ) 作为新的特征输入到元学习器。元学习器的目标是优化以下函数：
$\min_{\theta} \sum_{i=1}^n L(y_i, g_\theta(z_i))$
其中， $z_i$ 是由基学习器的输出组成的向量， $g_\theta$ 是元学习器（如神经网络）， $\theta$ 是元学习器的参数。

通过这种方式，Stacking不仅组合了多个模型的预测，还能学习如何最优地组合这些预测。

Python示例

from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import StackingClassifier

# 定义基学习器
estimators = [
   

 ('rf', RandomForestClassifier(n_estimators=10, random_state=42)),
 ('svr', SVC(probability=True, random_state=42))
]

# Stacking模型，使用神经网络作为元学习器
stacking_model = StackingClassifier(estimators=estimators, final_estimator=MLPClassifier(random_state=42))
stacking_model.fit(X_train, y_train)
predictions = stacking_model.predict(X_test)