LightGBM算法详解

1. 概述

LightGBM是微软亚洲研究院于2017年提出的梯度提升框架，其核心设计目标是高效和可扩展。相比XGBoost，LightGBM在大规模数据集上可以快10-20倍，同时保持相当的准确率。

1.1 核心创新

技术	作用
GOSS	基于梯度的单边采样，减少计算量
EFB	互斥特征捆绑，减少特征维度
直方图算法	将连续特征离散化到bins，加速分裂
Leaf-wise	叶子优先生长策略，提高精度
直接支持类别特征	无需独热编码

1.2 性能对比

数据规模	XGBoost	LightGBM	加速比
10万样本	~50s	~10s	5×
100万样本	~8min	~1min	8×
1000万样本	~2h	~15min	8×

2. GOSS：基于梯度的单边采样

2.1 背景

在梯度提升中，大梯度样本对信息增益的贡献更大。因此，保留大梯度样本而对小梯度样本进行采样是合理的。

2.2 GOSS算法

输入: 训练数据 D, 大梯度比例 a, 小梯度比例 b

1. 计算所有样本的梯度绝对值 |g_i|

2. 选择 top-a×100% 的样本（大概率梯度）
   A = {top a × N 个样本}

3. 从剩余样本中随机采样 b×100% 的样本
   B = {从 N - |A| 中随机采样 b × N 个样本}

4. 使用采样后的数据训练树：
   - 大梯度样本权重保持: w_i = 1
   - 小梯度样本权重放大: w_i = (1-a)/b
   
   这样保持整体分布不变

2.3 理论基础

设原始数据的梯度分布为 $G$ ，采样后数据的梯度分布为 $\hat{G}$ ：

\hat{G} = \frac{1}{( 1 - a ) N} i \in / A \sum g_{i} + \frac{1}{a N} i \in A \sum g_{i}

通过权重补偿，采样后的梯度期望与原始分布一致：

E [\hat{G}] = E [G]

2.4 GOSS vs 随机采样

采样方法	大梯度样本	小梯度样本	方差
随机采样	保留a%	保留a%	较大
GOSS	保留100%	保留b%	较小

GOSS通过保留所有大梯度样本，减少了估计的方差。

3. EFB：互斥特征捆绑

3.1 稀疏特征的特性

在真实数据中，许多特征是稀疏的（如one-hot编码）。互斥特征捆绑通过将互斥的特征合并为一个特征来减少维度。

3.2 互斥的定义

两个特征互斥当且仅当它们不会同时取非零值：

\forall i : feature_{a}^{(i)} \times feature_{b}^{(i)} = 0

3.3 EFB算法

输入: 特征集合 F, 冲突阈值 K

1. 构建特征冲突图:
   - 节点: 特征
   - 边: 两个特征的冲突样本数 > K

2. 对图进行贪心着色:
   - 按度排序
   - 将特征分配到冲突最少的颜色

3. 特征捆绑:
   - 同一颜色的特征合并为一个新特征
   - 新特征的原始值 = 原始值
   - 新特征的捆绑偏移 = 累积偏移

3.4 捆绑过程

给定两个互斥特征 $f_{a}$ 和 $f_{b}$ ，捆绑特征 $f_{c}$ 为：

f_{c}^{(i)} = f_{a}^{(i)} + τ \cdot f_{b}^{(i)}

其中 $τ$ 是确保两个特征不重叠的缩放因子。

3.5 GOSS + EFB = GOSS-EFB

在实际实现中，LightGBM使用GOSS-EFB结合两者：

使用EFB减少特征维度
使用GOSS减少样本维度
两者结合实现高效训练

4. 直方图算法

4.1 直方图构建

LightGBM将连续特征离散化到固定数量的bins（默认255）：

# 伪代码
def build_histogram(feature_values, gradients, max_bins=255):
    histogram = [(0, 0)] * max_bins  # (gradient_sum, count)
    
    for value, grad in zip(feature_values, gradients):
        bin_idx = find_bin(value, max_bins)  # O(1)
        g_sum, cnt = histogram[bin_idx]
        histogram[bin_idx] = (g_sum + grad, cnt + 1)
    
    return histogram

4.2 分裂查找

使用直方图后，分裂查找只需要遍历bins而非所有样本：

For each feature j:
    For each split point s (bin boundary):
        计算 Gain = Left_score + Right_score - Parent_score
        选择最大Gain的分裂点

4.3 复杂度对比

算法	分裂查找复杂度
精确贪婪（XGBoost）	$O (N)$
近似（XGBoost）	$O (N \cdot ϵ)$
直方图（LightGBM）	$O (N_{bin s})$

当 $N_{bin s} ≪ N$ 时，直方图算法显著更快。

4.4 直方图的边界情况

特征值: [0.1, 0.3, 0.5, 0.7, 0.9]
bins:   [-∞, 0.2, 0.4, 0.6, 0.8, +∞]

样本 -> bin映射:
  0.1 -> bin 1
  0.3 -> bin 2
  0.5 -> bin 3
  ...

5. Leaf-wise生长策略

5.1 Level-wise vs Leaf-wise

策略	说明	特点
Level-wise	每层所有叶节点同时分裂	树更平衡，不易过拟合
Leaf-wise	选择最大增益的叶节点分裂	精度更高，可能过拟合

5.2 Leaf-wise算法

LightGBM(Leaf-wise):
    While depth < max_depth:
        For each leaf node:
            计算所有可能分裂的Gain
        
        选择 Gain 最大的叶节点进行分裂
        更新树结构
        
XGBoost(Level-wise):
    For depth in 1 to max_depth:
        For each leaf node at current depth:
            计算所有可能分裂的Gain
        
        For each leaf node:
            执行分裂（如果Gain > 0）

5.3 Leaf-wise的效率

Leaf-wise的分裂策略减少了搜索空间：

Level-wise: $O (N \times D \times 2^{D - 1})$ 次候选分裂评估
Leaf-wise: $O (N \times D \times L)$ 次候选分裂评估，其中 $L ≪ 2^{D - 1}$

5.4 防止过拟合

由于Leaf-wise可能生成较深的树，LightGBM使用以下策略防止过拟合：

params = {
    'num_leaves': 31,      # 限制叶节点数量
    'max_depth': -1,       # 不限制深度
    'min_data_in_leaf': 20 # 叶节点最小样本数
}

6. 类别特征支持

6.1 LightGBM的类别特征处理

LightGBM原生支持类别特征，无需独热编码：

import lightgbm as lgb
 
# 直接使用类别特征
train_data = lgb.Dataset(
    X_train, 
    label=y_train,
    categorical_feature=['category_col']  # 指定类别列
)
 
params = {
    'objective': 'binary',
    'categorical_feature': 'auto'
}

6.2 类别分裂的最优策略

LightGBM使用类别划分而非数值划分处理类别特征：

对于类别特征 C = {cat_1, cat_2, ..., cat_K}:

1. 计算每个类别的梯度统计 (G, H)

2. 对类别进行排序（按 G/H 从大到小）

3. 寻找最优的类别子集划分:
   - 划分1: {cat_1, cat_2, cat_3} vs {cat_4, cat_5, ...}
   - 划分2: {cat_1, cat_2} vs {cat_3, cat_4, ...}
   - ...

6.3 类别特征的优势

方法	类别数	需要的分裂数
独热编码 + 数值分裂	K	K-1
类别划分（LightGBM）	K	K-1（但更高效）

7. 系统优化

7.1 并行学习

LightGBM支持三种并行模式：

模式	并行维度	适用场景
特征并行	特征列	小数据集、多特征
数据并行	样本行	大数据集、少特征
Voting并行	投票聚合	超大数据集

7.2 特征并行

将特征分散到不同机器:
Machine 1: feature_1, feature_2, ...
Machine 2: feature_3, feature_4, ...

每个机器计算本地最优分裂
通过通信选出全局最优分裂

7.3 GPU加速

params = {
    'device': 'gpu',
    'gpu_platform_id': 0,
    'gpu_device_id': 0
}

7.4 分布式训练

LightGBM支持多种分布式框架：

MPI: Message Passing Interface
Spark: Apache Spark MLlib
Dask: Python并行计算库

# Spark示例
from pyspark.sql import SparkSession
from lightgbm import SparkLGBMClassifier
 
spark = SparkSession.builder.appName("LightGBM").getOrCreate()
train_df = spark.createDataFrame(pandas_df)
classifier = SparkLGBMClassifier(numIterations=100)
model = classifier.fit(train_df)

8. 参数详解

8.1 核心参数

参数	默认值	说明
`objective`	`regression`	任务类型
`boosting_type`	`gbdt`	提升类型
`num_leaves`	31	叶节点数量
`max_depth`	-1	最大深度（-1表示不限）
`learning_rate`	0.1	学习率
`n_estimators`	100	迭代次数
`min_child_samples`	20	叶节点最小样本数

8.2 正则化参数

参数	默认值	说明
`reg_alpha`	0	L1正则化
`reg_lambda`	0	L2正则化
`min_gain_to_split`	0	最小分裂增益
`feature_fraction`	1	特征采样比例
`bagging_fraction`	1	样本采样比例
`bagging_freq`	0	采样频率

8.3 GOSS和EFB参数

参数	默认值	说明
`top_rate`	0.2	大梯度样本比例
`other_rate`	0.1	小梯度样本采样比例
`max_bin`	255	最大bin数
`min_data_in_bin`	3	每个bin的最小样本数

8.4 调参建议

# 基础参数
params = {
    'objective': 'binary',
    'metric': 'auc',
    'boosting_type': 'gbdt',
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.9,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'verbose': -1
}
 
# 增加迭代次数（配合小学习率）
model = lgb.train(
    params,
    train_data,
    num_boost_round=1000,
    valid_sets=[train_data, valid_data],
    callbacks=[lgb.early_stopping(50), lgb.log_evaluation(100)]
)

9. 代码实现

9.1 基础用法

import lightgbm as lgb
import numpy as np
from sklearn.model_selection import train_test_split
 
# 加载数据
X_train, X_test, y_train, y_test = ...  # 你的数据
 
# 创建Dataset
train_data = lgb.Dataset(X_train, label=y_train)
valid_data = lgb.Dataset(X_test, label=y_test, reference=train_data)
 
# 参数配置
params = {
    'objective': 'binary',
    'metric': 'auc',
    'boosting_type': 'gbdt',
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.9,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'verbose': -1,
    'seed': 42
}
 
# 训练
model = lgb.train(
    params,
    train_data,
    num_boost_round=1000,
    valid_sets=[train_data, valid_data],
    callbacks=[
        lgb.early_stopping(stopping_rounds=50),
        lgb.log_evaluation(period=100)
    ]
)
 
# 预测
predictions = model.predict(X_test, num_iteration=model.best_iteration)
 
# 特征重要性
importance = model.feature_importance(importance_type='gain')

9.2 回归任务

params = {
    'objective': 'regression',
    'metric': 'rmse',
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.9
}
 
model = lgb.train(params, train_data, num_boost_round=1000)
predictions = model.predict(X_test)

9.3 多分类任务

params = {
    'objective': 'multiclass',
    'num_class': 3,
    'metric': 'multi_logloss'
}
 
train_data = lgb.Dataset(X_train, label=y_train)  # y是0/1/2
model = lgb.train(params, train_data, num_boost_round=1000)
 
# 预测概率
predictions = model.predict(X_test)  # shape: (N, 3)

9.4 自定义损失函数

# 自定义MSE损失
def mse_loss(y_pred, train_data):
    y_true = train_data.get_label()
    grad = y_pred - y_true
    hess = np.ones_like(grad)
    return grad, hess
 
# 自定义评估指标
def rmsle_eval(y_pred, train_data):
    y_true = train_data.get_label()
    rmsle = np.sqrt(np.mean((np.log1p(y_pred) - np.log1p(y_true)) ** 2))
    return 'rmsle', rmsle, False  # False表示越小越好
 
params = {
    'objective': mse_loss,
    'metric': 'None'  # 不使用默认metric
}
 
model = lgb.train(
    params,
    train_data,
    num_boost_round=1000,
    valid_sets=[train_data],
    feval=rmsle_eval
)

9.5 交叉验证

# 5折交叉验证
cv_results = lgb.cv(
    params,
    train_data,
    num_boost_round=1000,
    nfold=5,
    stratified=True,  # 分类任务分层采样
    metrics=['auc'],
    callbacks=[lgb.early_stopping(50), lgb.log_evaluation(100)]
)
 
print(f"Best CV AUC: {max(cv_results['valid auc-mean']):.4f}")

10. 与XGBoost的对比

10.1 算法层面

特性	XGBoost	LightGBM
生长策略	Level-wise	Leaf-wise
分裂算法	精确/近似	直方图+GOSS
类别特征	需One-Hot	原生支持
内存占用	较大	较小（直方图+EFB）
稀疏优化	稀疏感知设计	原生稀疏支持
正则化	L1/L2/γ	L1/L2/叶节点数

10.2 系统层面

特性	XGBoost	LightGBM
训练速度	中等	最快
GPU支持	是	是
分布式	是	是
API风格	原生C++	scikit-learn兼容

10.3 实际选择建议

选择 LightGBM 当:
- 数据量 > 100万样本
- 需要快速迭代开发
- 特征是稀疏的
- 需要原生类别特征支持

选择 XGBoost 当:
- 需要更稳定的性能
- 需要更多的正则化选项
- 部署到生产环境需要更严格的测试

11. 高级技巧

11.1 提升准确率

params = {
    'num_leaves': 127,      # 增大叶节点数
    'min_data_in_leaf': 10, # 减小最小样本数
    'feature_fraction': 0.8, # 特征采样
    'bagging_fraction': 0.8, # 样本采样
    'learning_rate': 0.01,  # 减小学习率
    'n_estimators': 3000    # 增加迭代次数
}

11.2 防止过拟合

params = {
    'num_leaves': 15,       # 减小叶节点数
    'max_depth': 5,         # 限制深度
    'min_data_in_leaf': 50, # 增加最小样本数
    'reg_alpha': 0.1,       # L1正则化
    'reg_lambda': 0.1,       # L2正则化
    'feature_fraction': 0.7, # 特征采样
    'bagging_fraction': 0.7, # 样本采样
    'bagging_freq': 1        # 每次迭代都采样
}

11.3 特征重要性可视化

import matplotlib.pyplot as plt
 
# 获取特征重要性
importance = model.feature_importance(importance_type='gain')
feature_names = X_train.columns
indices = np.argsort(importance)[::-1]
 
# 绘制
plt.figure(figsize=(10, 6))
plt.title("Feature Importance")
plt.bar(range(len(indices)), importance[indices])
plt.xticks(range(len(indices)), [feature_names[i] for i in indices], rotation=45)
plt.tight_layout()
plt.show()

Metaphor

探索