手写决策树：从纯度、剪枝到缺失值处理的完整实现指南

做机器学习落地这几年，我发现一个很有意思的现象：很多人调参时可以用 sklearn 用得飞起，但一旦被问到“决策树到底是怎么长出来的”，常常卡壳。这个问题不是面试官的刁难，它直接决定了你遇到一棵决策树表现诡异时，能不能一眼看出问题在哪。我自己第一次手写决策树，是在一个需要强解释性的风控规则场景里，业务方不接受黑盒模型，只好决定从零实现一棵能落地的决策树。这个过程里，信息增益、增益率、基尼指数、预剪枝、后剪枝、缺失值处理全部重走了一遍。今天这篇就把决策树实现的核心逻辑从头到尾拆开讲，包括代码骨架、算法选型原因和踩过的坑。

1. 为什么决策树实现的第一行代码往往从“纯度”写起

很多人以为决策树的核心是 if-else 嵌套，其实不是。真正决定树长成什么样的，是那个反复出现的选择题：每一步该选哪个特征、在哪个阈值上切。而“怎么选”这件事，需要一个统一的度量标准——纯度。

1.1 信息熵计算只是表象，“不确定性下降”才是决策树的灵魂

信息熵这个词听起来唬人，但它描述的东西很朴素：一个系统里有多少不确定性。如果一组样本全部属于同一个类别，那它没有不确定性，熵为 0；如果类别均匀分布，你猜下一个样本属于哪一类基本靠蒙，熵最大。

公式写成文本形式就是这样：

code复制Ent(D) = -Σ p_k * log2(p_k)

这里的 D 是当前节点上的样本集合，p_k 是第 k 类样本在 D 中占比。log 以 2 为底时，熵的单位是比特，也就是“还需要多少信息才能确定类别”。

信息增益就是在问：用特征 a 把数据集切分成若干子集之后，不确定性下降了没有？下降了多少？

code复制Gain(D, a) = Ent(D) - Σ |D_v| / |D| * Ent(D_v)

D_v 是按特征 a 的第 v 个取值划分出来的子集，权重 |D_v|/|D| 表示这个子集样本量占比。

这里有一个特别容易被忽略的点：权重不是按子集个数平均分配的，而是按样本量占比。为什么？因为样本量大的子集对整体预测的影响更大，理应获得更高的话语权。

我举个例子。假设 14 个样本里 9 个好瓜 5 个坏瓜，初始熵大约是 0.940。如果“色泽”这个特征把样本分成三堆，每一堆内部要么全好要么全坏，那加权后的熵约等于 0，信息增益约等于 0.940。这意味着用“色泽”划分后，不确定性几乎被完全消除——这是最理想的情况。实际上不会有这么完美的特征，但优化的目标就是这个落差。

理解了熵和信息增益，后续所有准则都是在这个框架上打补丁。

1.2 三种切分准则的取舍：从一道面试题说起

面试题常问：ID3、C4.5、CART 分别用什么准则？CART 为什么用基尼指数而不是信息增益？这个问题看起来是背诵题，其实考的是对准则本质的理解。

ID3 用信息增益，有一个明显毛病：它偏好取值数量多的特征。为什么？因为取值越多，划分出的子集越碎，每个子集内部越可能只剩下少量样本，纯度高，熵就低，增益自然大。但这样的树泛化能力很差，比如“样本ID”这个特征，每个取值只对应一条样本，切分后熵直接为 0，信息增益爆表，但毫无预测意义。

C4.5 的增益率是在信息增益基础上除以一个固有值（Intrinsic Value），相当于给“取值多”的特征加一个惩罚项：

code复制Gain_ratio(D, a) = Gain(D, a) / IV(a)
IV(a) = -Σ |D_v| / |D| * log2(|D_v| / |D|)

IV 本身描述的是特征 a 的取值分散程度，取值越多，IV 越大，增益率就被压得越低。

CART 用了另一套逻辑：基尼指数。基尼指数度量的是“从样本集中随机抽两个样本，它们的类别不一样”的概率，公式是：

code复制Gini(D) = 1 - Σ p_k^2

基尼指数越小，纯度越高。特征 a 的基尼指数是各个子集基尼指数的加权平均，选最小的那个特征划分。

我在实际实现里默认走 CART 的基尼指数路线，原因有三个：一是它天然是二叉树，代码里处理起来简单；二是不需要算 log，建树速度快；三是 sklearn 的 DecisionTreeClassifier 用的就是优化过的 CART，跟生态对齐，后续接随机森林没有心智负担。

但如果你做的是业务解释型项目，信息增益的直观性更好，跟业务方讲“这个特征让系统的不确定度下降了 XX”比讲“基尼不纯度下降了 XX”要顺口得多。所以我的建议是：把评估函数做成一个可插拔的接口，建树框架共用，准则可以随时切换。这个设计后面会讲到。

2. 递归建树的真正边界条件：不是“分到不能分”就完事

如果说切分准则是决策树的“心脏”，那递归建树就是“骨架”。整个构建过程其实就是一棵树的递归生长：当前节点上选最优特征和阈值，把样本分到左右子树，然后对每个子树重复同样的事情。

2.1 终止条件的四个层级

很多资料里只讲两个终止条件：样本全同类，或者特征集为空。但写代码的时候你会发现，真实场景远不止这两种情况。

我建议把终止条件分成四个层级来处理：

1. 当前节点所有样本类别一致，标记为叶节点，类别就是该类别。
2. 候选特征集为空，或者剩余特征在所有样本上的取值已经完全相同，无法继续划分，标记为叶节点，类别取多数类。
3. 按某特征划分后产生了空子集，即另一个分支没有样本落到那里。此时不能什么都不做，应该把该分支的叶节点类别设为父节点的多数类。
4. 实践中的预剪枝约束：最大深度、最小样本数、纯度阈值，这些会在递归早期就砍掉分支。

第 3 条是新手最容易漏的。测试阶段如果进来一个训练时没见过的特征组合，树没办法继续走，就会直接崩。你在实现时一定要在递归入口处把“当前样本集为空”的分支兜住。

给一个建树骨架的简化代码，方便理解整体流程：

python复制def build_tree(X, y, feature_idx, depth=0):
    # 终止条件
    if len(set(y)) == 1:
        return LeafNode(class_distribution(y))
    if len(feature_idx) == 0 or depth >= max_depth:
        return LeafNode(class_distribution(y))
    
    best_feat, best_thr = find_best_split(X, y, feature_idx)
    
    if best_feat is None:
        return LeafNode(class_distribution(y))
    
    left_mask = X[:, best_feat] <= best_thr
    right_mask = X[:, best_feat] > best_thr
    
    # 处理空子集：直接返回叶节点
    if not left_mask.any() or not right_mask.any():
        return LeafNode(class_distribution(y))
    
    left_child = build_tree(X[left_mask], y[left_mask], 
                            feature_idx, depth + 1)
    right_child = build_tree(X[right_mask], y[right_mask],
                             feature_idx, depth + 1)
    
    return InternalNode(best_feat, best_thr, left_child, right_child)

这里的 feature_idx 我没让你在每层都删掉已用特征，因为 sklearn 的 CART 允许同一个特征在一条路径上反复使用。这个细节在你的实现中可以有不同选择，但无论如何必须保证函数在递归过程中收敛，不会因为特征集不变而陷入死循环。

2.2 叶节点该存什么：类别分布比简单多数票更有用

叶节点只存一个预测类别是最朴素的做法，但这在真实业务里不够用。我强烈建议叶节点存类别分布，也就是每个类别的样本占比。

为什么？因为业务方问你的不只是“这个用户会不会违约”，而是“你有几成把握说他会不会违约”。类别分布天然就是预测概率，可以直接对接任意下游的阈值调整、收益-损失计算。sklearn 的 predict_proba 就是这么来的。

另外，存类别分布对剪枝算法特别重要。后剪枝时需要估计“把子树替换成叶节点后，错误率会不会上升”，这就要用到叶节点的多数类概率。只存一个硬编码类别的话，这个计算就得重新遍历样本，白白增加开销。

2.3 连续属性的二分阈值：排序后相邻均值，还是更高阶的搜索

处理连续特征时，候选阈值不是拍脑袋定的，标准做法是：

1. 对当前节点上的样本按该特征值排序。
2. 取相邻样本特征值的均值作为候选阈值。
3. 对每个候选阈值计算不纯度增益，选增益最大的那个。

这个过程的复杂度是 O(m log m) 加上阈值扫描的 O(m)，是决策树训练里最耗时的部分之一。工程上可以按特征预排序，或者用分位数抽样减少候选点。

这里有一个新手常犯的错误：以为一个连续特征在整个树里只有一个阈值。不是的。同一个特征在不同分支上，面对的是不同的样本子集，排序结果不同，最优阈值也不同。所以每一层都要重新搜索。这个“每次划分重新搜索”的机制，是决策树对连续特征建模能力的关键。如果全局只用一个阈值，那这个特征本质上被当成二值特征用了，能力折损很大。

3. 剪枝不是优化项，而是决策树实现的必备环节

先摆一个结论：不剪枝的决策树在训练集上很容易做到“零错误”，但这种完美没有任何意义，因为测试集上大概率一塌糊涂。决策树的模型复杂度跟叶节点数量直接相关，叶节点越多，边界越碎，拟合的噪声越多。剪枝就是用一个尺度规则，把这些碎屑砍掉。

3.1 预剪枝的几种常见阈值及其副作用

预剪枝是在建树过程中提前终止生长。常用的阈值就那么几个：最大深度 max_depth、最小分裂样本数 min_samples_split、叶节点最小样本数 min_samples_leaf、最大叶节点数 max_leaf_nodes。

看起来很好理解，但预剪枝有一个天然缺陷：它做的每一步决策都是贪心的局部决策。当前这个划分在验证集上没有带来精度提升，不代表后续深度划分之后整体效果也不好。

举个例子：某次划分后，两个子节点在验证集上的错误率分别上升了一点点，但其中一个子节点如果再往下分一层，能把一小撮困难样本正确识别出来，整体错误率其实是下降的。预剪枝在这里直接停掉，就错过了这个收益。

我在项目中感受最深的是：单用 max_depth 或 min_samples_split 很容易欠拟合，尤其是数据里有交互效应的时候，浅树根本表达不了“A 特征只有在 B 特征大于某值时才有区分力”这种模式。预剪枝的超参组合最好用网格搜索或者随机搜索来做，并且验证集必须独立，否则本质上还是在拟合验证集。

3.2 后剪枝的经典流程：自底向上替换子树为叶节点

后剪枝的思路跟预剪枝相反：先把树长满，再从下往上尝试把内部节点替换成叶节点，替换后如果验证集错误率没有上升，就保留替换结果。

最经典也最好理解的是错误率降低剪枝（REP）。你可以把过程想象成给树做体检：从最深的内部节点开始，逐个考察“这棵子树还值不值得保留”。

python复制def post_prune(node, val_X, val_y):
    if node.is_leaf():
        return node
    
    node.left = post_prune(node.left, val_X, val_y)
    node.right = post_prune(node.right, val_X, val_y)
    
    if not node.is_leaf():
        # 计算当前子树的验证集错误
        subtree_error = evaluate(node, val_X, val_y)
        # 计算把该节点变成叶节点时的验证集错误
        leaf_error = evaluate_leaf(node, val_X, val_y)
        
        if leaf_error <= subtree_error:
            return LeafNode(class_distribution(node))
    
    return node

这个“自底向上”的顺序很关键，因为每个节点在决定剪不剪的时候，它的子树已经被判断过了，状态是修剪完成的。如果在顶层一次性判断整棵子树，很可能把本可以修剪的深层节点漏掉。

我的实操体会是：REP 算法短小精悍，面试题里只要考察后剪枝，十有八九是它。但它在工程上不是最优的，因为它依赖验证集，数据不够时验证集本身的噪音会被放大。

3.3 代价复杂度剪枝的 α 选择——面试题里最常问的细节

CART 用的后剪枝方法是代价复杂度剪枝（Cost-Complexity Pruning），思路比 REP 稍微绕一点，但面试题里经常考。

先定义一个损失函数：总损失 = 错分损失 + α × 叶节点数。

code复制R_α(T) = R(T) + α * |T_leaf|

这里的 R(T) 是训练集上的误分损失，|T_leaf| 是叶节点数量，α 是一个控制复杂度的惩罚系数。α 越大，树越偏向简单。

对每个内部节点，可以计算一个“剪掉它”的临界值：

code复制α = (R(t) - R(T_t)) / (|T_t| - 1)

R(t) 是把这个节点替换成叶节点后的误分损失，R(T_t) 是保留子树时的误分损失，|T_t| 是子树里叶节点的个数。这个公式的含义是：剪掉这棵子树，用多大一颗“错误率的雷”去换“模型复杂度的下降”才是划算的。

实现时，从完整的树出发，逐步剪掉 α 最小的那个节点，得到一棵更小的树；然后再剪，得到一棵更小的树。如此得到一串嵌套的候选树序列，最后用交叉验证在候选树里面挑一棵错误率最低的。

关键区别你发现了吗？REP 是一次性用固定的条件判断每个节点剪不剪，而代价复杂度剪枝生成了一条从复杂到简单的候选树路径，再整体选优。这条路径让剪枝的选择不仅仅依赖一个孤立的节点，而是考虑到了树的整体复杂度，所以更稳定。

我在实现代价复杂度剪枝时，通常会把参数 ccp_alpha 和 max_depth 一起调，因为它们两个会互相影响，单独调哪个都不够全面。

4. 缺失值与连续值的工程处理：决策树实战中真正拉差距的地方

学术帖里讲决策树，几乎不涉及实际业务里那些脏数据问题，但一到真实项目，缺失值能占到你数据量的三成。怎么处理缺失值，往往比选哪个切分准则更影响最终效果。

4.1 缺失值不是“删掉就行”：权重修正的划分逻辑

很多人的第一反应是删行，或者用均值/众数填充。这两种做法在决策树里都不够好。删行会丢掉有效信息，尤其在样本量本来就少的时候；均值填充则会把人为构造的值硬塞进去，扭曲特征分布。

C4.5 处理缺失值的方式值得参考，核心思路是：不要让缺失样本直接消失，而是让它们以权重形式参与各个环节。

具体来说：

1. 计算特征 a 的信息增益时，只拿特征 a 没有缺失的样本子集 D_tilde 来计算，然后把结果乘上一个无缺失样本比例 ρ，因为缺失样本不能为这个特征提供有效划分信息。
2. 划分样本时，没有缺失的样本正常进入对应分支；有缺失的样本，以不同权重同时进入所有分支，权重等于该分支中无缺失样本的占比。
3. 在后续递归中，每个样本自带一个权重。节点上的类别分布、纯度计算，都要按权重来汇总，而不是简单数个数。

这个权重方案带来的工程改动比想象中少，你只需要给训练样本增加一个一维的权重数组，在算熵和基尼指数时把“个数统计”改成“权重累加”就行。

我在一个用户分群项目里对比过：直接用均值填充的决策树，在测试集上的宏平均 F1 是 0.71；用 C4.5 式权重方案处理缺失值后，同样参数下 F1 上升到 0.77。差别就是这么明显。当然，如果你的缺失比例小于 2%，怎么处理影响都不大，权衡收益后可以直接删。

4.2 特征重要性怎么从建树过程里带出来

这也是个很实用但容易被忽略的细节。sklearn 里的 feature_importances_ 看着很神秘，其实原理非常简单：一个特征被选中做切分的次数越多、每次带来的不纯度下降越大，它就越重要。

具体做法是在建树过程中维护一个字典，每次找到最优划分时，把当前节点的样本占比乘以不纯度下降量，累加到该特征名下：

code复制importance[best_feat] += (len(node_samples) / len(total_samples)) * 
                         (gini_before - gini_left - gini_right)

训练结束后，把所有特征的累加值做一次归一化，就得到了特征重要性。

一个容易被坑的地方：剪枝会改变特征重要性的分布。因为剪掉的分支如果用了某个特征，那部分重要性就不存在了。所以我建议在业务汇报时明确说明“这个特征重要性是剪枝到当前复杂度下的结果”，否则前后两版模型的特征排序差异会让人困惑。

5. 从经典决策树到模糊决策树：实现思路的一次升级

决策树领域有两条扩展线路经常被提起，一条是模糊决策树，一条是多变量决策树。理解它们不需要新框架，因为你已经掌握了递归划分的核心逻辑，只是把“划分”这个动作改得更灵活了。

5.1 模糊决策树改了什么、保留了哪套框架

模糊决策树保留了树状递归结构，改的是样本跟分支的关系。经典决策树里，一个样本要么进左支，要么进右支，非黑即白；模糊决策树里，样本不是“确定进入”某个分支，而是以不同隶属度进入所有分支。

举个例子：特征“年龄”不再用“是否大于 30”硬切分，而是定义“年轻”“中年”“老年”三个模糊集合。一个 28 岁的人，可能 0.7 属于“年轻”，0.3 属于“中年”。训练时它同时进入两个分支，权重就是隶属度。

这个改动让树的决策边界从阶梯状变成平滑过渡，对噪声的鲁棒性更好。代价是树的解释性变差，不再是纯粹的“if-else”规则，而且隶属函数的定义需要经验和调参。

实现时保留上面建树的递归骨架，只需要改动两处：

1. 切分准则改成模糊熵，用加权隶属度代替硬计数。
2. 划分分支时不再用布尔掩码，而是把每个样本分裂成多个带权重的副本。

代码量不大，但工程调试周期会明显变长。我的建议是先把经典 CART 吃透再来碰模糊决策树，不然出了问题你会分不清是树结构的问题还是隶属函数的问题。

5.2 多变量划分：当单特征切分不够用时

多变量决策树的思路更直接：既然单个特征的轴平行切分对斜向边界拟合效率低，那干脆让每个节点学一个特征线性组合，用组合值作为划分条件。

经典 CART 的划分边界是 x_i <= t，多变量决策树的划分边界变成了 w1*x1 + w2*x2 + ... <= t，相当于在每个节点内嵌一个小的线性分类器。

这个扩展在实现上会让“特征重要性”“可解释性”这些决策树的招牌优势明显受损，业务解释场景慎用。但在一些特征相关性很强的数据集上，多变量树的表达能力确实远超单变量树，而且树深往往更浅。

面试里如果被问到“决策树怎么解决斜向分类边界”，你能说出用线性组合代替单特征划分，并且指出它的代价，就已经是加分的答案。

6. 自己写一棵决策树时，最容易踩的四个实现坑

这一段是我自己从零写决策树时被反复折磨后总结出来的，不是从教科书里抄来的，每一坑我都真实踩过。

6.1 第一个坑：递归里反复切片导致性能雪崩

一开始写建树，我用的是每次划分都复制一份子数据集，写起来很爽，但树一深，性能惨不忍睹。数据量 10 万、深度 10 层的时候，训练时间从几秒膨胀到几分钟，内存也直接起飞。

后来改成传索引数组，用布尔掩码来标记当前节点涉及哪些样本，而不是真正复制数据。连续特征可以先完成排序，划分时传递左侧和右侧的索引段。这个优化让建树速度提升了一个数量级，在高维稀疏数据上效果更明显。

6.2 第二个坑：空属性和空子集的边界判断

这个前面提过，但值得拿出来单独说：递归函数里如果没有显式处理“特征集为空”和“子集为空”两种情况，树会在某些数据划分下直接报错。表面上看是代码健壮性问题，实际是数据分布本身不满足你的隐含假设。

我遇到的问题是这样的：某个特征在剩余样本上只有一个取值，它依然在候选特征列表里。find_best_split 扫完所有候选阈值后返回 None，而我没做这个判断，导致递归不终止，直接栈溢出。解决方式是每一层都检查最优划分是否有效，无效就立即返回叶节点。

6.3 第三个坑：预测路径上的“数据泄漏”

训练时把目标列“不小心”留在了特征矩阵里，这个错误低级但真实存在。更隐蔽的数据泄漏是：用全量数据来评估剪枝效果。比如你后剪枝时用的是训练集本身的错误率来判断是否替换叶节点，那剪枝过程完全失去防过拟合的作用。验证集必须从训练数据里切出来，并且在整个建树和剪枝过程中都不能参与。

还有一个细节：计算特征重要性时，如果某个特征跟目标高度相关但现实中根本无法提前获取，它的重要性会被严重高估，误导业务决策。所以特征重要性永远只能解释模型，不能直接等于因果重要性。

6.4 第四个坑：类别不平衡影响下的叶节点赋值

分类问题中如果类别很不平衡，比如正样本只占 5%，多数票规则会把几乎所有叶节点都判成负类，模型评估看着准确率很高，但召回率趋近于 0。

处理方法我最推荐的是：叶节点输出概率分布，而不是硬编码类别，下游按业务阈值再决定分类。这样即使少数类占比低，概率输出也能保留足够的区分信息。训练侧可以配合样本权重，让少数类样本在计算基尼指数时拥有更高的权重。权重这个变量的引入，对纯度计算、类别分布、剪枝评估都会生效，属于“一处引入、全树受益”的杠杆改法。

这几个坑我在不同项目里都踩过一遍，每次排查到最后都发现不是算法思想的问题，而是工程细节没做到位。决策树这个模型看起来简单，真正自己动手实现一遍，你才能理解一个道理：算法的表现，永远是由这些彼此咬合的工程细节共同决定的。