手写随机森林实现：从bootstrap、基尼分裂到OOB与特征重要性

简介：随机森林模型代码资料包面向机器学习初学者、数据科学课程学习者以及需要可运行实现参考的开发者，围绕随机森林在分类与回归任务中的应用，提供从算法原理到代码实践的配套内容。压缩包共66个文件、约29.8MB，主体为cpp、m、mexw64/mexw32、h、makefile、mat、txt等类型，覆盖C++与Matlab源码、编译脚本、预编译二进制、示例数据和说明文档，并附pptx课件与wmv演示视频，便于对照理解bootstrap采样、随机特征选择、决策树构建及投票或均值预测流程。已有3733人学习下载。读者可借此梳理随机森林的完整代码结构，观察参数设置、特征重要性与模型调优的实现方式，并结合课件和视频加深对集成学习多样性与平均机制的理解。

1. 从一次线上误判说起：手写随机森林能补上哪些调包补不上的洞

去年有个推荐场景的二分类模型，离线 AUC 0.86，上线后某一段流量里几乎全判成负类。整个排查过程里最耗时间的不是调参，而是没人说得清模型到底在哪个特征上分裂、分裂点的阈值是怎么定的——sklearn 的RandomForestClassifier把决策树封得比较彻底，estimators_[0].tree_里那堆并行数组对新人不友好。那次之后我把随机森林按最小可运行版本重写了一遍：bootstrap 采样、基尼不纯度、CART 分裂、袋外估计、特征重要性全部自己算。这份代码包就是那次的产物，面向两类人：想搞懂集成学习内部机制的开发者，以及需要在业务里替换掉黑盒模型的工程师。它的价值不在于比 sklearn 快，而在于每一行都能打断点。

2. 项目全貌与技术选型：6 个文件怎么撑起一次完整训练

2.1 目录结构与模块职责

代码包刻意压得很扁，核心实现只有三个文件，其余都是脚本和测试。这样做的理由是：新人拿到包后要能在十分钟内定位到"树是在哪建的"，而不是在 20 层包目录里翻。

rf/包不引入任何 sklearn 依赖，只用 numpy。scripts/里的对照脚本才 import sklearn，这样部署到只有 numpy 的环境里也能跑推理。metrics.py单独抽出来是因为业务侧经常要求输出混淆矩阵做业务归因，把它和树实现解耦后续改起来不牵扯核心逻辑。

utils.py里有个容易被忽略的函数derive_seeds，它用np.random.SeedSequence(master).spawn(n)派生子种子。很多人复现不了结果就是栽在这里：森林层面设了random_state=42，但每棵树在并行时共享了同一个default_rng，实际拿到的随机流顺序依赖任务调度，跑两次结果就不一样。

2.2 技术栈选择：为什么用 numpy 手写加 sklearn 对照

选型上只做了两个决定。第一个是核心实现用 numpy 向量化，不用纯 Python 循环。基尼增益的计算里最贵的一步是对每个候选切分点算左右子集的类别分布，纯循环在 5000 行数据上要跑几十秒，改成前缀和 cumsum 之后降到秒级——这个技巧在best_split里体现得很直接。第二个是保留 sklearn 做对照，因为只写不比对，很容易出现"精度看着还行但其实分裂逻辑写反了"的情况。

依赖清单很短：numpy做数组运算，joblib做多进程并行，pandas只在数据加载脚本里用，scikit-learn只在对照脚本里用，matplotlib用来画特征重要性条形图，pytest跑单测。我一般不在requirements.txt里锁死小版本号，只锁大版本，随机森林这种算法实现不会因为 numpy 小版本更迭就崩。Python 用 3.9 以上，np.random.Generator的新接口在 3.9 之后才稳定。

一个常见的误用是把这份代码当生产级库来替换 sklearn。它不支持稀疏输入、不支持样本权重、不支持缺失值原生处理，也不做任何类型检查的兼容层。定位就是教学和可控性优先，真要上生产得自己补。

2.3 环境准备与第一条命令跑通

拉起环境只需要三步。第一步建虚拟环境装依赖，第二步跑单测确认核心逻辑没被环境搞坏，第三步跑演示脚本看端到端结果。

python -m venv .venv && source .venv/bin/activate pip install numpy joblib pandas scikit-learn matplotlib pytest # 先跑单测，确认树的分裂逻辑在当前 numpy 下行为一致 pytest tests/test_tree.py -q # 端到端演示：造 5000 行 30 维三类数据，8:2 切分 python scripts/train_demo.py --n-samples 5000 --n-features 30 --n-classes 3

train_demo.py会打印训练集准确率、测试集准确率、OOB 分数和耗时，最后把模型 joblib 序列化到artifacts/目录。命令行参数里--n-samples控制样本量，--n-features控制特征维度，--max-depth控制树深，--n-estimators控制树的数量。第一次跑建议先把--n-estimators压到 20，确认整条链路通了再往上加，不然一个MemoryError会让人误以为是数据问题。

跑完对照脚本能直接看到差距：

# 同数据同超参下和 sklearn 对比 python scripts/compare_sklearn.py --n-samples 20000 --n-features 50

输出里会并列显示两边在测试集上的准确率和训练耗时。手写版一般落后 1~2 个百分点，主要差在 sklearn 对连续特征做了预排序优化、切分点搜索更细。这个差距是正常的，能接受就继续往下改，接受不了说明你其实需要的是调包而不是这份代码。

提示：第一次跑之前先把scripts/train_demo.py顶部的RANDOM_STATE改成你们团队约定的种子，后面所有对照实验都从这里继承，省得每次解释"为什么这次结果又变了"。

3. 核心模块拆解：bootstrap 采样到基尼分裂的完整决策链

3.1 自助采样：bootstrap 与 OOB 样本是怎么切出来的

随机森林之所以叫"随机"，一半来自样本采样，一半来自特征采样。bootstrap 的做法是有放回地从 n 个样本里抽 n 次，大约 63.2% 的样本会被抽中，剩下 36.8% 从没进过训练集，这批样本就是袋外（Out-of-Bag）样本，可以当成一份免费的验证集。

实现上不要用np.random.choice(n, n)，它的默认replace=False，忘记传参就变成无放回抽样，森林直接退化成 Bagging 的普通版本。正确写法是rng.integers：

import numpy as np def bootstrap_indices(n_samples, rng): """有放回抽样，返回样本下标；同一棵树的重复样本会一起参与训练""" return rng.integers(low=0, high=n_samples, size=n_samples, dtype=np.int64) def in_bag_mask(idx, n_samples): """把下标数组转成布尔掩码，True 表示该样本进了这棵树的训练集""" mask = np.zeros(n_samples, dtype=bool) mask[idx] = True return mask

bootstrap_indices返回的是带重复的下标数组，直接拿去索引X[idx]和y[idx]就行，重复样本在树里对应更大的权重，这是 bootstrap 的本意，不要用np.unique去重。in_bag_mask的作用是把下标转成布尔掩码存在森林对象里，后面算 OOB 分数时，对每个样本找出所有mask[样本]=False的树，用这些树的预测做聚合。

参数上n_samples是训练集行数，rng必须是np.random.default_rng(seed)生成的独立 Generator 实例，不要用全局的np.random。原因在避坑那章会细说，简单讲就是全局随机状态在 joblib 多进程下会被 fork 出多份副本，种子相同、流不同，结果不可复现。

3.2 基尼不纯度与向量化最优分裂搜索

基尼不纯度衡量一个节点里类别有多混杂，公式是1 - Σp_k²，p_k 是第 k 类在该节点的占比。纯节点的基尼值是 0，正负类各一半的二分类节点是 0.5。

def gini(y, n_classes=None): """节点基尼不纯度；y 是已经编码到 0..C-1 的整数标签""" if y.size == 0: return 0.0 counts = np.bincount(y, minlength=n_classes or (int(y.max()) + 1)) p = counts / y.size return float(1.0 - np.sum(p * p))

真正难的是分裂点搜索：对每个候选特征，要把所有可能的切分点试一遍，算左右两侧的加权基尼，取加权基尼最小的那个。逐点算的复杂度是 O(n²)，5000 行数据光单节点就能卡住。常见做法是排序后用前缀和一次算完：

def best_split(X, y, n_classes, feature_indices, min_gain=1e-7): """在候选特征里找最优切分，返回 (特征下标, 阈值, 增益)；找不到返回 (None, None, 0.0)""" n_samples = X.shape[0] parent = gini(y, n_classes) best_gain, best_f, best_thr = 0.0, None, None for f in feature_indices: x = X[:, f] order = np.argsort(x, kind="mergesort") # 稳定排序，保证同值样本顺序一致 xs, ys = x[order], y[order] onehot = np.zeros((n_samples, n_classes), dtype=np.float64) onehot[np.arange(n_samples), ys] = 1.0 left_cnt = np.cumsum(onehot, axis=0)[:-1] # 前 i 个样本里各类的数量 right_cnt = onehot.sum(axis=0) - left_cnt n_left = np.arange(1, n_samples, dtype=np.float64)[:, None] n_right = n_samples - n_left g_left = 1.0 - np.sum((left_cnt / n_left) ** 2, axis=1) g_right = 1.0 - np.sum((right_cnt / n_right) ** 2, axis=1) weighted = (n_left[:, 0] * g_left + n_right[:, 0] * g_right) / n_samples gain = parent - weighted gain[xs[:-1] == xs[1:]] = -np.inf # 相同取值之间切不出信息增益，禁用 i = int(np.argmax(gain)) if gain[i] > best_gain: best_gain, best_f = float(gain[i]), int(f) best_thr = float((xs[i] + xs[i + 1]) / 2.0) if best_gain < min_gain: return None, None, 0.0 return best_f, best_thr, best_gain

几个参数要说清楚。feature_indices是这一层允许参与分裂的特征下标，随机森林的"特征随机性"就体现在调用前用rng.choice(n_features, size=max_features, replace=False)抽一个子集传进来。min_gain是增益下限，小于它的分裂不做，防止树为了 0.0001 的增益一路裂到每个叶子只有两个样本。kind="mergesort"是稳定排序，保证连续特征里相同取值的样本顺序一致，否则xs[:-1] == xs[1:]这个去重逻辑会误判相邻同值的位置。best_thr取相邻两个值的均值，是 CART 处理连续特征的标准做法，预测时用x <= thr走左子树。

3.3 用显式栈代替递归建树

递归建树在数据大的时候会碰到 Python 的递归深度限制，默认 1000 层，虽然决策树很少裂那么深，但一旦触发RecursionError报错点会落在build_tree里，和业务数据看起来毫无关系，排查体验极差。改用显式栈：

class Node: __slots__ = ("feature", "threshold", "left", "right", "value", "is_leaf") def __init__(self): self.feature = None self.threshold = None self.left = None self.right = None self.value = None self.is_leaf = False def build_tree(X, y, n_classes, max_depth, min_samples_split, max_features, rng, min_gain): """迭代式建树，返回 (根节点, 每个特征的不纯度减少量)""" n_features = X.shape[1] importances = np.zeros(n_features, dtype=np.float64) root = Node() stack = [(root, np.arange(X.shape[0]), 0)] while stack: node, idx, depth = stack.pop() yy = y[idx] counts = np.bincount(yy, minlength=n_classes) node.value = int(np.argmax(counts)) # 叶子预测取多数类 node.is_leaf = True # 三种终止条件：到达深度上限、样本太少、节点已经纯 if depth >= max_depth or idx.size < min_samples_split or np.count_nonzero(counts) == 1: continue feat_idx = rng.choice(n_features, size=max_features, replace=False) f, thr, gain = best_split(X[idx], yy, n_classes, feat_idx, min_gain) if f is None: continue node.feature, node.threshold = f, thr node.is_leaf = False importances[f] += gain * idx.size # 按样本量加权累加 mask = X[idx, f] <= thr left_idx, right_idx = idx[mask], idx[~mask] if left_idx.size == 0 or right_idx.size == 0: # 退化切分，回滚成叶子 node.is_leaf = True node.feature = node.threshold = None continue node.left, node.right = Node(), Node() stack.append((node.left, left_idx, depth + 1)) stack.append((node.right, right_idx, depth + 1)) return root, importances

Node用__slots__是为了省内存，一棵深度 15 的树大概几万个节点，不加__slots__每个节点多带一个__dict__，五百棵树的森林内存能差出几百兆。importances在这里就开始累加，用gain * idx.size而不是裸增益，因为一个节点覆盖的样本越多、它的分裂对整体影响越大，这是 MDI（Mean Decrease Impurity）特征重要性的标准定义。最后那个退化切分的回滚判断不能省：虽然best_split里已经过滤了同值切分点，但浮点误差偶尔会让X[idx, f] <= thr把全部样本划到一边，不处理的话会在下一轮因为空数组崩掉。

4. 训练主循环与预测聚合：OOB 分数和特征重要性的落地方式

4.1 RandomForest 的 fit 主循环

森林层要做的三件事：给每棵树派生独立种子、并行训练、把每棵树的训练样本掩码存下来。并行用 joblib 的Parallel，进程级并行对纯 numpy 计算最划算，线程池会被 GIL 拖住。

import numpy as np from joblib import Parallel, delayed from .tree import DecisionTree class RandomForest: def __init__(self, n_estimators=100, max_depth=10, min_samples_split=2, max_features="sqrt", bootstrap=True, min_gain=1e-7, n_jobs=-1, random_state=None): self.n_estimators = n_estimators self.max_depth = max_depth self.min_samples_split = min_samples_split self.max_features = max_features self.bootstrap = bootstrap self.min_gain = min_gain self.n_jobs = n_jobs self.random_state = random_state def fit(self, X, y): X = np.asarray(X, dtype=np.float64) y = np.asarray(y, dtype=np.int64) self.classes_, y_enc = np.unique(y, return_inverse=True) self.n_classes_ = int(self.classes_.size) self.n_features_ = int(X.shape[1]) n_samples = X.shape[0] # 特征子集大小：分类任务默认 sqrt(p)，也可以传 log2 或固定整数 if self.max_features == "sqrt": mf = max(1, int(np.sqrt(self.n_features_))) elif self.max_features == "log2": mf = max(1, int(np.log2(self.n_features_))) else: mf = int(self.max_features or self.n_features_) # 关键：每棵树一个独立种子，避免并行调度影响随机流 ss = np.random.SeedSequence(self.random_state) seeds = [int(s.generate_state(1)[0]) for s in ss.spawn(self.n_estimators)] def _fit_one(seed): rng = np.random.default_rng(seed) if self.bootstrap: idx = rng.integers(0, n_samples, n_samples, dtype=np.int64) else: idx = np.arange(n_samples) mask = np.zeros(n_samples, dtype=bool) mask[idx] = True tree = DecisionTree(max_depth=self.max_depth, min_samples_split=self.min_samples_split, max_features=mf, min_gain=self.min_gain, random_state=seed) tree.fit(X[idx], y_enc[idx], n_classes=self.n_classes_) return tree, mask results = Parallel(n_jobs=self.n_jobs, prefer="processes")( delayed(_fit_one)(s) for s in seeds ) self.estimators_ = [t for t, _ in results] self.in_bag_ = np.vstack([m for _, m in results]) # 特征重要性：所有树的不纯度减少量求和后归一化 total = np.sum([t.feature_importances_ for t in self.estimators_], axis=0) s = total.sum() self.feature_importances_ = total / s if s > 0 else total return self

max_features三种取值的含义得说清："sqrt"是分类任务的默认值，特征维度越高单棵树看到的特征越少，树之间的相关性越低，这正是随机森林比单棵决策树稳的原因；"log2"适合特征特别多（上千维）的文本类场景；传整数则是完全手动控制。prefer="processes"强制走多进程，如果你们环境里 joblib 后端配置被改过，这一行能避免退化成串行。n_classes显式传给DecisionTree.fit是必须的，因为某棵树抽到的 bootstrap 样本里可能刚好缺了某个类别，靠y.max()+1推出来的类别数会偏小，预测时数组越界。

4.2 预测聚合：分类投票与概率平均

森林的预测有两种聚合方式。硬投票是每棵树投一票看谁票多，软投票是把每棵树的叶子类别分布取平均再 argmax。软投票通常更稳，因为保留了置信度信息，这份实现走的是软投票。

def predict_proba(self, X): X = np.asarray(X, dtype=np.float64) proba = np.zeros((X.shape[0], self.n_classes_), dtype=np.float64) for tree in self.estimators_: proba += tree.predict_proba(X) return proba / len(self.estimators_) def predict(self, X): proba = self.predict_proba(X) return self.classes_[np.argmax(proba, axis=1)]

单棵树的predict_proba走的是叶子节点的类别分布，实现上是一次从根到叶的循环：

def predict_proba(self, X): X = np.asarray(X, dtype=np.float64) out = np.zeros((X.shape[0], self.n_classes_), dtype=np.float64) for i in range(X.shape[0]): node = self.root_ while not node.is_leaf: node = node.left if X[i, node.feature] <= node.threshold else node.right out[i, node.value] = 1.0 return out

这段循环是整份代码最慢的地方，20 万行数据 500 棵树在单进程下要跑好几分钟。真要提速有两条路：一是把树的判断逻辑用 numpy 展平成数组做批量遍历，二是推理侧直接用 joblib 并行到多进程。我一般选后者，改起来简单，把predict_proba里那个 for 循环换成Parallel就行，代价是进程间传数组有一次拷贝开销，样本量小于一万时反而更慢。

classes_是原始标签的映射表，predict最后要用它把内部编码0..C-1还原回业务标签（比如字符串类别）。这一步经常被忘掉，导致下游拿到一堆数字不知道对应什么，尤其是标签是中文类别名的时候。

4.3 OOB 袋外估计与特征重要性

OOB 分数是随机森林相对单棵决策树最实用的赠品：不用额外切验证集就能得到一个偏差很小的泛化估计。计算逻辑是，对每个训练样本，找出所有没把它装进 bootstrap 的树，用这些树的预测结果做平均，再和真实标签比。

def oob_decision_function(self, X): """只能在训练集上调用；返回 (n_samples, n_classes)，没有 OOB 投票的样本该行为 nan""" X = np.asarray(X, dtype=np.float64) n = X.shape[0] acc = np.zeros((n, self.n_classes_), dtype=np.float64) cnt = np.zeros(n, dtype=np.int64) for tree, mask in zip(self.estimators_, self.in_bag_): out_idx = np.where(~mask)[0] # 这棵树没见过这批样本 if out_idx.size == 0: continue acc[out_idx] += tree.predict_proba(X[out_idx]) cnt[out_idx] += 1 proba = np.full((n, self.n_classes_), np.nan) valid = cnt > 0 proba[valid] = acc[valid] / cnt[valid, None] return proba def oob_score(self, X, y): y_enc = np.searchsorted(self.classes_, y) proba = self.oob_decision_function(X) valid = ~np.isnan(proba[:, 0]) pred = proba[valid].argmax(axis=1) return float((pred == y_enc[valid]).mean())

三个参数细节要注意。X必须是训练集本身，传测试集算出来的东西没有意义。np.full(..., np.nan)用 NaN 填充没被投票的样本，是为了让调用方一眼看出哪些样本是无效的，比用 0 填充安全。oob_score里valid = ~np.isnan(proba[:, 0])只看第一列，因为要么整行是 nan 要么整行有效，不会出现部分列有值的情况。树的数量少于 50 的时候 OOB 分数波动会很大，某些样本可能一次都没落袋外，这时候的分数不如直接用 5 折交叉验证。

特征重要性就是fit里算出的feature_importances_，所有值加起来等于 1。它反映的是每个特征在所有树里被选中分裂时带来的不纯度减少总量，业务侧做特征筛选时很直观。但它有明确的偏向性：对高基数的连续特征会高估，对取值少的类别特征会低估，这一点在第 5 章会展开。

注意：feature_importances_不能当成因果依据。某个特征重要性排第一，只能说明它在这批数据、这个超参组合下对不纯度降低贡献最大，不代表业务上它是根因。要更可靠的结论，用置换重要性（permutation importance）再验证一遍。

5. 避坑与排查：树不分裂、内存打爆、结果不可复现的 5 条记录

这一章的五条都是我自己踩过的，按出现频率排序，每条按现象、原因、解决三段落。

5.1 树全都退化成单叶，测试集准确率等于多数类占比

现象是训练集准确率 100%，测试集准确率正好等于样本里多数类的比例（比如三类数据就是 0.34 左右），打印每棵树的深度全是 0。这种情况十有八九是特征里混了 ID 列或者自增主键。连续的高基数特征在best_split里会产生大量几乎不重复的切分点，如果min_gain设得太松，第一层就用 ID 列把每个样本切成独立的一格，之后所有节点的基尼都是 0，树整棵退化成记忆训练集的查找表。

原因有两层。表层是特征预处理没做，深层是 MDI 类算法对高基数特征天然偏好，这不是实现 bug，是算法特性。解决办法是先做特征体检：df.nunique()看一遍，凡是唯一值数量接近行数的列直接删掉；业务上确实需要这类特征，就把它做分桶或者目标编码后再喂进去。另外把max_features从None改成"sqrt"也能立刻压住，因为 ID 列进入候选分裂特征的概率从 100% 降到1/sqrt(p)。

5.2 OOB 分数是 nan 或者低得反常

现象是oob_score返回nan，或者只有 0.5 出头而测试准确率有 0.85。第一种情况先检查bootstrap参数，构造森林时如果传了bootstrap=False，每棵树的in_bag_全是 True，没有任何 OOB 样本，oob_decision_function返回全 nan，分数自然是 nan。第二种情况多半是树太少，n_estimators只有 10 的时候，每个样本平均只有 3.7 棵树见过它，剩下的树做预测的方差极大，聚合出来自然偏低。

解决上，bootstrap=False的场景就别用 OOB 了，老老实实切验证集。树太少的情况把n_estimators加到 100 以上再看，一般到 200 就趋于稳定。还有个隐蔽原因是数据量太小，几百行的数据集上 OOB 理论上有 36.8% 的样本永远不进训练集，但统计涨落很大，这时候交叉验证比 OOB 可靠得多。

5.3 训练中途 MemoryError，进程被系统杀掉

现象是n_estimators=500、数据 20 万行的时候跑到一半报MemoryError，或者容器直接 OOM 被杀。打开监控会看到内存在建树阶段阶梯上升，每建完一棵树涨一截不回落。

原因在best_split里那个 onehot 矩阵。每个节点每算一个候选特征都要构造一个(n_node, n_classes)的浮点矩阵，20 万样本十几类的时候单个矩阵就是十几兆，深度 15 的树在上层节点反复分配，加上 joblib 多进程每进程一份副本，内存直接炸。解决有三招一起上：一是把n_jobs从-1降到cpu_count() // 2，进程数减半内存就减半；二是加min_samples_leaf剪枝，节点样本数小于阈值的直接判成叶子，不进分裂搜索；三是把 onehot 的 dtype 从float64降成float32，基尼计算对精度不敏感，这一项能省一半内存。如果是几十万行以上的数据，建议直接分块训练或者换用 xgboost 这类直方图算法，随机森林的精确分裂搜索在大数据上不划算。

5.4 特征重要性清一色是小数值，或者明显偏向某个特征

现象是打印feature_importances_发现所有值都在 0.01 附近，没有明显的主次；或者某个业务上无关的高基数列排第一。前者通常是min_gain设得太大，很多微小增益的分裂被丢弃，importances根本没累加上去，归一化之后摊平了。后者就是前面说的高基数偏好。

解决方式是换评估口径。手头这份实现用的是 MDI，想更可靠就自己加一份置换重要性：训练完后逐列把某个特征的取值打乱，看 OOB 分数掉多少，掉得多的才是真重要。打乱这一步用rng.permutation就行，重复 5 次取均值，成本是 5 倍的推理时间，但结论比 MDI 站得住。另外单看重要性排序不如看聚类后的特征组，同源的几个特征会互相分掉重要性，单独看每个都低，合起来其实是主因。

5.5 同样的种子跑两次结果不一样

现象最气人：random_state=42写死了，跑两次测试准确率差 0.3 个百分点，模型文件 md5 都不一样。原因在并行上。早期版本里每棵树的DecisionTree直接用森林的random_state初始化default_rng，joblib 多进程 fork 的时候每个子进程拿到的 Generator 状态是父进程那一刻的快照，任务完成的先后顺序不同，随机流就不一样。

解决办法是用SeedSequence.spawn提前把种子全派生好，每棵树一个独立的整数种子，和任务调度顺序彻底解耦。这就是fit里seeds列表那段代码的意义，它不是为了好看，是为了让并行和可复现同时成立。改完之后还要检查两处：数据切分用的train_test_split有没有固定种子，以及np.random的全局状态有没有被别的地方np.random.seed()污染过。两头都锁死，结果才真正可复现。

6. 二次开发：把随机森林接进自己的数据管道

要把这份代码接到真实业务数据上，改动集中在一个适配层，不用碰树和分裂的逻辑。我一般的做法是加一个rf/pipeline.py，把读数据、编码、切分、训练、评估、落盘串起来，主逻辑保持原样。这样做的好处是核心实现永远可以被单测覆盖，业务变化只影响适配层。

import pandas as pd, numpy as np from rf.forest import RandomForest def load_xy(csv_path, target_col, drop_cols=()): df = pd.read_csv(csv_path) df = df.drop(columns=[c for c in drop_cols if c in df.columns]) # 类别特征先做 one-hot，数值特征不做标准化（树模型对单调变换不敏感） y = df[target_col].astype("category").cat.codes.to_numpy() X = pd.get_dummies(df.drop(columns=[target_col]), dummy_na=False).to_numpy(np.float64) return X, y def train_from_csv(csv_path, target_col, out_path="artifacts/rf.joblib"): from joblib import dump X, y = load_xy(csv_path, target_col) model = RandomForest(n_estimators=200, max_depth=12, min_samples_split=5, max_features="sqrt", n_jobs=4, random_state=42).fit(X, y) print("OOB:", round(model.oob_score(X, y), 4)) dump(model, out_path) return model

接自己数据时最容易出错的是三处。第一处是pd.get_dummies在训练集和预测集上生成的列顺序可能不一致，线上推理时用同一份编码器，别两边各调一次。第二处是类别标签反解，classes_存的是编码后的顺序，业务侧要中文或字符串标签就得自己维护一张映射表。第三处是特征顺序，feature_importances_的下标对应的是喂进去的矩阵列序，中间任何一步删列都要同步更新特征名清单。

调参的优先级我按这张表走，从上到下依次确认，不跳步：

验证方法上不要只看一次留出集的分数。我的习惯是 5 折交叉验证配合 OOB 分数交叉看，两者接近说明模型稳定，差很多说明数据分布有偏或者某折的样本太少。确认稳定之后再做特征筛选实验，每次只删一组特征重跑一遍，记录 OOB 和交叉验证分数变化，别一次删十几列然后归因不了。

有个具体的技巧值得单独说：如果在业务里需要解释单条预测，可以加一个explain方法，遍历所有树记录这条样本走过的分裂路径，把每次分裂用到的特征按增益累加，输出一个样本级的局部重要性。这比全局特征重要性有用得多，客服场景里能直接回答"为什么这单被判成异常"。实现上在predict_proba的下降循环里顺手记录就行，额外开销很小。

从那以后我每次改这类集成模型，都会先把种子派生、类别编码、特征列序这三件事在适配层强制走一遍断言，任何一个不满足就抛异常，而不是等到线上指标掉了再回头查。血泪经验是，随机森林这种看着"玄学"的模型，问题九成不在算法本身，在数据管道和随机状态的细枝末节上。希望帮到你。

本文还有配套的精品资源，点击获取