Kaggle实战：XGBoost从数据准备到Stacking融合的完整打法-代码聚汇网

不用怀疑，XGBoost到现在依然是Kaggle赛场上胜率最高的单模型，没有之一。拿我自己的参赛经历来说，从结构化数据的回归赛到点击率预测赛，凡是能拿牌的场次，最终提交的模型里几乎都有一棵或几棵XGBoost在撑底盘。这篇文章不打算重复官方文档里那一套参数表，我想从一个实际比赛参与者的角度，把XGBoost从数据准备、验证策略、调参路线到Stacking融合的完整打法和大家拆开揉碎聊一遍，尤其是那些文档里不会写，但真正决定你能不能拿牌的关键细节。

Kaggle比赛表面拼模型，实际拼的是两件事：验证方案是否可靠，以及特征是否能表达业务信息。XGBoost只是把这两件事的执行效率放大了而已。它处理表格数据的能力极强，自带缺失值处理、内置正则化、支持自定义目标函数，还能通过早停机制防止过拟合——这套组合拳让它在绝大多数表格型比赛里都能稳定输出高精度结果。但如果你只是pip install xgboost然后直接fit，那你大概率会输给那些花了一周时间雕琢验证框架和特征的对手。

我会按照一场标准比赛从开始到结束的时间线来组织这篇文章，读完你至少能获得一条清晰的执行路线：数据到手后先做什么，验证框架怎么搭，特征怎么做才有效，XGBoost的参数怎么一步步调到最优，以及最后怎么用Stacking框架把XGBoost和其他模型组合成夺冠阵容。这中间我会穿插很多我自己实战中踩过的坑和验证过的小技巧，希望能帮你在下一次比赛里少走弯路。

1. 比赛开始后的前两小时：数据加载与基线模型搭建

Kaggle比赛的数据处理门槛其实不在模型，而在数据规模和数据形态。很多新手一上来就急着跑模型，结果光是把数据读进内存就花了半小时，或者因为没处理好缺失值导致训练直接报错。我从一个非常实际的场景开始聊。

1.1 数据加载效率：不要反复读大文件

Kaggle经常有那种几个GB到几十个GB的数据集。最常见的错误是一边写特征工程脚本一边反复读CSV，每次花好几分钟，浪费时间不说，内存还被反复占满。

我自己的习惯是：第一次读入数据后，立刻用parquet格式写一份到本地磁盘。示例如下：

python复制import pandas as pd

# 第一次读取原始数据
df_train = pd.read_csv('train.csv', nrows=10000)
df_train = pd.read_csv('train.csv')  # 全量读取

# 转存为parquet，后续全部从parquet读取
df_train.to_parquet('train.parquet')
df_test = pd.read_csv('test.csv')
df_test.to_parquet('test.parquet')

# 之后每次读取
df_train = pd.read_parquet('train.parquet')

Parquet格式是列式存储，读取速度比CSV快一个数量级，而且压缩后体积小得多。Kaggle的磁盘空间够用，这个步骤能帮你省下大量等待时间。

另外，数据类型也要优化。默认读入的整数列通常被识别为int64，但很多列实际值域很小，用int8或int16就够。数值列也可以根据范围从float64降到float32。内存降到原来四分之一之后，后面做特征交叉、K折训练时会舒服很多。我用一个简单的函数处理：

python复制def reduce_mem_usage(df):
    for col in df.columns:
        col_type = df[col].dtype
        if col_type != 'object':
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
            else:
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
    return df

Kaggle的数据集下载和上传确实慢，这是大家都会抱怨的痛点，所以本地管理好数据变体非常重要——每一步特征工程的产物都单独存一份，避免从头重新计算。这样哪怕后来发现某个特征不行，也能快速回退。

1.2 基线模型：不需要完美，但需要完整流程

很多新手犯的第二个错误是：一开始就想把所有特征做到完美再做模型。实际上，先搭一个能跑通的基线，再逐步迭代，才是比赛的正常节奏。

基线模型的目标是验证整个pipeline是通的，包括数据读取、预处理、交叉验证、模型训练、预测提交这一整套流程。XGBoost在默认参数下已经能给出不错的结果，所以拿来当基线很合适：

python复制import xgboost as xgb
from sklearn.model_selection import KFold
from sklearn.metrics import roc_auc_score

params = {
    'objective': 'binary:logistic',
    'eval_metric': 'auc',
    'learning_rate': 0.1,
    'max_depth': 6,
    'subsample': 0.8,
    'colsample_bytree': 0.8,
    'random_state': 42
}

kf = KFold(n_splits=5, shuffle=True, random_state=42)
oof_pred = np.zeros(len(X_train))
test_pred = np.zeros(len(X_test))

for fold, (train_idx, valid_idx) in enumerate(kf.split(X_train, y_train)):
    X_tr, X_val = X_train.iloc[train_idx], X_train.iloc[valid_idx]
    y_tr, y_val = y_train.iloc[train_idx], y_train.iloc[valid_idx]
    
    dtrain = xgb.DMatrix(X_tr, label=y_tr)
    dvalid = xgb.DMatrix(X_val, label=y_val)
    
    model = xgb.train(
        params,
        dtrain,
        num_boost_round=10000,
        evals=[(dvalid, 'valid')],
        early_stopping_rounds=100,
        verbose_eval=500
    )
    
    oof_pred[valid_idx] = model.predict(dvalid, iteration_range=(0, model.best_iteration + 1))
    test_pred += model.predict(xgb.DMatrix(X_test), iteration_range=(0, model.best_iteration + 1)) / 5

注意几个关键点：

使用DMatrix接口而不是sklearn接口。DMatrix是XGBoost的原生数据格式，支持缓存加速，在迭代实验时速度优势很明显。sklearn接口封装得方便，但原生接口对参数控制和预测控制更精细。
设置早停轮数。num_boost_round设得很大，让模型自己决定什么时候停。early_stopping_rounds=100表示连续100轮验证集指标没有提升就停止。这比手动指定树的数量科学得多。
保存OOF预测。Out-of-Fold预测是后续做Stacking的原料，现在就要留好。很多人赛程后半段发现需要OOF来喂给上层模型，结果没有保存，只能重新训练，白白浪费几个小时。

基线跑通之后，你手里就有了一个可提交的分数。这个分数不用太在意，它是用来衡量后续每一步特征工程和调参是否有效的参照物。没有这个参照，你做的一切改进都无法量化评估。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 验证方案不牢靠，后面全是白干：K折与评估指标的选择逻辑

我见过太多参赛者，模型训练得头头是道，结果因为验证方案有问题，线下分数和线上排名差距巨大，最后白白丢牌。验证方案是整个比赛中你最需要花时间搞清楚的一步。

2.1 评估指标不是摆设：先搞清楚比赛怎么打分

Kaggle比赛在开赛页面上会明确给出评估指标——AUC、LogLoss、RMSE、MAE、Quadratic Weighted Kappa等等。这个指标不仅决定了最终排名，也决定了你整个训练过程中的目标函数设计。

以XGBoost的使用为例，如果你的任务是二分类且评估指标是AUC：

python复制params = {
    'objective': 'binary:logistic',
    'eval_metric': 'auc'
}

这里objective和eval_metric保持一致，用起来最省心。但有些情况两者需要分离：比如评估指标是LogLoss，你可以把objective设为binary:logistic，eval_metric设为logloss，XGBoost在早停时会按logloss来选最优迭代次数。

如果是回归任务且评估指标是RMSE：

python复制params = {
    'objective': 'reg:squarederror',
    'eval_metric': 'rmse'
}

如果评估指标是MAE，我建议把objective设为reg:absoluteerror，虽然收敛会慢一些，但模型会直接优化目标指标。XGBoost有个reg:pseudohubererror目标函数，它是Huber损失的平滑版本，对离群点不敏感，适合数据噪音比较大的情况——这在真实比赛场景里很常见。

这里有一个从实战中得出的经验：不要为了用AUC就去改objective。你听别人说AUC好，就把binary:logistic换成rank:pairwise，这会改变模型的概率输出语义，最后提交时还要额外处理，得不偿失。老老实实按任务类型选objective，按比赛指标选eval_metric，这套组合在绝大多数情况下都是最优解。

2.2 K折不是胡乱切：不同任务形态下的折法差异

默认的KFold适合普通回归和分类任务，但它假设样本是独立同分布的。实际比赛里，经常出现时间序列预测、多标签分类、组别相关性这些特殊场景，K折切法必须随之调整。

时间序列类比赛，比如预测下个月的销量，最稳妥的是按时间切分：

python复制from sklearn.model_selection import TimeSeriesSplit

tscv = TimeSeriesSplit(n_splits=5)

TimeSeriesSplit确保训练集只包含更早的数据，验证集在时间上永远晚于训练集。这和真实业务环境完全吻合：你要用历史数据预测未来，而不是未来数据倒推历史。

分类问题如果类别极度不均衡，比如正样本只占1%，随机K折很可能出现某一折验证集里正样本一个都没有的情况。这时必须用StratifiedKFold：

python复制from sklearn.model_selection import StratifiedKFold

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

StratifiedKFold保证每一折的正负样本比例和全量数据一致，这样每一折的验证分数才稳定可靠。

还有一种容易被忽略的形态是同组数据不能跨折。比如一个用户产生了多行行为记录，如果同一用户的记录既出现在训练集又出现在验证集，模型就等于见过答案，验证分数虚高。这种情况需要用GroupKFold，按用户ID分组切分：

python复制from sklearn.model_selection import GroupKFold

gkf = GroupKFold(n_splits=5)
for train_idx, valid_idx in gkf.split(X, y, groups=user_id):
    # train_idx保证没有和valid_idx重叠的user_id

验证方案要和比赛评估方式保持一致，这是铁律。你线下验证做得越贴近线上评测逻辑，你的模型迭代就越有方向。

2.3 OOF与验证分数的正确读法

用K折训练时，每一折的验证集预测拼在一起，得到的就是OOF预测。计算OOF预测与真实标签的指标分数，就是你的线下验证分数。

线下验证分数的意义不在于它高不高，而在于它和线上LB分数的相关性。如果你发现线下分数提升了，但线上分数反而下降，说明验证方案有问题，或者你的特征过拟合了验证集。

我通常会在每一轮特征或调参实验后，把线下分数和上一次已验证的线上分数做一个对比，形成一张简单的实验记录表。比如：

实验版本	特征改动	线下AUC	线上LB	备注
v1	基线	0.8521	0.8498	-
v2	添加目标编码	0.8610	0.8562	有效
v3	添加统计特征	0.8630	0.8501	线下过拟合，回退
v4	调参后	0.8710	0.8620	有效

这张表看着简单，但能帮你快速定位哪些特征或参数真正提升了泛化能力，哪些只是虚高的线下分数。永远用验证分数和LB分数的一致来验证，不要只看线下分数。

3. 让XGBoost吃饱饭：面向树模型的特征工程核心逻辑

特征工程是Kaggle比赛里投入产出比最高的环节，也是新手和高手差距最大的地方。XGBoost是树模型家族的王者，它的工作方式决定了特征工程的做法和深度学习有本质不同——不需要做标准化，不需要处理共线性，但需要把原始信息编码成树模型能高效切分的形态。

3.1 树模型特征工程的第一性原理

XGBoost通过不断寻找最优切分点来分裂树节点，它关注的是特征是否包含判别信息，以及特征取值的分布是否适合切分。

这就推导出两个实操原则：

第一，不需要标准化和归一化。 对线性模型，特征尺度直接决定权重可比性；对XGBoost这种基于切分的树模型，把特征放大100倍和缩小100倍，切分点也会等比变化，模型效果完全不变。所以你在Kaggle的baseline代码里经常看到树模型pipeline里没有scaler，这是正常的，不是漏了。

第二，需要把信息显式编码。 树模型不会自己发现特征组合。比如购物网站的用户年龄和商品品类，单独看对购买的预测力都一般，但“40岁男性喜欢买户外装备”这个组合是非常强的信号。树模型单棵树的深度有限，虽然理论上深树能自动捕捉这种交互，但实际训练中你很难把每棵树的深度放大到能发现所有交互的程度。所以人工构造组合特征、统计特征、目标编码特征，是喂给树模型最有效的信息编码方式。

3.2 三类高价值特征：统计、目标编码、时序

统计特征是最稳定有效的特征类型。它的核心思想是用标签或其他列的分组聚合信息来增强样本表达能力。举一个电商购买预测比赛的例子：

python复制# 假设每个用户有多个浏览记录
user_stats = df.groupby('user_id').agg(
    user_view_count=('item_id', 'count'),
    user_click_rate=('is_click', 'mean'),
    user_unique_item=('item_id', 'nunique'),
    user_last_behavior_time_max=('behavior_time', 'max'),
    user_last_behavior_time_min=('behavior_time', 'min')
).reset_index()

df = df.merge(user_stats, on='user_id', how='left')

is_click的均值就是用户的历史点击率，这个特征表达了用户的活跃偏好；behavior_time的最大值表达了用户的最近活跃时间，这个信息对时效性强的任务特别有价值。

目标编码是另一个大杀器，尤其适合高基数类别特征。比如城市有1000个取值，如果直接用LabelEncoder编成0-999，树模型会把它们当成有大小关系的数值序列，一塌糊涂。如果做OneHot，会生成999列，稀疏又笨重。目标编码的本质是用目标变量的统计量来编码类别：

python复制# 目标编码，注意只能在训练集内部做，避免数据泄露
city_target_mean = df.groupby('city')['target'].mean()
df['city_target_enc'] = df['city'].map(city_target_mean)

但这个操作有数据泄露风险——你用全量数据的target均值编码了训练和测试，测试集的信息就混进来了。标准做法是在K折框架内做目标编码，每一折只用训练部分的数据计算编码映射，再应用到验证部分。我通常封装成一个类，方便复用：

python复制from sklearn.model_selection import KFold

class TargetEncoder:
    def __init__(self, col, n_splits=5, random_state=42):
        self.col = col
        self.n_splits = n_splits
        self.random_state = random_state
        
    def fit_transform(self, X, y):
        kf = KFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state)
        X = X.copy()
        X[f'{self.col}_target_enc'] = np.nan
        for train_idx, valid_idx in kf.split(X):
            train_target_mean = y.iloc[train_idx].groupby(X.iloc[train_idx][self.col]).transform('mean')
            X.loc[valid_idx, f'{self.col}_target_enc'] = X.loc[valid_idx, self.col].map(
                y.iloc[train_idx].groupby(X.iloc[train_idx][self.col]).mean()
            )
        # 填充测试集时用全量统计
        global_mean = y.groupby(X[self.col]).transform('mean')
        X[f'{self.col}_target_enc'] = X[f'{self.col}_target_enc'].fillna(global_mean)
        return X[f'{self.col}_target_enc']

时间序列比赛里，滞后特征和滑窗特征是主流。滞后特征就是取过去第1天、第7天、第30天的值作为特征；滑窗特征就是过去7天、30天的均值、方差、最大值：

python复制df['sales_lag_7'] = df.groupby('item_id')['sales'].shift(7)
df['sales_rolling_mean_7'] = df.groupby('item_id')['sales'].transform(lambda x: x.rolling(7).mean())
df['sales_rolling_std_7'] = df.groupby('item_id')['sales'].transform(lambda x: x.rolling(7).std())

这类特征能让XGBoost的回归模型捕捉到时间上的趋势和周期性，尤其配合reg:squarederror目标函数，在销量预测类比赛里效果非常显著。热词里提到的“xgboost回归模型”“xgboost回归预测模型”主要就是这一类场景，回归任务里特征工程的权重要比调参大得多。

3.3 缺失值的黄金处理法则

XGBoost原生支持缺失值处理，它在训练时会自动学习将缺失值分到哪个节点，所以你不一定需要专门填充。这一点在实际使用中非常省心，也是XGBoost比很多传统GBDT实现更受欢迎的原因之一。

不过有几种情况我建议主动处理：

缺失比例过高的列（超过90%）：这种列信息量太少，模型学到的大多是噪音，建议直接删除。
树模型无法有效利用的无序缺失：比如某些特征缺失与标签负相关（只有负样本才缺失），XGBoost能学会，但如果缺失比例适中（10%-50%），主动填一个极端值（-999）有时比让它自己学更快。这个需要实验验证。
时间特征：如果时间是对象类型，先把缺失的日期填成一个固定日期，再提取年月日时分秒等特征。

核心原则是：不要让缺失值处理成为你花最多时间的事。XGBoost自带的缺失值路由机制已经足够强大，你更应该把时间花在构造新特征上。

4. 调参不是玄学：从误差分解出发的分阶段调参路线

XGBoost的参数多如牛毛，官方文档列了几十个，新手一看就懵。其实绝大多数参数在默认值下就很好用了，真正需要精调的参数不超过十个。我根据自己从多场比赛里总结的调参经验，给出一个分阶段的调参路线。

4.1 第一阶段：固定学习率，调树结构参数

学习率（learning_rate或eta）决定每一步迭代的步长。学习率越小，模型越不容易过拟合，但需要的树数量越多，训练时间越长。我的习惯是先把学习率固定为0.1，这个值在绝大多数比赛中表现均衡。

然后调三个树结构参数：

max_depth：控制每棵树的最大深度。默认值6。深度越大，模型越能捕捉复杂交互，但也越容易过拟合。Kaggle表格比赛的常见有效范围是4-8。
min_child_weight：控制叶子节点的最小样本权重和。默认值1。值越大，模型越保守，越不容易过拟合。常见有效范围1-10。
gamma：控制节点分裂所需的最小损失下降量。默认值0。值越大，分裂越保守。常见有效范围0-5。

调这三个参数的方法是网格搜索配K折验证，但网格不用太大，用少量有代表性的值快速筛方向：

python复制from sklearn.model_selection import GridSearchCV
import xgboost as xgb

param_grid = {
    'max_depth': [4, 6, 8],
    'min_child_weight': [1, 3, 5]
}

xgb_model = xgb.XGBClassifier(
    objective='binary:logistic',
    eval_metric='auc',
    learning_rate=0.1,
    n_estimators=300,
    subsample=0.8,
    colsample_bytree=0.8,
    random_state=42
)

grid = GridSearchCV(
    xgb_model,
    param_grid,
    cv=5,
    scoring='roc_auc',
    verbose=1,
    n_jobs=-1
)
grid.fit(X_train, y_train)
print(grid.best_params_)

需要特别注意：网格搜索里给n_estimators一个较小的上限（比如300），配合早停逻辑使用，不要直接设几千棵树，否则网格搜索会非常慢。

4.2 第二阶段：调采样参数和正则化参数

树结构确定后，下一步调采样参数，控制每棵树看到的样本和特征比例：

subsample：每棵树随机采样的样本比例。默认值1。调小到0.6-0.9可以减少过拟合。
colsample_bytree：每棵树随机采样的特征比例。默认值1。调小到0.6-0.9同样能减少过拟合，还能加速训练。

然后是正则化参数：

alpha：L1正则化项的权重。默认值0。值越大，模型越稀疏，特征重要性都集中在少数强特征上。
lambda：L2正则化项的权重。默认值1。值越大，模型越保守。默认值通常就能用，比赛里常见范围1-10。

这些参数的调法和第一阶段一样，网格搜索或随机搜索都行。我倾向于用随机搜索，因为参数组合空间大了之后，网格搜索的采样效率不如随机搜索。RandomizedSearchCV是个好工具。

4.3 第三阶段：降学习率，加树数量，吃满早停

前两个阶段把模型结构定下来之后，最后一步就是把学习率降到0.01或0.02，同时把最大迭代次数放到很大（10000以上），依赖早停找最优树数量。

这一步是最花时间但最值钱的。同样的特征和参数，学习率0.1和0.01的最终精度差距在AUC上往往有0.005-0.01的差异，这个差距在排行榜上可能就是几十个名次。

python复制params = {
    'objective': 'binary:logistic',
    'eval_metric': 'auc',
    'learning_rate': 0.01,   # 降低学习率
    'max_depth': 6,
    'min_child_weight': 3,
    'subsample': 0.8,
    'colsample_bytree': 0.8,
    'alpha': 0,
    'lambda': 1,
    'tree_method': 'hist',   # 使用直方图近似加速训练
    'random_state': 42
}

model = xgb.train(
    params,
    dtrain,
    num_boost_round=50000,
    evals=[(dvalid, 'valid')],
    early_stopping_rounds=200,
    verbose_eval=1000
)

注意tree_method参数。hist模式用直方图近似替代精确贪心搜索，训练速度提升好几倍，内存占用也少得多，Kaggle比赛里基本都用hist。如果数据量特别大（百万行以上），还可以考虑gpu_hist，用GPU训练能再快一个数量级。Kaggle的GPU环境对XGBoost支持很成熟，我强烈建议有GPU的选手全部用gpu_hist。

4.4 早停轮数与过拟合的边界

早停轮数是调参里的隐性参数，它决定了模型会多“贪心”地继续训练。early_stopping_rounds设为100-200是比较稳妥的范围。

有一个我从实战里总结的经验：早停轮数不要设太大，否则模型在验证集上过拟合了也不自知。早停的本质是用验证集的指标来选择最优迭代点，但如果验证集本身有一定噪音，轮数设大了，模型会过拟合验证集的噪音。200是一个比较平衡的数值，既能保证找到全局最优，又不会过分消耗算力。

另外要提防的是，模型在接近最优迭代点时，验证集指标可能会出现随机波动。早停逻辑允许这种波动存在，只要在后续200轮内有提升就会继续。但如果你频繁看到验证分数在震荡中缓慢下降，说明模型容量已经太大，需要回到第一阶段把max_depth调低或把min_child_weight调高。

5. Stacking才是把XGBoost变成冠军模型的打开方式：从OOF到元模型

如果你已经拥有了一个不错的XGBoost单模型，你可能会想：还能怎么提升？答案几乎一定是模型融合。而Stacking框架是目前Kaggle表格类比赛里最有效的融合方式。热词里专门提到了“stacking框架结合xgboost算法”，说明这是很多选手关注的进阶方向。

5.1 为什么单模型永远不够：偏差和方差的双重困境

任何单一模型都有它的偏好：XGBoost对特征交互敏感，LightGBM对大数据量训练效率高，CatBoost对类别特征处理更友好，线性模型对高维稀疏特征有天然优势。当你把多个模型的结果组合起来，相当于让一群具有不同“偏见”的专家投票，最终结果通常比任何一个专家都靠谱。

K折交叉验证本身已经帮了模型一把，但它只是让模型看到不同的训练子集，没有改变模型的偏好。Stacking的核心价值在于用元模型学习多个基模型的预测模式，从而互补优缺点。

5.2 Stacking的标准做法：K折基模型输出OOF特征

Stacking的标准做法分两步：

第一步，对每个基模型（比如XGBoost、LightGBM、CatBoost各自单独训练）做K折，得到OOF预测和测试集预测：

python复制def train_oof(model_params, X_train, y_train, X_test, model_name, n_splits=5):
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)
    oof_pred = np.zeros(len(X_train))
    test_pred = np.zeros(len(X_test))
    
    for fold, (train_idx, valid_idx) in enumerate(kf.split(X_train)):
        X_tr, X_val = X_train.iloc[train_idx], X_train.iloc[valid_idx]
        y_tr, y_val = y_train.iloc[train_idx], y_train.iloc[valid_idx]
        
        if model_name == 'xgb':
            dtrain = xgb.DMatrix(X_tr, label=y_tr)
            dvalid = xgb.DMatrix(X_val, label=y_val)
            model = xgb.train(
                model_params, dtrain, num_boost_round=10000,
                evals=[(dvalid, 'valid')], early_stopping_rounds=100, verbose_eval=0
            )
            oof_pred[valid_idx] = model.predict(dvalid, iteration_range=(0, model.best_iteration + 1))
            test_pred += model.predict(xgb.DMatrix(X_test), iteration_range=(0, model.best_iteration + 1)) / n_splits
        # 其他模型类似
        
        print(f'Fold {fold + 1} finished.')
    
    return oof_pred, test_pred

第二步，把多个基模型的OOF预测拼成新的特征矩阵（每列对应一个基模型），用元模型去拟合真实标签：

python复制stacking_features_train = np.column_stack([
    xgb_oof,
    lgb_oof,
    cat_oof
])

stacking_features_test = np.column_stack([
    xgb_test,
    lgb_test,
    cat_test
])

# 元模型用简单的逻辑回归或XGBoost
meta_model = xgb.XGBClassifier(
    objective='binary:logistic',
    eval_metric='auc',
    learning_rate=0.01,
    max_depth=3,
    n_estimators=500,
    random_state=42
)

meta_model.fit(
    stacking_features_train, y_train,
    eval_set=[(stacking_features_train, y_train)],
    verbose=0
)

stacking_pred = meta_model.predict_proba(stacking_features_test)[:, 1]

这里有一个非常重要的细节：元模型不能再用K折的方式重新把OOF喂进去训练，否则会过拟合。OOF已经是基模型在验证集上的预测，它们天然带有一定的“欠拟合”性质，元模型要学的正是这种预测模式与真实标签的关系。如果元模型训练过度，会把基模型的缺陷也学进去。我通常给元模型设一个比较低的n_estimators（300-500）和一个很小的max_depth（3-4），防止它过度自信。

5.3 元模型选XGBoost还是逻辑回归？我的经验

元模型的选择取决于你的基模型数量和相关性。如果基模型只有2-3个，逻辑回归往往表现就很好，因为它足够简单，不容易过拟合OOF特征。如果基模型有5个以上，XGBoost作为元模型能捕捉到基模型之间的非线性关系，效果更好。

我见过很多Stacking翻车的案例，原因几乎都是元模型过于复杂。记住一个原则：元模型要简单，基模型要多而杂。多个强基模型的低相关性互补，配一个简单可靠的元模型，是最稳的结构。你可以在后期尝试用XGBoost当元模型，但一定要配合早停和很强的正则化。

Stacking里的另一个实用技巧是，把原始特征中最重要的几个（比如特征重要性排名前10的列）也拼进元模型的特征矩阵。这样元模型不仅能看基模型的预测，还能直接看关键原始特征，相当于给了它额外的信息源。这个技巧在好几个比赛里帮我稳定提升了0.001-0.002的AUC，算是一个锦上添花的加分项。

6. 决定名次的细节：随机种子、特征重要性与反复验证

写到这里，技术层面的核心内容基本聊完了。但Kaggle比赛决定名次的往往是那些看起来不起眼的细节处理。这些经验是文档里绝对找不到的，我做一次系统总结。

6.1 随机种子不是随便定的

XGBoost训练时，样本采样和特征采样的随机性由random_state控制。如果你跑了几次实验，发现结果波动很大，说明你的模型对数据分布很敏感，这时随机种子的选择就很重要。

我的做法是：固定一组种子（通常是42、2023、7各跑一遍），取它们在测试集上预测的均值作为最终提交。这就是一种轻量级的Bagging融合，能有效降低单次训练的方差。对Top选手来说，他们会把多个种子的模型分别保存，最后统一做平均，这种做法非常基础但非常有效。

同时要注意：Stacking框架里的K折随机种子和基模型的随机种子要保持一致，否则OOF的划分不一致，元模型的特征分布就会错位。我固定一个seed对象，在代码开头统一设置np.random.seed(42)和各个模型的random_state=42。

6.2 特征重要性：用来理解而不是用来删特征

XGBoost训练完成后，可以用model.get_score()或特征的gain字段查看特征重要性。这个信息对理解模型行为很有价值，但不要直接拿它来删特征。

特征重要性反映的是特征在树分裂中的贡献，不是边际预测能力的完整度量。两个高度相关的特征，重要性会被分散，单独看都不高，但删掉其中一个，模型精度可能明显下降。所以我把特征重要性当诊断工具，而不是筛选工具。

当你想降维时，正确的做法是先按特征重要性排序，删除最末尾的10%-20%特征，重新训练看验证分数变化。如果分数不变或提升，说明这部分特征确实是噪音；如果分数下降，说明这些特征虽小但有信息量，保留。

6.3 反复迭代的节奏：一次只改一个变量

Kaggle比赛的迭代过程很容易失控。尤其是到了后期，你手里有几十个特征、十几版参数，改了这个忘了那个，最后分数不知道是哪个改动带来的提升。

我的习惯是每次实验只改一个变量：要么只加一个新特征，要么只动一个参数，要么只换一个验证方式。实验记录表记下每次的线下分数和线上LB分数，确保每次改动的影响都可追溯。这个习惯在长赛程比赛里尤其重要——比赛进行到一个月时，没有实验记录的人几乎完全陷入了参数和特征的随机组合，而拿着实验记录表的人每一步都走得很清楚。

另外一个很实用的习惯是保留历史最佳模型的文件。model.save_model('xgb_best.json')保存模型文件，方便在比赛后期重新提交旧的强模型。Kaggle有些比赛的提交次数有限，能随时回到历史最优版本是非常重要的策略。

关于数据集上传下载太慢的问题，我也说两句。这确实是很多选手的真实痛点，但这不是无法优化的。在本地对数据做好压缩和精简，把不需要的列提前删掉，只上传必要的特征文件；数据下载时用Kaggle的API工具配合断点续传，比浏览器下载稳定得多。这些小事看着不起眼，但在比赛冲刺阶段能省下大量宝贵时间。

7. 一个完整的实战案例：从数据到提交的全流程演示

前面六节的分享偏方法论，这一节我用一个简化但完整的Kaggle风格比赛案例，把从数据到最终提交的全流程串起来，方便你对照着实践。

7.1 赛题模拟：电商用户购买预测

假设比赛任务是根据用户的历史行为预测其是否会在未来7天内购买商品。数据包含训练集和测试集，特征有用户ID、商品ID、浏览行为日志（时间戳、行为类型），标签是二分类（是否购买）。评估指标是AUC。

7.2 建模全流程代码

以下是完整流程的核心代码框架：

python复制import pandas as pd
import numpy as np
import xgboost as xgb
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score

# 1. 数据加载与类型优化
df_train = reduce_mem_usage(pd.read_parquet('train.parquet'))
df_test = reduce_mem_usage(pd.read_parquet('test.parquet'))
y = df_train['target']
X = df_train.drop(columns=['target', 'user_id', 'item_id'])
X_test = df_test.drop(columns=['user_id', 'item_id'])

# 2. 特征工程
# 统计特征
user_stats = df_train.groupby('user_id')['behavior_cnt'].agg(['mean', 'std', 'max']).reset_index()
user_stats.columns = ['user_id', 'user_behavior_mean', 'user_behavior_std', 'user_behavior_max']
X = X.merge(user_stats, on='user_id', how='left')
X_test = X_test.merge(user_stats, on='user_id', how='left')

# 时间特征
X['hour'] = pd.to_datetime(X['behavior_time']).dt.hour
X_test['hour'] = pd.to_datetime(X_test['behavior_time']).dt.hour

# 3. 验证框架
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
params = {
    'objective': 'binary:logistic',
    'eval_metric': 'auc',
    'learning_rate': 0.01,
    'max_depth': 6,
    'min_child_weight': 3,
    'subsample': 0.8,
    'colsample_bytree': 0.8,
    'lambda': 2,
    'tree_method': 'hist',
    'random_state': 42
}

oof_pred = np.zeros(len(X))
test_pred = np.zeros(len(X_test))

for fold, (train_idx, valid_idx) in enumerate(skf.split(X, y)):
    X_tr, X_val = X.iloc[train_idx], X.iloc[valid_idx]
    y_tr, y_val = y.iloc[train_idx], y.iloc[valid_idx]
    
    dtrain = xgb.DMatrix(X_tr, label=y_tr)
    dvalid = xgb.DMatrix(X_val, label=y_val)
    
    model = xgb.train(
        params, dtrain, num_boost_round=30000,
        evals=[(dvalid, 'valid')], early_stopping_rounds=200, verbose_eval=2000
    )
    
    oof_pred[valid_idx] = model.predict(dvalid, iteration_range=(0, model.best_iteration + 1))
    test_pred += model.predict(xgb.DMatrix(X_test), iteration_range=(0, model.best_iteration + 1)) / 5

print(f'CV AUC: {roc_auc_score(y, oof_pred)}')

7.3 全流程的经验清单

对照这个流程，我给出一个自己的执行清单，每次比赛我都会过一遍：

数据加载：CSV转parquet，内存优化。
验证方案：考虑任务形态，分类用StratifiedKFold，时间序列用TimeSeriesSplit，分组数据用GroupKFold。
特征工程：统计特征、目标编码（K折内）、时序特征（滞后+滑窗）、缺失值处理。
基线模型：XGBoost默认参数先跑通pipeline，记录线下分数。
逐步调参：按“树结构→采样→正则化→降学习率”的顺序分阶段调参。
模型多样性：训练LightGBM和CatBoost作为基模型，和XGBoost形成互补。
Stacking：用多个基模型的OOF预测拼接成新特征，喂给元模型，元模型保持简单。
细节处理：固定随机种子、保存历史最佳模型、记录每次实验的改动和分数。

每次比赛结束后，不管成绩如何，我都会复盘这个清单的哪几个环节做得不够好。说实话，大多数比赛输掉都不是输在模型能力上，而是输在验证方案没搭牢、特征工程没吃透、迭代节奏没控制好。这些经验比任何一个参数都值钱。

以我自己带过几批新手的经验来看，一个认真读了这篇文章并且严格执行这套流程的人，第一次完整参加Kaggle比赛，就足以从底层混到中上游。剩下的，就是一场一场比赛去积累对业务的敏感度和对数据的感觉了。

Kaggle实战：XGBoost从数据准备到Stacking融合的完整打法