Purged K-Fold 交叉验证：给回测一个诚实的样本外

交叉验证是机器学习里最被信任的一步：把数据划成几折，轮流留一折当测试，看模型在没见过的样本上表现如何。但在金融里，这一步常常在骗你——而且骗得非常隐蔽。

原因很具体：金融标签几乎都「向前看」。你想预测「未来 20 根 K 线里是否触发止盈」，那第 t 根 K 线的标签就依赖 t 之后的价格；你想预测「下个月收益是否为正」，标签就依赖下个月的收益。于是相邻观测的标签高度重叠——第 t 根和第 t+1 根的标签共享了 19/20 的未来信息，几乎是同一个东西。

普通 KFold(shuffle=True) 把数据随机打乱再切分。问题来了：被分到测试集的第 t 根 K 线，它的「时间邻居」第 t±1 根很可能落在训练集里。这两个样本特征近重复、标签又高度相关，模型（尤其 kNN、深树这类「记性好」的模型）只要抄邻居的标签就能答对。于是交叉验证分数虚高，而你以为自己挖到了一个 0.85 AUC 的好信号。

本文用 López de Prado 的 Purged K-Fold 把这种泄漏连根拔起，并用量化方式告诉你：那个「0.85」到底有多少是假的。所有数字和配图都由文末代码真实生成。

一、泄漏从哪里来：观测重叠（observation overlap）#

关键不在于特征有没有未来信息，而在于标签的信息区间与特征的时间位置重叠。给一个形式化定义：设第 i 个样本的特征取自时间 t_i，但它的标签 y_i 依赖未来区间 [t_i, t_i+h]（h 是前瞻窗口）。那么：

• 第 i 个样本的「标签信息区间」是 [t_i, t_i+h]；
• 第 j 个样本若满足 [t_j, t_j+h] ∩ [t_i, t_i+h] ≠ ∅，就与 i 共享标签信息；
• 当 i 在测试集、j 在训练集，且 j 是 i 的时间邻居时，模型在训练时已经「见过」与测试标签高度相关的信号——这就是泄漏。

普通打乱切分不尊重时间顺序，天然会把这种重叠样本拆进训练和测试两侧。下图直观对比了两种切分：

上面是普通 KFold：时间相邻的块被随机染成训练/测试，相邻块之间红线标出的就是泄漏通道。下面是 Purged K-Fold：切分按时间有序，当前测试折（蓝）之外、凡是标签窗口与之重叠的邻域（红）全部被 purge 掉，模型无从抄作业。

二、Purged K-Fold 怎么做：purge + embargo#

思路一句话：任何训练样本的标签信息区间，只要和测试折的标签信息区间重叠，就从这折的训练集里删掉；再额外留一道 embargo 缓冲，防止边界污染。

测试折覆盖时间 [a, b]，它的标签信息区间是 [a, b+h]。训练样本 t 的标签区间是 [t, t+h]。两者重叠当且仅当 t ≤ b+h 且 t+h ≥ a，即 t ∈ [a−h, b+h]。把这段全部剔除。embargo 再额外剔除 (b, b+⌊frac·N⌋] 这一段。下面是实现：

import numpy as np
from sklearn.model_selection import KFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import roc_auc_score

class PurgedKFold:
    def __init__(self, n_splits=5, h=10, embargo_frac=0.0):
        self.n_splits = n_splits
        self.h = h                      # 标签前瞻窗口
        self.embargo_frac = embargo_frac

    def split(self, n):
        edges = np.linspace(0, n, self.n_splits + 1).astype(int)
        folds = []
        for i in range(self.n_splits):
            a, b = edges[i], edges[i + 1] - 1
            test = np.arange(a, b + 1)
            train = np.arange(n)
            # purge：训练点 t 的标签窗口 [t, t+h] 与测试标签窗口 [a, b+h] 重叠
            keep = (train < a - self.h) | (train > b + self.h)
            if self.embargo_frac > 0:   # embargo：测试结束后的缓冲段也剔除
                emb_end = int(b + self.embargo_frac * n)
                keep &= train > emb_end
            folds.append((train[keep], test))
        return folds

注意这和「时间序列切分（TimeSeriesSplit）」不同：TimeSeriesSplit 只保证训练早于测试，但没有 purge，所以仍会让重叠样本留在训练里。Purged 的核心动作是「删」，不是「排顺序」。

三、实验设计：让泄漏「可被测量」#

要证明泄漏存在，得构造一个特征对标签零预测力、但标签彼此高度相关的数据。这样任何高于 0.5 的 CV 分数都只能来自泄漏，而不是真信号。

def build_data(N=4000, lag=20, h=10, phi=0.995, seed=20260712):
    rng = np.random.default_rng(seed)
    eta = rng.standard_normal(N)            # 驱动平滑过程 s_t 的噪声
    zeta = rng.standard_normal(N + h)       # 独立的「前瞻噪声」，只决定标签
    s = np.zeros(N)
    s[0] = eta[0]
    for t in range(1, N):
        s[t] = phi * s[t - 1] + 0.05 * eta[t]   # 平滑持久 => 时间邻居=特征近重复
    X = np.zeros((N, lag))
    for t in range(N):
        lo = max(0, t - lag + 1)
        X[t, -len(s[lo:t + 1]):] = s[lo:t + 1]  # 特征 = 最近 lag 个 s 的窗口
    y = np.zeros(N, dtype=int)
    for t in range(N - h):
        y[t] = 1 if zeta[t + 1:t + 1 + h].sum() > 0 else 0  # 标签用独立噪声
    return X[:N - h], y[:N - h]

设计要点：特征来自平滑过程 s_t，时间相邻的窗口几乎完全重合 → 特征空间里「近重复」唯一地就是时间邻居；标签却由一段完全独立的前瞻噪声 zeta 决定 → 特征对标签真实 AUC≈0.5（零信号，这是真相），但 y_t 与 y_{t+1} 共享 h−1 个噪声 → 标签高度相关。于是打乱 CV 下 kNN 抄到相关标签刷高分，Purged 删掉邻居后只能落到 0.5。

四、三种口径：虚高 vs 诚实#

我们用 kNN（n_neighbors=5，最擅长利用近重复邻居）在三种评估口径下比较 AUC：

def cv_score(X, y, h, n_splits=5, purged=True, embargo_frac=0.0):
    n = len(y); aucs = []
    if purged:
        for tr, te in PurgedKFold(n_splits=n_splits, h=h,
                                  embargo_frac=embargo_frac).split(n):
            if len(tr) < 50 or len(te) < 5: continue
            m = KNeighborsClassifier(5).fit(X[tr], y[tr])
            aucs.append(roc_auc_score(y[te], m.predict_proba(X[te])[:, 1]))
    else:
        for tr, te in KFold(n_splits, shuffle=True, random_state=42).split(X):
            m = KNeighborsClassifier(5).fit(X[tr], y[tr])
            aucs.append(roc_auc_score(y[te], m.predict_proba(X[te])[:, 1]))
    return np.mean(aucs), np.std(aucs)

X, y, _ = build_data(N=4000, lag=20, h=10)
auc_shuf, _ = cv_score(X, y, 10, purged=False)        # 普通 KFold 打乱
auc_purg, _ = cv_score(X, y, 10, purged=True)         # Purged K-Fold
auc_emb,  _ = cv_score(X, y, 10, purged=True, embargo_frac=0.01)  # + embargo

实测结果（数据 N=3970，标签正类占比 0.491，即无方向性真实信号）：

一个刺眼的事实：打乱 CV 报的 0.745，和真实时间外样本的 0.482，差了 0.26。也就是说，如果你用普通 KFold 选模型、汇报成绩，你会以为自己有个「74.5% 区分度」的策略；而它真正上场（用前 70% 训练、后 30% 测试）只是个硬币——这 0.26 的「泄漏溢价」全是假象。

五、泄漏溢价随前瞻窗口 h 放大#

泄漏的严重程度不是常数，它正比于标签重叠的程度。h 越大，相邻标签共享的未来信息越多，y_t 与 y_{t+1} 越像，抄作业越容易。扫一遍 h：

溢价从 h=2 的 0.13 一路涨到 h=20 的 0.28。在真实策略里 h 常常很大（持有一周、一个月），所以泄漏不是小修小补能糊弄过去的问题——它随你的持有期线性放大。

六、真实陷阱（这一步栽的人最多）#

1. TimeSeriesSplit ≠ Purged K-Fold：前者只排了顺序，没删重叠样本。标签重叠下的泄漏，TimeSeriesSplit 照样有。必须显式 purge。
2. 「最终模型」也用打乱训练会怎样？ 不会——泄漏污染的是评估与超参选择，不是最终系数本身（线性模型尤甚）。但你会被虚假 CV 分数骗去部署一个其实无效、或选错超参的模型。坏在决策层，不在权重层。
3. embargo 长度怎么定？ 经验法则是 embargo ≈ 测试折长度的一小部分（如 1–2%），用于吸收边界处的微观结构污染。太小留尾巴，太大浪费样本。本文 1% 已足够，与纯 purge 几乎一致。
4. 分组泄漏（entity/group leakage）更隐蔽：若同一股票的多条样本被拆进训练/测试两侧，模型靠「记住这只股票」而非学规律。此时要按股票分组 purge（GroupPurgedKFold），光按时间不够。
5. 特征本身带未来字段：本文特征与标签独立，所以干净。真实里常有人不小心把 未来成交量、明日换手 之类混进特征——那比标签重叠更致命，Purged 也救不回来。先审特征，再谈切分。
6. 小样本下 purge 会饿死训练集：h 很大、折很多时，每折能用的训练样本可能骤减。要监控每折 len(tr)，过少的折直接跳过（代码里 len(tr)<50 已处理）。

七、结论#

金融 ML 的交叉验证，难点从来不是「怎么切分」，而是「怎么不让未来信息从标签的缝隙里漏回训练」。Purged K-Fold 用一句话解决问题：凡是标签信息区间和测试折重叠的训练样本，删。再补一道 embargo 缓冲。

本文用一段「特征零信号、标签纯重叠」的合成数据把这件事钉死：普通 KFold 报 0.745 的「好模型」，真实时间外只有 0.482——那个 0.26 的溢价，就是泄漏本身的重量。记住，交叉验证分数虚高，往往不是模型强，而是你的切分在帮它作弊。先 purge，再庆祝。

完整可复现代码（含合成数据、PurgedKFold 切分器、三种口径对比、泄漏随 h 扫描、三张配图）已随本文生成脚本一并运行，所有统计数字均来自该脚本的真实输出。