深入浅出剖析 XGBoost 建树过程

后端

2024-01-14 00:55:19

机器学习基础：XGBoost 建树过程分析与 Python 实现

引言

XGBoost 作为机器学习领域备受推崇的算法，凭借其高效性和准确性，在众多应用中大放异彩。其核心思想是梯度提升决策树（GBDT），它通过逐步添加决策树，并对每个树的预测进行加权，最终构建一个强大的集成模型。

本文将重点探讨 XGBoost 的建树过程，从贪婪特征分裂到损失函数优化和正则化，深入浅出地剖析其工作原理。同时，我们将提供 Python 代码实现，让读者亲自动手实践，加深对 XGBoost 的理解。

贪婪特征分裂

XGBoost 在建树时，会采用贪婪特征分裂算法。该算法从所有候选特征中，选择一个能够最大程度减少目标函数（损失函数）的特征作为分裂点。

目标函数由两个部分组成：训练误差和正则化项。训练误差衡量模型对训练数据的拟合程度，正则化项则惩罚模型的复杂度。XGBoost 使用平方误差作为损失函数，正则化项包括 L1 和 L2 正则化。

损失函数优化

在选择分裂点后，XGBoost 需要优化损失函数，以确定最佳分裂阈值。该过程涉及计算每个特征的不同分裂点处的损失函数值，并选择损失函数减小最显著的点。

正则化

为了防止模型过拟合，XGBoost 采用正则化技术。L1 正则化（即 Lasso 回归）通过惩罚特征权重之和来减少特征数量，L2 正则化（即岭回归）通过惩罚特征权重平方和来约束模型的复杂度。

Python 实现

为了便于理解，我们提供了一个简易的 Python 实现，模拟 XGBoost 的建树过程。代码如下：

import numpy as np

class Node:
    def __init__(self, feature, threshold, left, right):
        self.feature = feature
        self.threshold = threshold
        self.left = left
        self.right = right

def build_tree(data, max_depth, min_samples_split):
    # 递归终止条件：达到最大深度或样本数不足
    if max_depth <= 0 or len(data) < min_samples_split:
        return None

    # 计算目标函数（平方误差）
    target = data[:, -1]
    y_mean = np.mean(target)
    mse = np.mean((target - y_mean) ** 2)

    # 初始化最佳分裂
    best_feature = None
    best_threshold = None
    best_mse = mse

    # 遍历所有特征
    for feature in range(data.shape[1] - 1):
        # 遍历所有分裂点
        for threshold in np.unique(data[:, feature]):
            # 计算分裂后的损失函数
            left_mse, right_mse = _calculate_loss(data, feature, threshold)

            # 更新最佳分裂
            if left_mse + right_mse < best_mse:
                best_feature = feature
                best_threshold = threshold
                best_mse = left_mse + right_mse

    # 递归构建子树
    if best_feature is not None:
        left_data = data[data[:, best_feature] <= best_threshold]
        right_data = data[data[:, best_feature] > best_threshold]
        left_tree = build_tree(left_data, max_depth - 1, min_samples_split)
        right_tree = build_tree(right_data, max_depth - 1, min_samples_split)
        return Node(best_feature, best_threshold, left_tree, right_tree)

# 计算分裂后的损失函数
def _calculate_loss(data, feature, threshold):
    left_data = data[data[:, feature] <= threshold]
    right_data = data[data[:, feature] > threshold]
    left_y = left_data[:, -1]
    right_y = right_data[:, -1]
    left_mse = np.mean((left_y - np.mean(left_y)) ** 2)
    right_mse = np.mean((right_y - np.mean(right_y)) ** 2)
    return left_mse, right_mse

# 训练数据
data = np.array([[1, 2, 3, 4],
                  [5, 6, 7, 8],
                  [9, 10, 11, 12],
                  [13, 14, 15, 16]])

# 构建决策树
tree = build_tree(data, max_depth=3, min_samples_split=2)