交叉验证：K折、分层K折、时序交叉验证

一句话概述

交叉验证（Cross-Validation）是评估模型泛化性能的黄金标准，它通过多次划分训练集和验证集来减少单次划分的随机性。K 折交叉验证将数据分为 K 份，轮流用 K−1 份训练、1 份验证；分层 K 折保持了每折中类别比例与原始数据一致；时序交叉验证严格按照时间顺序划分，防止未来信息泄露。交叉验证是模型选择、超参数调优和性能评估的基石。

💡 核心要点：① 交叉验证的核心目标是获得泛化误差的无偏估计，而非提高模型精度 ② K 通常取 5 或 10，K 越大偏差越小但方差越大 ③ 分层 K 折是分类任务的标准做法，保证每折类别分布一致 ④ 时序数据必须使用时序交叉验证，否则会导致严重的数据泄露

教学与演示

一、K 折交叉验证

是什么：K 折交叉验证（K-Fold Cross-Validation）将数据集随机分为 K 个大小相等的互斥子集（折）。每次选择一个折作为验证集，其余 K−1 个折作为训练集，共进行 K 次训练和评估。最终的泛化性能估计为 K 次验证结果的平均值。K 通常取 5 或 10。

大白话 K 折交叉验证就像「K 次模拟考试」——把试卷分成 K 份，每次拿一份当考试题，剩下 K−1 份当练习题。这样每道题都当过考试题，最终的分数是 K 次考试的平均分，比单次考试更能反映真实水平。

为什么：单次训练/验证集划分的随机性可能导致性能估计偏差很大——如果「倒霉」地把所有难样本都分到了验证集，模型表现会异常差。K 折交叉验证通过多次评估取平均，降低了这种随机性。偏差-方差角度看：K 越大，训练集越接近全集（偏差越小），但 K 次评估之间的相关性越高（方差可能增大）。K=5 或 10 是偏差和方差之间的最佳平衡点。

怎么做：

import numpy as np

# ========== K 折交叉验证实现 ==========
np.random.seed(42)

def k_fold_cv_demo():
    """从零实现 K 折交叉验证"""
    n_samples = 100
    n_features = 5
    K = 5  # 折数
    
    # 生成模拟数据
    X = np.random.randn(n_samples, n_features)
    y = (X[:, 0] + X[:, 1] + np.random.randn(n_samples) * 0.5 > 0).astype(int)
    
    print("=== K 折交叉验证（K-Fold CV）===")
    print(f"样本数: {n_samples}, 折数: K={K}")
    print(f"每折大小: {n_samples // K} 个样本")
    print()
    
    # 生成 K 折索引
    indices = np.arange(n_samples)
    np.random.shuffle(indices)  # 随机打乱
    
    fold_size = n_samples // K
    fold_scores = []
    
    for fold in range(K):
        # 确定验证集索引
        val_start = fold * fold_size
        val_end = (fold + 1) * fold_size if fold < K - 1 else n_samples
        val_idx = indices[val_start:val_end]
        # 训练集索引 = 全部索引 - 验证集索引
        train_idx = np.setdiff1d(indices, val_idx)
        
        # 模拟训练和评估（实际中应在此训练模型）
        X_train, y_train = X[train_idx], y[train_idx]
        X_val, y_val = X[val_idx], y[val_idx]
        
        # 简化：用简单规则模拟预测
        # 实际中应该是: model.fit(X_train, y_train); score = model.score(X_val, y_val)
        # 这里用特征0的符号作为简单预测
        train_threshold = np.median(X_train[:, 0])
        pred = (X_val[:, 0] > train_threshold).astype(int)
        score = np.mean(pred == y_val)
        
        fold_scores.append(score)
        print(f"第{fold+1}折: 验证集索引 [{val_start}:{val_end}], "
              f"准确率 = {score:.3f}")
    
    # 汇总结果
    print(f"\n=== 汇总 ===")
    print(f"各折准确率: {[f'{s:.3f}' for s in fold_scores]}")
    print(f"平均准确率: {np.mean(fold_scores):.3f}")
    print(f"标准差: {np.std(fold_scores):.3f}")
    print(f"95% 置信区间: [{np.mean(fold_scores) - 1.96*np.std(fold_scores)/np.sqrt(K):.3f}, "
          f"{np.mean(fold_scores) + 1.96*np.std(fold_scores)/np.sqrt(K):.3f}]")
    
    print(f"\nK 的选择:")
    print(f"  K=5: 偏差稍大，方差小，计算快（常用）")
    print(f"  K=10: 偏差小，方差稍大，计算慢（精度优先）")
    print(f"  K=n (留一法): 偏差最小，方差最大，计算最慢（小数据集）")

k_fold_cv_demo()

大白话 K 折交叉验证就是「把数据分成 K 份，轮流考试」。K=5 就像是 5 次模拟考，每次用不同的 4/5 数据复习、1/5 数据考试。最终成绩是 5 次考试的平均分——比单次考试可靠得多。

二、分层 K 折交叉验证

是什么：分层 K 折交叉验证（Stratified K-Fold）在普通 K 折的基础上，保证每折中各类别的样本比例与原始数据集一致。这对于类别不平衡的分类任务尤其重要——如果某类别只有 10 个样本，普通 K 折可能导致某折完全没有该类别，验证结果将不可靠。

大白话 分层 K 折就像「按比例分班」——如果原始数据中男女比例是 6:4，那么每个班（折）的男女比例也保持 6:4。这样每个班都是原始数据的「微缩版」，评估结果更可靠。

为什么：普通 K 折在类别不平衡时可能出现极端情况：某折中完全没有少数类样本，导致该折的验证结果偏离真实性能。分层 K 折通过保持每折的类别分布，确保每折都「有代表性」，从而获得更稳定的性能估计。分层 K 折是分类任务中交叉验证的标准做法。

怎么做：

import numpy as np

# ========== 分层 K 折交叉验证 ==========
np.random.seed(42)

def stratified_kfold_demo():
    """演示分层 K 折与普通 K 折的区别"""
    n_samples = 100
    # 模拟不平衡数据集：类别0有90个，类别1只有10个
    y = np.array([0] * 90 + [1] * 10)
    np.random.shuffle(y)  # 打乱顺序
    
    K = 5
    print("=== 分层 K 折 vs 普通 K 折 ===")
    print(f"总样本: {n_samples}, 类别分布: 0={np.sum(y==0)}, 1={np.sum(y==1)}")
    print(f"类别1 占比: {np.mean(y==1):.0%}")
    print()
    
    # 普通 K 折
    print("--- 普通 K 折 ---")
    indices = np.arange(n_samples)
    np.random.shuffle(indices)
    fold_size = n_samples // K
    
    for fold in range(K):
        val_start = fold * fold_size
        val_end = (fold + 1) * fold_size
        val_idx = indices[val_start:val_end]
        val_y = y[val_idx]
        print(f"  第{fold+1}折: 类别0={np.sum(val_y==0)}, 类别1={np.sum(val_y==1)} "
              f"(1占比={np.mean(val_y==1):.0%})")
    
    print(f"  注意：某些折中类别1可能很少或没有 → 评估不可靠")
    
    # 分层 K 折
    print("\n--- 分层 K 折 ---")
    # 分别获取两个类别的索引
    idx_0 = np.where(y == 0)[0]
    idx_1 = np.where(y == 1)[0]
    np.random.shuffle(idx_0)
    np.random.shuffle(idx_1)
    
    # 按比例分配
    fold_size_0 = len(idx_0) // K
    fold_size_1 = len(idx_1) // K
    
    for fold in range(K):
        val_0 = idx_0[fold * fold_size_0:(fold + 1) * fold_size_0]
        val_1 = idx_1[fold * fold_size_1:(fold + 1) * fold_size_1]
        val_idx = np.concatenate([val_0, val_1])
        val_y = y[val_idx]
        print(f"  第{fold+1}折: 类别0={np.sum(val_y==0)}, 类别1={np.sum(val_y==1)} "
              f"(1占比={np.mean(val_y==1):.0%})")
    
    print(f"  注意：每折中类别1占比始终为 10% → 评估更可靠")
    print(f"  分层 K 折是分类任务中交叉验证的标准做法")

stratified_kfold_demo()

大白话 分层 K 折的核心价值在于「保证每折都有代表性」。如果数据中只有 1% 的欺诈交易，普通 K 折可能导致某折完全没有欺诈案例——那这个折的评估就毫无意义。分层 K 折确保每折都有 1% 的欺诈交易，评估结果才靠谱。

三、时序交叉验证

是什么：时序交叉验证（Time Series Cross-Validation）专门用于时间序列数据。它的核心原则是：训练集的时间必须早于验证集的时间（不能用「未来」数据预测「过去」）。常用方法包括：① 滚动窗口（Rolling Window）——固定窗口大小，随时间滑动，② 扩展窗口（Expanding Window）——训练集随时间增长，验证集在训练集之后，③ 向前链式（Forward Chaining）——逐步扩展训练集，每次验证下一段时间。

大白话 时序交叉验证的「铁律」是：不能用明天的数据来预测今天。普通 K 折随机打乱数据，会混入未来信息。时序数据必须按时序划分——训练集永远是「过去」的数据，验证集永远是「未来」的数据。

为什么：时间序列数据具有自相关性和时间依赖性——相邻时间点的数据高度相关。如果随机打乱，模型会「偷看」到未来信息，导致验证结果过于乐观，但上线后效果差。时序交叉验证严格保证因果性，得到的性能估计更接近真实部署效果。

怎么做：

import numpy as np

# ========== 时序交叉验证 ==========
np.random.seed(42)

def time_series_cv_demo():
    """演示时序交叉验证的三种方式"""
    n_days = 50  # 50 天的数据
    # 模拟时间序列数据（带趋势和季节性）
    t = np.arange(n_days)
    trend = 0.1 * t  # 线性趋势
    seasonal = 5 * np.sin(2 * np.pi * t / 7)  # 周季节性
    noise = np.random.randn(n_days) * 2
    y = trend + seasonal + noise  # 目标变量
    
    print("=== 时序交叉验证 ===")
    print(f"时间序列: {n_days} 天")
    print("核心原则：训练集的时间必须早于验证集的时间")
    print()
    
    # 方法1：滚动窗口
    print("--- 方法1：滚动窗口（Rolling Window）---")
    window_size = 30  # 训练窗口大小
    test_size = 5     # 验证窗口大小
    n_splits = (n_days - window_size) // test_size
    
    for split in range(min(n_splits, 3)):  # 只展示前3个划分
        train_end = window_size + split * test_size
        train_start = train_end - window_size
        val_start = train_end
        val_end = val_start + test_size
        print(f"  划分{split+1}: 训练 [{train_start}:{train_end}], 验证 [{val_start}:{val_end}]")
    
    # 方法2：扩展窗口
    print(f"\n--- 方法2：扩展窗口（Expanding Window）---")
    initial_train = 20  # 初始训练集大小
    test_size = 5
    
    for split in range(min(3, (n_days - initial_train) // test_size)):
        train_end = initial_train + split * test_size
        val_start = train_end
        val_end = val_start + test_size
        print(f"  划分{split+1}: 训练 [0:{train_end}], 验证 [{val_start}:{val_end}]")
    
    print(f"  注意：训练集随时间增长 → 越多历史数据，模型越强")
    
    # 方法3：向前链式
    print(f"\n--- 方法3：向前链式（Forward Chaining）---")
    min_train = 20
    step = 5
    
    for split in range(min(3, (n_days - min_train) // step)):
        train_end = min_train + split * step
        val_start = train_end
        val_end = val_start + step
        print(f"  划分{split+1}: 训练 [0:{train_end}], 验证 [{val_start}:{val_end}]")
    
    print(f"\n=== 为什么不能用普通 K 折？ ===")
    print("普通 K 折随机打乱数据，会导致：")
    print("  1. 用第30天的数据训练，去预测第10天的数据 → 因果颠倒")
    print("  2. 模型「偷看」到未来趋势 → 验证准确率虚高")
    print("  3. 上线后效果比验证时差很多 → 严重的泛化问题")

time_series_cv_demo()

大白话 时序交叉验证的「铁律」就是：训练数据永远在验证数据之前。就像你不能用下周的股价来预测这周的股价——如果模型能做到，那一定是数据泄露。

什么用：在 AI 工业中，交叉验证是模型选择、超参数调优和性能评估的标准工具。K 折交叉验证用于独立同分布（i.i.d.）数据，分层 K 折用于分类任务（尤其不平衡数据），时序交叉验证用于金融预测、销量预测、异常检测等时间序列场景。Scikit-learn 中 KFold、StratifiedKFold、TimeSeriesSplit 等类封装了这些功能。

哪些坑：交叉验证最常见的错误是「数据泄露」——在交叉验证之前对整个数据集做特征工程（如标准化、缺失值填充），导致验证集信息泄露到训练集中。正确做法是将特征工程放在交叉验证的循环内部。此外，K 折交叉验证的 K 次评估不是独立的（训练集有重叠），标准误需要校正。

概念关系图谱

重点答疑

Q1: K 折交叉验证中 K 应该取多大？

K 的选择是偏差-方差权衡：K 越大（如 K=n 留一法），训练集越接近全集，偏差越小，但 K 次评估之间的相关性高，方差可能增大，且计算成本高。K 越小（如 K=2），训练集小，偏差大，但计算快。实践中 K=5 或 10 是最常用的折中。小数据集可以用留一法（K=n），大数据集可以用 K=5。

Q2: 交叉验证中的「数据泄露」是什么意思？

数据泄露是指验证集的信息在训练阶段被模型「偷看」到了。最常见的泄露场景：在交叉验证之前对整个数据集做标准化（用全量数据的均值和标准差），或者在交叉验证之前做特征选择（用全量数据选特征）。正确做法是将所有预处理步骤放在交叉验证的循环内部，每次只用训练集计算参数，然后应用到验证集。

Q3: 分类任务中为什么必须使用分层 K 折？

分层 K 折保证每折中各类别的比例与原始数据一致。如果不分层，在类别不平衡的数据中，某折可能完全没有少数类样本，导致该折的评估结果完全不可靠（如准确率可为 100%，因为模型只需预测多数类）。分层 K 折确保每折的评估都有意义，是分类任务中交叉验证的标准做法。

章节单词汇总