机器学习（五） ----------集成学习（2）（Adaboost算法+GDBT算法+XGBoost算法）

AdaBoost算法（Adaptive Boosting）是一种迭代算法，其核心思想是将多个弱分类器组合成一个强分类器。在机器学习中，弱分类器通常指的是分类能力稍强于随机猜测的分类器，而强分类器则是指分类能力很强的分类器。AdaBoost算法通过调整样本权重和弱分类器权重，使得每次迭代中，被错分的样本权重增加，而被正确分类的样本权重减小，从而确保弱分类器能够更多地关注那些难以分类的样本。

4.2 算法流程

初始化训练数据的权重分布：
- 对于每一个训练样本，初始时都被赋予相同的权重。如果有N个样本，则每一个训练样本的初始权值为1/N。这步操作可以表示为初始化一个权重向量D1=(w11, w12, ..., w1N)，其中w1i=1/N，i=1,2,...,N。
迭代训练弱分类器：
- 对于m=1,2,...,M（M为指定的最大迭代次数，即弱分类器的个数）：
  - 使用具有权值分布Dm的训练数据集进行学习，得到弱分类器Gm(x)。这通常是一个简单的分类器，如决策树桩（决策树深度为1的决策树）。
  - 计算Gm(x)在训练数据集上的分类误差率em。这通常通过计算Gm(x)错误分类的样本的权值之和，然后除以所有样本的权值之和来得到。
  - 计算Gm(x)的系数αm。αm通常与em成反比，即em越小，αm越大，表示该弱分类器在最终强分类器中的重要性越大。
- 模型权重计算公式: $a_t = \frac{1}{2}ln\left ( \frac{1-e_m}{e_m} \right )$
- 样本权重计算公式:
更新训练数据集的权值分布：
- 对于每一个样本，根据其是否被Gm(x)正确分类，调整其权重。如果Gm(x)将样本正确分类，则降低其权重；如果Gm(x)将样本错误分类，则增加其权重。这样可以使得在下一轮迭代中，被Gm(x)错误分类的样本能够得到更多的关注。
构建强分类器：
- 在经过M轮迭代后，我们得到了M个弱分类器g1(x), g2(x), ..., gM(x)以及它们对应的系数α1, α2, ..., αM。将这些弱分类器按照其系数进行线性组合，即得到最终的强分类器H(x)。
- $H\left ( x \right ) = sign\left ( \sum_{m}^{i=1}\alpha _ig_i(x) \right )$
预测：
- 使用得到的强分类器H(x)对新的数据进行预测。

4.3 算法特点

高性能：AdaBoost算法能够自动选择并整合多个弱分类器，从而提高整体分类性能。它通过关注错误分类样本，并加大它们的权重，使得后续的弱分类器能够更加关注这些困难样本，从而提高整体性能。
简单易用：AdaBoost算法不需要对弱分类器进行特别的要求，只需要它们能够稍微好于随机猜测即可。这使得AdaBoost算法非常灵活和容易实现。
鲁棒性：AdaBoost算法对噪声和异常值具有一定的鲁棒性。通过不断调整样本权重，AdaBoost能够在一定程度上减小噪声和异常值对整个模型的影响。

4.4 API

4.4.1 api

sklearn.ensemble.AdaBoostClassifier()

4.4.2 参数介绍

base_estimator：指定基分类器，默认为 DecisionTreeClassifier(max_depth=1)，即深度为 1 的决策树（决策树桩）。
n_estimators：弱分类器的数量，默认为 50。
learning_rate：学习率，用于控制每个弱分类器权重的更新速度，默认为 1.0。
algorithm：指定用于提升的算法，可以是 "SAMME" 或 "SAMME.R"，默认为 "SAMME.R"。
random_state：控制随机性的种子，用于基分类器的训练和数据集的划分。

4.4.3 代码实现

from sklearn.ensemble import AdaBoostClassifier  
from sklearn.datasets import make_classification  
from sklearn.model_selection import train_test_split  
from sklearn.metrics import accuracy_score  
  
# 生成一个模拟的二分类数据集  
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.2, random_state=42)  
  
# 初始化 AdaBoostClassifier，使用默认参数  
abc = AdaBoostClassifier(random_state=42)  
  
# 使用训练数据拟合模型  
abc.fit(X_train, y_train)  
  
# 使用测试集进行预测  
y_pred = abc.predict(X_test)  
  
# 计算并打印准确率  
accuracy = accuracy_score(y_test, y_pred)  
print("Accuracy: {:.2f}%".format(accuracy * 100))  
  
# 你还可以查看模型的更多属性，如弱分类器的数量、每个弱分类器的权重等  
print("Number of estimators:", abc.n_estimators_)  
print("Estimator weights:", abc.estimator_weights_)  
print("Estimator errors:", abc.estimator_errors_)

5 梯度提升树（Gradient Boosting Decision Tree）

梯度提升树（Gradient Boosting Decision Tree，简称GBDT）是一种集成学习算法，它通过构建多个决策树并将它们的结果进行组合来改进预测性能。梯度提升树被认为是统计学习中性能最好的方法之一，它结合了梯度提升（Gradient Boosting）和决策树（Decision Tree）两种技术。

5.1 原理

1. 初始化：

GBDT通过迭代地训练弱学习器（如决策树）并将它们组合起来，以最小化损失函数。
在每一步迭代中，GBDT会计算当前模型在训练数据上的梯度，并根据这个梯度来更新弱学习器。
具体来说，GBDT会找到一个最佳的弱学习器，使得在当前模型预测错误的地方进行修正，从而最小化损失函数。

2. 公式推导：

假设我们有一个损失函数 $L(y, F(x))$ ，其中y是真实标签，F(x)是模型预测值。
初始模型 $F_0(x)$ 通常是一个常数。
在第m步迭代，我们的目标是找到一个函数 $T_m(x)$ （即弱学习器）和一个系数 $\beta_m$ ，使得 $F_m(x) = F_{m-1}(x) + \beta _m * T_m(x)$ 的损失函数最小化。
我们可以使用梯度下降的思想来找到β_m和T_m(x)。首先，计算损失函数关于F(x)的梯度，记为 $g_m(x) = \frac{\partial L(y, F_{m-1}(x))}{\partial F_{m-1}(x)}$ 。
然后，我们使用这个梯度来拟合一个弱学习器 $T_m(x)$ （例如决策树），使得 $T_m(x)$ 在某种度量下尽可能地逼近 $g_m(x)$ 。
接下来，我们通过最小化 $L(y, F_{m-1}(x) + \beta _m * T_m(x))$ 关于β_m的导数来找到最优的β_m。
最后，更新模型 $F_m(x) = F_{m-1}(x) + \beta _m * T_m(x)$ 。

3.负梯度拟合

当损失函数是平方损失或指数损失时，梯度提升树的每一步优化相对简单。但对于一般损失函数，通常使用负梯度作为提升树算法中残差的近似值，进而拟合一个CART回归树。

5.2 步骤

初始化弱学习器：
- GBDT的训练过程从初始化一个弱学习器开始。这个初始的弱学习器通常是一个常数模型，其预测输出是一个固定的值，例如所有训练样本的平均值或众数（对于分类问题）。
迭代训练：
- GBDT通过多轮迭代来优化模型。在每一轮迭代中，它都会基于前一轮的预测结果和真实标签之间的差异（残差）来训练一个新的弱学习器（通常是决策树）。
- 具体来说，在每一轮迭代中，GBDT会计算前一轮模型的预测残差，即真实标签与前一轮模型预测值之间的差异。然后，它会在这个残差的基础上训练一个新的决策树（弱学习器）。这个新的决策树的目标是尽可能拟合当前的残差。
模型更新：
- 在每轮迭代结束后，GBDT会更新其模型。具体来说，它会将新训练的决策树的预测结果（乘以一个学习率）添加到前一轮模型的预测结果中，从而得到一个新的预测模型。这个新的预测模型将作为下一轮迭代的起点。
迭代停止：
- 迭代过程会一直进行，直到达到预定的迭代次数或满足其他停止条件（如模型在验证集上的性能不再提升）。
最终模型：
- 当训练过程结束后，GBDT会得到一个包含多个加权弱学习器的最终模型。这个最终模型将用于对新的未见过的数据进行预测。

5.3 API

在scikit-learn库中，GradientBoostingClassifier 和 GradientBoostingRegressor 是实现梯度提升决策树（Gradient Boosting Decision Tree）的类。这两个类提供了构建GBDT模型的API接口。以下是关于这些API的基本介绍：

`5.3.1 GradientBoostingClassifier`

主要参数

loss: 损失函数。对于分类问题，可选的有'deviance'（对数似然损失，等同于'exponential'）和'exponential'。默认是'deviance'。
learning_rate: 学习率（或收缩率），用于权重更新。较小的值指定了更多的迭代次数。默认是0.1。
n_estimators: 弱学习器的最大数量（即树的数量）。默认是100。
max_depth: 单个回归估计器的最大深度。默认是3。
min_samples_split: 分割内部节点所需的最小样本数。默认是2。
min_samples_leaf: 叶子节点所需的最小样本数。默认是1。
subsample: 用于拟合各个基础学习器的样本比例。默认是1.0，即使用全部样本。
random_state: 随机数生成器的种子。

主要方法

fit(X, y[, sample_weight, ...]): 使用输入数据X和标签y来训练模型。
predict(X): 对输入数据X进行预测。
predict_proba(X): 返回每个类别的概率估计。
predict_log_proba(X): 返回每个类别的对数概率估计。
score(X, y[, sample_weight]): 返回给定测试数据和标签上的平均准确度。

`5.3.2 GradientBoostingRegressor`

GradientBoostingRegressor的API与GradientBoostingClassifier非常相似，但有一些差异：

主要参数

loss: 对于回归问题，可选的有'ls'（均方误差），'lad'（绝对损失，等同于'huber'且epsilon=1.0），'huber'和'quantile'。默认是'ls'。
其他参数与GradientBoostingClassifier类似。

主要方法

与GradientBoostingClassifier的方法类似，但通常没有predict_proba和predict_log_proba方法，因为回归问题不涉及概率估计。

5.4 代码实现

from sklearn.datasets import load_iris  
from sklearn.model_selection import train_test_split  
from sklearn.ensemble import GradientBoostingClassifier  
  
# 加载数据集  
iris = load_iris()  
X = iris.data  
y = iris.target  
  
# 划分训练集和测试集  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  
  
# 初始化GBDT分类器  
gbdt = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)  
  
# 训练模型  
gbdt.fit(X_train, y_train)  
  
# 预测  
y_pred = gbdt.predict(X_test)  
  
# 评估模型  
print("Accuracy:", gbdt.score(X_test, y_test))

6 XGboost（Extreme Gradient Boosting）极端梯度提升树

6.1 核心思想

XGBoost是对梯度提升算法的改进，求解损失函数极值时使用了牛顿法，将损失函数泰勒展开到二阶。另外，损失函数中加入了正则化项，这有助于防止过拟合。正则化项定义了模型的复杂程度，其中包含了人工设置的参数以及决策树所有叶子节点值形成的向量和叶子节点数。

6.2 公式推导

XGBoost算法的公式推导主要涉及其目标函数的构建和优化。以下是一个简化的推导过程：

1. 目标函数

XGBoost的目标函数由两部分组成：损失函数和正则化项。损失函数衡量了模型对训练数据的拟合程度，而正则化项则用于控制模型的复杂度，防止过拟合。

目标函数的一般形式为：

$[ \text{obj}(\theta) = \sum_{i=1}^{n} L(y_i, \hat{y}i) + \sum_{k=1}^{K} \Omega(f_k) ]$

其中：

$( L(y_i, \hat{y}_i) )$ 是损失函数，衡量了模型对第 $( i )$ 个样本的预测值 $( \hat{y}_i )$ 与真实值 $( y_i )$ 之间的差异。
$( \Omega(f_k) )$ 是第 $( k )$ 棵树的正则化项，用于控制树的复杂度。
$( n )$ 是样本数量， $( K )$ 是树的数量。

2. 正则化项

在XGBoost中，常用的正则化项包括树的叶子节点数 $( T )$ 和叶子节点权重 $( w )$ 的 $( L_2 )$ 范数。因此，正则化项可以表示为：

$[ \Omega(f) = \gamma T + \frac{1}{2} \lambda \sum_{j=1}^{T} w_j^2 ]$

其中：

$( \gamma )$ 和 $( \lambda )$ 是超参数，用于控制正则化的强度。
$( T )$ 是树的叶子节点数。
$( w_j )$ 是第 $( j )$ 个叶子节点的权重。

3. 泰勒展开

在优化目标函数时，XGBoost使用了泰勒展开来近似损失函数。假设在第 $( t )$ 次迭代时，模型对第 $( i )$ 个样本的预测值为 $( \hat{y}_i^{(t-1)} )$ ，则在第 $( t )$ 次迭代时，损失函数可以表示为：

$[ L(y_i, \hat{y}_i^{(t)}) \approx L(y_i, \hat{y}_i^{(t-1)}) + g_i f_t(x_i) + \frac{1}{2} h_i f_t^2(x_i) ]$

其中：

$( g_i )$ 和 $( h_i )$ 分别是损失函数 $( L )$ 关于 $( \hat{y}_i^{(t-1)} )$ 的一阶导数和二阶导数。
$( f_t(x_i) )$ 是第 $( t )$ 棵树对第 $( i )$ 个样本的预测值。

4. 求解目标函数

将损失函数的泰勒展开式和正则化项代入目标函数，得到：

$[ \text{obj}^{(t)} \approx \sum_{i=1}^{n} \left[ L(y_i, \hat{y}i^{(t-1)}) + g_i f_t(x_i) + \frac{1}{2} h_i f_t^2(x_i) \right] + \gamma T + \frac{1}{2}\lambda\sum_{j=1}^{T} w_j^2 ]$

接下来，可以通过求解这个目标函数的最小值来得到第 $( t )$ 棵树的参数。这通常涉及到对目标函数进行化简、求导和求解最优解等步骤。

5. 移除常数项

首先，我们注意到目标函数中的 $( \sum_{i=1}^{n} L(y_i, \hat{y}_i^{(t-1)}) )$ 是一个常数项，因为它不依赖于第 ( t ) 棵树的参数。因此，在求解最优解时，我们可以将其从目标函数中移除。

6. 合并同类项

接下来，我们将目标函数中与 $( f_t(x_i) )$ 相关的项合并在一起，得到：

$[ \text{obj}^{(t)} \approx \sum_{i=1}^{n} \left[ g_i f_t(x_i) + \frac{1}{2} h_i f_t^2(x_i) \right] + \gamma T + \frac{1}{2} \lambda \sum_{j=1}^{T} w_j^2 ]$

7. 改写为树结构形式

由于 $( f_t(x_i) )$ 表示第 $( t )$ 棵树对第 $( i )$ 个样本的预测值，我们可以将其改写为树结构的形式。假设树有 $( T )$ 个叶子节点，每个叶子节点的权重为 $( w_j )$ ，则 $( f_t(x_i) )$ 可以表示为 $( w_{q(x_i)} )$ ，其中 $( q(x_i) )$ 表示样本 $( x_i )$ 所属的叶子节点。

因此，目标函数可以改写为：

$[ \text{obj}^{(t)} \approx \sum_{j=1}^{T} \left[ \left( \sum_{i \in I_j} g_i \right) w_j + \frac{1}{2} \left( \sum_{i \in I_j} h_i + \lambda \right) w_j^2 \right] + \gamma T ]$

其中， $( I_j )$ 表示所有属于第 $( j )$ 个叶子节点的样本的集合。

8. 求解最优权重

为了求解最优权重 $( w_j^* )$ ，我们可以对目标函数关于 $( w_j )$ 求导并令其等于零。这样，我们可以得到每个叶子节点的最优权重：

$[ w_j^* = -\frac{\sum_{i \in I_j} g_i}{\sum_{i \in I_j} h_i + \lambda} ]$

9. 求解最优结构

得到最优权重后，我们可以将其代入目标函数，得到仅与树结构相关的目标函数：

$[ \text{obj}^{(t)}(q) = -\frac{1}{2} \sum_{j=1}^{T} \frac{\left( \sum_{i \in I_j} g_i \right)^2}{\sum_{i \in I_j} h_i + \lambda} + \gamma T ]$

6.3 特点

梯度提升框架：XGBoost通过迭代地训练多个决策树（弱学习器）来不断改进模型的预测能力。这种集成学习的方法使得XGBoost能够构建一个更强大、更准确的模型。
正则化：XGBoost引入了正则化技术，包括L1和L2正则化，以控制模型的复杂度并减少过拟合的风险。这有助于提高模型的泛化能力，使其在未见过的数据上也能保持良好的性能。
特征重要性评估：XGBoost能够评估特征的重要性，并根据特征的贡献度进行特征选择。这使得用户能够了解哪些特征对模型的预测结果影响最大，从而进行更有针对性的特征工程。
自动处理缺失值：XGBoost能够自动处理缺失值，无需对缺失值进行预处理。这减少了数据清洗和预处理的工作量，并使得模型更加健壮。
并行计算：XGBoost支持并行计算，可以有效地利用多个CPU核心加速训练过程。这使得XGBoost在处理大规模数据集时表现出色，具有较高的效率。
优化策略：XGBoost在损失函数中引入了泰勒展开近似，使用一阶和二阶导数的信息来加速训练过程。此外，它还使用了近似的贪婪算法来选择最佳切分点，进一步提高了模型的训练效率。
高准确性：由于XGBoost在训练过程中会不断迭代地优化模型，因此它在预测精度上通常优于其他算法。这使得它在各种机器学习任务中表现出色，包括分类、回归、排序、推荐系统等。
可解释性：通过XGBoost的特征重要性评估功能，用户可以了解模型对输入特征的依赖程度，从而增加模型的可解释性。

6.4 API

XGBoost（Extreme Gradient Boosting）是一个优化分布式梯度提升库的开源实现，旨在高效、灵活且可移植。其Python API允许用户轻松地构建、训练和评估模型。以下是XGBoost API的一些关键组件和常用参数的简要概述：

6.4.1 核心类

XGBClassifier：用于分类任务的类。
XGBRegressor：用于回归任务的类。

6.4.2 核心函数

train：用于训练模型。这个函数接受一个参数字典，指定了模型的参数配置，如学习率（eta）、树的最大深度（max_depth）等。

6.4.3 通用参数（General Parameters）

booster：选择使用的booster类型，可以是'gbtree'（基于树的模型）、'gblinear'（线性模型）或'dart'。
silent：设置为0时打印运行信息，设置为1时静默模式。
nthread：用于运行XGBoost的并行线程数，通常设置为CPU的核心数。
verbosity：控制打印消息的详细程度。有效值为0（静默）、1（警告）、2（信息）和3（调试）。

6.4.4 Tree Booster参数

eta/learning_rate：学习率，控制每次迭代中权重更新的步长。
max_depth：树的最大深度。
min_child_weight：子树中最小样本权重和，用于防止过拟合。
gamma：节点分裂所需的最小损失函数下降值。
subsample：用于训练的数据子集比例。
colsample_bytree：构建每棵树时使用的特征比例。

6.4.5 目标参数（Objective Parameters）

objective：定义学习任务和相应的学习目标。例如，对于二分类问题，可以使用'binary:logistic'；对于回归问题，可以使用'reg:squarederror'。

6.4.6 评估参数（Evaluation Parameters）

eval_metric：用于验证数据的评估指标。例如，对于分类问题，可以使用'mlogloss'（多类对数损失）、'auc'（曲线下面积）等；对于回归问题，可以使用'rmse'（均方根误差）、'mae'（平均绝对误差）等。

6.4.7 调用示例

以下是一个使用XGBoost API进行二分类任务的基本示例：

import xgboost as xgb  
from sklearn.model_selection import train_test_split  
from sklearn.datasets import load_breast_cancer  
  
# 加载数据集  
data = load_breast_cancer()  
X, y = data.data, data.target  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  
  
# 转换为DMatrix格式，这是XGBoost内部的数据结构  
dtrain = xgb.DMatrix(X_train, label=y_train)  
dtest = xgb.DMatrix(X_test, label=y_test)  
  
# 设置参数  
param = {  
    'max_depth': 3,  # 树的深度  
    'eta': 0.3,  # 学习率  
    'objective': 'binary:logistic',  # 二分类问题的目标函数  
    'num_class': 1}  # 类别数，二分类问题设置为1  
  
# 训练模型  
num_round = 20  # 迭代次数  
bst = xgb.train(param, dtrain, num_round)  
  
# 预测  
preds = bst.predict(dtest)  
  
# 将预测概率转换为类别（0或1）  
y_pred = [1 if x > 0.5 else 0 for x in preds]  
  
# ...（此处可以添加评估代码，如计算准确率、召回率等）

一九11111

关注

50
点赞
踩
30

收藏

觉得还不错? 一键收藏
3
评论
机器学习（五） ----------集成学习（2）（Adaboost算法+GDBT算法+XGBoost算法）

Boosting思想是一种强大的机器学习策略，它基于“知错就改”的原则，旨在通过迭代地训练多个弱学习器（如决策树）并将它们组合成一个强学习器，从而提升模型的预测能力。Boosting通过不断调整样本权重，使得先前学习器错误分类的样本在后续迭代中获得更多关注，从而逐步优化模型性能。这种策略不仅提高了模型的泛化能力，还使得模型对复杂问题的处理更加灵活和高效。
复制链接

扫一扫