机器学习（14）——模型调参

一、动态调参方法论

1. 调参策略选择

2. 千万数据优化原则

1. 数据采样：首轮调参使用10%-20%的随机采样数据
2. 交叉验证：使用2-3折代替5折，或采用分层抽样（StratifiedKFold）
3. 并行计算：设置n_jobs=-1（全核心） + 模型内置并行
4. 早停机制：设置early_stopping_rounds（对GBDT有效）
5. 内存管理：使用内存映射文件或分块加载数据

二、模型调参策略对比

1. LightGBM调参路线

# 首轮粗调（快速筛选）
param_grid = {
    'num_leaves': [31, 63, 127],  # 控制树复杂度
    'learning_rate': [0.05, 0.1],  # 学习率
    'min_data_in_leaf': [100, 500],  # 防止过拟合
    'feature_fraction': [0.8, 1.0]  # 特征采样
}

# 次轮精调（添加正则化）
param_grid_refined = {
    'lambda_l1': [0, 0.1, 0.5],
    'lambda_l2': [0, 0.1, 0.5],
    'bagging_freq': [3, 5]  # 配合bagging_fraction使用
}

2. XGBoost调参路线

# 基础参数组
base_params = {
    'max_depth': [3, 5, 7],  # 树深度
    'eta': [0.05, 0.1],  # 学习率
    'subsample': [0.8, 1.0],  # 样本采样
    'colsample_bytree': [0.8, 1.0]  # 特征采样
}

# 扩展参数组
extended_params = {
    'gamma': [0, 0.1, 0.5],  # 分裂最小增益
    'scale_pos_weight': [1, 5, 10]  # 处理类别不平衡
}

3. 随机森林调参策略

# 核心参数空间
rf_params = {
    'n_estimators': [100, 200],  # 树的数量
    'max_depth': [None, 10, 20],  # 控制复杂度
    'max_features': ['sqrt', 0.8],  # 特征采样
    'min_samples_split': [50, 100]  # 节点最小样本
}

# 大数据优化参数
large_data_params = {
    'n_jobs': -1,  # 全核心并行
    'verbose': 1,
    'warm_start': True  # 增量训练
}

三、代码实现示例

通用数据准备（适用于所有模型）

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

# 千万级数据加载优化（分块读取）
chunk_size = 1e6  # 根据内存调整
data_chunks = pd.read_csv('10m_data.csv', chunksize=chunk_size)
df = pd.concat(chunk for chunk in data_chunks)

# 特征/标签分离
X = df.drop('target', axis=1)
y = df['target']

# 内存优化（减少内存占用）
for col in X.columns:
    if X[col].dtype == 'float64':
        X[col] = X[col].astype('float32')
    if X[col].dtype == 'int64':
        X[col] = X[col].astype('int8')

# 数据集划分（分层抽样）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)

1. LightGBM调参示例

import lightgbm as lgb
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV

# 内存友好型数据集转换
train_data = lgb.Dataset(X_train, label=y_train, free_raw_data=False)

# 参数网格
lgb_params = {
    'boosting_type': ['gbdt'],
    'num_leaves': [63, 127],
    'learning_rate': [0.05, 0.1],
    'min_data_in_leaf': [500, 1000],
    'feature_fraction': [0.7, 0.8]
}

# 创建模型
lgb_model = lgb.LGBMClassifier(
    n_jobs=-1,
    objective='binary',
    metric='auc',
    n_estimators=1000,
    verbosity=-1
)

# 增量式网格搜索
search = HalvingGridSearchCV(
    estimator=lgb_model,
    param_grid=lgb_params,
    factor=3,  # 每轮保留1/3的参数组合
    cv=2,  # 2折交叉验证
    scoring='roc_auc',
    verbose=2,
    n_jobs=-1
)

# 执行搜索（使用子样本加速）
search.fit(X_train[:100000], y_train[:100000])  # 先用10万样本筛选

# 最佳参数应用
best_lgb = search.best_estimator_.fit(
    X_train,
    y_train,
    eval_set=[(X_test, y_test)],
    early_stopping_rounds=20,
    verbose=10
)

2. XGBoost调参示例

import xgboost as xgb
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

# 转换为DMatrix格式（优化内存）
dtrain = xgb.DMatrix(X_train, label=y_train, enable_categorical=True)

# 参数分布
xgb_dist = {
    'max_depth': randint(3, 8),
    'eta': uniform(0.05, 0.15),  # 0.05~0.2
    'subsample': uniform(0.6, 0.4),  # 0.6~1.0
    'colsample_bytree': uniform(0.6, 0.4),
    'gamma': uniform(0, 0.5)
}

# 创建模型
xgb_model = xgb.XGBClassifier(
    tree_method='hist',  # 内存优化模式
    objective='binary:logistic',
    n_jobs=-1,
    eval_metric='auc',
    use_label_encoder=False
)

# 随机搜索
search = RandomizedSearchCV(
    estimator=xgb_model,
    param_distributions=xgb_dist,
    n_iter=50,  # 随机采样50组参数
    cv=2,
    scoring='roc_auc',
    verbose=2,
    random_state=42,
    n_jobs=-1
)

# 执行搜索
search.fit(X_train.iloc[:500000], y_train.iloc[:500000])  # 使用50万样本

# 最佳模型训练
best_xgb = search.best_estimator_.fit(
    X_train,
    y_train,
    eval_set=[(X_test, y_test)],
    early_stopping_rounds=20,
    verbose=10
)

3. 随机森林调参示例

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

# 参数网格（精简版）
rf_params = {
    'n_estimators': [100, 150],
    'max_depth': [15, 20, None],
    'max_features': ['sqrt', 0.7]
}

# 创建模型（内存优化配置）
rf_model = RandomForestClassifier(
    n_jobs=-1,
    class_weight='balanced',
    verbose=1,
    warm_start=True  # 允许增量训练
)

# 分阶段调参
# 阶段1：确定最佳树数量
grid_stage1 = GridSearchCV(
    estimator=rf_model,
    param_grid={'n_estimators': [50, 100, 150]},
    cv=2,
    scoring='roc_auc'
)
grid_stage1.fit(X_train[:100000], y_train[:100000])

# 阶段2：确定深度和特征数
best_n = grid_stage1.best_params_['n_estimators']
rf_model.set_params(n_estimators=best_n)

grid_stage2 = GridSearchCV(
    estimator=rf_model,
    param_grid={
        'max_depth': [10, 15, 20],
        'max_features': ['sqrt', 0.6, 0.8]
    },
    cv=2,
    scoring='roc_auc'
)
grid_stage2.fit(X_train[:200000], y_train[:200000])

# 最终模型训练
best_rf = grid_stage2.best_estimator_
best_rf.n_estimators = 200  # 增加树数量
best_rf.fit(X_train, y_train)

四、千万级数据调参特别技巧

1. 分布式计算集成

# 使用Dask进行分布式调参（示例）
from dask.distributed import Client
from dask_ml.model_selection import RandomizedSearchCV

client = Client(n_workers=4)  # 启动Dask集群

# 创建Dask版本搜索器
dask_search = RandomizedSearchCV(
    estimator=xgb_model,
    param_distributions=xgb_dist,
    n_iter=100,
    cv=3,
    scoring='roc_auc',
    scheduler='distributed'
)

# 执行分布式搜索
dask_search.fit(X_train, y_train)

2. 特征工程优化

# 类别特征处理（LightGBM优化）
categorical_features = ['user_id', 'product_category']
for col in categorical_features:
    X_train[col] = X_train[col].astype('category')
    X_test[col] = X_test[col].astype('category')

# 高频类别截断（处理高基数特征）
high_cardinality_cols = ['ip_address']
for col in high_cardinality_cols:
    freq = X_train[col].value_counts(normalize=True)
    mask = X_train[col].isin(freq[freq > 0.01].index)
    X_train[col] = np.where(mask, X_train[col], 'RARE')

3. 内存管理技巧

# 分块训练（适用于所有模型）
chunk_size = 500000
for i in range(0, len(X_train), chunk_size):
    chunk_X = X_train.iloc[i:i+chunk_size]
    chunk_y = y_train.iloc[i:i+chunk_size]
    
    best_lgb.partial_fit(
        chunk_X,
        chunk_y,
        eval_set=[(X_test, y_test)],
        reset=False  # 保持已有训练结果
    )

五、性能评估与参数分析

1. 评估指标对比

2. 关键参数影响分析

• LightGBM：
  • num_leaves >31时AUC提升显著
  • feature_fraction设为0.7-0.8防止过拟合
• XGBoost：
  • max_depth设为5-7时性价比最高
  • subsample对稳定性影响显著
• 随机森林：
  • max_depth设为None时效果最佳
  • max_features=0.7比sqrt更适合该数据集

六、生产环境建议

1. 模型监控：

   • 部署模型性能监控（AUC衰减报警）
   • 设置特征分布偏移检测
   • 定期进行概念漂移测试

2. 在线更新策略：

   # LightGBM在线更新示例
   for new_data in streaming_data:
       best_lgb = lgb.Booster(model_file='production_model.txt')
       best_lgb.update(new_data)  # 增量更新
       monitor_auc = evaluate_model(best_lgb, validation_data)
       if monitor_auc < threshold:
           trigger_retrain()  # 触发全量重训练
   

3. 硬件配置推荐：

   • CPU：至少16核（推荐32核）
   • 内存：数据大小的2倍以上
   • 存储：NVMe SSD加速数据读取
   • GPU：对XGBoost/LightGBM可选（需特定版本）

通过以上策略和代码示例，可以在千万级数据集上高效完成模型调参。实际应用中建议结合业务特点调整参数范围，并通过自动化流水线实现持续优化。