分层抽样：保证数据分布一致的关键技巧

可视化演示

展示分层抽样在各类别内保持比例的划分原理、随机抽样与分层抽样在不平衡数据上的分布差异、以及分层K折交叉验证的折划分过程。

抽样困境：随手舀一勺有多危险

外婆煮了一大锅八宝粥，红豆最多，绿豆次之，红枣最少。分粥时，外婆让小明先舀。小明兴冲冲拿起勺子，随手一舀——碗里的红豆占了七成，好不容易熬好的红枣一颗都没捞着。小红在边上不乐意了：“红枣呢？这碗不公平！”其实小明没有偏心，只是“随机”的结果天然会偏心。

机器学习里的数据划分也一样。设想一个信用卡欺诈检测数据集，99% 是正常交易，1% 是欺诈。你用 train_test_split 随手一划，看似公平的随机抽样，完全可能让 1000 条测试样本里一条欺诈样本都没有。模型在那样的测试集上“准确率 99%”，实际上它根本没见过欺诈长什么样，评估自然失真。

随机抽样为什么会有这种风险？因为每个类别在样本中出现的次数是一个随机变量。假设总共有 N 个样本，其中 r 个是稀有类别，要抽取 n 个样本进测试集，稀有类全体缺席的概率可以用组合数算出来：

$$\displaystyle P_{\mathrm{miss}} = \frac{C_{N-r}^{n}}{C_{N}^{n}}$$

1. 组合数符号 C：从 N 个东西里选 n 个的选法总数，写作组合数。

$$C_{N}^{n}$$

2. 分子 C(N-r, n)：所有被选中的样本都来自非稀有类（共有 N−r 个）时，能选出多少种测试集。

$$C_{N-r}^{n}$$

3. 分母 C(N, n)：从全部 N 个样本里随便选 n 个，总共有多少种选法。

$$C_{N}^{n}$$

4. 两者相除：分子除以分母，就是“稀有类整类缺席”在随机抽样中发生的机会。

$$\frac{C_{N-r}^{n}}{C_{N}^{n}}$$

外婆后来立了条规矩：谁敢随手舀，谁就负责吃掉碗里那颗硌牙的花生。道理很简单——评估一个模型可不可靠，前提是测试集必须“见多识广”。随手一勺，总有概率让某个类别缺席，而一旦缺席，模型的成绩单就像缺了参考文献的论文，看似完整，实则不可信。

分层原理：先看清锅里有什么

外婆的解决之道并不复杂。她先拿大勺子把锅搅了几圈，然后眯着眼睛数了数：红豆大概六成，绿豆三成，红枣一成。于是她宣布：每碗粥都按六三一的配方来——红豆舀六勺的量，绿豆三勺，红枣一勺。这样分出来的每一碗，配方和整锅完全一致，谁也没话说。

分层抽样（Stratified Sampling）就是这个思路。它把“抽样”拆成两步：第一步，按类别把全部样本分组，每一组叫一个“层”（stratum）；第二步，对每个层分别进行随机抽样，抽多少由该层在全量数据中的占比决定。层内是随机的，层间是定量的——既保留了随机性，又锁住了比例。

用数学语言说，假设全量数据有 N 个样本、共 K 个类别，第 j 类有 N_j 个样本；我们希望总共抽取 n 个样本进入测试集，那么第 j 类应抽取的数量就是：

$$\displaystyle n_j = n \times \frac{N_j}{N}$$

1. 总体 N 与各类 N_j：总样本量等于各类样本量之和。

$$N = \sum_{j=1}^{K} N_j$$

2. 类别占比 p_j：第 j 类在整体中所占的比例。

$$p_j = \frac{N_j}{N}$$

3. 按占比分配名额：抽取总量 n 乘以占比 p_j，就是第 j 类分到的样本数。

$$n_j = n \times \frac{N_j}{N}$$

4. 名额守恒：所有类别分到的样本数加起来，恰好等于要抽取的总数。

$$\sum_{j=1}^{K} n_j = n$$

外婆的“六三一配方”写在纸上贴在厨房，成了家规；分层抽样的“配方”则写进了划分代码。有了这层保护，每一碗粥端出去都是同样的配方，孩子们的抱怨自然就少了——训练集和测试集，也从此站在了同一条起跑线上。

实现方法：把配方写进代码

外婆的配方用嘴说就够，但机器学习工程师得把配方写进代码。不要慌，这不是要你手写一个复杂算法，scikit-learn 早就把“外婆的分粥秘方”封装好了。

train_test_split 函数里有一个 stratify 参数。把标签数组 y 传给它，函数就会先按 y 的取值把数据分组，再在各组内部“随手舀”出比例相同的训练集和测试集。一行代码，外婆的智慧就生效了。

如果非要看清这行代码背后的算术，其实也就三个数：设测试集占比为 t，第 j 类共有 N_j 个样本，则该类进入测试集的数量是 N_j × t 向下取整，剩下全部进训练集：

$$\displaystyle N_j^{\mathrm{test}} = \left\lfloor N_j \times t \right\rfloor, \quad N_j^{\mathrm{train}} = N_j - N_j^{\mathrm{test}}$$

1. 测试集占比 t：t 是划分时指定的测试集比例，比如 0.2 表示 20%。

$$t \in (0, 1)$$

2. 第 j 类的测试集样本数：取该类样本数的 t 倍并向下取整。

$$N_j^{\mathrm{test}} = \left\lfloor N_j \times t \right\rfloor$$

3. 第 j 类的训练集样本数：该类剩下的样本全部进入训练集。

$$N_j^{\mathrm{train}} = N_j - N_j^{\mathrm{test}}$$

4. 完整性校验：两类样本数量相加等于该类的总数量，没有样本被浪费或重复。

$$N_j = N_j^{\mathrm{train}} + N_j^{\mathrm{test}}$$

外婆的配方是“六三一”，你的配方是“二八开”。一字之差，道理相通：分层不是玄学，而是把“公平”固化成一个可执行的规则。代码写好，数据划分就再也不会“出锅不匀”了。

适用场景：什么时候必须分层

外婆也不是每锅粥都这么较真。如果煮的是白米粥，每碗都一个样，随手舀完全没问题。但凡食材丰富、种类悬殊的八宝粥，分粥就必须按配方来。机器学习里也一样，分不分层，得看数据长什么样。

最典型的场景是类别不均衡的分类任务：欺诈检测、罕见病预测、垃圾邮件识别，正类可能只占 1%。此时随机划分就像“白米粥里挑红豆”，稀有类在测试集里朝不保夕。小样本数据集同样要分层——总共 100 条数据，测试集 20 条，某个只占 5% 的类别平均只能进测试集 1 条，随手一舀就没了。甚至回归任务也有分层变体：把连续目标值切成几个区间（分箱），再按区间分层。

用期望来衡量：设第 j 类占比为 p_j，测试集大小为 n，那么该类在测试集中的期望数量是 n·p_j，波动幅度由方差决定：

$$\displaystyle E[X_j] = n p_j, \quad \mathrm{Var}(X_j) = n p_j (1 - p_j)$$

1. 期望数量：类别 j 在测试集中出现的平均次数，等于测试集大小乘以占比。

$$E[X_j] = n p_j$$

2. 波动方差：随机抽样下该数量不会乖乖等于期望，而是围绕期望上下波动。

$$\mathrm{Var}(X_j) = n p_j (1 - p_j)$$

3. 可靠性判据：当期望不足 1，说明类别 j 很可能整个从测试集消失。

$$n p_j \ge 1$$

外婆的直觉是“八宝粥必分，白粥不用分”——对应到工程上就是：类别越不均衡、样本量越小、评估结论越重要，分层就越不能省。省下这一步，省的是代码量，赔的是评估可靠性。

效果评估：分层让成绩单更可信

外婆分层分粥之后，孩子们不再抱怨了。但有人问：外婆你怎么知道这样分就真的公平？外婆说：你随便去检查每一碗，配方都对得上整锅，这就是证据。

机器学习评估也一样，分层带来的可验证的好处是：类别占比的“估计误差”被清零。随机抽样下，测试集里每个类别的占比都是一个随机数，忽高忽低；分层抽样直接把占比锁死在目标值上，不给你波动的机会。

数学上，随机抽样时类别占比估计值的方差为：

$$\displaystyle \mathrm{Var}(\hat{p}_j) = \frac{p_j(1 - p_j)}{n} \times \frac{N - n}{N - 1}$$

分层之后，这个方差在类别比例这一维度上变成 0——因为比例是“设计”出来的，不是“抽”出来的。

1. 单样本不确定度：p(1−p) 来自“一次抽样是否命中该类”的伯努利波动。

$$p_j(1 - p_j)$$

2. 有限总体校正：无放回抽样时样本量越大，波动越小，乘上这个小于 1 的校正因子。

$$\frac{N - n}{N - 1}$$

3. 分层后的方差：类别比例被设计锁定，这一项化为零，评估指标不再因抽样而抖动。

$$\mathrm{Var}_{\mathrm{strat}}(\hat{p}_j) = 0$$

当然，外婆也明白：配方一致不等于每一颗红枣一样甜——分层消除的是“类别比例”的偏差，特征层面的噪声依然存在。但至少，模型成绩单上的每个数字，都建立在“见多识广”的基础上，给决策者看的时候，腰杆硬了。

分层K折：轮流当评委也要守规矩

光分一次碗，外婆还是不放心。她想：谁说这一锅粥的配方一定好？得让每个孩子都来当一次评委。于是她定下规矩：把一锅粥分成 5 份，轮流让 1 份当“待审样品”，另外 4 份当“标准对照”，5 轮下来每个孩子都评过一次。这就是交叉验证的思路。

交叉验证里，数据被分成 K 份（fold），每份轮流做验证集，其余 K−1 份做训练集。但如果分 K 份时随手切，某些份里可能缺了红枣，轮到它当验证集时就又不公平了。于是外婆升级了配方：分 K 份时，每一份都按“六三一”来配。这就是分层K折（Stratified K-Fold）。

形式化地说，普通 K 折只保证份与份不相交、合起来是全集：

$$\displaystyle D = \bigcup_{k=1}^{K} D_k, \quad D_k \cap D_{k'} = \emptyset \ (k \neq k')$$

分层 K 折还额外要求每一折保持类别比例：

$$\displaystyle \frac{|D_k^{(j)}|}{|D_k|} = \frac{N_j}{N}, \quad k = 1, \dots, K$$

1. K 折划分：全集被拆成 K 个子集，拼起来正好是整锅数据。

$$D = \bigcup_{k=1}^{K} D_k$$

2. 互不相交：任意两份没有重叠样本，保证每轮评委和对照都不“串味”。

$$D_k \cap D_{k'} = \emptyset$$

3. 逐折保比例：每一折中第 j 类样本占比都等于它在全量中的占比。

$$\frac{|D_k^{(j)}|}{|D_k|} = \frac{N_j}{N}$$

外婆把“分粥一次”升级成“轮流评比”，从单次分层走向了分层 K 折。单次分层抽样是“一锤定音”，分层 K 折是“多方会审”——两者共用同一套配方，后者把可靠性再乘以 K 次。

实操陷阱：别让外婆的配方翻车

配方是好配方，可外婆也有失手的时候。比如，若锅里的红枣一共就两颗，她还想给五个孩子每人都分到红枣，那必然有人分不到。这不是配方的问题，是原料太少的问题。

分层抽样的第一个陷阱就是“层太小”。某个类别只有四五个样本，测试集又想占 20%，按比例算下来一层可能分到 0 个或全被划走，类别就在训练集或测试集中消失了。第二个陷阱是“标签不可信”：分层依赖的类别标签本身就是错的，那分层等于给错误分类建了档案，越分越歪。第三个陷阱是“泄露”：在划分训练测试集之前，就用全量数据做了归一化、填补缺失值等预处理，测试集的信息悄悄溜进了训练过程，分层再准也救不回来。

一个稳妥的检查标准是：每一个层，在训练集和测试集里都必须“至少留下一个样本”：

$$\displaystyle 1 \le n_j \le N_j - 1, \quad j = 1, 2, \dots, K$$

凡是打破这个条件的划分，都是在用一口缺料的锅硬熬八宝粥。

1. 下界：第 j 类在测试集中至少分到 1 个样本，否则该类在测试集中消失。

$$n_j \ge 1$$

2. 上界：第 j 类在测试集中最多分到 N_j−1 个，否则训练集里就没有该类。

$$n_j \le N_j - 1$$

3. 逐类检查：K 个类别必须全部满足，一个都不能例外。

$$\forall j \in \{1, 2, \dots, K\}$$

外婆后来在厨房贴了张便条：“红枣不够，就厚着脸皮跟隔壁再借两颗。”工程师们也有自己的借法：对极稀有的类别，用更小的验证集占比、分层K折，或者干脆把稀有类做上采样。总之，分层不是万能药，它只保证“能分到的食材按比例分”，食材本身就缺时，先补食材（数据），再谈公平（评估）。

AI 应用场景

Python 演示

import numpy as npfrom collections import Counter rng = np.random.default_rng(42) # 模拟 1000 个样本, 3 个类别, 比例 70:20:10 (类别不平衡)y = np.array([0] * 700 + [1] * 200 + [2] * 100)rng.shuffle(y)  def random_split(y, test_ratio=0.3, seed=1):    """随机抽样: 从头到尾都没有考虑类别比例"""    rng2 = np.random.default_rng(seed)    idx = rng2.permutation(len(y))    cut = int(len(y) * test_ratio)    return idx[:cut], idx[cut:]  def stratified_split(y, test_ratio=0.3, seed=1):    """分层抽样: 按类别分组, 组内随机抽取同样比例"""    rng2 = np.random.default_rng(seed)    test_idx, train_idx = [], []    for cls in np.unique(y):        cls_idx = np.where(y == cls)[0]        rng2.shuffle(cls_idx)        cut = int(len(cls_idx) * test_ratio)        test_idx.extend(cls_idx[:cut])        train_idx.extend(cls_idx[cut:])    return np.array(test_idx), np.array(train_idx)  def show(tag, idx, y):    counts = dict(Counter(y[idx]))    print("%s: %s" % (tag, {k: counts[k] for k in sorted(counts)}))  print("全量数据类别分布:", dict(Counter(y)))print("--- 随机抽样 ---")for seed in [0, 1, 2]:    test_idx, _ = random_split(y, seed=seed)    show("随机测试集(seed=%d)" % seed, test_idx, y)print("--- 分层抽样 ---")for seed in [0, 1, 2]:    test_idx, _ = stratified_split(y, seed=seed)    show("分层测试集(seed=%d)" % seed, test_idx, y)

1. y = np.array([0] * 700 + [1] * 200 + [2] * 100)构造一个 7:2:1 的不平衡标签序列，模拟八宝粥里三种食材的份额。
2. idx = rng2.permutation(len(y))随机打乱所有样本的序号，这就是“随手舀一勺”的随机动作。
3. cls_idx = np.where(y == cls)[0]找出第 cls 类样本的下标，相当于外婆先把食材按种类分好堆。
4. rng2.shuffle(cls_idx)在每一类内部再洗一次牌，保证组内随机，不引入顺序偏差。
5. cut = int(len(cls_idx) * test_ratio)每类都切出同样的 test_ratio 比例，这是“六三一配方”的代码化身。
6. train_idx.extend(cls_idx[cut:])该类剩下的样本进训练集，保证每类在两侧都留有代表。
7. counts = dict(Counter(y[idx]))统计测试集里的实际类别数量，用来验证分层后比例是否精确锁定。

常见误区

面试题