LightGBM 简介 #

┌─────────────────────────────────────────────────────────────┐
│                        LightGBM                              │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  直方图算法  │  │   GOSS     │  │    EFB      │         │
│  │ Histogram   │  │ 梯度采样   │  │ 特征捆绑    │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │ Leaf-wise   │  │ 类别特征    │  │ 分布式训练  │         │
│  │ 叶子生长    │  │ 原生支持    │  │ 高可扩展    │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
└─────────────────────────────────────────────────────────────┘

2016年 ─── LightGBM 项目启动
    │
    │      Microsoft 亚洲研究院
    │      针对大规模数据优化
    │      提出 GOSS 和 EFB 算法
    │
2017年 ─── GitHub 开源
    │
    │      正式开源发布
    │      Kaggle 竞赛广泛应用
    │      性能惊艳众人
    │
2018年 ─── 功能增强
    │
    │      GPU 训练支持
    │      类别特征优化
    │      分布式训练完善
    │
2019年 ─── 生态扩展
    │
    │      Python API 完善
    │      R 接口支持
    │      更多评估指标
    │
2020年 ─── 持续优化
    │
    │      新的叶子生长策略
    │      内存优化
    │      训练速度提升
    │
至今   ─── 广泛应用
    │
    │      Kaggle 竞赛首选
    │      工业界大规模应用
    │      活跃的开源社区

┌─────────────────────────────────────────────────────────────┐
│                    传统 GBDT 的问题                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. 训练速度慢                                               │
│     - 需要遍历所有数据点找最优分裂点                         │
│     - 时间复杂度 O(#data × #feature)                        │
│                                                             │
│  2. 内存占用高                                               │
│     - 需要存储预排序的索引                                   │
│     - 内存消耗是数据量的 2 倍                               │
│                                                             │
│  3. 不支持类别特征                                           │
│     - 需要独热编码                                          │
│     - 特征维度爆炸                                          │
│                                                             │
│  4. 并行效率低                                               │
│     - 难以高效并行                                          │
│     - 通信开销大                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    LightGBM 的解决方案                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ✅ 直方图算法                                               │
│     - 连续特征离散化                                        │
│     - 时间复杂度 O(k × #feature)，k << #data               │
│                                                             │
│  ✅ 内存优化                                                 │
│     - 只存储离散直方图                                      │
│     - 内存使用减少 1/8                                      │
│                                                             │
│  ✅ 类别特征原生支持                                         │
│     - 无需独热编码                                          │
│     - 最优分割算法                                          │
│                                                             │
│  ✅ 高效并行                                                 │
│     - 特征并行、数据并行                                    │
│     - 投票并行降低通信                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

import numpy as np

def histogram_binning(feature_values, k=255):
    """
    将连续特征离散化为 k 个桶
    """
    min_val, max_val = feature_values.min(), feature_values.max()
    bin_width = (max_val - min_val) / k
    
    bin_indices = ((feature_values - min_val) / bin_width).astype(int)
    bin_indices = np.clip(bin_indices, 0, k - 1)
    
    return bin_indices

data = np.array([1.2, 3.5, 2.1, 4.8, 0.5])
bins = histogram_binning(data, k=4)
print(f"原始数据: {data}")
print(f"离散化后: {bins}")

import numpy as np

def goss_sampling(gradients, a=0.1, b=0.1):
    """
    GOSS 采样策略
    a: 保留大梯度样本的比例
    b: 随机采样小梯度样本的比例
    """
    n_samples = len(gradients)
    abs_gradients = np.abs(gradients)
    
    n_top = int(n_samples * a)
    top_indices = np.argsort(abs_gradients)[-n_top:]
    
    remaining_indices = np.setdiff1d(np.arange(n_samples), top_indices)
    n_random = int(len(remaining_indices) * b)
    random_indices = np.random.choice(remaining_indices, n_random, replace=False)
    
    selected_indices = np.concatenate([top_indices, random_indices])
    
    weights = np.ones(n_samples)
    weights[random_indices] = (1 - a) / b
    
    return selected_indices, weights

gradients = np.array([0.1, 0.5, 0.01, 0.8, 0.02, 0.3])
indices, weights = goss_sampling(gradients, a=0.3, b=0.2)
print(f"选中的样本索引: {indices}")
print(f"样本权重: {weights[indices]}")

import numpy as np

def find_exclusive_features(feature_matrix, threshold=0.01):
    """
    找出互斥特征（很少同时非零的特征）
    """
    n_features = feature_matrix.shape[1]
    conflict_matrix = np.zeros((n_features, n_features))
    
    for i in range(n_features):
        for j in range(i + 1, n_features):
            conflict = np.sum((feature_matrix[:, i] != 0) & 
                            (feature_matrix[:, j] != 0))
            conflict_matrix[i, j] = conflict / len(feature_matrix)
    
    bundles = []
    used = set()
    
    for i in range(n_features):
        if i in used:
            continue
        bundle = [i]
        for j in range(i + 1, n_features):
            if j not in used and conflict_matrix[i, j] < threshold:
                bundle.append(j)
                used.add(j)
        bundles.append(bundle)
        used.add(i)
    
    return bundles

features = np.array([
    [1, 0, 0, 2],
    [0, 3, 0, 0],
    [0, 0, 4, 0],
    [5, 0, 0, 0]
])

bundles = find_exclusive_features(features)
print(f"特征捆绑组: {bundles}")

class TreeNode:
    def __init__(self, value=None):
        self.value = value
        self.left = None
        self.right = None
        self.split_feature = None
        self.split_value = None

def leaf_wise_growth(X, y, max_depth=3, min_samples=10):
    """
    Leaf-wise 生长策略
    每次选择增益最大的叶子节点分裂
    """
    root = TreeNode()
    leaves = [(root, np.arange(len(X)), 0)]
    
    while leaves and leaves[0][2] < max_depth:
        leaves.sort(key=lambda x: -x[2])
        node, indices, depth = leaves.pop(0)
        
        if len(indices) < min_samples:
            node.value = np.mean(y[indices])
            continue
        
        best_gain = -np.inf
        best_split = None
        
        for feature in range(X.shape[1]):
            values = np.unique(X[indices, feature])
            for val in values:
                left_idx = indices[X[indices, feature] <= val]
                right_idx = indices[X[indices, feature] > val]
                
                if len(left_idx) < min_samples or len(right_idx) < min_samples:
                    continue
                
                gain = calculate_gain(y[indices], y[left_idx], y[right_idx])
                if gain > best_gain:
                    best_gain = gain
                    best_split = (feature, val, left_idx, right_idx)
        
        if best_split:
            node.split_feature = best_split[0]
            node.split_value = best_split[1]
            node.left = TreeNode()
            node.right = TreeNode()
            
            leaves.append((node.left, best_split[2], depth + 1))
            leaves.append((node.right, best_split[3], depth + 1))
        else:
            node.value = np.mean(y[indices])
    
    for node, indices, _ in leaves:
        node.value = np.mean(y[indices])
    
    return root

def calculate_gain(parent, left, right):
    """计算分裂增益"""
    def variance(arr):
        return np.var(arr) * len(arr)
    
    gain = variance(parent) - variance(left) - variance(right)
    return gain

┌─────────────────────────────────────────────────────────────┐
│                    训练速度对比                              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  XGBoost   ████████████████████████████████████  1x         │
│                                                              │
│  LightGBM  ████                                  20x         │
│                                                              │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    内存占用对比                              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  XGBoost   ████████████████████████████████████  1x         │
│                                                              │
│  LightGBM  ██████                               1/8          │
│                                                              │
└─────────────────────────────────────────────────────────────┘

import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2
)

train_data = lgb.Dataset(X_train, label=y_train)

params = {
    'objective': 'binary',
    'metric': 'auc',
    'num_leaves': 31,
    'learning_rate': 0.05
}

model = lgb.train(params, train_data, num_boost_round=100)
predictions = model.predict(X_test)

from sklearn.datasets import load_iris

data = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2
)

train_data = lgb.Dataset(X_train, label=y_train)

params = {
    'objective': 'multiclass',
    'num_class': 3,
    'metric': 'multi_logloss',
    'num_leaves': 31
}

model = lgb.train(params, train_data, num_boost_round=100)
predictions = model.predict(X_test)
predictions = predictions.argmax(axis=1)

from sklearn.datasets import load_diabetes

data = load_diabetes()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2
)

train_data = lgb.Dataset(X_train, label=y_train)

params = {
    'objective': 'regression',
    'metric': 'rmse',
    'num_leaves': 31
}

model = lgb.train(params, train_data, num_boost_round=100)
predictions = model.predict(X_test)

import numpy as np

query_train = np.array([100, 100, 100, 50, 50])
X_train = np.random.randn(400, 10)
y_train = np.random.randint(0, 5, 400)

train_data = lgb.Dataset(X_train, label=y_train, group=query_train)

params = {
    'objective': 'lambdarank',
    'metric': 'ndcg',
    'num_leaves': 31
}

model = lgb.train(params, train_data, num_boost_round=100)

✅ 极快的训练速度
   - 直方图算法加速
   - GOSS 减少样本量
   - EFB 减少特征量

✅ 低内存占用
   - 直方图存储
   - uint8 替代 float32
   - 内存效率高

✅ 高准确率
   - Leaf-wise 策略
   - 类别特征最优分割
   - 正则化效果

✅ 大规模支持
   - 分布式训练
   - GPU 加速
   - 亿级数据处理

✅ 易于使用
   - 简洁的 API
   - 丰富的参数
   - 活跃的社区

⚠️ 可能过拟合
   - Leaf-wise 策略可能过拟合
   - 需要限制 max_depth

⚠️ 参数较多
   - 需要理解各参数含义
   - 调参需要经验

⚠️ 小数据集优势不明显
   - 数据量小时优势不明显
   - 可能不如简单模型

⚠️ 类别特征需要预处理
   - 需要转换为整数编码
   - 需要指定类别特征列

入门阶段
├── LightGBM 简介（本文）
├── 安装与配置
├── 第一个模型
└── 核心概念

基础阶段
├── 数据接口
├── 参数配置
├── 训练与预测
└── 模型评估

进阶阶段
├── GBDT 基础
├── 直方图算法
├── GOSS 算法
└── EFB 算法

高级阶段
├── 特征工程
├── 调参技巧
├── 类别特征处理
└── 缺失值处理

专家阶段
├── 单机并行
├── 分布式训练
├── GPU 加速
└── 实战项目