从零手写决策树：信息熵、基尼系数与决策边界可视化实战

1. 决策树到底在解决什么问题

决策树这个算法，我刚开始学机器学习的时候觉得它特别"土"——不就是一堆if-else堆起来的判断逻辑吗？但真正在项目里用过几轮之后才发现，越是简单直观的模型，越能在实际场景中发挥出意想不到的价值。它不像神经网络那样需要调参调到怀疑人生，也不像支持向量机那样对核函数选择极其敏感。决策树的核心思想非常朴素：通过一系列"是或否"的问题，一步步把数据切分到足够纯净的子集里。

这篇文章适合谁看？如果你已经了解机器学习的基本概念，知道什么是特征、标签、训练集和测试集，但还没真正动手实现过一个完整算法，那决策树是最好的练手项目。它涉及的数学不深，主要是信息熵和基尼系数这两个指标，但代码实现过程中能让你真正理解"模型到底在学什么"这件事。另外，如果你已经用过sklearn的DecisionTreeClassifier但对其内部机制一知半解，这篇文章也会帮你把那些黑盒打开看看。

决策树能做什么？分类和回归都行。分类场景比如：根据用户的年龄、消费频次、客单价判断是否会复购；根据天气、温度、湿度决定要不要去打羽毛球。回归场景比如：根据房屋面积、地段、楼层预测房价。它的输出不是概率值，而是一条条从根节点到叶子节点的路径，每条路径就是一条决策规则。这个特性在需要解释性的场景里特别吃香——银行风控、医疗辅助诊断，这些领域往往要求模型给出"为什么"。

我打算从三个层面来讲：第一，把决策树的数学原理拆开揉碎，让你明白它凭什么这么切分数据；第二，手写一个完整的决策树实现，不依赖sklearn，从零开始；第三，用matplotlib把决策边界画出来，直观感受模型到底学到了什么。整个过程我会穿插自己踩过的坑和实际项目中的经验，尽量让你少走弯路。

2. 核心原理拆解：信息熵、信息增益与基尼系数

2.1 信息熵：衡量数据"混乱程度"的尺子

决策树每次切分数据的时候，都要回答一个问题：用哪个特征来切最好？这个"最好"需要一个量化标准，信息熵就是最常用的那个。熵这个概念来自信息论，用来衡量一个系统的不确定性。熵越大，数据越混乱，越难预测；熵越小，数据越纯净，越容易预测。

用公式表示，对于有K个类别的数据集D，信息熵的定义是：

H(D) = -Σ(p_k * log2(p_k))，其中p_k是第k类样本在D中占的比例。

我举个具体例子你就明白了。假设一个数据集有10个样本，5个正例5个负例，那么p_正=0.5，p_负=0.5，熵就是-(0.5log2(0.5) + 0.5log2(0.5)) = 1。这是二分类问题中熵的最大值，代表数据完全混乱，跟抛硬币一样没法预测。

如果10个样本里9个正例1个负例，p_正=0.9，p_负=0.1，熵就是-(0.9log2(0.9) + 0.1log2(0.1)) ≈ 0.469。数据明显更纯净了，熵也降下来了。

如果10个全是正例，p_正=1，p_负=0，熵就是0。数据完全纯净，没有任何不确定性。

注意：计算熵的时候，如果某个类别的概率为0，log2(0)在数学上是负无穷，但实际代码中要约定0*log2(0)=0，因为极限是0。这个细节在写代码时一定要处理，否则会报错或者得到nan。

2.2 信息增益：切分前后熵的差值

知道了怎么衡量数据的混乱程度，接下来就要看用某个特征切分之后，混乱程度降低了多少。这个降低的量就叫信息增益。

信息增益 = 切分前的熵 - 切分后各子集熵的加权平均。

加权平均的权重是每个子集的样本数占总样本数的比例。公式写出来是：

Gain(D, A) = H(D) - Σ(|D_v|/|D|) * H(D_v)

其中A是用于切分的特征，D_v是特征A取值为v的样本子集。

我拿一个经典例子来算一遍。假设有14个样本，目标是判断"是否去打网球"，特征有"天气"（晴、阴、雨）。14个样本中9个"去"、5个"不去"，切分前的熵是：

H(D) = -(9/14)*log2(9/14) - (5/14)*log2(5/14) ≈ 0.940

按天气切分后：

• 晴天：5个样本，2去3不去，熵 = -(2/5)*log2(2/5) - (3/5)*log2(3/5) ≈ 0.971
• 阴天：4个样本，4去0不去，熵 = 0
• 雨天：5个样本，3去2不去，熵 = -(3/5)*log2(3/5) - (2/5)*log2(2/5) ≈ 0.971

加权平均熵 = (5/14)*0.971 + (4/14)*0 + (5/14)*0.971 ≈ 0.694

信息增益 = 0.940 - 0.694 = 0.246

这就是"天气"这个特征带来的信息增益。决策树在每一步会选择信息增益最大的特征来切分，这就是ID3算法的核心逻辑。

2.3 基尼系数：另一种衡量纯度的方式

信息增益有个问题：它偏向于取值较多的特征。极端情况下，如果有个特征是"样本ID"，每个样本的ID都不同，按它切分后每个子集只有一个样本，熵全是0，信息增益达到最大，但这个切分毫无意义。C4.5算法用信息增益率来修正这个问题，而CART算法则直接换了一个指标——基尼系数。

基尼系数的定义是：

Gini(D) = 1 - Σ(p_k^2)

还是用刚才的例子，切分前的基尼系数 = 1 - (9/14)^2 - (5/14)^2 ≈ 0.459。

按天气切分后：

• 晴天：1 - (2/5)^2 - (3/5)^2 = 0.48
• 阴天：1 - (4/4)^2 - 0 = 0
• 雨天：1 - (3/5)^2 - (2/5)^2 = 0.48

加权平均基尼 = (5/14)*0.48 + (4/14)*0 + (5/14)*0.48 ≈ 0.343

基尼系数越小，数据越纯。CART算法选择使基尼系数最小的特征来切分。相比信息熵，基尼系数的计算不需要对数运算，速度更快，这也是sklearn默认使用基尼系数的原因。

2.4 决策树的生长与剪枝

决策树构建是一个递归过程：选择最优特征，切分数据，对每个子集重复这个过程，直到满足停止条件。停止条件通常有三种：子集已经纯净（所有样本同一类别）、没有特征可用了、或者达到了预设的最大深度。

但这样长出来的树往往过拟合——它在训练集上表现完美，但测试集上一塌糊涂。原因很简单：树太深了，把训练数据中的噪声也学进去了。解决办法是剪枝。

剪枝分两种：预剪枝和后剪枝。预剪枝是在树生长过程中提前停止，比如限制最大深度、要求每个叶子节点最少包含多少个样本、要求信息增益至少达到某个阈值。后剪枝是先让树完全生长，然后自底向上地考察每个子树，如果把它替换成叶子节点能提升验证集准确率，就剪掉。

实操心得：在实际项目中，我通常先用预剪枝快速跑一版，看看大概的深度和叶子节点数量，然后再用后剪枝（代价复杂度剪枝）精细调整。sklearn的DecisionTreeClassifier提供了ccp_alpha参数来做后剪枝，调这个参数比调max_depth更有效，因为它不是一刀切，而是根据子树对整体损失的贡献来决定剪不剪。

3. 从零手写决策树：代码实现与逐行解析

3.1 数据结构设计与工具函数

在动手写代码之前，先想清楚数据结构。决策树本质上是一个嵌套的字典结构，每个节点要么是叶子节点（存储类别标签），要么是内部节点（存储切分特征、切分阈值、左子树、右子树）。

我定义两个类：Node表示树节点，DecisionTree表示整个树。Node包含feature_idx（切分特征索引）、threshold（切分阈值）、left、right、value（叶子节点的类别）。DecisionTree包含根节点和一系列方法。

先写几个工具函数。计算基尼系数的函数：

import numpy as np def gini(y): if len(y) == 0: return 0 _, counts = np.unique(y, return_counts=True) probs = counts / len(y) return 1 - np.sum(probs ** 2)

计算信息熵的函数：

def entropy(y): if len(y) == 0: return 0 _, counts = np.unique(y, return_counts=True) probs = counts / len(y) return -np.sum(probs * np.log2(probs + 1e-10))

注意这里加了1e-10防止log2(0)的问题。虽然理论上概率为0时该项贡献为0，但代码里直接算会出问题。

3.2 最优切分点的搜索逻辑

对于连续特征，切分点通常是排序后相邻两个值的中点。对于离散特征，如果取值不多，可以直接按每个取值切分；如果取值很多，也可以当作连续特征处理。

搜索最优切分的逻辑是：遍历每个特征，对每个候选切分点，计算切分后的加权不纯度，选最小的那个。

def best_split(X, y, criterion='gini'): best_gain = -1 best_feature = None best_threshold = None n_features = X.shape[1] base_score = gini(y) if criterion == 'gini' else entropy(y) for feat_idx in range(n_features): thresholds = np.unique(X[:, feat_idx]) if len(thresholds) == 1: continue # 取相邻值的中点作为候选切分点 candidates = (thresholds[:-1] + thresholds[1:]) / 2 for thresh in candidates: left_mask = X[:, feat_idx] <= thresh right_mask = ~left_mask if np.sum(left_mask) == 0 or np.sum(right_mask) == 0: continue y_left, y_right = y[left_mask], y[right_mask] if criterion == 'gini': score = (len(y_left) * gini(y_left) + len(y_right) * gini(y_right)) / len(y) else: score = (len(y_left) * entropy(y_left) + len(y_right) * entropy(y_right)) / len(y) gain = base_score - score if gain > best_gain: best_gain = gain best_feature = feat_idx best_threshold = thresh return best_feature, best_threshold, best_gain

这段代码有个性能问题：每次都要遍历所有特征的所有候选切分点，数据量大时会很慢。实际项目中我会用向量化操作加速，但作为教学版本，这样写最清晰。

注意：候选切分点取相邻值的中点，而不是直接用特征值，是为了避免切分点恰好等于某个样本值导致边界模糊。比如特征值有1、2、3，取1.5和2.5作为候选，这样切分后左右子集不会重叠。

3.3 递归构建树的完整流程

有了最优切分函数，构建树就是一个递归过程：

class Node: def __init__(self, feature=None, threshold=None, left=None, right=None, value=None): self.feature = feature self.threshold = threshold self.left = left self.right = right self.value = value # 叶子节点的类别 class DecisionTree: def __init__(self, max_depth=10, min_samples_split=2, min_samples_leaf=1, criterion='gini'): self.max_depth = max_depth self.min_samples_split = min_samples_split self.min_samples_leaf = min_samples_leaf self.criterion = criterion self.root = None def fit(self, X, y): self.root = self._grow(X, y, depth=0) def _grow(self, X, y, depth): n_samples, n_features = X.shape n_classes = len(np.unique(y)) # 停止条件 if (depth >= self.max_depth or n_classes == 1 or n_samples < self.min_samples_split): return Node(value=self._majority(y)) feat, thresh, gain = best_split(X, y, self.criterion) if feat is None or gain <= 0: return Node(value=self._majority(y)) left_mask = X[:, feat] <= thresh right_mask = ~left_mask if (np.sum(left_mask) < self.min_samples_leaf or np.sum(right_mask) < self.min_samples_leaf): return Node(value=self._majority(y)) left = self._grow(X[left_mask], y[left_mask], depth + 1) right = self._grow(X[right_mask], y[right_mask], depth + 1) return Node(feature=feat, threshold=thresh, left=left, right=right) def _majority(self, y): values, counts = np.unique(y, return_counts=True) return values[np.argmax(counts)] def predict(self, X): return np.array([self._predict_one(x, self.root) for x in X]) def _predict_one(self, x, node): if node.value is not None: return node.value if x[node.feature] <= node.threshold: return self._predict_one(x, node.left) return self._predict_one(x, node.right)

这个实现虽然简单，但已经包含了决策树的所有核心要素：递归生长、停止条件、多数投票。你可以用它跑iris数据集，准确率大概在95%左右，跟sklearn的默认配置差不多。

3.4 与sklearn实现的对比验证

为了验证手写版本的正确性，我拿iris数据集做了对比：

from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import accuracy_score iris = load_iris() X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, test_size=0.3, random_state=42) # 手写版本 my_tree = DecisionTree(max_depth=5, criterion='gini') my_tree.fit(X_train, y_train) my_pred = my_tree.predict(X_test) # sklearn版本 sk_tree = DecisionTreeClassifier(max_depth=5, criterion='gini', random_state=42) sk_tree.fit(X_train, y_train) sk_pred = sk_tree.predict(X_test) print(f"手写版本准确率: {accuracy_score(y_test, my_pred):.4f}") print(f"sklearn版本准确率: {accuracy_score(y_test, sk_pred):.4f}")

实测下来，两者准确率非常接近，差异主要来自切分点选择的细微不同。sklearn在连续特征上做了优化，会预先对特征排序并缓存，搜索效率更高。另外sklearn还支持样本权重、类别权重等高级功能，这些在生产环境中很有用。

4. 决策边界绘制：让模型"看得见"

4.1 决策边界的本质与绘制思路

决策边界是模型在特征空间中的划分线。对于二维特征的数据，决策边界就是一条曲线（或折线），把平面分成不同的区域，每个区域对应一个类别。决策树因为切分都是轴对齐的（即沿着某个特征维度垂直切分），所以它的决策边界是由一系列水平线和垂直线组成的阶梯状折线。

绘制决策边界的思路很直接：在特征空间上生成密集的网格点，对每个点用模型预测类别，然后用不同颜色填充。这样就能直观看到模型是怎么划分空间的。

import matplotlib.pyplot as plt from matplotlib.colors import ListedColormap def plot_decision_boundary(model, X, y, title="Decision Boundary"): # 生成网格 x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5 y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5 h = 0.02 # 网格步长 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) # 预测网格点 grid_points = np.c_[xx.ravel(), yy.ravel()] Z = model.predict(grid_points) Z = Z.reshape(xx.shape) # 绘制 cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF']) cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF']) plt.figure(figsize=(10, 6)) plt.contourf(xx, yy, Z, alpha=0.4, cmap=cmap_light) plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold, edgecolor='k', s=30) plt.title(title) plt.xlabel('Feature 1') plt.ylabel('Feature 2') plt.show()

这段代码的关键是meshgrid生成网格，然后对每个网格点预测。步长h越小，边界越精细，但计算量越大。0.02是个比较平衡的选择，画出来的图足够清晰，计算也不会太慢。

4.2 不同深度下的决策边界对比

决策树的深度直接决定了决策边界的复杂度。我用一个二维的合成数据集来演示：

from sklearn.datasets import make_classification X, y = make_classification(n_samples=300, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=42) fig, axes = plt.subplots(1, 3, figsize=(18, 5)) for ax, depth in zip(axes, [1, 3, 10]): tree = DecisionTree(max_depth=depth) tree.fit(X, y) x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5 y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5 xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02)) Z = tree.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape) ax.contourf(xx, yy, Z, alpha=0.4, cmap='RdYlBu') ax.scatter(X[:, 0], X[:, 1], c=y, cmap='RdYlBu', edgecolor='k', s=20) ax.set_title(f'Max Depth = {depth}') plt.tight_layout() plt.show()

深度为1时，决策边界就是一条直线（一个切分点），模型只能做最简单的划分，欠拟合明显。深度为3时，边界变成阶梯状，能捕捉到数据的主要分布模式。深度为10时，边界变得非常碎，出现了很多小区域，这就是过拟合的典型表现——模型把训练数据中的噪声也当成了真实模式。

实操心得：看决策边界是诊断过拟合最快的方法。如果边界出现很多孤立的"小岛"或"锯齿"，基本可以确定是过拟合了。这时候优先考虑增加min_samples_leaf，而不是减小max_depth。因为min_samples_leaf直接限制了叶子节点的最小样本数，能有效防止模型为个别样本单独划区域。

4.3 决策边界的解读与模型诊断

决策边界不仅能看，还能读出很多信息。比如边界的方向告诉你哪些特征更重要——如果边界主要是垂直的，说明第一个特征在起主要作用；如果边界是阶梯状的，说明两个特征都在被使用。

另外，边界上的样本点就是那些"难分"的样本，它们离决策边界很近，预测结果容易受噪声影响。在实际项目中，我会特别关注这些边界附近的样本，看看它们是不是标注错误或者特征缺失。

还有一个技巧：把训练集和测试集的决策边界画在一起对比。如果训练集的边界很复杂但测试集的边界很简单，说明模型在训练集上过拟合了。如果两者都很简单，说明模型欠拟合。理想情况是两者复杂度接近，且测试集准确率跟训练集差不多。

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

5.1 决策树过拟合了怎么办

这是最常见的问题。表现是训练集准确率接近100%，测试集准确率低很多。排查思路按优先级来：

第一，检查max_depth。默认不限制深度的话，树会一直长到每个叶子节点只有一个样本。先设一个合理的值，比如5到10，看看效果。

第二，调min_samples_leaf。这个参数比max_depth更精细，它直接控制叶子节点的最小样本数。我一般从5开始试，逐步增加到20，观察验证集准确率的变化。

第三，用ccp_alpha做后剪枝。这个参数需要交叉验证来选，但效果通常比预剪枝好。sklearn提供了cost_complexity_pruning_path来帮你找候选值。

第四，检查特征。如果特征里有ID类的唯一标识，或者跟标签高度相关的泄漏特征，树会抓住这些特征过拟合。把这类特征删掉再试。

5.2 决策树欠拟合了怎么办

欠拟合的表现是训练集和测试集准确率都低。这时候要反着来：增加max_depth，减小min_samples_leaf，减小min_samples_split。如果还是不行，可能是特征不够，需要做特征工程，构造更多有区分度的特征。

还有一种可能是数据本身就不适合用决策树。决策树的决策边界是轴对齐的，如果真实边界是斜的（比如y = x这条线），决策树需要用很多阶梯去逼近，效率很低。这种情况下换模型可能更合适。

5.3 特征重要性怎么解读

sklearn的feature_importances_属性给出的是每个特征对不纯度降低的贡献总和，归一化到0到1之间。但要注意，这个重要性是基于训练集的，如果模型过拟合了，重要性也会失真。

我通常会把特征重要性跟业务知识对照。如果模型认为最重要的特征跟业务直觉不符，要么是数据有问题，要么是发现了新的模式。两种情况都值得深挖。

另外，特征重要性对相关性高的特征会"分摊"重要性。比如两个特征高度相关，模型可能随机选一个来切分，导致两个特征的重要性都不高。这时候需要用permutation importance来交叉验证。

5.4 决策树需要特征缩放吗

不需要。决策树是基于阈值切分的，特征的尺度不影响切分点的选择。比如特征值从[0, 1]缩放到[0, 100]，切分点也会等比例缩放，树的形状完全一样。这是决策树相比SVM和KNN的一个优势——省去了标准化这一步。

但要注意，如果特征里有异常值，决策树会受影响。因为切分点可能被异常值拉到极端位置。这种情况下，先做异常值处理或者用分位数变换把特征映射到均匀分布，效果会更好。

6. 从单棵树到集成模型：决策树的进阶方向

单棵决策树虽然直观，但在实际项目中很少单独使用。原因很简单：方差太大。数据稍微变一点，树的结构可能完全不一样。解决办法是集成——把多棵树组合起来。

Bagging的思路是：有放回地采样多份数据，每份数据训练一棵树，然后投票。随机森林在此基础上更进一步，每次切分时只随机考虑一部分特征，进一步降低树之间的相关性。这两个方法都能显著降低方差，提升泛化能力。

Boosting的思路不同：它是一棵树一棵树地串行训练，每棵新树专注于修正前面模型的错误。梯度提升树和它的高效实现是结构化数据竞赛中的常胜将军。

但集成模型牺牲了可解释性。随机森林你没法画出一棵完整的树，只能看特征重要性。所以如果业务要求模型必须可解释，单棵决策树仍然是首选。我的经验是：先跑一版随机森林看上限，再用单棵决策树去逼近那个上限，同时保持可解释性。

决策树还有一个常被忽略的用途：特征离散化。用一棵浅层决策树对连续特征做分箱，比等频分箱、等距分箱更合理，因为切分点是基于标签信息选的。这个技巧在风控评分卡模型中很常用。

代码实现层面，如果你想继续深入，我建议做这几件事：给手写版本加上后剪枝、支持缺失值处理、实现多分类的基尼系数计算。这几个改动都不大，但能让你对决策树的理解上一个台阶。另外，把决策边界的绘制封装成一个通用函数，以后换其他模型也能直接用，省得每次重写。