本文是销量预测系列的深度技术文，聚焦机器学习中最核心的超参数调优环节。LightGBM因其高效、精度高、支持大规模数据等优点，成为Kaggle竞赛和工业实践中的首选模型。但很多同学只知道简单的learning_rate=0.1, n_estimators=100调参，实际上LightGBM有几十个可调参数，每个参数背后都有深刻的机器学习理论支撑。本文将从参数分类、理论解释、实战调参策略、贝叶斯优化到完整的调参代码，全方位提升你的调参功力。

一、LightGBM架构解析：为什么它这么快？

LightGBM vs XGBoost：技术原理对比

在深入调参之前，理解LightGBM的工作原理能帮助我们更好地理解每个参数的作用。

特性	LightGBM	XGBoost
分裂策略	Leaf-wise（叶-wise）	Level-wise（层-wise）
分裂点查找	Gradient-based One-Side Sampling (GOSS)	Pre-sorted / Histogram
内存优化	直方图缓存、类别特征原生支持	相对较高
并行化	特征并行、数据并行	特征并行
稀疏数据处理	无需额外处理	需要稀疏矩阵优化
训练速度	快2-10倍	中等
精度	通常相当	通常相当

Leaf-wise vs Level-wise

Level-wise (XGBoost):
        根节点
        /  |  \
      L1   L1   L1      <- 每一层所有节点都分裂
     / \  / \  / \
    L2 L2 L2 L2 L2 L2   <- 深度优先展开所有层

Leaf-wise (LightGBM):
        根节点
           |
         左子节点       <- 只分裂能最大减少损失的叶子节点
           |
        左子节点       <- 继续分裂该叶子
           |
        最优叶子       <- 深度更深但叶子数更少

为什么Leaf-wise更快？

因为LightGBM只分裂能带来最大增益的叶子节点，而不是逐层分裂所有节点。这减少了无效分裂，大幅提高了效率。

GOSS（梯度单边采样）

传统的梯度提升需要对所有样本计算梯度来确定分裂点，计算量大。GOSS的核心思想是：

1. 保留大梯度样本：梯度大的样本对信息增益贡献大，全部保留
2. 采样小梯度样本：对梯度小的样本随机采样，减少计算量
3. 补偿权重：给采样的小梯度样本更高的权重，保持数据分布

原始梯度分布:  ████████████████░░░░░░░░
               大梯度          小梯度
               (全保留)        (随机采样)

GOSS后:        ████████████████░░░ (保留部分小梯度样本，权重补偿)

二、参数分类：一张图说清楚LightGBM参数体系

按功能分类的完整参数表

LightGBM参数体系
├── 核心控制参数
│   ├── task: 任务类型 (train/predict)
│   ├── objective: 目标函数 (regression/classification)
│   ├── boosting_type: 提升类型 (gbdt/dart/goss)
│   ├── device: 计算设备 (cpu/gpu)
│   └── num_threads: 线程数
│
├── 目标函数参数
│   ├── objective: 回归: mse/mae/huber/quantile
│   │           分类: binary/multiclass
│   │           排序: lambdarank
│   └── metric: 评估指标
│
├── 树的参数
│   ├── num_leaves: 叶子节点数 (重要！)
│   ├── max_depth: 最大深度
│   ├── min_child_samples/min_child_weight: 叶节点最小样本数/权重
│   ├── min_split_gain: 最小分裂增益
│   ├── max_bin: 最大分桶数
│   ├── subsample: 行采样比例
│   ├── subsample_freq: 行采样频率
│   ├── colsample_bytree: 列采样比例
│   └── reg_alpha/reg_lambda: L1/L2正则化
│
├── 学习参数
│   ├── learning_rate: 学习率
│   ├── n_estimators: 迭代次数
│   ├── early_stopping_rounds: 早停轮数
│   └── num_iterations: 迭代次数（别名）
│
├── GOSS参数 (GOSS boosting专用)
│   ├── top_rate: 大梯度样本保留比例
│   └── other_rate: 小梯度样本采样比例
│
├── DART参数 (DART boosting专用)
│   ├── drop_rate: Dropout比例
│   ├── max_drop: 每轮最大drop数
│   └── skip_drop: 跳过drop的概率
│
└── 其他参数
    ├── seed: 随机种子
    ├── verbose: 日志详细程度
    ├── importance_type: 特征重要性类型
    └── silent: 是否静默模式

三、核心参数详解：从原理到实践

1. num_leaves —— 最重要的参数

作用：控制单棵树的最大叶子节点数

默认值：31

理论背景：叶子节点数决定了模型的复杂度。假设深度为D，Level-wise树的叶子数最多为2^{D，但Leaf-wise树的叶子数可以超过2}D（因为同一深度的叶子可能不在同一层）。

经验公式：

推荐值：num_leaves = 2^(max_depth) - 1  # 这是避免过拟合的上限
但更保守的公式：num_leaves = 2^(max_depth-1)

例如：max_depth=7 → num_leaves ≤ 127

实战建议：

样本量	num_leaves建议范围	备注
< 10,000	15-31	小数据集容易过拟合
10,000-100,000	31-63	适中
100,000-1,000,000	63-127	大数据量
> 1,000,000	127-255	超大数据量

过拟合时的调整策略：

# 如果validation loss上升（过拟合）
# 策略1：减少num_leaves
params['num_leaves'] = 31 → 15

# 策略2：同时增加max_depth限制
params['max_depth'] = 7  # 配合num_leaves限制复杂度

2. learning_rate 与 n_estimators —— 学习率的艺术

作用：

• learning_rate：每次迭代对模型的修正幅度
• n_estimators：迭代次数

核心矛盾：

学习率高（如0.3）→ 收敛快 → 迭代次数少 → 可能欠拟合
学习率低（如0.01）→ 收敛慢 → 迭代次数多 → 可能过拟合

经典结论：树的集成模型中，较小的学习率配合更多的迭代通常能取得更好的泛化性能。

实战建议：

# 标准配置
learning_rate = 0.05  # 适中的学习率
n_estimators = 500    # 配合early_stopping

# 高精度配置
learning_rate = 0.01  # 低学习率
n_estimators = 2000   # 更多的树
early_stopping_rounds = 100  # 早停防止过拟合

# 快速实验配置
learning_rate = 0.1   # 高学习率
n_estimators = 100    # 快速看baseline效果

调度学习率（Learning Rate Scheduling）：

# 方案1：指数衰减
params = {
    'learning_rate': 0.05,
    'lr_schedule': {
        'type': 'exp',
        'decay_rate': 0.95,
        'decay_steps': 50
    }
}

# 方案2：阶梯衰减
def lgb_decay_schedule(epoch):
    if epoch < 100:
        return 0.1
    elif epoch < 200:
        return 0.05
    elif epoch < 300:
        return 0.01
    else:
        return 0.005

# 方案3：余弦退火
params = {
    'learning_rate': 0.05,
    'lr_schedule': {
        'type': 'cosine',
        'warmup_epochs': 10,
        'min_lr': 0.001
    }
}

3. 正则化三剑客：reg_alpha、reg_lambda、min_child_samples

reg_alpha（L1正则化）：

• 对应线性回归中的Lasso
• 会让部分特征权重变为0，实现特征选择
• 适合高维稀疏数据

reg_lambda（L2正则化）：

• 对应线性回归中的Ridge
• 让所有特征权重都趋近于0但不等于0
• 适合大多数场景

min_child_samples（叶节点最小样本数）：

• 防止过拟合的硬限制
• 值越大，模型越保守

实战配置：

# 标准配置（防止过拟合）
params = {
    'reg_alpha': 0.1,          # L1正则
    'reg_lambda': 1.0,         # L2正则
    'min_child_samples': 20    # 叶节点最少20个样本
}

# 高维稀疏数据（如文本特征）
params = {
    'reg_alpha': 1.0,          # 增大L1进行特征选择
    'reg_lambda': 0.1,         # 减小L2
    'min_child_samples': 50    # 保守一些
}

# 大数据量
params = {
    'reg_alpha': 0.01,
    'reg_lambda': 0.5,
    'min_child_samples': 100   # 数据多，可以设大一些
}

4. 采样参数：subsample、colsample_bytree

subsample（行采样）：

• 每次迭代随机选择部分样本训练
• 默认1.0（不使用），推荐0.7-0.9
• 类似于随机森林的样本抽样

colsample_bytree（列采样）：

• 每次迭代随机选择部分特征
• 默认1.0（不使用），推荐0.6-0.9
• 强烈推荐使用，能有效减少过拟合

实战配置：

# 推荐的采样配置
params = {
    'subsample': 0.8,           # 80%的样本
    'subsample_freq': 1,        # 每轮都采样
    'colsample_bytree': 0.8,    # 80%的特征
}

# 极致防止过拟合
params = {
    'subsample': 0.7,
    'colsample_bytree': 0.6,
}

5. max_bin 与 feature_pre_filter

max_bin（最大分桶数）：

• LightGBM使用直方图算法，将连续特征离散化
• max_bin越大，精度越高，但计算量越大
• 默认255，通常不需要调整

# 标准场景
max_bin = 255

# 高精度需求（计算资源充足）
max_bin = 511

# 高速需求（大数据量）
max_bin = 127

feature_pre_filter（特征预过滤）：

• 如果设为True，训练前会按特征重要性过滤低贡献特征
• 默认True，可能影响特征选择结果

四、调参策略：从盲目到科学

策略1：Grid Search（网格搜索）

适用场景：小数据集、参数空间较小

from sklearn.model_selection import GridSearchCV
import lightgbm as lgb

# 定义参数网格
param_grid = {
    'num_leaves': [31, 63, 127],
    'learning_rate': [0.01, 0.05, 0.1],
    'n_estimators': [100, 500, 1000],
    'min_child_samples': [10, 20, 50],
}

# 基础模型
base_model = lgb.LGBMRegressor(
    objective='regression',
    random_state=42,
    n_jobs=-1
)

# 网格搜索
grid_search = GridSearchCV(
    base_model,
    param_grid,
    cv=5,
    scoring='neg_mean_absolute_percentage_error',
    verbose=2,
    n_jobs=-1
)

grid_search.fit(X_train, y_train)

print(f"最佳参数: {grid_search.best_params_}")
print(f"最佳CV分数: {-grid_search.best_score_:.4f}")

问题：参数组合数 = 3×3×3×3 = 81，如果再加参数会爆炸。

策略2：Random Search（随机搜索）

适用场景：参数空间大、计算资源有限

理论证明：在相同的尝试次数下，随机搜索比网格搜索更容易找到最优参数，因为它不执着于"均匀分布"。

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

param_dist = {
    'num_leaves': randint(15, 255),
    'learning_rate': uniform(0.01, 0.3),
    'n_estimators': randint(100, 2000),
    'min_child_samples': randint(5, 100),
    'subsample': uniform(0.6, 0.4),
    'colsample_bytree': uniform(0.6, 0.4),
    'reg_alpha': uniform(0, 2),
    'reg_lambda': uniform(0, 2),
}

random_search = RandomizedSearchCV(
    lgb.LGBMRegressor(objective='regression', random_state=42),
    param_dist,
    n_iter=100,  # 随机尝试100种组合
    cv=5,
    scoring='neg_mean_absolute_percentage_error',
    random_state=42,
    n_jobs=-1
)

random_search.fit(X_train, y_train)

策略3：贝叶斯优化（推荐）

适用场景：参数空间大、每次评估代价高

贝叶斯优化的核心思想：利用历史评估结果，建立代理模型（Surrogate Model），预测哪些参数组合可能表现更好，然后智能地选择下一组参数测试。

from optuna.integration import LightGBMPruningCallback
import optuna
from sklearn.model_selection import cross_val_score
import numpy as np

def objective(trial, X, y):
    """Optuna目标函数"""
    
    params = {
        # 搜索空间
        'objective': 'regression',
        'metric': 'mape',
        'boosting_type': 'gbdt',
        'verbosity': -1,
        'random_state': 42,
        'n_jobs': -1,
        
        # 树结构参数
        'num_leaves': trial.suggest_int('num_leaves', 15, 255),
        'max_depth': trial.suggest_int('max_depth', 3, 12),
        'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),
        'min_child_weight': trial.suggest_float('min_child_weight', 1e-5, 10, log=True),
        
        # 采样参数
        'subsample': trial.suggest_float('subsample', 0.5, 1.0),
        'subsample_freq': trial.suggest_categorical('subsample_freq', [1]),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        
        # 正则化
        'reg_alpha': trial.suggest_float('reg_alpha', 1e-8, 10.0, log=True),
        'reg_lambda': trial.suggest_float('reg_lambda', 1e-8, 10.0, log=True),
        
        # 学习参数
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'n_estimators': trial.suggest_int('n_estimators', 100, 2000),
    }
    
    # 5折交叉验证
    cv_scores = []
    skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
    
    # 分层标签（用于回归，取y的分箱）
    y_binned = pd.cut(y, bins=10, labels=False)
    
    for train_idx, val_idx in skf.split(X, y_binned):
        X_train_fold, X_val_fold = X.iloc[train_idx], X.iloc[val_idx]
        y_train_fold, y_val_fold = y.iloc[train_idx], y.iloc[val_idx]
        
        model = lgb.LGBMRegressor(**params)
        model.fit(
            X_train_fold, y_train_fold,
            eval_set=[(X_val_fold, y_val_fold)],
            callbacks=[lgb.early_stopping(50, verbose=False)]
        )
        
        y_pred = model.predict(X_val_fold)
        mape = np.mean(np.abs((y_val_fold - y_pred) / (y_val_fold + 1))) * 100
        cv_scores.append(mape)
    
    return np.mean(cv_scores)


# 运行优化
study = optuna.create_study(
    direction='minimize',
    study_name='lightgbm_optimization',
    storage='sqlite:///optuna_study.db',
    load_if_exists=True
)

study.optimize(
    lambda trial: objective(trial, X_train, y_train),
    n_trials=100,  # 尝试100种组合
    timeout=3600,  # 最多运行1小时
    show_progress_bar=True
)

print(f"最佳MAPE: {study.best_value:.4f}%")
print(f"最佳参数: {study.best_params}")

策略4：渐进式调参（推荐流程）

最实用的调参策略，按顺序逐类调整：

class LGBMProgressiveTuner:
    """LightGBM渐进式调参器"""
    
    def __init__(self, X, y, cv=5):
        self.X = X
        self.y = y
        self.cv = cv
        self.best_params = {}
    
    def tune_step1_tree_structure(self):
        """第一步：调树结构参数"""
        print("="*50)
        print("Step 1: 调树结构参数")
        print("="*50)
        
        param_grid = {
            'num_leaves': [15, 31, 63, 127, 255],
            'max_depth': [4, 6, 8, 10, 12, -1],
            'min_child_samples': [10, 20, 50, 100],
        }
        
        best_score = float('inf')
        best_combo = None
        
        for num_leaves in param_grid['num_leaves']:
            for max_depth in param_grid['max_depth']:
                for min_child in param_grid['min_child_samples']:
                    params = {
                        'n_estimators': 500,
                        'learning_rate': 0.05,
                        'num_leaves': num_leaves,
                        'max_depth': max_depth,
                        'min_child_samples': min_child,
                    }
                    
                    score = self._cv_score(params)
                    print(f"num_leaves={num_leaves}, max_depth={max_depth}, min_child={min_child} → MAPE={score:.4f}")
                    
                    if score < best_score:
                        best_score = score
                        best_combo = params.copy()
        
        self.best_params.update(best_combo)
        print(f"\n最佳树结构: MAPE={best_score:.4f}")
        print(f"参数: {best_combo}")
    
    def tune_step2_sampling(self):
        """第二步：调采样参数"""
        print("\n" + "="*50)
        print("Step 2: 调采样参数")
        print("="*50)
        
        base_params = self.best_params.copy()
        base_params['n_estimators'] = 1000
        base_params['learning_rate'] = 0.02
        
        param_grid = {
            'subsample': [0.6, 0.7, 0.8, 0.9, 1.0],
            'colsample_bytree': [0.6, 0.7, 0.8, 0.9, 1.0],
        }
        
        best_score = float('inf')
        
        for subsample in param_grid['subsample']:
            for colsample in param_grid['colsample_bytree']:
                params = base_params.copy()
                params['subsample'] = subsample
                params['colsample_bytree'] = colsample
                
                score = self._cv_score(params)
                print(f"subsample={subsample}, colsample={colsample} → MAPE={score:.4f}")
                
                if score < best_score:
                    best_score = score
                    self.best_params.update(params)
        
        print(f"\n加入采样参数后: MAPE={best_score:.4f}")
    
    def tune_step3_regularization(self):
        """第三步：调正则化参数"""
        print("\n" + "="*50)
        print("Step 3: 调正则化参数")
        print("="*50)
        
        param_grid = {
            'reg_alpha': [0, 0.01, 0.1, 1.0, 10.0],
            'reg_lambda': [0, 0.01, 0.1, 1.0, 10.0],
        }
        
        best_score = float('inf')
        
        for alpha in param_grid['reg_alpha']:
            for lambda_val in param_grid['reg_lambda']:
                params = self.best_params.copy()
                params['reg_alpha'] = alpha
                params['reg_lambda'] = lambda_val
                
                score = self._cv_score(params)
                print(f"reg_alpha={alpha}, reg_lambda={lambda_val} → MAPE={score:.4f}")
                
                if score < best_score:
                    best_score = score
                    self.best_params.update(params)
        
        print(f"\n加入正则化后: MAPE={best_score:.4f}")
    
    def tune_step4_learning_rate(self):
        """第四步：细调学习率"""
        print("\n" + "="*50)
        print("Step 4: 细调学习率")
        print("="*50)
        
        best_score = float('inf')
        best_lr = None
        
        for lr in [0.005, 0.01, 0.02, 0.03, 0.05]:
            params = self.best_params.copy()
            params['learning_rate'] = lr
            params['n_estimators'] = int(500 / lr)  # 学习率越小，树越多
            
            score = self._cv_score(params, early_stopping=100)
            print(f"learning_rate={lr}, n_estimators={params['n_estimators']} → MAPE={score:.4f}")
            
            if score < best_score:
                best_score = score
                best_lr = lr
                self.best_params.update(params)
        
        print(f"\n最终MAPE: {best_score:.4f}")
        print(f"最佳学习率: {best_lr}")
    
    def _cv_score(self, params, early_stopping=None):
        """计算交叉验证分数"""
        model = lgb.LGBMRegressor(**params, random_state=42, verbosity=-1)
        
        skf = StratifiedKFold(n_splits=self.cv, shuffle=True, random_state=42)
        y_binned = pd.cut(self.y, bins=10, labels=False)
        
        scores = []
        for train_idx, val_idx in skf.split(self.X, y_binned):
            X_tr, X_val = self.X.iloc[train_idx], self.X.iloc[val_idx]
            y_tr, y_val = self.y.iloc[train_idx], self.y.iloc[val_idx]
            
            if early_stopping:
                model.fit(X_tr, y_tr,
                         eval_set=[(X_val, y_val)],
                         callbacks=[lgb.early_stopping(early_stopping, verbose=False)])
            else:
                model.fit(X_tr, y_tr)
            
            y_pred = model.predict(X_val)
            mape = np.mean(np.abs((y_val - y_pred) / (y_val + 1))) * 100
            scores.append(mape)
        
        return np.mean(scores)
    
    def run(self):
        """运行完整调参流程"""
        self.tune_step1_tree_structure()
        self.tune_step2_sampling()
        self.tune_step3_regularization()
        self.tune_step4_learning_rate()
        
        print("\n" + "="*50)
        print("最终最佳参数:")
        print("="*50)
        for k, v in self.best_params.items():
            print(f"  {k}: {v}")
        
        return self.best_params


# 使用示例
tuner = LGBMProgressiveTuner(X_train, y_train)
best_params = tuner.run()

五、实战：销量预测完整调参案例

完整的调参脚本

import lightgbm as lgb
import numpy as np
import pandas as pd
from sklearn.model_selection import KFold
from sklearn.metrics import mean_absolute_percentage_error
import warnings
warnings.filterwarnings('ignore')

def train_lgb_with_tuning(X_train, y_train, X_test, param_space=None):
    """
    完整的光GBM训练和调参流程
    """
    
    # 默认参数空间
    if param_space is None:
        param_space = {
            'objective': 'regression',
            'metric': 'mape',
            'boosting_type': 'gbdt',
            'random_state': 42,
            'n_jobs': -1,
            'verbosity': -1,
            
            # 基础参数（经验值）
            'num_leaves': 63,
            'max_depth': 8,
            'min_child_samples': 20,
            'learning_rate': 0.05,
            'n_estimators': 500,
            
            # 采样参数
            'subsample': 0.8,
            'subsample_freq': 1,
            'colsample_bytree': 0.8,
            
            # 正则化
            'reg_alpha': 0.1,
            'reg_lambda': 1.0,
            
            # 其他
            'max_bin': 255,
            'feature_pre_filter': False,
        }
    
    # 特征列表（用于LightGBM原生类别特征支持）
    categorical_features = ['store', 'family', 'city', 'state', 'type']
    cat_features = [f for f in categorical_features if f in X_train.columns]
    
    # K-Fold交叉验证
    n_folds = 5
    kf = KFold(n_splits=n_folds, shuffle=True, random_state=42)
    
    oof_predictions = np.zeros(len(X_train))
    test_predictions = np.zeros(len(X_test))
    feature_importance = pd.DataFrame()
    
    fold_scores = []
    
    for fold, (train_idx, val_idx) in enumerate(kf.split(X_train)):
        print(f"\n{'='*50}")
        print(f"Fold {fold + 1}/{n_folds}")
        print(f"{'='*50}")
        
        X_tr, X_val = X_train.iloc[train_idx], X_train.iloc[val_idx]
        y_tr, y_val = y_train.iloc[train_idx], y_train.iloc[val_idx]
        
        # 创建数据集
        train_data = lgb.Dataset(
            X_tr, label=y_tr,
            categorical_feature=cat_features
        )
        val_data = lgb.Dataset(
            X_val, label=y_val,
            categorical_feature=cat_features,
            reference=train_data
        )
        
        # 训练模型
        model = lgb.train(
            param_space,
            train_data,
            valid_sets=[train_data, val_data],
            valid_names=['train', 'valid'],
            callbacks=[
                lgb.early_stopping(stopping_rounds=50),
                lgb.log_evaluation(period=100)
            ]
        )
        
        # 验证集预测
        val_pred = model.predict(X_val, num_iteration=model.best_iteration)
        oof_predictions[val_idx] = val_pred
        
        # 测试集预测
        test_pred = model.predict(X_test, num_iteration=model.best_iteration)
        test_predictions += test_pred / n_folds
        
        # 计算本Fold的MAPE
        fold_mape = mean_absolute_percentage_error(y_val, val_pred) * 100
        fold_scores.append(fold_mape)
        print(f"Fold {fold + 1} MAPE: {fold_mape:.4f}%")
        
        # 特征重要性
        fold_importance = pd.DataFrame({
            'feature': X_train.columns,
            'importance': model.feature_importance(importance_type='gain'),
            'fold': fold + 1
        })
        feature_importance = pd.concat([feature_importance, fold_importance], axis=0)
    
    # 总体评估
    overall_mape = mean_absolute_percentage_error(y_train, oof_predictions) * 100
    print(f"\n{'='*50}")
    print(f"Overall OOF MAPE: {overall_mape:.4f}%")
    print(f"Fold MAPE: {fold_scores}")
    print(f"Mean Fold MAPE: {np.mean(fold_scores):.4f}% ± {np.std(fold_scores):.4f}%")
    print(f"{'='*50}")
    
    # 特征重要性排名
    importance_summary = feature_importance.groupby('feature').agg({
        'importance': ['mean', 'std']
    }).reset_index()
    importance_summary.columns = ['feature', 'importance_mean', 'importance_std']
    importance_summary = importance_summary.sort_values('importance_mean', ascending=False)
    
    print("\nTop 20 重要特征:")
    print(importance_summary.head(20).to_string(index=False))
    
    return {
        'oof_predictions': oof_predictions,
        'test_predictions': test_predictions,
        'overall_mape': overall_mape,
        'fold_scores': fold_scores,
        'feature_importance': importance_summary,
        'n_estimators_used': model.best_iteration
    }

六、高级技巧：CatBoost融合与Stacking

LightGBM + XGBoost + CatBoost融合

单一模型总有局限，融合多个模型是提升性能的有效手段。

from catboost import CatBoostRegressor
import xgboost as xgb

class ModelEnsemble:
    """模型融合"""
    
    def __init__(self):
        self.models = []
        self.weights = []
        self.model_types = []
    
    def add_lgb_model(self, params):
        self.models.append(('lgb', lgb.LGBMRegressor(**params)))
        self.model_types.append('lgb')
    
    def add_xgb_model(self, params):
        self.models.append(('xgb', xgb.XGBRegressor(**params)))
        self.model_types.append('xgb')
    
    def add_catboost_model(self, params, cat_features):
        self.models.append(('cat', CatBoostRegressor(**params)))
        self.model_types.append('cat')
        self.cat_features = cat_features
    
    def fit(self, X, y):
        """训练所有模型"""
        for name, model in self.models:
            print(f"Training {name}...")
            if name == 'cat':
                model.fit(X, y, cat_features=self.cat_features)
            else:
                model.fit(X, y)
    
    def predict(self, X, weights=None):
        """加权平均预测"""
        if weights is None:
            weights = [1.0 / len(self.models)] * len(self.models)
        
        predictions = []
        for name, model in self.models:
            pred = model.predict(X)
            predictions.append(pred)
        
        # 加权平均
        final_pred = np.zeros_like(predictions[0])
        for pred, weight in zip(predictions, weights):
            final_pred += pred * weight
        
        return final_pred

七、调参常见问题与避坑指南

Q1：过拟合了怎么办？

症状：训练集MAPE很低，但验证集MAPE很高

解决策略（按优先级）：
1. 增大min_child_samples（20→50→100）
2. 减少num_leaves（63→31→15）
3. 增大正则化（reg_alpha/reg_lambda: 0.1→1→10）
4. 减小subsample和colsample_bytree（0.8→0.7→0.6）
5. 降低n_estimators或增大early_stopping

Q2：欠拟合了怎么办？

症状：训练集和验证集MAPE都很高

解决策略：
1. 增加num_leaves（31→63→127）
2. 增大max_depth限制（-1→10→12）
3. 减小min_child_samples（50→20→10）
4. 增大learning_rate（0.01→0.05→0.1）
5. 增加n_estimators
6. 减少正则化参数

Q3：早停不work？

原因：验证集loss一直在下降，没触发早停

解决方案：
1. 检查early_stopping_rounds设置是否合理
2. 降低学习率，让曲线更平滑
3. 可能需要更多特征工程

Q4：GPU训练不稳定？

建议：
1. 使用CUDA版本的LightGBM（需要编译）
2. 减小batch或num_threads
3. 检查GPU内存是否足够
4. 或者直接用CPU模式

八、LightGBM调参速查表

┌─────────────────────────────────────────────────────────────────┐
│                    LightGBM 调参速查表                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  【第1优先级：树结构】                                           │
│  ┌─────────────────┬──────────────┬──────────────────────────┐  │
│  │ 参数            │  推荐范围    │ 说明                      │  │
│  ├─────────────────┼──────────────┼──────────────────────────┤  │
│  │ num_leaves      │ 15-255       │ 通常31-63                │  │
│  │ max_depth       │ 3-12, -1无限制│ 配合num_leaves使用       │  │
│  │ min_child_samples│ 10-100       │ 数据量越大，值越大       │  │
│  └─────────────────┴──────────────┴──────────────────────────┘  │
│                                                                 │
│  【第2优先级：采样与正则化】                                     │
│  ┌─────────────────┬──────────────┬──────────────────────────┐  │
│  │ subsample       │ 0.6-0.9      │ 推荐0.8                  │  │
│  │ colsample_bytree│ 0.6-0.9      │ 推荐0.8                  │  │
│  │ reg_alpha       │ 0-10         │ L1正则，稀疏数据用大值   │  │
│  │ reg_lambda      │ 0-10         │ L2正则，大多数场景1.0    │  │
│  └─────────────────┴──────────────┴──────────────────────────┘  │
│                                                                 │
│  【第3优先级：学习率】                                           │
│  ┌─────────────────┬──────────────┬──────────────────────────┐  │
│  │ learning_rate   │ 0.01-0.3     │ 推荐0.05，配合early_stop  │  │
│  │ n_estimators    │ 100-3000     │ 学习率低时需要更多树     │  │
│  │ early_stopping  │ 50-200       │ 防止过拟合               │  │
│  └─────────────────┴──────────────┴──────────────────────────┘  │
│                                                                 │
│  【调参顺序】                                                   │
│  1. num_leaves → 2. max_depth → 3. min_child_samples           │
│  4. subsample → 5. colsample_bytree                             │
│  6. reg_alpha → 7. reg_lambda                                   │
│  8. learning_rate → 9. n_estimators                             │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

---

写在最后

调参是科学与艺术的结合。理解每个参数背后的原理，才能在遇到问题时快速定位原因。希望这篇调参圣经能成为你征战Kaggle和工业项目的利器。

最后送大家一句话：“调参调到最后，比的不是技术，而是耐心。”

如果觉得有帮助，欢迎一键三连！有更多问题欢迎评论区交流~