XGBoost梯度提升算法实战教程

本文集文档发布于灏天文库

3.2 Booster参数 (Booster Parameters)

文档摘要

3.2 Booster参数 (Booster Parameters) XGBoost Booster参数详解与调优：打造高性能模型的基石 在机器学习的广阔天地中，梯度提升树 (Gradient Boosting Tree, GBT) 算法族以其强大的预测能力和广泛的应用场景占据着举足轻重的地位。而XGBoost (Extreme Gradient Boosting) 作为 GBT 的杰出代表，凭借其高效、灵活和可扩展性，成为了数据科学家和机器学习工程师的首选工具。想要充分发挥 XGBoost 的潜力，深入理解并合理调优其参数至关重要。 3.

3.2 Booster参数 (Booster Parameters)

XGBoost Booster参数详解与调优：打造高性能模型的基石

在机器学习的广阔天地中，梯度提升树 (Gradient Boosting Tree, GBT) 算法族以其强大的预测能力和广泛的应用场景占据着举足轻重的地位。而XGBoost (Extreme Gradient Boosting) 作为 GBT 的杰出代表，凭借其高效、灵活和可扩展性，成为了数据科学家和机器学习工程师的首选工具。想要充分发挥 XGBoost 的潜力，深入理解并合理调优其参数至关重要。

3.2 Booster 参数 (Booster Parameters)

Booster 参数是 XGBoost 模型的核心参数，它定义了使用哪种类型的 Booster 模型，以及Booster 模型内部的结构和学习方式。Booster 参数直接决定了模型的学习能力、复杂度和泛化性能。在 XGBoost 中，我们可以选择两种主要的 Booster 类型：

  • gbtree (Tree Booster): 基于树模型的 Booster，也是 XGBoost 最常用和最强大的 Booster 类型。它使用梯度提升决策树 (Gradient Boosting Decision Tree) 作为基学习器，通过迭代构建一系列决策树来逐步提升模型性能。

  • gblinear (Linear Booster): 基于线性模型的 Booster，使用线性回归或逻辑回归作为基学习器。适用于特征数量巨大且线性关系较强的数据集，训练速度更快，但通常在复杂数据集上的表现不如 gbtree。

  • dart (Dropout meets Multiple Additive Regression Trees): 也是基于树模型的 Booster，是 gbtree 的一种变体。dart 在训练过程中引入了 dropout 技术，随机丢弃一部分树，可以有效缓解过拟合，提高模型的泛化能力，尤其是在小数据集上。

接下来，我们将分别深入探讨 gbtree、gblinear 和 dart 这三种 Booster 类型下的关键参数。

3.2.1 gbtree (Tree Booster) 参数详解与调优

gbtree 是 XGBoost 中最核心和最常用的 Booster 类型，其参数也最为丰富。理解和掌握 gbtree 的参数，是精通 XGBoost 的关键一步。gbtree 的参数可以进一步细分为以下几类：

1. 通用参数 (General Parameters, 尽管部分通用参数也会影响 Booster，但这里我们主要关注 Booster 特有的参数)

  • 我们假设通用参数已经在其他章节进行了讨论，此处重点关注 Booster 专属参数。

2. Booster 特有参数 (Booster Specific Parameters)

这些参数直接控制了树模型的结构和学习过程，是 gbtree 的核心。

  • eta (learning_rate): 学习率

    • 定义: eta 控制了每次迭代中更新步长的大小，也被称为学习率或收缩率。它决定了每棵树对最终预测结果的贡献程度。较小的 eta 值意味着每次迭代的步长更小，模型学习速度更慢，但能够更精细地逼近最优解，通常可以获得更好的泛化性能。较大的 eta 值则相反，学习速度快，但容易错过最优解，甚至导致过拟合。

    • 取值范围: 通常在 [0, 1] 之间。

    • 调优策略:

      • 小 eta + 大 n_estimators (迭代次数): 这是最常见的调优策略。较小的学习率需要更多的迭代次数才能达到相同的性能水平，但可以提高模型的稳定性和泛化能力。通常建议 eta 取值在 0.01 到 0.2 之间。

      • 配合 early_stopping_rounds: 在使用小 eta 和大 n_estimators 时，配合 early_stopping_rounds 可以有效防止过拟合，并在验证集性能不再提升时提前停止训练，节省计算资源。

      • 网格搜索或贝叶斯优化: 可以使用网格搜索或贝叶斯优化等方法，在一定的范围内搜索最优的 eta 值。

    • 代码实践:

    import xgboost as xgb
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, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 不同 eta 值的模型训练与评估
eta_values = [0.01, 0.1, 0.3]
for eta in eta_values:
    xgb_classifier = xgb.XGBClassifier(
        objective='binary:logistic',  # 二分类任务
        eta=eta,                     # 设置 eta 参数
        n_estimators=100,            # 固定迭代次数，方便比较
        random_state=42
    )
    xgb_classifier.fit(X_train, y_train)
    y_pred = xgb_classifier.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"eta = {eta}, Accuracy: {accuracy}")
​

  • gamma (min_split_loss): 最小分裂损失减少量

    • 定义: gamma 定义了节点分裂所需的最小损失函数下降值。只有当节点分裂后，损失函数减少的值大于等于 gamma 时，该节点才会被分裂。gamma 值越大，算法越保守，越不容易分裂节点，从而产生更简单的树模型，有助于防止过拟合。gamma 实际上是对树的复杂度进行惩罚。

    • 取值范围: [0, ∞]，通常不需要设置过大，一般在 [0, 20] 范围内调优。

    • 调优策略:

      • 控制模型复杂度: gamma 越大，树模型越简单，模型越不容易过拟合，但可能导致欠拟合。反之，gamma 越小，树模型越复杂，容易过拟合。

      • 配合其他参数: gamma 通常需要与其他参数（如 max_depth, min_child_weight）一起调优，找到模型复杂度与性能之间的平衡点。

      • 交叉验证: 使用交叉验证来选择合适的 gamma 值。

    • 可视化与解释: gamma 越大，树的分裂越少，树的深度和复杂度降低。

    • 代码实践与 Mermaid 图:

    import xgboost as xgb
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, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 不同 gamma 值的模型训练与评估
gamma_values = [0, 5, 10, 20]
for gamma in gamma_values:
    xgb_classifier = xgb.XGBClassifier(
        objective='binary:logistic',
        gamma=gamma,                     # 设置 gamma 参数
        n_estimators=100,
        max_depth=3,                    # 固定 max_depth，方便比较
        random_state=42
    )
    xgb_classifier.fit(X_train, y_train)
    y_pred = xgb_classifier.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"gamma = {gamma}, Accuracy: {accuracy}")
# Mermaid 图示例 (展示 gamma 对树结构的影响，需要手动绘制，此处仅为示例)
print("""
```mermaid

​

graph TD

subgraph gamma_0
    A[Root] --> B[Feature X less than threshold]
    B --> C{Leaf 1}
    B --> D{Leaf 2}
end

subgraph gamma_10
    E[Root] --> F{Leaf 3}
end

style F fill:#f9f,stroke:#333,stroke-width:2px
style C fill:#ccf,stroke:#333,stroke-width:2px
style D fill:#ccf,stroke:#333,stroke-width:2px
​
    """)
    ```



    **Mermaid 图解释:**  当 `gamma = 0` 时，只要分裂能够带来收益 (哪怕很小)，树就会继续分裂，形成更复杂的结构 (左侧子图)。当 `gamma = 10` 时，只有当分裂带来的收益足够大时，树才会分裂。如果收益不足，则节点会直接成为叶子节点，形成更简单的树结构 (右侧子图)。



* **`max_depth`:  树的最大深度**



    * **定义:** `max_depth`  限制了每棵树的最大深度。树的深度越大，模型可以学习到更复杂的特征交互，但也更容易过拟合。`max_depth` 是控制模型复杂度的重要参数。



    * **取值范围:**  `[1, ∞]`，通常建议在 `[3, 10]` 范围内调优。



    * **调优策略:**

        * **控制模型复杂度:**  `max_depth` 越大，模型越复杂，容易过拟合；`max_depth` 越小，模型越简单，容易欠拟合。

        * **数据集大小:**  对于小数据集，`max_depth` 不宜设置过大，以防止过拟合。对于大数据集，可以适当增加 `max_depth`，以提高模型的学习能力。

        * **交叉验证:**  使用交叉验证来选择合适的 `max_depth` 值。



    * **可视化与解释:**  `max_depth` 直接限制了树的层数，影响树的结构和复杂度。



    * **代码实践与 Mermaid 图:**



    ```python
    import xgboost as xgb
    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, random_state=42)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    # 不同 max_depth 值的模型训练与评估
    max_depth_values = [3, 5, 7, 10]
    for max_depth in max_depth_values:
        xgb_classifier = xgb.XGBClassifier(
            objective='binary:logistic',
            max_depth=max_depth,            # 设置 max_depth 参数
            n_estimators=100,
            random_state=42
        )
        xgb_classifier.fit(X_train, y_train)
        y_pred = xgb_classifier.predict(X_test)
        accuracy = accuracy_score(y_test, y_pred)
        print(f"max_depth = {max_depth}, Accuracy: {accuracy}")
    # Mermaid 图示例 (展示 max_depth 对树结构的影响，需要手动绘制，此处仅为示例)
    print("""
    ```mermaid

graph TD

    subgraph Level_2
        A[Root] --> B[Feature X less than threshold]
        B --> C{Leaf 1}
        B --> D{Leaf 2}
    end

    subgraph Level_4
        E[Root] --> F[Feature Y less than threshold]
        F --> G[Feature Z less than threshold]
        G --> H{Leaf 3}
        G --> I{Leaf 4}
        F --> J[Feature W less than threshold]
        J --> K{Leaf 5}
        J --> L{Leaf 6}
    end

    style C fill:#ccf,stroke:#333,stroke-width:2px
    style D fill:#ccf,stroke:#333,stroke-width:2px
    style H fill:#ccf,stroke:#333,stroke-width:2px
    style I fill:#ccf,stroke:#333,stroke-width:2px
    style K fill:#ccf,stroke:#333,stroke-width:2px
    style L fill:#ccf,stroke:#333,stroke-width:2px

​
""")
```



**Mermaid 图解释:**  `max_depth` 为 2 时，树的深度被限制为两层 (左侧子图)。`max_depth` 为 4 时，树可以生长到更深的层数 (右侧子图)，模型能够学习更复杂的特征组合。
​

  • min_child_weight: 子节点的最小权重和

    • 定义: min_child_weight 定义了一个节点要被进一步分裂所需要的最小叶子节点样本权重之和。 在回归任务中，权重通常等于样本数量。在分类任务中，权重可能与类别分布有关。min_child_weight 越大，算法越保守，越不容易分裂节点，有助于防止过拟合。

    • 取值范围: [0, ∞]，通常建议在 [1, 10] 范围内调优。

    • 调优策略:

      • 控制模型复杂度: min_child_weight 越大，模型越简单，不容易过拟合；min_child_weight 越小，模型越复杂，容易过拟合。

      • 处理不平衡数据: 在处理类别不平衡的数据集时，可以适当增大 min_child_weight，以防止模型过度关注少数类别，提高模型在多数类别上的泛化能力。

      • 交叉验证: 使用交叉验证来选择合适的 min_child_weight 值。

    • 可视化与解释: min_child_weight 限制了叶子节点包含的最小样本量，影响树的结构和泛化能力.

    • 代码实践与 Mermaid 图:

    import xgboost as xgb
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, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 不同 min_child_weight 值的模型训练与评估
min_child_weight_values = [1, 5, 10, 20]
for min_child_weight in min_child_weight_values:
    xgb_classifier = xgb.XGBClassifier(
        objective='binary:logistic',
        min_child_weight=min_child_weight,  # 设置 min_child_weight 参数
        n_estimators=100,
        max_depth=3,                        # 固定 max_depth，方便比较
        random_state=42
    )
    xgb_classifier.fit(X_train, y_train)
    y_pred = xgb_classifier.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"min_child_weight = {min_child_weight}, Accuracy: {accuracy}")
# Mermaid 图示例 (展示 min_child_weight 对树结构的影响，需要手动绘制，此处仅为示例)
print("""
```mermaid

​

graph TD

subgraph min_child_weight_1
    A[Root Weight=1000] --> B[Feature X < threshold, Weight=500]
    B --> C[Leaf 1 Weight=250]
    B --> D[Leaf 2 Weight=250]
end

subgraph min_child_weight_10
    E[Root Weight=1000] --> F[Leaf 3 Weight=1000]
end

style C fill:#ccf,stroke:#333,stroke-width:2px
style D fill:#ccf,stroke:#333,stroke-width:2px
style F fill:#f9f,stroke:#333,stroke-width:2px
​
    """)
    ```



    **Mermaid 图解释:**  当 `min_child_weight = 1` 时，只要子节点的权重和大于等于 1，节点就可以继续分裂 (左侧子图)。当 `min_child_weight = 10` 时，如果子节点的权重和小于 10，则节点不会分裂，直接成为叶子节点 (右侧子图)。



* **`subsample`:  样本子采样比例**



    * **定义:** `subsample`  控制了每棵树训练时使用的样本比例。例如，`subsample=0.8` 表示每棵树随机抽取 80% 的样本进行训练。样本子采样可以降低模型的方差，防止过拟合，并加速训练过程。类似于随机森林中的样本随机抽样。



    * **取值范围:**  `(0, 1]`，通常建议在 `[0.5, 1]` 范围内调优。



    * **调优策略:**

        * **防止过拟合:**  `subsample` 越小，模型越不容易过拟合，但可能导致欠拟合。

        * **加速训练:**  `subsample` 越小，每次迭代使用的样本越少，训练速度越快。

        * **交叉验证:**  使用交叉验证来选择合适的 `subsample` 值。



    * **代码实践:**



    ```python
    import xgboost as xgb
    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, random_state=42)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    # 不同 subsample 值的模型训练与评估
    subsample_values = [0.5, 0.7, 0.9, 1.0]
    for subsample in subsample_values:
        xgb_classifier = xgb.XGBClassifier(
            objective='binary:logistic',
            subsample=subsample,            # 设置 subsample 参数
            n_estimators=100,
            random_state=42
        )
        xgb_classifier.fit(X_train, y_train)
        y_pred = xgb_classifier.predict(X_test)
        accuracy = accuracy_score(y_test, y_pred)
        print(f"subsample = {subsample}, Accuracy: {accuracy}")
    ```



* **`colsample_bytree`, `colsample_bylevel`, `colsample_bynode`:  特征子采样比例**



    * **定义:**  这三个参数都用于控制特征子采样，但作用的粒度不同。

        * **`colsample_bytree`:**  控制每棵树训练时使用的特征比例。例如，`colsample_bytree=0.8` 表示每棵树随机抽取 80% 的特征进行训练。

        * **`colsample_bylevel`:**  控制每个树的层级 (level) 分裂时使用的特征比例。例如，`colsample_bylevel=0.8` 表示在树的每一层分裂时，随机抽取 80% 的特征进行候选分裂点的选择。

        * **`colsample_bynode`:**  控制每个树的节点分裂时使用的特征比例。例如，`colsample_bynode=0.8` 表示在树的每个节点分裂时，随机抽取 80% 的特征进行候选分裂点的选择。



    * **取值范围:**  `(0, 1]`，通常建议在 `[0.5, 1]` 范围内调优。



    * **调优策略:**

        * **防止过拟合:**  特征子采样可以降低模型的方差，防止过拟合，尤其是当特征数量很多时。

        * **加速训练:**  特征子采样可以减少每次分裂时需要考虑的特征数量，加速训练过程。

        * **提高模型鲁棒性:**  特征子采样可以使模型对特征选择更加鲁棒，提高模型的泛化能力。

        * **组合使用:**  可以组合使用这三个参数，例如，`colsample_bytree=0.8`, `colsample_bylevel=0.9`, `colsample_bynode=1`，以实现更精细的特征子采样控制。

        * **交叉验证:**  使用交叉验证来选择合适的特征子采样比例。



    * **可视化与解释:** 特征子采样限制了每棵树或每个节点在分裂时可用的特征数量，影响树的结构和特征选择。



    * **代码实践与 Mermaid 图 (`colsample_bytree` 示例):**



    ```python
    import xgboost as xgb
    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, random_state=42)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    # 不同 colsample_bytree 值的模型训练与评估
    colsample_bytree_values = [0.5, 0.7, 0.9, 1.0]
    for colsample_bytree in colsample_bytree_values:
        xgb_classifier = xgb.XGBClassifier(
            objective='binary:logistic',
            colsample_bytree=colsample_bytree,  # 设置 colsample_bytree 参数
            n_estimators=100,
            random_state=42
        )
        xgb_classifier.fit(X_train, y_train)
        y_pred = xgb_classifier.predict(X_test)
        accuracy = accuracy_score(y_test, y_pred)
        print(f"colsample_bytree = {colsample_bytree}, Accuracy: {accuracy}")
    # Mermaid 图示例 (展示 colsample_bytree 对特征选择的影响，需要手动绘制，此处仅为示例)
    print("""
    ```mermaid

graph TD

    subgraph All_Features
        A[Root] --> B[Feature X < threshold]
        B --> C{Leaf 1}
        B --> D{Leaf 2}
    end

    subgraph Subset_of_Features
        E[Root] --> F[Feature Y < threshold]
        F --> G{Leaf 3}
        F --> H{Leaf 4}
    end

    style C fill:#ccf,stroke:#333,stroke-width:2px
    style D fill:#ccf,stroke:#333,stroke-width:2px
    style G fill:#ccf,stroke:#333,stroke-width:2px
    style H fill:#ccf,stroke:#333,stroke-width:2px

​
""")
```



**Mermaid 图解释:**  当 `colsample_bytree = 1.0` 时，所有特征都可能被用于树的分裂 (左侧子图)。当 `colsample_bytree = 0.5` 时，每棵树只随机选择一半的特征进行训练，因此不同的树可能会使用不同的特征进行分裂 (右侧子图)。
​

  • lambda (reg_lambda), alpha (reg_alpha): L2 和 L1 正则化项

    • 定义:

      • lambda (reg_lambda): L2 正则化系数，作用于叶子节点权重的 L2 正则化项。增加 lambda 可以使模型更加保守，降低模型的复杂度，防止过拟合。

      • alpha (reg_alpha): L1 正则化系数，作用于叶子节点权重的 L1 正则化项。增加 alpha 可以使模型更加稀疏，即让一部分叶子节点权重变为 0，从而进行特征选择，降低模型的复杂度，防止过拟合。

    • 取值范围: [0, ∞]，通常建议在 [0, 1] 或 [0, 10] 范围内调优。

    • 调优策略:

      • 防止过拟合: 增加 lambda 和 alpha 都可以降低模型的复杂度，防止过拟合。

      • 特征选择 (L1 正则化): alpha (L1 正则化) 可以进行特征选择，使模型更加稀疏，提高模型的可解释性。

      • 组合使用: 可以同时使用 L1 和 L2 正则化，例如，lambda=1, alpha=0.1。

      • 交叉验证: 使用交叉验证来选择合适的正则化系数。

    • 代码实践:

    import xgboost as xgb
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, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 不同 lambda 和 alpha 值的模型训练与评估
lambda_alpha_values = [(0, 0), (1, 0), (0, 1), (1, 1)] # (lambda, alpha) pairs
for lambda_val, alpha_val in lambda_alpha_values:
    xgb_classifier = xgb.XGBClassifier(
        objective='binary:logistic',
        reg_lambda=lambda_val,         # 设置 lambda (L2 正则化) 参数
        reg_alpha=alpha_val,          # 设置 alpha (L1 正则化) 参数
        n_estimators=100,
        random_state=42
    )
    xgb_classifier.fit(X_train, y_train)
    y_pred = xgb_classifier.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"lambda = {lambda_val}, alpha = {alpha_val}, Accuracy: {accuracy}")
​

  • tree_method: 树的构建算法

    • 定义: tree_method 指定了 XGBoost 使用的树构建算法。常用的选项包括：

      • 'auto': XGBoost 会自动选择最合适的算法。通常对于小数据集会使用 'exact'，对于大数据集会使用 'approx' 或 'hist'。

      • 'exact': 精确贪心算法，枚举所有可能的特征分裂点，计算量大，但能找到最优分裂点，适用于小数据集。

      • 'approx': 近似贪心算法，使用直方图近似特征分布，减少候选分裂点，加速训练，适用于大数据集。

      • 'hist': 更快的直方图算法，也适用于大数据集，通常比 'approx' 更快。

      • 'gpu_hist': GPU 加速的直方图算法，如果使用 GPU 训练，可以显著加速训练过程。

    • 取值范围: ['auto', 'exact', 'approx', 'hist', 'gpu_hist']

    • 调优策略:

      • 数据集大小: 小数据集可以使用 'exact'，大数据集建议使用 'approx', 'hist' 或 'gpu_hist'。

      • 训练速度: 'hist' 和 'gpu_hist' 通常比 'approx' 和 'exact' 更快。

      • GPU 加速: 如果使用 GPU 训练，强烈建议使用 'gpu_hist'。

3.2.1 树模型参数 (Tree Booster Parameters - gbtree, dart)

XGBoost 树模型参数详解 (gbtree, dart)

3.2.1 树模型参数 (Tree Booster Parameters - gbtree, dart)

XGBoost 提供了两种主要的 Booster 类型：树模型 (Tree Booster) 和 线性模型 (Linear Booster)。树模型 Booster 基于决策树集成学习，是 XGBoost 最核心和常用的部分。线性模型 Booster 则适用于线性关系明显的数据，但本文将专注于树模型 Booster，特别是 gbtree 和 dart 这两种类型。

gbtree (Gradient Boosting Tree) 是 XGBoost 默认也是最经典的树模型 Booster。它采用传统的梯度提升决策树算法，通过迭代地构建新的决策树来拟合残差，从而逐步提升模型的预测能力。

dart (Dropout Additive Regression Trees) 是另一种树模型 Booster，它在 gbtree 的基础上引入了 Dropout 技术，旨在进一步增强模型的泛化能力，尤其是在处理过拟合问题时表现出色。

接下来，我们将分别详细介绍 gbtree 和 dart 的原理、参数以及代码实践。

3.2.1.1 gbtree (Gradient Boosting Tree)

gbtree 是 XGBoost 的默认 Booster，其核心思想是梯度提升 (Gradient Boosting)。梯度提升是一种迭代的加法模型，它通过不断地在负梯度方向上训练新的弱学习器 (这里是决策树)，并将这些弱学习器线性组合起来，最终得到一个强学习器。

gbtree 的工作流程可以概括为：

  1. 初始化： 初始化一个弱学习器 (通常是一个常数模型)。

  2. 迭代训练： 进行多轮迭代，每一轮迭代执行以下步骤：

    • 计算负梯度 (残差)： 计算当前模型在训练集上的负梯度，也称为残差。负梯度反映了模型预测值与真实值之间的差距，是下一步学习的目标。

    • 训练新的决策树： 使用训练数据和计算得到的负梯度，训练一个新的决策树。这个决策树的目标是拟合负梯度，尽可能减小残差。

    • 更新模型： 将新训练的决策树添加到模型中，并乘以一个学习率 (learning rate, eta) 进行加权，更新模型。

  3. 输出最终模型： 经过多轮迭代后，将所有训练得到的决策树进行加权求和，得到最终的 XGBoost 模型。

gbtree 的关键参数：

gbtree Booster 提供了丰富的参数来控制决策树的构建过程和模型的复杂度。以下是一些最重要的参数，并附带详细解释和代码示例：

  • eta (学习率, learning_rate): 控制每个弱学习器 (决策树) 对最终模型的贡献程度。较小的 eta 值意味着每棵树的权重较低，模型学习速度更慢，但可能更稳定，更不容易过拟合。较大的 eta 值则相反。

    • 取值范围: (0, 1]，通常设置为 0.01-0.2。

    • 默认值: 0.3

    • 影响: 控制模型学习速度和过拟合风险。

    import xgboost as xgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
# 生成示例数据
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 训练 gbtree 模型，调整 eta 参数
params = {
    'objective': 'binary:logistic',
    'booster': 'gbtree',
    'eval_metric': 'logloss',
    'eta': 0.1  # 设置学习率为 0.1
}
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
print(f"最佳迭代轮数: {model.best_iteration}")
​

  • gamma (最小分裂损失减小量, min_split_loss): 控制节点分裂所需的最小损失函数下降值。只有当分裂带来的损失函数下降值大于 gamma 时，节点才会被分裂。gamma 值越大，算法越保守，不容易过拟合。

    • 取值范围: [0, ∞)，通常设置为 0-0.2。

    • 默认值: 0

    • 影响: 控制树的复杂度，防止过拟合。

    params['gamma'] = 0.1  # 设置 gamma 为 0.1
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • max_depth (最大树深度): 控制决策树的最大深度。max_depth 越大，树越复杂，模型学习能力越强，但也更容易过拟合。

    • 取值范围: [1, ∞)，通常设置为 3-10。

    • 默认值: 6

    • 影响: 控制树的复杂度，防止过拟合和欠拟合。

    params['max_depth'] = 5  # 设置最大深度为 5
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • min_child_weight (最小叶子节点样本权重和): 控制叶子节点所需的最小样本权重和。只有当叶子节点的样本权重和大于 min_child_weight 时，该叶子节点才会被创建。min_child_weight 越大，算法越保守，不容易过拟合。在分类问题中，样本权重通常等于样本数量。

    • 取值范围: [0, ∞)，通常设置为 1-10。

    • 默认值: 1

    • 影响: 控制树的复杂度，防止过拟合。

    params['min_child_weight'] = 3  # 设置最小叶子节点样本权重和为 3
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • subsample (样本子采样比例): 控制每棵树训练时使用的样本比例。subsample 越小，模型越随机，可以降低方差，防止过拟合。

    • 取值范围: (0, 1]，通常设置为 0.5-1。

    • 默认值: 1

    • 影响: 降低方差，防止过拟合。

    params['subsample'] = 0.8  # 设置样本子采样比例为 0.8
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • colsample_bytree (列子采样比例): 控制每棵树训练时使用的特征列比例。colsample_bytree 越小，模型越随机，可以降低方差，防止过拟合。

    • 取值范围: (0, 1]，通常设置为 0.5-1。

    • 默认值: 1

    • 影响: 降低方差，防止过拟合。

    params['colsample_bytree'] = 0.7  # 设置列子采样比例为 0.7
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • lambda (L2 正则化系数, reg_lambda): 控制 L2 正则化的强度。L2 正则化通过对模型权重 (叶子节点输出值) 进行惩罚，来防止过拟合。lambda 值越大，正则化越强，模型越保守。

    • 取值范围: [0, ∞)，通常设置为 0-1。

    • 默认值: 1

    • 影响: 防止过拟合。

    params['lambda'] = 1.5  # 设置 L2 正则化系数为 1.5
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • alpha (L1 正则化系数, reg_alpha): 控制 L1 正则化的强度。L1 正则化除了防止过拟合外，还可以进行特征选择，将不重要的特征权重置为 0。alpha 值越大，正则化越强，模型越保守。

    • 取值范围: [0, ∞)，通常设置为 0-1。

    • 默认值: 0

    • 影响: 防止过拟合，进行特征选择。

    params['alpha'] = 0.1  # 设置 L1 正则化系数为 0.1
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • tree_method (树构建算法): 选择树的构建算法，不同的算法在速度和内存使用上有所差异。常用的选项包括：

    • 'auto': 让 XGBoost 自动选择最合适的算法。

    • 'exact': 精确贪心算法，适用于小数据集。

    • 'approx': 近似贪心算法，适用于大数据集，速度更快但可能精度略有下降。

    • 'hist': 直方图算法，速度更快，内存占用更少，推荐用于大数据集。

    • 'gpu_hist': GPU 加速的直方图算法，速度最快，需要 GPU 支持。

    • 取值范围: 'auto', 'exact', 'approx', 'hist', 'gpu_hist' 等。

    • 默认值: 'auto'

    • 影响: 算法速度和内存使用。

    params['tree_method'] = 'hist'  # 设置树构建算法为直方图算法
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • grow_policy (树增长策略): 控制树的生长方式。

    • 'depthwise': 按深度优先生长，每次分裂选择损失下降最多的节点进行分裂。

    • 'lossguide': 按损失引导生长，每次分裂选择损失下降最多的叶子节点进行分裂。lossguide 通常可以构建更深但更不规则的树，可能更有效，尤其是在数据分布不均匀的情况下。

    • 取值范围: 'depthwise', 'lossguide'

    • 默认值: 'depthwise'

    • 影响: 树的结构和复杂度。

    params['grow_policy'] = 'lossguide'  # 设置树增长策略为 lossguide
params['max_leaves'] = 64 # 使用 lossguide 时，通常需要设置 max_leaves 来限制树的复杂度
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • max_leaves (最大叶子节点数): 当 grow_policy='lossguide' 时使用，限制树的最大叶子节点数。可以替代 max_depth 来控制树的复杂度。

    • 取值范围: [0, ∞)，通常设置为 32-256。

    • 默认值: 0 (无限制，但受限于内存)

    • 影响: 控制树的复杂度。

    params['grow_policy'] = 'lossguide'
params['max_leaves'] = 64  # 设置最大叶子节点数为 64
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

gbtree 模型结构可视化 (mermaid graph TD):

上图展示了一个简单的 gbtree 模型结构，它由多个决策树组成。每个决策树从根节点开始，根据特征值进行分裂，最终到达叶子节点，叶子节点输出预测值。

3.2.1.2 dart (Dropout Additive Regression Trees)

dart Booster 是 gbtree 的一个变体，它在梯度提升过程中引入了 Dropout 技术。Dropout 是一种常用的正则化方法，在神经网络中被广泛使用，其核心思想是在训练过程中随机地 "dropout" (丢弃) 一部分神经元，防止模型过度依赖某些特定的神经元，从而增强模型的泛化能力。

在 dart 中，Dropout 被应用于决策树。在每一轮迭代中，dart 会随机地 "dropout" 一部分已有的树，这意味着这些被 dropout 的树在当前轮迭代中不会参与残差的计算和新树的构建。这样做可以强制模型学习更鲁棒的特征表示，避免过度依赖之前迭代中已经学习到的树，从而提高模型的泛化能力，尤其是在处理过拟合问题时效果显著。

dart 的关键参数 (与 gbtree 的差异和新增参数):

dart Booster 除了继承 gbtree 的大部分参数外，还引入了一些新的参数来控制 Dropout 行为。

  • rate_drop (dropout 比例): 控制每轮迭代中 dropout 树的比例。例如，rate_drop=0.1 表示每轮迭代中会随机 dropout 10% 的树。

    • 取值范围: [0, 1]，通常设置为 0.1-0.5。

    • 默认值: 0

    • 影响: dropout 强度，影响模型泛化能力。

    params['booster'] = 'dart' # 切换 booster 为 dart
params['rate_drop'] = 0.2 # 设置 dropout 比例为 0.2
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • skip_drop (跳过 dropout 的概率): 控制是否跳过 dropout 过程的概率。如果 skip_drop 较小，dropout 过程会更频繁地发生，模型更具随机性。

    • 取值范围: [0, 1]，通常设置为 0-0.5。

    • 默认值: 0

    • 影响: dropout 频率，影响模型随机性和泛化能力。

    params['skip_drop'] = 0.1 # 设置跳过 dropout 的概率为 0.1
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • sample_type (采样类型): 控制 dropout 树的采样方式。

    • 'uniform': 均匀采样，随机选择固定比例 (rate_drop) 的树进行 dropout。

    • 'weighted': 加权采样，根据树的权重进行采样，权重越大的树越容易被 dropout。

    • 取值范围: 'uniform', 'weighted'

    • 默认值: 'uniform'

    • 影响: dropout 树的选择方式。

    params['sample_type'] = 'weighted' # 设置采样类型为加权采样
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • normalize_type (归一化类型): 控制 dropout 后剩余树的归一化方式。

    • 'tree': 树归一化，将剩余树的权重除以 (1 - rate_drop)。

    • 'forest': 森林归一化，将整个森林的权重除以 (1 - rate_drop)。forest 归一化通常效果更好。

    • 取值范围: 'tree', 'forest'

    • 默认值: 'tree'

    • 影响: dropout 后权重调整方式。

    params['normalize_type'] = 'forest' # 设置归一化类型为森林归一化
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

  • one_drop (强制至少 dropout 一棵树): 布尔值，如果设置为 True，则每轮迭代中强制至少 dropout 一棵树，即使 rate_drop=0。

    • 取值范围: True, False

    • 默认值: False

    • 影响: 确保每轮迭代都有 dropout 发生。

    params['one_drop'] = True # 强制至少 dropout 一棵树
model = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtrain, 'train'), (dtest, 'eval')])
​

dart 模型结构可视化 (mermaid graph TD):

上图展示了 dart 模型中 Dropout 的概念。在每一轮迭代中，部分树 (例如 Tree 5 和 Tree 6) 被随机 dropout，它们对当前轮迭代的贡献被减弱或忽略，从而迫使模型学习更具有泛化能力的特征。

3.2.1.3 gbtree vs dart: 如何选择？

gbtree 和 dart 都是强大的树模型 Booster，选择哪个 Booster 取决于具体的数据集和任务。

gbtree 的优点：

  • 速度快： gbtree 是 XGBoost 的默认 Booster，经过高度优化，训练速度通常更快。

  • 成熟稳定： gbtree 经过长时间的实践检验，在各种场景下都表现稳定可靠。

  • 参数丰富： gbtree 提供了丰富的参数来控制模型，可以灵活地进行调优。

dart 的优点：

  • 更强的泛化能力： 由于引入了 Dropout 技术，dart 在某些情况下可以获得更好的泛化能力，尤其是在处理过拟合问题时。

  • 更鲁棒的特征表示： Dropout 迫使模型学习更鲁棒的特征表示，避免过度依赖某些特定特征。

如何选择：

  • 数据集较小，过拟合风险较低： 优先选择 gbtree，速度更快，参数调优更简单。

  • 数据集较大，过拟合风险较高： 可以尝试 dart，通过 Dropout 增强泛化能力，但需要仔细调整 Dropout 相关参数 (rate_drop, skip_drop 等)。

  • 追求极致性能： 可以同时尝试 gbtree 和 dart，并进行交叉验证和参数调优，选择在验证集上表现更好的 Booster。

总结:

gbtree 和 dart 是 XGBoost 中两种重要的树模型 Booster。gbtree 是经典且高效的梯度提升决策树算法，而 dart 在 gbtree 的基础上引入了 Dropout 技术，旨在增强模型的泛化能力。理解它们的原理、参数和适用场景，并结合实际问题进行选择和调优，才能充分发挥 XGBoost 的强大威力，构建高性能的机器学习模型。

作者与出处
原作者： 灏天文库
来源：灏天文库
整理： 灏天文库整理
由灏天文库平台收录，内容或由平台用户上传，仅供学习交流
发布者: 作者: 灏天文库 转发
评论区 (0)
U
0/500