企业官网建设流程全解析

这几年Kaggle比赛打下来，XGBoost一直是我工具箱里最稳的一把刀。从结构化数据的二分类、回归到多分类，XGBoost几乎都能在很短的时间内跑出一个不错的基线分数，而且它的容错率相当高——很多场景下不调参也能进前30%，稍微花点工夫调参和做特征，就能摸到前排门槛。这篇文章我想带你把XGBoost从头到尾吃透，从参数原理到调参路线，再到实战代码，最后到集成和后处理，完整走一遍Kaggle竞赛里真正会用到的东西。

不管你是正准备打第一场Kaggle的新手，还是已经跑过几场比赛但CV分数一直卡住的老玩家，这篇文章都有参考价值。我不太想写那种“参数表贴出来你自己调”的文档，而是想把我实际踩过的坑、验证过有效的操作，以及每一组参数背后的工作原理都讲清楚。因为只有理解了XGBoost为什么这么做，你才能在比赛里灵活调整，而不是死记硬背一堆参数值。

1. 为什么Kaggle赛场上XGBoost这么能打

先聊一个最基础的问题：为什么偏偏是XGBoost，而不是随机森林、逻辑回归，或者神经网络？

Kaggle上大量比赛都是表格数据，行数从几千到几百万不等，特征是数值和类别混合，而且经常带缺失值。神经网络在这种场景下不是不能打，而是对特征工程和调参的要求非常高，训练成本也高。逻辑回归和线性模型则难以自动处理非线性关系和特征交互，需要你手动构造大量交叉特征。而XGBoost作为梯度提升树（Gradient Boosting Decision Tree, GBDT）的一种优秀实现，天然具备几个优势：对特征尺度不敏感，不需要做标准化；能捕捉非线性关系；能自动学习特征之间的交互；对缺失值有内置的处理机制。这就让它在表格数据上几乎成了最省心的起点。

XGBoost全称是eXtreme Gradient Boosting，它在原始GBDT的基础上做了几个关键改进。最核心的是二阶导数近似优化：普通的梯度提升只利用一阶导数（梯度），而XGBoost利用损失函数对预测值的一阶和二阶导数来逼近目标函数，相当于在每一步迭代中考虑了损失函数的曲率信息，收敛更准确。其次是显式加入了正则化项：目标函数里除了训练损失，还会惩罚树的叶子节点数量和叶子权重的大小，天然抑制过拟合。再加上列采样（colsample）、行采样（subsample）、稀疏感知的缺失值处理、缓存优化这些工程细节，XGBoost在精度和速度上都很均衡。

我用一个表格对比一下XGBoost、LightGBM和CatBoost，比赛里这三个GBDT变体最常出现：

Kaggle实战中我的习惯是：先用XGBoost建立baseline，确认特征工程和CV流程没问题，再训练LightGBM和CatBoost作为兄弟模型，最后做集成。为什么不让XGBoost单打独斗？因为三个模型的结构差异带来了预测的多样性，集成多样模型的效果通常比调一个模型半天提升的成绩更显著。这个我们放在后面章节展开。

XGBoost也并非万能。遇到图像、文本嵌入、语音这类非结构化数据，它的表现就不如深度模型。遇到超高维稀疏特征（比如几十万维的TF-IDF向量），线性模型或LightGBM的直方图方案反而更合适。但在Kaggle最常见的表格数据赛道上，XGBoost依然是性价比最高的起点。

2. 动手前的环境准备与工具选型

把环境准备好是个容易被忽视但必须做对的事。我建议用conda管理Python环境，避免包版本互相打架。

conda create -n kaggle_xgb python=3.10 conda activate kaggle_xgb pip install xgboost pandas numpy scikit-learn scipy

如果你常用Kaggle Notebook或Colab，直接装上最新版XGBoost即可，一般网络环境没问题。安装之后检查一下版本，因为不同版本默认参数和接口有差异：

import xgboost as xgb print(xgb.__version__)

现在XGBoost 2.x系列默认使用的是hist直方图算法，如果从旧版本切过来，你会发现之前常用的tree_method='gpu_hist'和tree_method='hist'语义有所调整。在2.x版本中，用tree_method='hist'加device='cuda'来跑GPU，而不是像1.x那样写tree_method='gpu_hist'。如果代码报错说参数无效，大概率是版本不匹配。

XGBoost提供两套API，你必须清楚区分它们：

第一套是原生API，核心是xgb.train()和xgb.DMatrix()。优点是可以直接控制evals_result、自定义目标函数和评估函数，适合深度调优和进阶玩法。

import xgboost as xgb dtrain = xgb.DMatrix(X_train, label=y_train) dvalid = xgb.DMatrix(X_valid, label=y_valid) params = { "objective": "binary:logistic", "eval_metric": "auc", "max_depth": 6, "learning_rate": 0.05, "subsample": 0.8, "colsample_bytree": 0.8 } bst = xgb.train( params, dtrain, num_boost_round=5000, evals=[(dtrain, "train"), (dvalid, "valid")], early_stopping_rounds=100, verbose_eval=100 )

第二套是sklearn API，核心是XGBClassifier()和XGBRegressor()。优点是能直接用GridSearchCV、RandomizedSearchCV、Pipeline这些sklearn工具，写起来顺手，回归和二分类流程标准化。

两套API在参数命名上有差异，比如原生API叫eta，sklearn API叫learning_rate；原生API的num_boost_round对应sklearn API的n_estimators。这个对应关系要心里有数，否则调参时容易写错参数名却不自知。

DMatrix是XGBoost高效运行的数据结构，它在内存里做了一些预计算，训练时比直接用numpy数组更快。不过现在sklearn API内部也会自动转换，所以日常写代码直接用numpy/pandas没问题。需要手动构建DMatrix的场景通常是要处理weight（样本权重）、missing（缺失值）和base_margin（初始预测值）。比如二分类不平衡场景，你可以在DMatrix里指定每个样本的权重，也可以在参数里用scale_pos_weight，效果类似，但前者更精确。

3. XGBoost参数体系拆解

XGBoost的参数表面上看很多，实际上按功能可以分成三组：booster参数（控制每棵树的复杂度）、learning task参数（控制任务目标和评价方式）、正则化参数（控制模型的复杂度惩罚）。调参之前最好先把这三个组理清楚，否则东调一个西调一个，永远停在碰运气状态。

3.1 树模型核心参数

下面这张表是我平时调参时最常用的参数清单，也是比赛里最常见的调参范围：

3.2 这些参数背后的原理

我重点讲几个容易理解偏差的地方。

min_child_weight在很多文档里被解释成“叶子节点最小样本数”，但实际上它是叶子节点的最小样本权重和（hessian的二阶导数之和）。当所有样本权重都为1时，它才等价于最小样本数。所以当你想通过增加min_child_weight来抑制过拟合时，不代表设成50就要求叶子上有50个样本，要结合样本权重理解。

gamma比大多数人想象得重要。它代表一次分裂要成立所必须减少的最小损失量。换句话说，如果某次分裂带来的增益小于gamma，XGBoost就不会进行这次分裂。默认值是0，意味着只要损失不增加就可以分裂。比赛后期如果验证集分数上不去，适当提高gamma往往能把分数推到新高，因为它逼迫模型只保留真正有信息量的分裂。

subsample和colsample_bytree的实质是随机化。每次建树时，随机抽取一部分样本和一个特征子集，这样每一棵树看到的都是不完全相同的数据，最终求平均时方差显著降低。这和随机森林的思路类似，是GBDT家族缓解过拟合特别有效的手段。我个人的经验是，这两个参数的性价比比单纯调max_depth高，因为它们几乎不损失模型容量，但能明显改善泛化。

learning_rate和n_estimators必须放在一起看。低学习率意味着每一棵树对最终预测的贡献小，这就需要更多树慢慢逼近目标。如果learning_rate设为0.3但树的数量只有100，模型大概率还没收敛；反过来，如果learning_rate设为0.01但树的数量达到5000，也难保不会过拟合。正确姿势是给一个比较大的n_estimators上限，再通过early stopping在验证集上自动选一个合适的迭代次数。

3.3 参数之间的依赖关系

调参最大的误区是单独调一个参数。因为参数之间高度耦合，一个参数变了，另一个参数的最优值也会变。比如减小max_depth后，树变得浅了，模型欠拟合的风险增加，这时反而可以适当降低min_child_weight，让叶子节点更容易产生。或者你把learning_rate从0.1降到0.01之后，原来的max_depth可能都不需要那么深，因为低学习率已经在起作用了。

我常用的调参顺序是：先定一个较低学习率（0.05～0.1），然后依次调max_depth、min_child_weight、subsample、colsample_bytree、gamma，最后调正则化系数，最后再把学习率降下去做最终训练。这个顺序不是随意的，因为前面的参数决定树的结构，后面的参数影响整个模型的复杂度，结构没定就直接加正则，效果很飘。

4. 调参策略与实战路线

有了参数意识，下一步是实际操作。很多新手喜欢直接套用网上的最佳参数，然后在公共排行榜上看分数，这个做法很容易走进死胡同。正规流程应该是：建立一个可以快速迭代的实验框架，把调参变成一件有反馈的事。

4.1 先建立可靠的CV流程

任何调参都离不开可靠的交叉验证。Kaggle场景里我最常用的方案是Stratified K-Fold，分类用StratifiedKFold，回归用KFold。如果比赛是时间序列，则必须用TimeSeriesSplit或者自定义按时间分段的划分，切不可把未来数据混进训练折里。

给出一个我自己常用的二分类CV框架代码：

import numpy as np import pandas as pd import xgboost as xgb from sklearn.model_selection import StratifiedKFold from sklearn.metrics import roc_auc_score def run_xgb_cv(X, y, params, n_folds=5, seed=42): skf = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=seed) oof_pred = np.zeros(len(X)) scores = [] for fold, (tr_idx, va_idx) in enumerate(skf.split(X, y)): X_tr, X_va = X.iloc[tr_idx], X.iloc[va_idx] y_tr, y_va = y.iloc[tr_idx], y.iloc[va_idx] dtrain = xgb.DMatrix(X_tr, label=y_tr) dvalid = xgb.DMatrix(X_va, label=y_va) bst = xgb.train( params, dtrain, num_boost_round=3000, evals=[(dtrain, "train"), (dvalid, "valid")], early_stopping_rounds=100, verbose_eval=0 ) pred = bst.predict(dvalid, iteration_range=(0, bst.best_iteration + 1)) oof_pred[va_idx] = pred auc = roc_auc_score(y_va, pred) scores.append(auc) print(f"Fold {fold + 1} AUC: {auc:.6f}") print(f"CV AUC: {np.mean(scores):.6f} ± {np.std(scores):.6f}") return oof_pred, scores

这个框架的关键点是每折都重新训练一个模型，并且使用early stopping自动选取树的数量。注意iteration_range的使用，这样能确保预测时用的迭代次数和早停到的best_iteration一致，避免默认用全部树带来的偏差。

4.2 从粗调到细调

调参过程像剥洋葱，先粗后细。第一步，用默认参数跑一遍CV，确认数据和特征没有问题。如果连默认参数都跑不出有效分数，多半是特征工程或数据清洗出了问题，这时候别急着调参。

第二步，调整树的复杂度。把max_depth从3到10逐个尝试，每个深度下搭配不同的min_child_weight。这里我们先用learning_rate=0.1和较大的树数上限。我的经验是，绝大多数Kaggle表格赛的max_depth最优值落在4到7之间。如果你用hist算法且数据量很大，浅一些的树往往效果更好，因为树多了之后模型容量已经够了。

第三步，调整采样比例。subsample从0.6到1.0，colsample_bytree从0.5到1.0。这个过程最好把两个参数放进随机搜索里一起找，因为它们的交互作用很强。可以用RandomizedSearchCV，不过更高效的方式是直接写一个参数组列表，自己遍历。因为GridSearchCV和RandomizedSearchCV默认会对每个参数组合做一次完整的K折训练，成本高且和早停配合不自然。我通常的做法是写一个简单的循环，每次都用同样的CV框架跑，肉眼对比均值分数。这样虽然看起来原始，但调试起来非常透明，能看见每个折的具体走向。

第四步，调正则化。lambda从1到100之间尝试，alpha一般作用在高维稀疏特征较多的时候，Kaggle表格赛里可以只重点调lambda和gamma。gamma从0到5慢慢往上加，每次递增0.1或0.2，看到验证集分数不再提升就停止。

第五步，把learning_rate降到0.01左右，重新训练一个更大的n_estimators配合early stopping。这时你会发现模型会更稳，因为低学习率下每棵树的贡献更小，模型对噪声不那么敏感。如果时间紧张，也可以停在learning_rate=0.05。

4.3 用Optuna做贝叶斯搜索

当特征工程稳定之后，我会把调参交给Optuna。它使用树结构贝叶斯优化（TPE）来搜索参数空间，比随机搜索和网格搜索都更高效。下面是一个官方式的Optuna调参模板，可以直接套用：

import optuna from sklearn.model_selection import cross_val_score def objective(trial): params = { "objective": "binary:logistic", "eval_metric": "auc", "tree_method": "hist", "max_depth": trial.suggest_int("max_depth", 3, 8), "min_child_weight": trial.suggest_int("min_child_weight", 1, 10), "subsample": trial.suggest_float("subsample", 0.6, 1.0), "colsample_bytree": trial.suggest_float("colsample_bytree", 0.5, 1.0), "gamma": trial.suggest_float("gamma", 0, 3), "lambda": trial.suggest_float("lambda", 1, 20), "learning_rate": 0.05, } model = xgb.XGBClassifier(**params, n_estimators=1000, early_stopping_rounds=100) # 这里需要传入eval_set才能用早停，所以一般我们自定义CV循环 ...

用Optuna的时候不要再把learning_rate放进搜索空间，固定成一个较低值，因为树数和学习率高度耦合，同时搜索会让搜索空间变得很复杂。我把n_estimators留给early stopping处理，learning_rate固定，搜索空间集中在树的复杂度、采样和正则化上，这样收敛速度最快。

5. 特征工程与数据预处理

模型再强，特征不行也白搭。XGBoost虽然对缺失值、特征尺度比较宽容，但并不是说可以直接把原始数据丢进去就完事。

5.1 缺失值处理

XGBoost原生支持缺失值处理，训练时会把缺失值分成一类，自动学习最优方向。但在比赛中我发现，完全交给模型处理不一定是最好的选择。如果某个特征缺失比例超过30%，模型可能把它当成一个噪声信号。更稳妥的做法是先用业务逻辑判断缺失原因。比如年龄缺失可能代表未成年人或隐私保护，这种缺失本身就有信息量，可以单独用一个is_missing标记。批量填充时，数值特征常用中位数填充，类别特征常用“Missing”类别填充，然后还可以试试把缺失值设为一个极端值如-999，让树更容易分出一条路径。

5.2 类别特征编码

XGBoost 2.x原生支持类别特征，设置了enable_categorical=True后，你可以直接传入category类型的列。但我觉得除非类别编码很干净，否则不如自己处理更可控。类别基数低的特征用LabelEncoder或OneHotEncoder都行。类别基数高（比如上千个城市）时，OneHot会让数据膨胀，这时Target Encoding往往更有效。但Target Encoding最大的坑是数据泄漏——如果用全量数据的target均值去编码，验证集分数会虚高，线上就翻车。正确做法是在每一折内部，只用训练部分计算target均值，再映射到验证部分。sklearn里有TargetEncoder，或者可以自己写一个这样的小工具：

from sklearn.model_selection import KFold import pandas as pd def target_encode(trn_series, val_series, target, n_folds=5, seed=42): temp = pd.concat([trn_series, target], axis=1).groupby(trn_series)[target.name].agg(["mean"]).reset_index() ...

简单说，凡是涉及用目标变量做统计的特征工程，必须放在交叉验证的每一折内部进行，这是Kaggle红线规则。

5.3 目标变量变换

回归任务里，目标变量经常是长尾分布。价格、点击量、销售额，这类数据如果直接预测，模型会把注意力放在大数值上，小数值的预测误差很大。比赛里最常见的做法是对目标做对数变换：

df["log_price"] = np.log1p(df["price"])

训练时预测log_price，提交前再expm1还原。这个小小的变换经常能让RMSE分数大幅下降，尤其是在目标跨多个数量级的时候。做变换之前可以先看看目标分布长什么样，如果直方图严重右偏，log变换基本是稳赚不赔的操作。

5.4 特征构造与重要度分析

XGBoost能学交互，但不代表它能凭空造出高信息量的特征。时间字段可以拆成年、月、日、星期、是否节假日。数值特征可以做一些聚合统计，比如“用户历史平均消费”“该用户群体占比”这类。但聚合特征要谨慎，特别是按ID统计时，训练集和测试集的分布不一定一致，一旦测试集出现训练集没见过的ID，聚合特征就会失效或泄漏。

训练结束后，看feature_importance是判断特征质量最直接的方式。如果某个你认为很重要的特征重要度几乎为零，要么是它和别的特征高度重复，要么就是你的直觉有误。我常用的两个图是weight和gain，weight统计特征被用作分裂的次数，gain统计特征带来的平均增益。后者更接近特征的真实贡献，看重要度时优先看gain。

6. 实战：二分类与回归的完整流程

理论讲再多，不如跑一遍流程。这里我给出两个可以直接参考的实战模板，一个用原生API做二分类，一个用sklearn API做回归，覆盖了绝大多数Kaggle表格赛的场景。

6.1 二分类竞赛实战模板

假设比赛给了训练集和测试集，目标是预测用户是否会点击广告，评估指标是AUC。

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 train = pd.read_csv("train.csv") test = pd.read_csv("test.csv") # 简单特征工程 train["total_activity"] = train["num_views"] + train["num_clicks"] test["total_activity"] = test["num_views"] + test["num_clicks"] features = [c for c in train.columns if c not in ["id", "label"]] X = train[features] y = train["label"] params = { "objective": "binary:logistic", "eval_metric": "auc", "tree_method": "hist", "max_depth": 6, "min_child_weight": 3, "subsample": 0.8, "colsample_bytree": 0.8, "gamma": 0.5, "lambda": 2, "learning_rate": 0.03, "seed": 42 } skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42) test_pred = np.zeros(len(test)) for fold, (tr_idx, va_idx) in enumerate(skf.split(X, y)): X_tr, X_va = X.iloc[tr_idx], X.iloc[va_idx] y_tr, y_va = y.iloc[tr_idx], y.iloc[va_idx] dtrain = xgb.DMatrix(X_tr, label=y_tr) dvalid = xgb.DMatrix(X_va, label=y_va) bst = xgb.train( params, dtrain, num_boost_round=5000, evals=[(dvalid, "valid")], early_stopping_rounds=100, verbose_eval=0 ) test_pred += bst.predict(xgb.DMatrix(test[features]), iteration_range=(0, bst.best_iteration + 1)) / skf.n_splits submission = pd.DataFrame({ "id": test["id"], "prediction": test_pred }) submission.to_csv("submission.csv", index=False)

这个模板的细节在于：训练时evals只放验证集，不放训练集，这样早停的判据更干净；预测测试集时一定要用iteration_range限定到最佳迭代次数，否则预测会比期望的树数多；测试集预测概率取5折的平均，这本身就是最简单的集成。

6.2 回归竞赛实战模板

回归比赛里最典型的场景是预测房价，评估指标通常是RMSE。

import pandas as pd import numpy as np import xgboost as xgb from sklearn.model_selection import KFold from sklearn.metrics import mean_squared_error train = pd.read_csv("house_train.csv") test = pd.read_csv("house_test.csv") y = np.log1p(train["SalePrice"].values) features = [c for c in train.columns if c not in ["id", "SalePrice"]] X = train[features] model = xgb.XGBRegressor( n_estimators=3000, learning_rate=0.03, max_depth=5, min_child_weight=5, subsample=0.8, colsample_bytree=0.8, gamma=0.3, reg_lambda=3, tree_method="hist", random_state=42 ) kf = KFold(n_splits=5, shuffle=True, random_state=42) test_pred = np.zeros(len(test)) for fold, (tr_idx, va_idx) in enumerate(kf.split(X)): X_tr, X_va = X.iloc[tr_idx], X.iloc[va_idx] y_tr, y_va = y.iloc[tr_idx], y.iloc[va_idx] model.fit( X_tr, y_tr, eval_set=[(X_va, y_va)], early_stopping_rounds=100, verbose=False ) test_pred += np.expm1(model.predict(test[features])) / kf.n_splits # 保存提交 submission = pd.DataFrame({ "id": test["id"], "SalePrice": test_pred }) submission.to_csv("house_submission.csv", index=False)

回归任务里目标变量做了log变换，所以验证集的RMSE也是在log空间计算，而不是在原空间。如果你在log空间训练，但用原空间算RMSE，你会发现分数偏大，因为对数误差和原始误差不是线性关系。比赛提交前要确认评估指标是在哪个空间计算的。

6.3 公共榜与私有榜的注意事项

Kaggle的公共排行榜（Public LB）只用了测试集的一部分数据，私有排行榜（Private LB）用了另一部分。很多人过度相信Public LB，反复在它上面验证，最后翻车。实际上，Public LB分数波动比你想象的大，尤其是比赛样本量小的时候。我的原则是：以本地CV为准，Public LB只用来确认流程有没有大问题，而不是用来做模型选择的依据。如果Public LB和本地CV出现了明显的不一致，先怀疑数据泄漏或分布差异，而不是怀疑CV框架算错了。

7. 常见问题与排查技巧实录

打比赛这几年，我见过很多问题的坑，也自己踩过不少。把最常见的几个整理成速查表：

除了这些速查项，我再额外补充几个容易被忽视的实操细节。

第一个是随机种子。random_state不仅影响模型初始化，也影响CV划分。同一个参数组合用不同的种子跑，分数会有波动。比赛里很多队伍把多个随机种子的结果平均起来作为最终预测，这是一个很稳的提分手段。具体做法是：固定参数，但用5个不同的种子各训练一个模型，最后对预测求平均。AUC往往能提升0.001～0.003，别小看这几毫，前排差距就是这么拉开的。

第二个是评估指标和早停指标要一致。很多初学者用AUC做评估指标，却用logloss做early stopping，结果模型迭代次数选出来不是最优的，分数自然上不去。eval_metric应该和比赛评分指标保持一致，除非你明确知道某种指标和比赛指标有强相关性。

第三个是类别不平衡的处理。scale_pos_weight的经验值是负样本数除以正样本数。比如负样本9000个，正样本1000个，那么scale_pos_weight=9。但如果比赛指标是AUC或LogLoss，不平衡本身并不一定需要特殊处理，因为AUC对阈值不敏感。我先跑一个scale_pos_weight=1的baseline，看验证集指标再决定要不要进行调整。直接套scale_pos_weight经常把LogLoss搞坏。

第四个是时间序列竞赛的特殊要求。如果用普通的KFold去切时间序列，训练折里包含未来信息，CV分数会过分乐观。时间序列比赛要用TimeSeriesSplit，或者干脆手写“前训练后验证”的折叠方式。XGBoost在时间序列里往往需要构造滞后特征、滚动统计特征，然后在切分上做严格的时间隔离。

8. 从“调好一个模型”到“拿更高名次”

一个XGBoost调得再好，提升空间也在某个阶段就开始变缓。真正拉开名次差距的，往往是模型集成和后处理。

8.1 三种GBDT的stacking集成

这是我实战中性价比最高的集成方式。用同一份特征，分别训练XGBoost、LightGBM、CatBoost，然后把它们的测试集预测拼接成三个新特征，再用一个简单的逻辑回归或Ridge模型做stacking。两层stacking的示意代码如下：

# 假设你已经有了三个模型在测试集上的预测 test_pred_xgb = ... # shape (n_test,) test_pred_lgb = ... # shape (n_test,) test_pred_cat = ... # shape (n_test,) stacking_features = np.column_stack([ test_pred_xgb, test_pred_lgb, test_pred_cat ]) # 用逻辑回归作为meta模型 from sklearn.linear_model import LogisticRegression meta_model = LogisticRegression() meta_model.fit(stacking_features, y_train_stack) # y_train_stack是训练集oof预测拼接后的label

stacking最基础的做法是把三个模型的预测概率当作新特征，但更精细的做法是让meta模型去学习每个模型在不同区间的可靠性，比如某个模型对高概率样本更准，另一个对中低概率样本更准。meta模型能自动加权。如果只取平均，同样有效，但缺乏adaptive能力。

8.2 种子集成与伪标签

种子集成前面已经提到过，再补充一个正确处理方式：不是只对final模型做种子平均，而是对每一个要进stacking的兄弟模型分别做种子平均，保证输入meta模型的特征是稳定的。否则meta模型学到的权重会被种子噪声干扰。

伪标签（Pseudo Labeling）是一种半监督思路：先用训练好的模型预测测试集，把高置信度的测试样本当成标注数据加入训练集，再重新训练。这个方法在某些比赛中很奏效，但风险也大。一个常见的错误是：测试集里正负样本比例和训练集差异很大，无脑加伪标签会放大这种偏移。正确做法是只选取预测概率极高或极低的样本，控制加入的比例，并且在加入后重新验证CV分数是否真的提升。

8.3 后处理技巧

二分类比赛里，最常见的后处理是阈值移动。模型输出概率后，默认阈值是0.5，但比赛指标如果看重召回率或F1，0.5不一定是好阈值。可以用验证集上的预测结果，遍历所有可能的阈值，找出能让指标最大化的阈值，再应用到测试集。

回归比赛里，常见的后处理包括预测值的上下界clip、对预测做单调变换、或者用多个模型的预测结果计算加权几何平均。比如房价预测，如果测试集里有一些异常值，模型预测出极大值，直接clip到训练集最大值往往能提升RMSE。但任何后处理都要先在本地CV里验证，不要在Public LB上反复试了一个又一个“免费”的提分操作，那只会让你的流程过拟合到Public LB。

8.4 最后聊一个小技巧

我自己在比赛后期常做的一件不起眼但很有用的事：把每折的oof预测保存下来，看它的分布和测试集预测分布是否接近。如果训练集的预测概率均值是0.4，测试集是0.5，说明测试集的正样本比例可能更高，或者特征分布有偏移。及时发现这类偏移，就能提前排除标签漂移或特征构造错误，而不是等提交后才发现分数崩了。

XGBoost这条路，从入坑到熟练，再到能在比赛里灵活变通，需要的就是“理解参数原理 + 建立可靠CV流程 + 大量练习”。希望这篇文章里的经验和代码能帮你少走几步弯路。真正打比赛的时候，你会发现，调参的时间其实只占20%，剩下80%时间都在做特征工程、验证和排查问题。把XGBoost这棵树的根扎稳了，后面的模型集成和复杂技巧才有地方长。