梯度提升用于高效的分类与回归

使用 决策树（Decision Tree） 实现 梯度提升（Gradient Boosting） 主要是模拟 GBDT（Gradient Boosting Decision Trees） 的原理，即：

第一棵树拟合原始数据
计算残差（负梯度方向）
用新的树去拟合残差
累加所有树的预测值
重复步骤 2-4，直至达到指定轮数

下面是一个 纯 Python + PyTorch 实现 GBDT（梯度提升决策树） 的代码示例。

1. 纯 Python 实现梯度提升决策树

import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

# 生成数据
X, y = make_regression(n_samples=1000, n_features=5, noise=0.1, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 参数
n_trees = 50   # 多少棵树
learning_rate = 0.1  # 学习率

# 初始化预测值（全部为 0）
y_pred_train = np.zeros_like(y_train)
y_pred_test = np.zeros_like(y_test)

# 训练梯度提升决策树
trees = []
for i in range(n_trees):
    residuals = y_train - y_pred_train  # 计算残差（负梯度方向）
    
    tree = DecisionTreeRegressor(max_depth=3)  # 这里使用较浅的树
    tree.fit(X_train, residuals)  # 让树学习残差
    trees.append(tree)
    
    # 更新预测值（累加弱学习器的结果）
    y_pred_train += learning_rate * tree.predict(X_train)
    y_pred_test += learning_rate * tree.predict(X_test)

    # 计算损失
    mse = mean_squared_error(y_train, y_pred_train)
    print(f"Iteration {i+1}: MSE = {mse:.4f}")

# 计算最终测试集误差
final_mse = mean_squared_error(y_test, y_pred_test)
print(f"\nFinal Test MSE: {final_mse:.4f}")

代码解析

第一步：构建一个基础决策树 DecisionTreeRegressor(max_depth=3)。
第二步：每棵树学习前面所有树的残差（负梯度方向）。
第三步：训练 n_trees 棵树，每棵树的预测结果乘以 learning_rate 累加到最终预测值。
第四步：每次迭代后更新预测值，减少误差。

2. 用 PyTorch 实现 GBDT

虽然 GBDT 主要基于决策树，但如果你希望用 PyTorch 计算梯度并模拟 GBDT，可以如下操作：

用 PyTorch 计算 损失函数的梯度
用 sklearn.tree.DecisionTreeRegressor 拟合梯度
用 PyTorch 计算最终误差

import torch
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

# 生成数据
X, y = make_regression(n_samples=1000, n_features=5, noise=0.1, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 参数
n_trees = 50  # 多少棵树
learning_rate = 0.1  # 学习率

# 转换数据为 PyTorch 张量
X_train_torch = torch.tensor(X_train, dtype=torch.float32)
y_train_torch = torch.tensor(y_train, dtype=torch.float32)

# 初始化预测值
y_pred_train = torch.zeros_like(y_train_torch)

# 训练 GBDT
trees = []
for i in range(n_trees):
    # 计算梯度（残差）
    residuals = y_train_torch - y_pred_train

    # 用决策树拟合梯度
    tree = DecisionTreeRegressor(max_depth=3)
    tree.fit(X_train, residuals.numpy())
    trees.append(tree)

    # 更新预测值
    y_pred_train += learning_rate * torch.tensor(tree.predict(X_train), dtype=torch.float32)

    # 计算损失
    mse = mean_squared_error(y_train, y_pred_train.numpy())
    print(f"Iteration {i+1}: MSE = {mse:.4f}")

PyTorch 实现的关键点

y_train_torch - y_pred_train 计算 损失的梯度
DecisionTreeRegressor 作为弱学习器，拟合梯度
预测值 += learning_rate * tree.predict(X_train)

3. 结合 PyTorch 和 XGBoost

如果你要 结合 PyTorch 和 GBDT，可以先用 XGBoost 训练 GBDT，再用 PyTorch 进行深度学习：

import xgboost as xgb
import torch.nn as nn
import torch.optim as optim
import torch
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

# 生成数据
X, y = make_regression(n_samples=1000, n_features=5, noise=0.1, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# 训练 XGBoost 作为特征提取器
xgb_model = xgb.XGBRegressor(n_estimators=50, max_depth=3, learning_rate=0.1)
xgb_model.fit(X_train, y_train)

# 提取 XGBoost 叶子节点特征
X_train_leaves = xgb_model.apply(X_train)
X_test_leaves = xgb_model.apply(X_test)

# 定义 PyTorch 神经网络
class NeuralNet(nn.Module):
    def __init__(self, input_size):
        super(NeuralNet, self).__init__()
        self.fc = nn.Linear(input_size, 1)

    def forward(self, x):
        return self.fc(x)

# 训练 PyTorch 神经网络
model = NeuralNet(X_train_leaves.shape[1])
optimizer = optim.Adam(model.parameters(), lr=0.01)
loss_fn = nn.MSELoss()

X_train_tensor = torch.tensor(X_train_leaves, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.float32).view(-1, 1)

for epoch in range(100):
    optimizer.zero_grad()
    output = model(X_train_tensor)
    loss = loss_fn(output, y_train_tensor)
    loss.backward()
    optimizer.step()

print("Training complete!")

结论

方法	适用场景	备注
纯 Python GBDT	适合小规模数据	使用 `sklearn.tree.DecisionTreeRegressor`
PyTorch 计算梯度 + GBDT	适合梯度优化实验	计算梯度后用 `DecisionTreeRegressor` 训练
XGBoost + PyTorch	适合大规模数据	先用 XGBoost 提取特征，再用 PyTorch 训练