企业官网建设流程全解析

回归任务里挑模型这件事，说简单也简单，说坑也多。很多教程一上来就甩一段CatBoostRegressor().fit(X, y)，跑出来一个R2就收工，但你真把它放到带十几个高基数类别特征的业务数据上，会立刻发现两类问题：一是不加处理直接喂类别特征，sklearn风格的接口会报类型错；二是照着老经验手动做目标编码（target encoding），线下验证分数漂亮得离谱，上线后一塌糊涂。CatBoost恰恰是为解决后一类问题长出来的，它最值钱的能力不是"又一个梯度提升库"，而是把类别特征处理和提升过程缝在了一起。这篇内容就是把我自己在Python里用CatBoostRegressor做回归项目的完整链路摊开讲：从数据准备、类别特征传参、参数联动、早停调优，到残差分析、和XGBoost/LightGBM的横向对比，再到模型持久化和上线前的一致性自查。适合已经会一点Python和sklearn、想真正把CatBoost用起来的同学，也适合被目标编码泄漏坑过、想找替代方案的人。

1. 为什么回归任务里我把CatBoost当默认首选

1.1 从一次房价预测的翻车说起

早几年做一个城市二手房估价的项目，特征里有小区ID、商圈、楼层区间、装修档次这类字段，其中小区ID有三千多个取值。当时的做法很"标准"：先用XGBoost，类别特征靠手工做目标编码，也就是按小区分组算成交价的均值，再替换掉原始ID。做法本身没错，但第一次跑出来的线下R2到了0.94，我差点以为模型调好了。上线后第一周就发现，模型对训练集里出现过的热门小区估得特别准，对没见过的、或者样本很少的小区估得离谱。

问题出在目标编码的泄漏上。算某个小区的均价时，如果这一行样本自己也参与了均值计算，那目标值就被"提前"写进了特征里。样本越少的小区，泄漏越严重，模型等于偷看了答案。当时的补救办法是加噪声、做K折编码、留出验证集，代码量一下子上去了，维护成本很高。

后来换成CatBoost，同一个数据集、同一套特征，只要把小区ID声明成cat_features，剩下的交给它。线下分数没有原来那么"虚高"，但线上线下基本对得上。这件事之后我就形成了一个习惯：只要数据里有类别特征，尤其是高基数的，先上CatBoost，不行再考虑别的。

1.2 对称树结构和有序提升到底解决了什么

CatBoost这个名字来自Category和Boosting，但它的技术底子有两块，跟"类别"同样重要。

第一块是oblivious tree（对称树/ oblivious decision tree）。普通GBDT每层分裂用的特征和阈值可以各不相同，CatBoost则要求同一层的所有节点用同一个分裂条件。很多人第一次听说会觉得这是自缚手脚，但对称树带来两个实际好处：一是预测时整棵树可以用位运算快速求值，推理延迟低；二是因为结构约束强，单棵树不容易长得过于刁钻，配合正则化后泛化更稳。可以类比成"规定每个路口只能朝同一个方向分叉"，路子变窄了，但不容易绕进死胡同。

第二块是ordered boosting与有序目标统计量。这正是解决1.1里那个泄漏问题的核心。CatBoost在处理类别特征时，不会用全部样本算某个类别的目标均值，而是给每个样本一个随机的排列顺序，只用排在它前面的样本来计算统计量。这样每行的编码都不包含它自己的目标值，泄漏被结构性掐断了。同时它引入了先验项和平滑系数，样本少的类别会被向全局均值拉近，避免"小区只有两套房就去估均价"这种极端情况。

这两点加起来，才解释了为什么CatBoost开箱即用就有不错的成绩，而不是靠调参硬堆出来的。

1.3 CatBoostRegressor和其他回归器的定位差异

选型的时候我一般按下面的思路判断，落到具体场景再看：

从这张表能看出，CatBoost的甜点区是类别特征密集、样本量中等、对上线稳定性要求高的回归任务。它不太适合那种几千万行、上百个数值特征、追求极致训练速度的场景，那时候LightGBM更划算。

2. 环境搭建与数据准备：把地基打牢

2.1 安装与版本选择

CatBoost的安装比想象中简单，因为它有预编译轮子：

# 基础安装 pip install catboost # 如果要用GPU训练（需要CUDA环境匹配） pip install catboost --upgrade # 确认版本 python -c "import catboost; print(catboost.__version__)"

几个我踩过的点。第一，Python版本别太旧，3.8以下在新版catboost上容易遇到轮子不匹配的问题，建议3.9到3.11之间。第二，Windows下如果装的时候报编译错误，八成是在尝试源码编译，先升级pip：python -m pip install --upgrade pip，再重试。第三，GPU版本对CUDA版本很敏感，如果你的显卡驱动和CUDA不是官方推荐的组合，老老实实用CPU版，CatBoost在CPU上处理类别特征的优势本来就很明显，GPU加速主要体现在大数据集的数值特征场景。

依赖方面，CatBoost会带上numpy、pandas、plotly之类的包。如果只想在离线环境装，可以先在有网的机器上pip download catboost -d ./pkgs，把整个pkgs目录拷过去再pip install --no-index --find-links=./pkgs catboost。

2.2 一份可以复现的回归数据集构造

很多教程用load_boston，那个接口在新版sklearn已经被移除了。我习惯直接合成一份带类别特征的回归数据，方便复现，也更贴近真实业务：

import numpy as np import pandas as pd from sklearn.datasets import make_regression np.random.seed(42) # 先造数值部分 X_num, y = make_regression( n_samples=8000, n_features=8, n_informative=6, noise=12.0, random_state=42 ) num_cols = [f"num_{i}" for i in range(X_num.shape[1])] df = pd.DataFrame(X_num, columns=num_cols) # 再挂上三个类别特征：低基数、中基数、高基数 df["city"] = np.random.choice(["北京", "上海", "广州", "深圳", "杭州"], size=len(df)) df["channel"] = np.random.choice( ["自然流量", "搜索", "社交", "线下", "推荐", "其他"], size=len(df), p=[0.3, 0.25, 0.2, 0.1, 0.1, 0.05] ) df["community_id"] = np.random.choice( [f"C{ i:04d}" for i in range(600)], size=len(df) ) # 让类别特征真的对目标有影响，否则模型学不到东西 city_effect = {"北京": 30, "上海": 25, "广州": 12, "深圳": 20, "杭州": 8} channel_effect = {"自然流量": 5, "搜索": 12, "社交": -6, "线下": -12, "推荐": 18, "其他": 0} df["target"] = ( y + df["city"].map(city_effect) + df["channel"].map(channel_effect) + np.random.normal(0, 3, size=len(df)) ) print(df.shape) print(df.dtypes)

这里有个关键动作：给类别特征人为注入真实效应。很多合成数据只加随机类别，模型跑出来的特征重要性全是噪声，你根本没法判断代码对不对。上面这段里，city和channel都按映射影响了target，只有community_id是纯随机的，正好用来观察CatBoost会不会把一个无关的高基数特征误判成重要特征。

2.3 训练集验证集切分的几个细节

回归任务不做分层其实也可以，但如果你的目标分布有偏（比如房价、销量这类右偏数据），用分箱后的分层切分会更稳：

from sklearn.model_selection import train_test_split import pandas as pd # 按目标值分箱，保证训练集和验证集的分布接近 y_bins = pd.qcut(df["target"], q=10, labels=False, duplicates="drop") train_idx, valid_idx = train_test_split( df.index, test_size=0.2, random_state=42, stratify=y_bins ) train_df = df.loc[train_idx].reset_index(drop=True) valid_df = df.loc[valid_idx].reset_index(drop=True) print(train_df.shape, valid_df.shape)

注意reset_index(drop=True)这一步。CatBoost的Pool对象对索引不敏感，但如果你后面手动做特征重要性对齐、或者拼预测结果，留着断裂的索引很容易出错。我吃过这个亏：训练时特征列顺序是靠X.columns定的，拼结果时用了旧索引，两边对不上，排查了半小时。

另外一个细节，别在切分前做全局标准化。树模型对单调变换不敏感，标准化意义不大，反而如果是先做全局统计再切分，会引入轻微的信息泄漏。数值特征如果确实需要处理（比如存在极端异常值），用分位数截断，且截断的阈值要在训练集上算。

3. 类别特征处理：CatBoost最不该被浪费的能力

3.1 目标编码为什么会在回归里泄漏

前面提了泄漏，这里把原理讲透一点，因为理解它是正确用CatBoost的前提。

假设小区C0001有三套成交房，价格分别是100万、110万、120万。做目标编码时，第一套房的特征里会填上(100+110+120)/3=110。但这条样本自己的标签是100，特征里却出现了由100算出来的均值，模型学到的是"给定特征110，预测100"。到训练集里其他行，模型同样在拟合这种偏移。样本越少的类别，这种自我包含的比例越高，模型越倾向于记住训练集。

标准补救方式有两种：留一法（leave-one-out，算均值时排除当前行）和K折编码。留一法一次只能排除一行，样本少时方差仍然大；K折编码要写循环、维护多份编码器，工程上麻烦。CatBoost的ordered target statistics本质上是留一法的一个更聪明的版本，它用一个随机排列保证每行只用"历史上更早"的样本，同时通过多次排列平均来降低方差。

要验证这一点，可以做个对比实验，同一份数据分别用XGBoost+手工目标编码和CatBoost原生类别处理，观察验证集和训练集的R2差距。手工编码那次，训练R2通常比验证R2高出0.1以上；CatBoost这边的差距会小得多。

3.2 cat_features参数的传参方式与踩坑

cat_features是CatBoost最容易写错的地方，我把常见写法摆出来：

from catboost import CatBoostRegressor, Pool import pandas as pd cat_cols = ["city", "channel", "community_id"] # 写法一：传列名列表（需要X是DataFrame） X_train = train_df.drop(columns=["target"]) y_train = train_df["target"] model = CatBoostRegressor( iterations=1000, learning_rate=0.05, depth=6, loss_function="RMSE", random_seed=42, verbose=100 ) model.fit(X_train, y_train, cat_features=cat_cols) # 写法二：传列索引（X是ndarray时用） # X_train_arr = X_train.values # model.fit(X_train_arr, y_train, cat_features=[9, 10, 11])

踩坑清单我列一下，都是真实报错换来的经验：

• 类别列不能是float类型。哪怕你里面的值是1.0、2.0这种整数值，CatBoost也会报Invalid type for cat_feature。解决办法是.astype(str)或者.astype(int)再转str。我习惯统一转str，避免后续新增取值时类型冲突。
• 不能有NaN。数值特征CatBoost能自己处理缺失，但类别特征的缺失值要显式填成字符串，比如"missing"，否则会报错。
• 列名和索引要跟传入的cat_features一致。如果你fit时用DataFrame、传的是列名，没问题；但如果中途把DataFrame转成ndarray却忘了改传索引，就会静默错列。这种错最恶心，模型能跑，但学的是错的。
• cat_features里的列别同时出现在ignored_features里，会报冲突。

推荐直接用Pool对象，把训练集和验证集都封装好，代码更清晰：

train_pool = Pool( data=X_train, label=y_train, cat_features=cat_cols ) valid_pool = Pool( data=valid_df.drop(columns=["target"]), label=valid_df["target"], cat_features=cat_cols )

3.3 高基数类别特征该不该手动处理

我的经验是交给CatBoost，但设一个上限。像community_id这种600个取值的特征，CatBoost会自动做目标统计量，不需要你手动聚合。但如果是几十万取值的用户ID、订单号，直接丢进去会显著拖慢训练并可能过拟合，这时候应该先做频次过滤，把出现次数少于N次的取值统一归到"other"：

min_count = 20 freq = train_df["community_id"].value_counts() rare = freq[freq < min_count].index train_df["community_id"] = train_df["community_id"].where( ~train_df["community_id"].isin(rare), other="other" ) valid_df["community_id"] = valid_df["community_id"].where( ~valid_df["community_id"].isin(rare), other="other" )

这里有个必须注意的点：频次统计只能基于训练集，然后用同一套规则去映射验证集和测试集。如果拿全量数据算频次，那就是把验证集信息泄漏进了训练。这个问题在团队协作里特别常见，因为写预处理脚本的人可能不知道后面会怎么切分。

另外，CatBoost有个参数叫one_hot_max_size，默认值是2（分类任务）或255（注意不同版本差异）。当类别取值个数不超过这个阈值时，它会用one-hot而不是目标统计量。对city、channel这种低基数特征，我一般会把one_hot_max_size设成10到20，让它们走one-hot，编码更直接、更稳定。

4. 模型训练与参数调优的实战路径

4.1 先跑通baseline再谈调参

新手最容易犯的错是先花两天调参，结果发现是数据流水线有问题。我的顺序永远是：先让模型跑起来、打印验证指标、看训练曲线，再动手调参。

model = CatBoostRegressor( iterations=2000, learning_rate=0.05, depth=6, loss_function="RMSE", eval_metric="RMSE", random_seed=42, verbose=200 ) model.fit( train_pool, eval_set=valid_pool, use_best_model=True ) from sklearn.metrics import r2_score, mean_absolute_error pred = model.predict(valid_pool) print("R2:", r2_score(valid_df["target"], pred)) print("MAE:", mean_absolute_error(valid_df["target"], pred)) print("best_iteration:", model.get_best_iteration()) print("best_score:", model.get_best_score())

如果这个baseline的验证R2远低于训练R2，先别调参，回去查类别特征有没有传对。我遇到过一次，cat_features传的索引错了两位，模型把所有类别列当成了数值，训练R2 0.99、验证R2 0.6，调了三天参数没救回来。

4.2 learning_rate、depth、l2_leaf_reg的联动关系

这三个参数是CatBoost回归里最需要联调的，单独看某一个没意义。

learning_rate和iterations是一对。学习率小，需要更多轮数才能收敛，但通常泛化更好；学习率大，收敛快但容易在验证集上抖动。我的惯例是：先用learning_rate=0.05、iterations=2000跑一遍看best_iteration落在哪。如果best_iteration在1500以上，说明还可以再降学习率；如果在300以内，说明学习率偏大，可以降到0.03再试。

depth控制树复杂度。CatBoost默认depth=6。回归任务我一般在4到8之间试。深度大了，模型能拟合更复杂的交互，但对高基数类别特征也更容易过拟合。有个小技巧：类别特征多的时候，depth不要设太大，因为有序目标统计量本身已经提供了很强的表达力，树再深容易过。

l2_leaf_reg是叶节点权重的L2正则，默认3.0。这个参数对高基数类别特征特别重要。当你发现训练R2和验证R2差距大、或者特征重要性里某个高基数特征一家独大，先把l2_leaf_reg从3提到10甚至30试试。

我常用的搜索范围：

4.3 早停法与过拟合判断

早停是最省事的防过拟合手段，但要用对：

model = CatBoostRegressor( iterations=5000, learning_rate=0.03, depth=6, l2_leaf_reg=6, loss_function="RMSE", eval_metric="RMSE", random_seed=42, od_type="Iter", # 按迭代次数判断 od_wait=200, # 连续200轮没提升就停 verbose=200 ) model.fit(train_pool, eval_set=valid_pool, use_best_model=True)

od_wait的设置要和learning_rate匹配。学习率0.03、od_wait=50就太激进，模型还没收敛就停了；学习率0.1、od_wait=500又太宽松，白跑很多无效轮次。我一般的经验值是od_wait取300到500，配合learning_rate<=0.05。

判断过拟合不能只看训练验证差距，还要看验证曲线形状。如果验证RMSE在下降后又缓慢上升，说明确实过拟合，加正则或减深度；如果验证曲线一直在小幅震荡、没有明显上升，那可能只是数据噪声大，这时候加大od_wait、多跑几轮反而更稳。

4.4 用GridSearchCV还是自己写循环

CatBoost自己的fit有eval_set和早停，直接套sklearn的GridSearchCV会有点别扭，因为网格搜索内部不支持把eval_set传进去做早停（新版本有一定支持但配置麻烦）。我的做法是用RandomizedSearchCV做粗筛，配置如下：

from sklearn.model_selection import RandomizedSearchCV, KFold from scipy.stats import uniform, randint param_dist = { "depth": randint(4, 9), "learning_rate": uniform(0.02, 0.06), "l2_leaf_reg": uniform(1, 15), "random_strength": uniform(0.5, 1.5), } base = CatBoostRegressor( iterations=1500, loss_function="RMSE", random_seed=42, verbose=0 ) cv = KFold(n_splits=3, shuffle=True, random_state=42) search = RandomizedSearchCV( base, param_dist, n_iter=20, cv=cv, scoring="neg_root_mean_squared_error", random_state=42, n_jobs=1, verbose=2 ) search.fit(X_train, y_train, cat_features=cat_cols) print(search.best_params_) print(-search.best_score_)

注意n_jobs=1。CatBoost本身就是多线程的，外面再开并行会资源打架，反而更慢。粗筛出候选参数后，再手动用eval_set精调一轮，加早停，这样效率最高。

如果团队里有Optuna，也可以直接上，但要注意：别让调参搜索把验证集也"训练"了。搜索阶段用交叉验证，最后留一个真正没碰过的测试集做最终评估，否则你报出来的分数没有意义。

5. 评估、残差分析与模型解释

5.1 回归指标不能只看R2

R2是相对指标，它衡量的是"比直接预测均值好多少"。一个R2=0.85的模型，在房价预测里可能很优秀，但在某些信噪比极低的场景里，你永远也到不了0.85。所以必须配着绝对误差看：

我的习惯是同时打印RMSE、MAE和R2，再加一句业务解释。比如"MAE是12.3万，意味着平均每套房价估错12万左右"，这种话给业务方看比R2有用得多。

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score import numpy as np pred = model.predict(valid_pool) y_true = valid_df["target"].values rmse = np.sqrt(mean_squared_error(y_true, pred)) mae = mean_absolute_error(y_true, pred) r2 = r2_score(y_true, pred) print(f"RMSE={rmse:.4f} MAE={mae:.4f} R2={r2:.4f}")

5.2 残差图应该怎么看

残差分析是回归里最容易被跳过、但最有价值的一步。我一般看三张图。

第一张是残差对预测值的散点图。理想情况是残差均匀地散布在0附近，没有形状。如果你看到一个喇叭形（预测值越大残差越大），说明模型对高值区拟合不足，可以考虑对目标做对数变换，或者加一个关于目标量级的特征。如果看到一个弯曲的U形，说明模型欠拟合，有非线性关系没被抓住。

第二张是残差分布直方图。如果明显偏斜或者有第二个峰，说明还有某个维度没被模型利用。我遇到过一次，残差里有个小峰，最后发现是某个类别特征的某个取值只在验证集出现，训练集里样本太少，模型没学好。

第三张是残差对关键特征的分组箱线图。按city分组看残差中位数，如果某个城市的残差系统性地偏正或偏负，说明模型对这个城市有系统性偏差，可能是训练样本里这个城市的样本太少。

import matplotlib.pyplot as plt import numpy as np residuals = y_true - pred fig, axes = plt.subplots(1, 2, figsize=(12, 4)) axes[0].scatter(pred, residuals, s=5, alpha=0.4) axes[0].axhline(0, color="red", linestyle="--") axes[0].set_xlabel("Predicted") axes[0].set_ylabel("Residual") axes[0].set_title("Residual vs Predicted") axes[1].hist(residuals, bins=50) axes[1].set_title("Residual Distribution") plt.tight_layout() plt.show()

5.3 特征重要性与SHAP

CatBoost自带特征重要性，用起来很方便：

import pandas as pd importance = model.get_feature_importance(train_pool) feat_names = X_train.columns imp_df = pd.DataFrame({ "feature": feat_names, "importance": importance }).sort_values("importance", ascending=False) print(imp_df.head(15))

get_feature_importance默认的type是FeatureImportance，也就是基于分裂增益的统计。对于类别特征，CatBoost还会单独报"类别特征处理方式"的重要性，可以用type="PredictionValuesChange"看看另一视角。我通常两个都打印，对比一下。

但要说清楚，基于分裂增益的重要性对高基数类别特征有偏。因为一个高基数特征有很多可能的切分点，它在训练中被选中的机会大，增益累计也大，但这不代表它真的贡献大。我一般在重要性之后补一个SHAP分析：

import shap explainer = shap.TreeExplainer(model) X_sample = X_train.sample(500, random_state=42) shap_values = explainer.shap_values(X_sample) # 全局重要性 shap.summary_plot(shap_values, X_sample, plot_type="bar") # 单样本解释 shap.plots._waterfall.waterfall_legacy( explainer.expected_value, shap_values[0], X_sample.iloc[0] )

在3.2节里那个数据里，如果community_id在基于增益的重要性里排前三，但在SHAP里排名靠后，基本可以判断它是个高基数噪声特征，考虑做频次过滤或直接删掉。

5.4 交叉验证的写法

最终的模型评估应该走交叉验证，而不是单次切分。写法如下：

from sklearn.model_selection import KFold from sklearn.metrics import mean_squared_error import numpy as np kf = KFold(n_splits=5, shuffle=True, random_state=42) scores = [] iterations = [] for fold, (tr_idx, va_idx) in enumerate(kf.split(X_train)): tr_pool = Pool(X_train.iloc[tr_idx], y_train.iloc[tr_idx], cat_features=cat_cols) va_pool = Pool(X_train.iloc[va_idx], y_train.iloc[va_idx], cat_features=cat_cols) m = CatBoostRegressor( iterations=3000, learning_rate=0.04, depth=6, l2_leaf_reg=6, loss_function="RMSE", od_type="Iter", od_wait=300, random_seed=42, verbose=0 ) m.fit(tr_pool, eval_set=va_pool, use_best_model=True) pred = m.predict(va_pool) rmse = np.sqrt(mean_squared_error(y_train.iloc[va_idx], pred)) scores.append(rmse) iterations.append(m.get_best_iteration()) print(f"fold {fold} RMSE={rmse:.4f} best_iter={m.get_best_iteration()}") print(f"CV RMSE = {np.mean(scores):.4f} +/- {np.std(scores):.4f}") print(f"平均最优迭代次数 = {int(np.mean(iterations))}")

这里有个实用技巧：记录每折的best_iteration，取平均后作为最终全量训练的迭代轮数。比如平均是800，那最终模型就用iterations=800在全量训练集上重训一次，不需要早停（因为没有验证集了），这样能把所有数据都用上。

6. 与XGBoost、LightGBM横向对比与选型

6.1 同一份数据上的三方对比

说CatBoost好，得拿出同一份数据的对比。下面这段代码把三个模型放在一起跑，参数都控制在"默认+轻度调优"的水平，避免为了黑而黑：

import time import numpy as np from sklearn.metrics import mean_squared_error, r2_score from catboost import CatBoostRegressor, Pool import xgboost as xgb import lightgbm as lgb # 为了方便，手工把类别特征做简单的one-hot，三方共用 X_train_enc = pd.get_dummies(X_train, columns=cat_cols).astype(float) X_valid_enc = pd.get_dummies(X_valid, columns=cat_cols).astype(float) X_valid_enc = X_valid_enc.reindex(columns=X_train_enc.columns, fill_value=0) results = [] # CatBoost t0 = time.time() cb = CatBoostRegressor(iterations=1000, learning_rate=0.05, depth=6, l2_leaf_reg=6, loss_function="RMSE", random_seed=42, verbose=0) cb.fit(Pool(X_train, y_train, cat_features=cat_cols), eval_set=Pool(X_valid, y_valid, cat_features=cat_cols), use_best_model=True) cb_pred = cb.predict(X_valid) results.append(("CatBoost", time.time()-t0, np.sqrt(mean_squared_error(y_valid, cb_pred)), r2_score(y_valid, cb_pred))) # XGBoost t0 = time.time() xgb_model = xgb.XGBRegressor( n_estimators=1000, learning_rate=0.05, max_depth=6, reg_lambda=3, random_state=42, n_jobs=4 ) xgb_model.fit(X_train_enc, y_train, eval_set=[(X_valid_enc, y_valid)], verbose=False) xgb_pred = xgb_model.predict(X_valid_enc) results.append(("XGBoost", time.time()-t0, np.sqrt(mean_squared_error(y_valid, xgb_pred)), r2_score(y_valid, xgb_pred))) # LightGBM t0 = time.time() lgb_model = lgb.LGBMRegressor( n_estimators=1000, learning_rate=0.05, num_leaves=31, reg_lambda=3, random_state=42, n_jobs=4, verbose=-1 ) lgb_model.fit(X_train_enc, y_train, eval_set=[(X_valid_enc, y_valid)], callbacks=[lgb.early_stopping(100, verbose=False)]) lgb_pred = lgb_model.predict(X_valid_enc) results.append(("LightGBM", time.time()-t0, np.sqrt(mean_squared_error(y_valid, lgb_pred)), r2_score(y_valid, lgb_pred))) for name, t, rmse, r2 in results: print(f"{name:10s} time={t:.1f}s RMSE={rmse:.4f} R2={r2:.4f}")

在我几台机器上跑下来，典型结果是：LightGBM训练最快，CatBoost和XGBoost接近；精度上CatBoost在这份高基数类别特征的合成数据上通常略胜。

6.2 什么时候CatBoost更值得选

别把CatBoost当成万能药。我的判断标准是看类别特征的"含金量"和数量。

如果你手头的数据有5个以上类别特征，其中至少有一个基数超过100，而且你不想在预处理上花太多时间，CatBoost的优势非常明显。反过来，如果你的数据全是连续数值特征，类别特征只有一两个低基数的，那用LightGBM就够了，CatBoost的类别处理能力用不上，训练还慢一点。

还有一个常被忽略的点：CatBoost对默认参数不敏感。同样不调参，CatBoost在很多数据集上开箱成绩就比XGBoost稳。项目周期紧、不想花时间调参的时候，这本身就是优势。我在做快速原型验证时基本都用CatBoost直接跑，出个baseline大概就能判断这个特征集有没有戏，再决定要不要用LightGBM精调。

最后提醒一句，别在同一个项目里三套框架全用上。库的版本兼容、依赖冲突、上线包体大小都是成本。选一个主力，深度用好它，比"每个都懂一点"强得多。

7. 上线前的收尾：模型持久化、推理一致性与常见报错

7.1 模型保存与加载

CatBoost的模型保存有两种格式：.cbm是二进制格式，.json是可读格式。生产环境用.cbm：

# 保存 model.save_model("catboost_reg.cbm") # 加载 from catboost import CatBoostRegressor loaded = CatBoostRegressor() loaded.load_model("catboost_reg.cbm") # 保存成json便于审查（文件更大） model.save_model("catboost_reg.json", format="json") # 导出为Python代码（方便嵌入到没有catboost环境的服务里） model.save_model("model_as_code.py", format="python")

.cbm跨平台兼容，Windows上训练、Linux上加载没问题。但有一个大坑：save_model保存的是模型结构，不是你的特征处理逻辑。如果预测时你把类别列的顺序改了、或者数值列做了训练时没做的填充，模型不会报错，只会给你一个错误的预测。

我的做法是把特征列表和类别列表一起序列化：

import json meta = { "feature_order": list(X_train.columns), "cat_features": cat_cols, "target_transform": None, # 如果做了log变换，这里要记 "version": "20240115_1" } with open("model_meta.json", "w", encoding="utf-8") as f: json.dump(meta, f, ensure_ascii=False)

预测服务启动时先读meta，按feature_order重排输入，再走loaded.predict。这套东西看着土，但能挡住九成"线上线下不一致"的锅。

7.2 训练推理特征不一致的排查

上线后预测偏差大，先按这个顺序查：

1. 特征列顺序。DataFrame转numpy时，列顺序最容易变。用meta["feature_order"]强制重排。
2. 类别特征取值类型。训练时community_id是str，推理时如果上游给的是int，CatBoost会把它当新类别处理，走默认编码。所以推理入口统一astype(str)。
3. 缺失值处理。训练时你填了"missing"，推理时如果填的是None或np.nan，行为不一致。
4. 特征计算逻辑。最容易出问题的一项。训练时的特征是从离线宽表里取的，线上是实时算的，逻辑不同就会漂移。建议对每个特征写一个对比脚本，拿一批样本同时走离线和线上逻辑，逐列比数值。

我一般会在模型上线前跑一个"一致性测试"：从验证集里抽1000行，离线预测一遍，再模拟线上流水线预测一遍，比较两次结果的差异。如果不一致，问题一定在流水线，而不在模型。

7.3 常见报错与对应处理

GPU显存那个坑值得多说一句。CatBoost在GPU上训练时，border_count默认是128，改成64或32能显著降显存，代价是分裂点变少，精度可能略降。另外GPU模式在某些版本上不支持类别特征的目标统计量计算，会回退到CPU，表现就是"明明开了GPU却还是很慢"，这时候看日志里的warning就能发现。

还有一个容易被忽略的报错：random_seed没固定导致的复现问题。CatBoost的bootstrap和特征采样都依赖随机种子，如果训练脚本里只固定了random_seed但没固定numpy的种子，某些预处理步骤（比如采样）还是会变。我的习惯是在脚本开头统一固定np.random.seed(42)、random.seed(42)，并在CatBoost里显式传random_seed=42。

最后说个我个人踩得最深的坑：别在最后一次训练时省略eval_set去做"全量训练"。我原来图省事，用交叉验证选好参数后，直接在全量训练集上不设验证集跑了固定轮数。结果因为全量数据比单折多，同样的轮数下模型其实还没充分训练。正确做法是用交叉验证里记录的best_iteration均值乘以一个系数（比如1.1，因为数据变多了）作为最终轮数，同时保留一小块留出集做监控。这一点在CatBoost这种对迭代轮数敏感的模型上尤其重要，宁可多留一点余量，也别让模型欠训练上线。