WEBKT

嵌套交叉验证：获取可靠模型性能评估的终极武器

19 0 0 0

引言：超参数调优与模型评估的困境

信息泄露：简单交叉验证 + 调优的致命缺陷

嵌套交叉验证：隔离调优与评估

为什么嵌套交叉验证能提供无偏估计？

实现嵌套交叉验证

伪代码

Scikit-learn 实现思路

关于 Repeated K-Fold

考量与权衡

结论

引言：超参数调优与模型评估的困境

在机器学习实践中，模型的性能很大程度上取决于超参数的选择。比如支持向量机（SVM）中的 C 和 gamma，随机森林中的 n_estimators 和 max_depth 等等。找到最优的超参数组合，即所谓的超参数调优（Hyperparameter Tuning），是模型开发流程中至关重要的一步。

通常，我们会使用交叉验证（Cross-Validation, CV），特别是 K 折交叉验证（K-Fold CV），来评估模型的泛化能力。它通过将数据分成 K 份，轮流使用 K-1 份训练，1 份验证，最后综合 K 次的结果来得到一个更鲁棒的性能估计，有效避免了单次划分训练集和测试集带来的偶然性。

那么，一个自然的想法是：能不能在 K 折交叉验证的框架内同时进行超参数调优和模型评估呢？比如，在每一折验证时，都尝试不同的超参数组合，选出在该折上表现最好的，然后用这个最好的超参数训练的模型在该折的验证集上评估性能，最后平均 K 次的性能得分？

听起来很合理？但这里隐藏着一个巨大的陷阱！ 这种看似方便的做法会导致对模型性能的过度乐观估计（Overly Optimistic Bias），从而让你误以为模型在新数据上也会表现得那么好，但现实往往是残酷的。为什么会这样？这就要引出我们今天的主角——嵌套交叉验证（Nested Cross-Validation）。

信息泄露：简单交叉验证 + 调优的致命缺陷

让我们仔细分析一下前面提到的那个“看似合理”的方法，也就是在单层 K 折交叉验证循环中同时进行调优和评估。

假设我们进行 5 折交叉验证。在第一折中：

  1. 我们将数据分为 Fold 1（验证集）和 Folds 2-5（训练集）。
  2. 我们使用 Folds 2-5 作为训练数据，尝试不同的超参数组合（比如通过网格搜索 Grid Search）。对于每个组合，我们在 Folds 2-5 内部（可能又做了一层划分，或者就直接用 Folds 2-5 训练，用 Fold 1 评估哪个超参数好——这里是问题的关键！）找到在 Fold 1 上表现最好的超参数组合 best_params_1。
  3. 我们用 best_params_1 在 Folds 2-5 上训练最终模型 model_1。
  4. 我们用 model_1 在 Fold 1 上进行预测，得到性能得分 score_1。

然后对 Fold 2, 3, 4, 5 重复这个过程，得到 score_2, score_3, score_4, score_5。最后计算平均分 (score_1 + ... + score_5) / 5 作为模型的最终性能评估结果。

问题出在哪里？

问题出在步骤 2 和步骤 4 使用了相同的数据集（Fold 1）。步骤 2 中，Fold 1 的数据指导了我们选择 best_params_1。也就是说，best_params_1 是“看到”了 Fold 1 数据后才被选出来的，它天生就对 Fold 1 的数据有“偏爱”。然后，在步骤 4 中，我们又用这个“偏爱”Fold 1 的模型在 Fold 1 上进行评估。这就像是让学生根据考试题目来复习，然后再用同一套题目来考试，得分自然会偏高！

这种现象被称为信息泄露（Information Leakage）。验证集（Fold 1）本应用于评估模型的泛化能力，但在上述流程中，它的一部分信息（哪些数据点让某个超参数组合表现更好）“泄露”到了超参数的选择过程中。因此，最终得到的性能得分 score_1 并不是模型在完全未知数据上的表现，而是模型在部分已知（至少在选择超参数时“见过”）数据上的表现。平均 K 次的结果，同样会带有这种乐观偏差。

这种偏差在数据集较小、模型复杂度较高、或者超参数空间很大时尤其严重。你可能会选出一个看起来很棒的模型，但实际部署后性能远低于预期。

嵌套交叉验证：隔离调优与评估

为了解决信息泄露问题，获得无偏的性能估计，我们需要引入嵌套交叉验证（Nested Cross-Validation）。

顾名思义，嵌套交叉验证包含两层交叉验证循环：

  1. 外层循环（Outer Loop）：

    • 目的：评估模型（或更准确地说，是评估整个调优流程）的泛化能力。
    • 操作：将整个数据集划分为 K_outer 折。在每一折中，将 1 折作为外层测试集（Outer Test Set），其余 K_outer-1 折作为外层训练集（Outer Training Set）。
    • 关键：外层测试集在当前外层循环的整个过程中，绝对不能用于训练或超参数选择，它只在最后一步用于评估最终选出的模型。

  2. 内层循环（Inner Loop）：

    • 目的：在外层训练集上找到最优的超参数组合。
    • 操作：对于当前外层循环提供的外层训练集，再进行一次独立的交叉验证（例如 K_inner 折交叉验证，或者直接使用 GridSearchCV、RandomizedSearchCV 等工具，它们内部就封装了交叉验证逻辑）。
    • 过程：内层循环使用外层训练集，尝试不同的超参数组合，通过其内部的交叉验证（划分成内层训练集和内层验证集）来评估每个组合的好坏，最终选出在该外层训练集上表现最优的超参数组合。

嵌套交叉验证的完整流程如下（以 5 折外循环，3 折内循环为例）：

整个数据集 D
 
外层循环 (k_outer = 1 to 5):
  1. 将 D 划分为 外层测试集 D_test_outer (Fold k_outer) 和 外层训练集 D_train_outer (其余 folds)
 
  2. 内层循环 (在 D_train_outer 上执行，例如 GridSearchCV(cv=3)):
     a. 将 D_train_outer 进一步划分为 3 个内层折叠。
     b. 对于每个超参数组合 C:
        i.  进行 3 次训练和验证：每次用 2 个内层折叠训练，1 个内层折叠验证。
        ii. 计算超参数组合 C 在内层交叉验证中的平均性能得分 inner_score(C)。
     c. 找到在内层交叉验证中平均性能最好的超参数组合 best_params_k_outer = argmax(inner_score(C))。
 
  3. 使用找到的最佳超参数 best_params_k_outer，在 **整个** 外层训练集 D_train_outer 上重新训练一个模型 final_model_k_outer。
 
  4. 使用 final_model_k_outer 在 **从未用于训练或调优** 的外层测试集 D_test_outer 上进行预测，计算性能得分 outer_score_k_outer。
 
最终性能估计：
  收集所有外层得分 [outer_score_1, outer_score_2, ..., outer_score_5]
  最终的无偏性能估计是这些得分的平均值或统计分布。

关键点在于：

  • 隔离：外层测试集 (D_test_outer) 就像是模拟了未来真正遇到的新数据，它完全独立于内层循环的超参数选择过程。
  • 评估对象：嵌套交叉验证评估的不是一个具有固定超参数的模型，而是整个超参数调优流程 + 模型训练这个完整 pipeline 的泛化能力。也就是说，它告诉你，“如果你遵循这套流程（在外层训练集上用内层交叉验证找到最优参数，然后用这些参数训练模型），那么这个流程产生的模型在新数据上大概会有这样的性能”。
  • 超参数可能变化：注意，在不同的外层循环中（k_outer = 1 vs k_outer = 2），内层循环找到的最佳超参数 best_params_k_outer 可能不同！这是完全正常的，因为每次外层循环使用的训练数据略有不同。这恰恰反映了超参数选择本身也依赖于具体数据。

为什么嵌套交叉验证能提供无偏估计？

对比一下简单方法和嵌套方法：

  • 简单方法：用验证集 V 来选超参数，然后又在 V 上评估。评估得分被“污染”了。
  • 嵌套方法：外层测试集 O 仅用于最终评估。超参数的选择是在外层训练集 T 上通过内层交叉验证完成的。内层交叉验证本身可能也有信息泄露（内层验证集指导了参数选择），但这个影响被限制在内层，不会泄露到外层测试集 O。因此，模型在 O 上的表现是其在真正未知数据上的表现的无偏估计。

你可以把外层循环想象成在进行 K 次独立的实验。每次实验都模拟了“拿到一批新数据（外层训练集），用交叉验证调好参数，训练模型，然后在另一批从未见过的数据（外层测试集）上测试”这个完整过程。最后综合 K 次实验的结果，得到一个对这个完整过程的稳定、无偏的评估。

实现嵌套交叉验证

理解了原理，我们来看看如何在实践中实现嵌套交叉验证，特别是在 Python 和 scikit-learn 中。

伪代码

# 假设有数据 X, y
# 定义模型 estimator (例如 SVC())
# 定义超参数搜索空间 param_grid
# 定义外层和内层交叉验证策略
outer_cv = KFold(n_splits=5, shuffle=True, random_state=42)
inner_cv = KFold(n_splits=3, shuffle=True, random_state=42)
 
outer_scores = []
 
for train_outer_idx, test_outer_idx in outer_cv.split(X, y):
    X_train_outer, X_test_outer = X[train_outer_idx], X[test_outer_idx]
    y_train_outer, y_test_outer = y[train_outer_idx], y[test_outer_idx]
 
    # 内层循环：超参数搜索
    # 使用 GridSearchCV (或其他如 RandomizedSearchCV)
    # cv 参数设置为 inner_cv
    grid_search = GridSearchCV(estimator=estimator, param_grid=param_grid, cv=inner_cv, scoring='accuracy') # 或者其他评估指标
    grid_search.fit(X_train_outer, y_train_outer)
 
    # 获取内层找到的最佳超参数
    best_params = grid_search.best_params_
 
    # 使用最佳超参数在外层训练集上训练最终模型
    # 注意：GridSearchCV 默认在 .fit() 后会用找到的最佳参数在整个输入数据上重新训练一个模型
    # 所以 grid_search.best_estimator_ 就是我们需要的模型
    final_model = grid_search.best_estimator_
 
    # 或者，如果你想更明确，可以这样做：
    # final_model = estimator.set_params(**best_params)
    # final_model.fit(X_train_outer, y_train_outer)
 
    # 在外层测试集上评估
    score = final_model.score(X_test_outer, y_test_outer)
    outer_scores.append(score)
 
# 计算最终的无偏性能估计
final_performance_estimate = np.mean(outer_scores)
final_performance_std = np.std(outer_scores)
 
print(f"嵌套交叉验证性能估计: {final_performance_estimate:.4f} +/- {final_performance_std:.4f}")

Scikit-learn 实现思路

scikit-learn 提供了便捷的方式来实现嵌套交叉验证，通常结合 cross_val_score（或 cross_validate）和 GridSearchCV / RandomizedSearchCV。

关键在于，GridSearchCV 本身就是一个估计器（estimator）。当你把它传递给 cross_val_score 时，cross_val_score 会执行外层循环。在每个外层循环的训练阶段，cross_val_score 会调用 GridSearchCV 的 .fit() 方法。而 GridSearchCV 的 .fit() 方法内部会执行内层循环来进行超参数搜索。

import numpy as np
from sklearn.model_selection import KFold, GridSearchCV, cross_val_score
from sklearn.svm import SVC
from sklearn.datasets import load_iris
 
# 加载数据
X, y = load_iris(return_X_y=True)
 
# 定义模型
svc = SVC(random_state=42)
 
# 定义超参数搜索空间
param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': [0.001, 0.01, 0.1, 1],
    'kernel': ['rbf']
}
 
# 定义内层交叉验证策略 (用于 GridSearchCV)
inner_cv = KFold(n_splits=3, shuffle=True, random_state=42)
 
# 定义外层交叉验证策略 (用于 cross_val_score)
outer_cv = KFold(n_splits=5, shuffle=True, random_state=42)
 
# 内层循环的执行器：GridSearchCV
# 它本身像一个 estimator，负责在给定的数据上找到最优参数并训练模型
grid_search = GridSearchCV(
    estimator=svc, 
    param_grid=param_grid, 
    cv=inner_cv, 
    scoring='accuracy', 
    refit=True # refit=True 确保 GridSearchCV 在找到最优参数后，用这些参数在整个输入数据（即外层训练集）上重新训练
)
 
# 外层循环：使用 cross_val_score
# cross_val_score 会将 grid_search 视为一个单一的 estimator
# 在每个外层 fold 中：
# 1. 它将外层训练集传递给 grid_search.fit()
# 2. grid_search.fit() 执行内层 CV，找到最佳参数，并用这些参数在外层训练集上训练模型 (因为 refit=True)
# 3. cross_val_score 使用训练好的 grid_search (即 best_estimator_) 在外层测试集上评估性能
nested_scores = cross_val_score(
    estimator=grid_search, 
    X=X, 
    y=y, 
    cv=outer_cv, 
    scoring='accuracy'
)
 
# 输出结果
print(f"嵌套交叉验证各折得分: {nested_scores}")
print(f"平均得分: {nested_scores.mean():.4f}")
print(f"得分标准差: {nested_scores.std():.4f}")
 
# 注意：这只是评估了调优流程的性能。
# 如果要部署模型，通常需要再次在 *整个数据集* 上运行 GridSearchCV 来找到最终的最佳参数
final_grid_search = GridSearchCV(estimator=svc, param_grid=param_grid, cv=inner_cv, scoring='accuracy', refit=True)
final_grid_search.fit(X, y) # 在所有数据上进行调优
 
print(f"\n在整个数据集上找到的最佳参数: {final_grid_search.best_params_}")
# 最终部署的模型应该是 final_grid_search.best_estimator_
# 或者用 final_grid_search.best_params_ 在整个数据集 X, y 上重新训练一个 SVC 模型

这个 scikit-learn 的实现简洁而强大。cross_val_score(grid_search, ...) 这一行代码就封装了整个嵌套交叉验证的逻辑。

关于 Repeated K-Fold

在原始提示中提到了重复 K 折交叉验证（Repeated K-Fold CV）。这是一种通过多次重复 K 折划分来进一步减少因单次 K 折划分偶然性带来的偏差，从而获得更稳定性能估计的方法。例如，进行 3 次 5 折交叉验证（RepeatedKFold(n_splits=5, n_repeats=3)），总共会产生 15 个训练/测试集对。

嵌套交叉验证完全可以与重复 K 折结合使用。只需将 outer_cv 设置为 RepeatedKFold 即可。例如：

from sklearn.model_selection import RepeatedKFold
 
# ... (前面的代码保持不变) ...
 
# 使用重复 K 折作为外层循环
outer_cv_repeated = RepeatedKFold(n_splits=5, n_repeats=3, random_state=42)
 
nested_scores_repeated = cross_val_score(
    estimator=grid_search, 
    X=X, 
    y=y, 
    cv=outer_cv_repeated, 
    scoring='accuracy'
)
 
print(f"\n使用重复 K 折的嵌套交叉验证得分 ({len(nested_scores_repeated)}个):")
print(nested_scores_repeated)
print(f"平均得分: {nested_scores_repeated.mean():.4f}")
print(f"得分标准差: {nested_scores_repeated.std():.4f}")

这样做会得到更多次的外部评估分数，其平均值通常被认为是对模型（流程）泛化性能更可靠的估计，但计算成本也会相应增加。

考量与权衡

尽管嵌套交叉验证是获取无偏性能估计的黄金标准，但它并非没有代价。

  • 计算成本：这是最显著的缺点。如果外层是 K_outer 折，内层是 K_inner 折，超参数组合有 N 种，那么总共需要训练 K_outer * K_inner * N 个模型（如果内层是 GridSearchCV）。这可能非常耗时，特别是对于大型数据集和复杂模型。
  • 何时必须使用：
    • 当你需要对模型的最终泛化性能有一个非常准确和可靠的估计时（例如，在学术论文中报告结果，或者在关键业务决策中比较模型）。
    • 当数据集相对较小时，简单划分训练/验证/测试集可能导致结果非常不稳定或有偏差，嵌套 CV 更为重要。
    • 当进行模型选择（比较不同类型的模型，如 SVM vs. 随机森林）时，使用嵌套 CV 可以确保比较的公平性，因为每个模型都经过了恰当的调优和无偏的评估。
  • 何时可以简化：
    • 如果你有非常非常大的数据集，简单地划分一次训练集、验证集（用于调优）和测试集（用于最终评估）可能就足够了，因为数据量足够大，单次划分的偶然性影响较小。
    • 在项目的早期探索阶段，你可能只想快速了解不同模型或参数的大致效果，可以使用简单的交叉验证（但要意识到其评估结果可能偏高）。
  • 结果解读：再次强调，嵌套 CV 的最终得分是对调优过程的评估。如果你需要部署一个最终模型，标准做法是在获得嵌套 CV 的性能估计后，在整个数据集上重新运行一次超参数搜索（即内层循环的逻辑，如 GridSearchCV），找到全局最优参数，然后用这些参数在所有数据上训练最终模型。嵌套 CV 给了你信心，让你知道这样产生的模型大概会有多好的泛化能力。

结论

超参数调优是机器学习不可或缺的一环，而如何准确评估经过调优后的模型性能同样关键。简单地在同一交叉验证循环中进行调优和评估会导致信息泄露，产生过于乐观的性能估计。

嵌套交叉验证通过引入外层循环（用于评估）和内层循环（用于调优）的结构，有效隔离了超参数选择过程和最终性能评估过程，从而能够提供对模型（或更准确地说是调优流程）泛化能力的无偏估计。

虽然计算成本较高，但在需要严格、可靠的模型评估和选择时，嵌套交叉验证是不可或缺的工具。掌握其原理和 scikit-learn 中的实现方法，将使你能够更自信地构建和评估高性能的机器学习模型，避免掉入“看似很好，实则过拟合”的陷阱。

下次当你需要同时进行超参数调优和模型评估时，请务必考虑使用嵌套交叉验证，让你的模型评估结果更加稳健、可信！

调参老中医 嵌套交叉验证超参数调优模型评估

评论点评

打赏赞助
sponsor

感谢您的支持让我们更好的前行

分享

QRcode

https://www.webkt.com/article/8883