🎨 直感で掴む — 「同じ問題集で勉強して同じ問題集でテストする」問題

🎯 ナイーブ CV のバイアス

普通の交差検証（CV）でモデル選択と性能評価を同時に行うと、 こんなことが起きます：

1. K=5 fold に分割
2. 各 α ∈ {0.01, 0.1, 1, 10} で 5 fold CV の平均 RMSE を計算
3. 最も RMSE が小さい α を「最適 α」として選ぶ
4. その最適 α での 5 fold CV 平均 RMSE を「最終性能」として報告

⚠️ 問題：手順 4 の「最終性能」は同じ fold 構造での CV 平均なので、 すでに「この fold でうまくいく α」を選んだ後の評価です。 つまりテストデータが間接的に α 選択に使われた。 結果、 報告される RMSE は実環境（真に未知のデータ）よりも小さく（楽観的に）出る。

🎓 喩え：模試と本番試験

大学受験で、 「直前模試の問題」と「本番試験の問題」が同じだったら、 模試で「この勉強法が一番点数が出る」と判明した方法は、 本番でも当然点数が出る。 でもそれは「本当に頭が良いから」ではなく、 「答えを知っていたから」です。

Nested CV の発想：

• 外側 fold：本番試験（真の未知データの代理）
• 内側 fold：模試（外側の訓練データだけで勉強法 = ハイパラを決める）
• 外側 fold で測った性能は、 内側で勉強法を決めたことを知らずに受けた本番試験の点数 ＝ 真の汎化性能の不偏推定

📊 nested CV vs naive CV の数字感

典型的な経験則：

つまり (1) ハイパラ候補が多いほど、 (2) サンプルが少ないほど、 naive CV のバイアスは大きくなる。 Kaggle で「CV では当たったのに、 LB（leaderboard）でガッカリ」というのは多くの場合これが原因。

📐 数式 — Nested CV の定式化

データセット $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^{n}$、 ハイパーパラメータ空間 $\Lambda$、 学習アルゴリズム $\mathcal{A}_\lambda$、 損失関数 $L$。

外側ループ

$\mathcal{D}$ を $K_o$ 個に分割：$\mathcal{D} = \mathcal{D}^{\text{outer}}_1 \cup \mathcal{D}^{\text{outer}}_2 \cup \dots \cup \mathcal{D}^{\text{outer}}_{K_o}$。 各 $k = 1, \dots, K_o$ について：

内側ループ（外側の各 fold k 内で）

$\mathcal{D}_{\text{train}}^{(k)}$ を $K_i$ 個に分割し、 各 $\lambda \in \Lambda$ について：

最適ハイパラを選択：

外側ループでの性能評価

$\hat{\lambda}^{(k)}$ を使って外側の訓練データ全体で再学習し、 外側テストで評価：

最終的に外側 fold での平均と標準偏差を報告：

計算コスト

🔬 数式を「言葉」で読み解く

💡 重要な性質：Nested CV は 「最終的にデプロイするモデル」を生成する手続きではないこと。 あくまで「ハイパラチューニング + 学習のパイプライン全体の性能を測る」プロトコル。 デプロイには別途、 全データで内側 CV を再実行して最適 λ を決め、 全データで学習する。

🧮 実値で計算してみる — SSDSE-B 人口予測タスク

タスク設定

SSDSE-B-2026 の 47 都道府県データから、 2020〜2022 年の経済・社会指標（人口、 出生率、 高齢化率、 県内総生産、 有効求人倍率、 大学進学率、 ...） を特徴量にして、 翌年（2023 年）の総人口を予測するリッジ回帰モデルを構築。 Ridge の正則化強度 α を Nested CV でチューニング。

STEP 1：データ構造とサイズ

• 対象：47 都道府県 × 3 年（2020, 2021, 2022） = 141 サンプル
• 特徴量：8 列（経済・人口統計）
• ターゲット：翌年の総人口（連続値）
• ハイパラ候補：α ∈ {0.001, 0.01, 0.1, 1, 10, 100, 1000} の 7 候補

STEP 2：nested CV の設定

• 外側 K_o = 5 → 各 fold ≈ 28 サンプル
• 内側 K_i = 3
• 総学習回数 = 5 × 3 × 7 + 5 = 110 回（リッジ回帰なので一瞬）

STEP 3：典型的な結果

解釈：

• 「最適 α」は fold によって違う（0.1, 1, 10 で揺れる）→ ハイパラ選択自体が不安定であることが明示される
• 外側 fold 間で RMSE が 148〜225 と大きく変動 → 「実環境では性能が大きくブレる可能性」を警告
• これらは naive CV だと見えない真実

📊 Cawley & Talbot (2010) の実証 — なぜ Nested CV が必要か

機械学習における Nested CV の必要性を最も明確に示したのが、 Cawley & Talbot (2010) "On Over-fitting in Model Selection and Subsequent Selection Bias in Performance Evaluation"（Journal of Machine Learning Research）。 著者らは UCI の 13 個のデータセットで、 ナイーブ CV と Nested CV を比較し、 ナイーブ CV が 平均 4〜8% 程度性能を楽観的に評価することを実証しました。

論文の核心メッセージ

1. モデル選択は、 それ自体が「学習」である。 ハイパラを CV で最適化する手順は、 そのハイパラ空間に対するメタ学習。 学習であるからには過学習が起こりうる
2. 同じデータで「メタ学習」と「最終評価」を行うと、 評価がバイアスを受ける。 これは Vapnik の VC 理論や Bonferroni 補正と同じ「多重比較問題」の現れ
3. 解決策は Nested CV か、 別個の test set。 メタ学習プロセス全体を外側ループで評価することで、 評価セットへの情報漏洩を断つ

論文の図表が示すもの

Cawley & Talbot は、 SVM のハイパラ（C と γ）を様々な手法で選択した結果を比較。 ナイーブ CV では「データが少ない場合に特に楽観バイアスが大きい」「ハイパラ候補が多いとバイアスが大きい」という 2 つの傾向を実証。 一方 Nested CV ではバイアスが事実上消失。

業界への影響

この論文以降、 機械学習の主要会議（NeurIPS, ICML）では、 ハイパラ調整を含む手法を提案する論文には Nested CV による評価 が事実上必須となりました。 Kaggle や DrivenData などのコンペでも、 「validation set はモデル選択に使う、 final leaderboard は完全分離した test set」というプロトコルが定着しています。

🎯 K_outer と K_inner はいくつにすべきか

Nested CV の唯一の自由パラメータは、 外側 fold 数 K_o と内側 fold 数 K_i です。 経験則と理論的な目安を整理：

外側 K_o の選び方

内側 K_i の選び方

• 慣習的に K_i = 3 または 5
• K_i を増やすほど、 内側でのハイパラ選択が安定するが、 計算量は K_i 倍に
• K_i = 3 が「コスト効率」のスイートスポット
• ハイパラ空間が大きい（Bayes 最適化など）場合は K_i = 3、 グリッドサーチで小さい場合は K_i = 5

計算コストの目安

SVM のように学習に O(n²) 〜 O(n³) かかるアルゴリズムでは：

• 5×3 nested CV + 5 ハイパラ → 75 回の学習 → n=1,000 で数分
• 10×5 nested CV + 10 ハイパラ → 500 回の学習 → n=1,000 で数十分
• ニューラルネット（1 回数時間）では nested CV は非現実的 → holdout で代替

🐍 Python 実装 — sklearn での Nested CV

方法 A：シンプルな手動実装（教育用）

# SSDSE-B 人口予測タスクで Ridge α を Nested CV で選ぶ
import numpy as np
import pandas as pd
from sklearn.linear_model import Ridge
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import StandardScaler

# データ読込
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=2)
df.columns = ['year', 'code', 'pref', 'pop'] + [f'c{i}' for i in range(len(df.columns)-4)]
df = df[df['year'].isin([2020, 2021, 2022])].copy()

# 特徴量（適当に 8 列選ぶ：人口、出生率、高齢化率、県内総生産、有効求人、大学進学率、医師数、犯罪件数の代用）
feature_cols = ['pop', 'c0', 'c5', 'c27', 'c30', 'c41', 'c52', 'c70']
X = df[feature_cols].values.astype(float)
y = df['pop'].shift(-47).values  # 翌年の人口
mask = ~np.isnan(y)
X, y = X[mask], y[mask]
print(f'サンプル数: {len(y)}, 特徴量数: {X.shape[1]}')

# Nested CV
alpha_grid = [0.001, 0.01, 0.1, 1, 10, 100, 1000]
outer_cv = KFold(n_splits=5, shuffle=True, random_state=42)
outer_rmses = []
chosen_alphas = []

for fold_idx, (train_idx, test_idx) in enumerate(outer_cv.split(X)):
    X_train, X_test = X[train_idx], X[test_idx]
    y_train, y_test = y[train_idx], y[test_idx]

    # 内側 CV：α 探索
    inner_cv = KFold(n_splits=3, shuffle=True, random_state=1)
    best_alpha, best_inner_rmse = None, np.inf
    for alpha in alpha_grid:
        inner_rmses = []
        for in_tr, in_va in inner_cv.split(X_train):
            scaler = StandardScaler().fit(X_train[in_tr])
            model = Ridge(alpha=alpha).fit(scaler.transform(X_train[in_tr]), y_train[in_tr])
            pred = model.predict(scaler.transform(X_train[in_va]))
            inner_rmses.append(np.sqrt(mean_squared_error(y_train[in_va], pred)))
        avg = np.mean(inner_rmses)
        if avg < best_inner_rmse:
            best_inner_rmse, best_alpha = avg, alpha

    # 外側評価：選ばれた α で全 X_train で再学習 → X_test 評価
    scaler = StandardScaler().fit(X_train)
    model = Ridge(alpha=best_alpha).fit(scaler.transform(X_train), y_train)
    pred = model.predict(scaler.transform(X_test))
    outer_rmse = np.sqrt(mean_squared_error(y_test, pred))
    outer_rmses.append(outer_rmse)
    chosen_alphas.append(best_alpha)
    print(f'Fold {fold_idx+1}: α={best_alpha}, outer RMSE={outer_rmse:.2f}')

print(f'\\nNested CV RMSE: {np.mean(outer_rmses):.2f} ± {np.std(outer_rmses, ddof=1):.2f}')
print(f'選ばれた α 群: {chosen_alphas}')

方法 B：sklearn の GridSearchCV + cross_val_score（推奨）

from sklearn.linear_model import Ridge
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV, cross_val_score, KFold
import numpy as np

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('ridge', Ridge())
])

param_grid = {'ridge__alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}

# 内側 CV（GridSearchCV 内）
inner_cv = KFold(n_splits=3, shuffle=True, random_state=1)
grid = GridSearchCV(pipe, param_grid, cv=inner_cv, scoring='neg_mean_squared_error')

# 外側 CV
outer_cv = KFold(n_splits=5, shuffle=True, random_state=42)
neg_mse_scores = cross_val_score(grid, X, y, cv=outer_cv, scoring='neg_mean_squared_error')
rmse_scores = np.sqrt(-neg_mse_scores)
print(f'Nested CV RMSE: {rmse_scores.mean():.2f} ± {rmse_scores.std(ddof=1):.2f}')

方法 C：deployment 用に「全データで再学習」

# Nested CV はあくまで「評価プロトコル」。デプロイ用モデルは全データで再学習する
final_grid = GridSearchCV(pipe, param_grid, cv=KFold(5, shuffle=True, random_state=0),
                          scoring='neg_mean_squared_error')
final_grid.fit(X, y)
print(f'最終モデル α: {final_grid.best_params_}')
# final_grid.best_estimator_ がデプロイ用モデル

方法 D：層化 / 時系列対応の nested CV

from sklearn.model_selection import StratifiedKFold, TimeSeriesSplit

# 分類タスクなら StratifiedKFold で fold ごとのクラス比率を保つ
# outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# 時系列なら過去→未来の順序を守る TimeSeriesSplit
# outer_cv = TimeSeriesSplit(n_splits=5)

# SSDSE-B の都道府県データは「グループ＝都道府県」なので GroupKFold が望ましい
from sklearn.model_selection import GroupKFold
groups = df['pref'].values[mask]  # 都道府県名
outer_cv = GroupKFold(n_splits=5)
for tr, te in outer_cv.split(X, y, groups=groups):
    # 同じ都道府県は train/test に分かれない（リーク防止）
    pass

方法 E：MLxtend ・ Optuna との組合せ

# Optuna でベイズ最適化を内側に組み込む例
import optuna
from sklearn.model_selection import cross_val_score

def objective_for_outer_fold(trial, X_tr, y_tr):
    alpha = trial.suggest_float('alpha', 1e-3, 1e3, log=True)
    model = Pipeline([('sc', StandardScaler()), ('r', Ridge(alpha=alpha))])
    scores = cross_val_score(model, X_tr, y_tr, cv=3, scoring='neg_mean_squared_error')
    return -scores.mean()

outer_rmses = []
for tr_idx, te_idx in outer_cv.split(X):
    study = optuna.create_study(direction='minimize')
    study.optimize(lambda t: objective_for_outer_fold(t, X[tr_idx], y[tr_idx]),
                   n_trials=20, show_progress_bar=False)
    best_alpha = study.best_params['alpha']
    model = Pipeline([('sc', StandardScaler()), ('r', Ridge(alpha=best_alpha))])
    model.fit(X[tr_idx], y[tr_idx])
    rmse = np.sqrt(mean_squared_error(y[te_idx], model.predict(X[te_idx])))
    outer_rmses.append(rmse)
print(f'Bayes-Nested CV: {np.mean(outer_rmses):.2f} ± {np.std(outer_rmses, ddof=1):.2f}')

⚠️ Nested CV の 5 つの落とし穴

🌐 Nested CV の派生・関連手法

使い分けフロー

1. n > 数万 → Holdout（train/val/test）で十分
2. n = 数百〜数千、 ハイパラあり → Nested CV 推奨
3. n < 100 → Repeated Nested CV または LOOCV
4. 時系列 → Time-Series Nested CV
5. グループ構造 → Group Nested CV
6. 計算余力なし → 「Nested CV 一回で評価 + 全データで再学習」が現実的解

🆚 普通の CV vs Nested CV — 早見表

運用ルール：「ハイパラ調整なしの単純性能チェック → k-fold CV」「ハイパラ調整あり、 論文・本番前の最終評価 → Nested CV」「大規模データ、 ニューラルネット → holdout（train/val/test）」と、 シナリオに応じて使い分け。

🚀 sklearn Pipeline と組み合わせる実用 Tips

Nested CV を実装する上で最大のミスポイントは「データリーク」です。 特に前処理（標準化、 PCA、 特徴選択、 欠損補完）を CV 外で行うと、 test fold の統計量が訓練に流れ込みます。 sklearn の Pipeline を使えば、 fold ごとに前処理が自動的に閉じられます：

• StandardScaler：fit_transform を train fold で、 transform を test fold で（Pipeline が自動）
• PCA：同上、 主成分行列も train fold だけで計算
• 欠損補完（SimpleImputer）：補完値（平均、 中央値）も train fold だけで計算
• 特徴選択（SelectKBest）：「ターゲットを使う特徴選択」は致命的なリークになりやすい。 必ず Pipeline 内に
• SMOTE などのオーバーサンプリング：必ず Pipeline 内、 imblearn の Pipeline を使う

正しい Pipeline 例

ハイパラ指定の構文

Pipeline のステップ名を頭に付けて二重アンダースコアで連結：

• 'feat_sel__k': [3, 5, 10]
• 'pca__n_components': [2, 3, 5]
• 'model__alpha': [0.01, 0.1, 1, 10]

複数のステップのハイパラを同時に探索可能。 候補が組み合わせ爆発しないよう、 ベイズ最適化（Optuna）に切り替えるのも選択肢。

🔗 関連用語（前提・並列・発展）

📚 前提（先に押さえたい）

🤝 並列（同じレイヤーの仲間）

🚀 発展（その先へ）

🛠 トラブルシューティング集

Q1：Nested CV と naive CV の結果がほぼ同じ。 やる意味はあった？

回答：「やってみたら差がなかった」のは、 (1) サンプルサイズが十分大きい、 (2) ハイパラ候補が少ない、 (3) ハイパラに対するモデル性能の感度が低い、 のいずれか。 結果として naive CV でもバイアスが小さい状況だった、 ということ。 Nested CV をやって「差がない」と確認したこと自体が研究の価値。

Q2：外側 fold ごとに違うハイパラが選ばれる。 これは問題？

回答：問題ではない、 むしろ重要な情報。 「ハイパラ選択が不安定」＝「データ依存で最適 λ が変動する」＝「実環境で 1 つの λ を固定するのが危険」を意味する。 デプロイ時は (a) 全データで再度内側 CV してハイパラ決定、 (b) アンサンブル（fold ごとのモデルを平均）、 (c) より広い CV+1-SE rule、 などの対策を取る。

Q3：内側 CV が時間がかかりすぎる。 ハイパラ候補を減らすべき？

回答：まず (1) Pipeline で正しく実装されているか確認（毎回 fit 直すべきは前処理だけ）、 (2) RandomizedSearchCV や Optuna で候補数を制限、 (3) HalvingGridSearchCV（sklearn 0.24+）で予算節約、 (4) 軽量モデルで予備実験して候補を絞ってから本番、 という順で対処。

Q4：分類タスクで stratification が必要だが Pipeline と組み合わせる方法は？

回答：StratifiedKFold を outer_cv と inner_cv の両方に指定。 Pipeline は学習器の前処理だけ担当し、 fold 分割とは独立。

Q5：階層構造（同じ患者の複数測定、 同じ都道府県の複数年）がある場合は？

回答：GroupKFold または StratifiedGroupKFold を使う。 「同じ患者／同じ県」を train と test に分けないことで、 評価の独立性を保つ。 これを忘れると性能が大きく過大評価される。

Q6：Nested CV で「statistical significant difference between models」を主張したい

回答：Dietterich (1998) の 5×2 CV paired t-test、 または corrected resampled t-test（Nadeau & Bengio 2003）を使う。 単純な「Nested CV 平均の差」では有意性検定にならない（fold が独立でないため）。

Q7：deep learning では Nested CV を回す余裕がない

回答：(1) holdout 3 分割（train / val / test）が現実解、 (2) val でハイパラ調整、 test で最終評価、 (3) test set は本当に最後に 1 回だけ評価、 (4) early stopping を val loss で行えば自動ハイパラ調整に近い効果。 サンプル数が数万を超えていれば、 holdout の評価精度は十分。

Q8：Nested CV の結果を論文に書くときの定型文は？

回答：例として "We evaluated model performance using nested cross-validation with K_outer = 5 outer folds and K_inner = 3 inner folds. Hyperparameters (α ∈ {0.001, 0.01, 0.1, 1, 10, 100, 1000}) were tuned via grid search in the inner CV loop on the training portion of each outer fold. The final performance is reported as the mean ± standard deviation across outer folds (RMSE = 187.3 ± 42.5)." といった記述。 K_outer, K_inner, ハイパラ範囲、 評価指標を明示するのが必須。

Q9：Repeated Nested CV って何？

回答：Nested CV を異なる乱数シードで 10〜30 回繰り返し、 性能の平均と SD を報告する手法。 fold 分割のランダム性によるブレを抑えられる。 計算コストが Nested CV のさらに数十倍になるため、 小規模データ・軽量モデルで論文に十分な精度を求めるときに採用する。 sklearn の RepeatedKFold を outer に使う。

Q10：CV のスコアと test set のスコアが大きく違う

回答：(1) Pipeline で前処理がきちんと閉じているか再確認（リーク疑い）、 (2) train と test の分布が違うかを KS 検定や PCA で可視化（distribution shift）、 (3) ハイパラを「test set に近づくように」 tweak していないか（実質的なリーク）、 (4) Nested CV に切り替えてバイアス除去。

🧪 自己診断 — 理解度チェック問題

1. 問題 1：n = 100 のデータで、 5 候補のハイパラを 5-fold CV で調整し、 同じ 5-fold CV の最良平均値を「最終性能」と報告した。 これは何が問題か？
   解答：選んだハイパラは fold ごとの val 性能を最大化するもので、 報告した値はもはや「未知データへの汎化」ではない。 Nested CV を使うべき。
2. 問題 2：5×3 nested CV で 5 つの外側 fold の RMSE が 100, 150, 200, 180, 170 だった。 何を報告すべき？
   解答：平均 ≈ 160、 SD ≈ 38。 「RMSE = 160 ± 38」と報告。 fold 間の変動の大きさが「実環境性能の不確実性」を示す。
3. 問題 3：内側 CV で最適 α = 0.1 が選ばれたあと、 外側 fold での RMSE を測ったあと、 「α = 0.1 をデプロイ用モデルに使う」のは正しいか？
   解答：1 つの外側 fold で選ばれた α を使うのは情報量を捨てる。 (a) 全データで再度内側 CV を回して最終 α を決める、 または (b) 5 つの fold モデルをアンサンブル、 が現代的解。
4. 問題 4：SSDSE のデータで 47 都道府県 × 3 年 = 141 サンプル。 普通の KFold で nested CV を回した。 何がリーク？
   解答：同じ都道府県の異なる年データが train と test に分かれる。 GroupKFold(groups=都道府県) に変更する。
5. 問題 5：Random Forest の n_estimators と max_depth を nested CV で調整したい。 何個の組合せ × fold？
   解答：5×3 nested CV、 n_estimators 4 候補 × max_depth 4 候補 = 16 ハイパラ → 5 × 3 × 16 + 5 = 245 回の学習。 n = 数百なら現実的、 数万なら不向き。

📚 関連グループ教材

• 論文一覧トップへ戻る — Nested CV で予測性能を評価した再現論文をハンズオン形式で読む
• クロスバリデーションページ：基本の k-fold CV から
• リッジ回帰ページ：α 調整の主役
• LASSO ページ：L1 正則化
• ハイパラページ：何を調整すべきか
• モデル選択ページ：AIC、 BIC、 CV ベースの比較
• ブートストラップページ：もう一つのリサンプリング法

🗺 概念マップ — モデル評価の階層

モデル評価プロトコル（ML パイプラインのバイアス管理）
├── レベル 0：訓練データそのもので評価
│   └── 致命的に楽観バイアス（過学習を見抜けない）
├── レベル 1：単一の hold-out（train / test）
│   └── 大規模データでは OK、 小データでは分散大
├── レベル 2：k-fold CV（ハイパラ固定）
│   └── 性能評価としては不偏
├── レベル 3：CV でハイパラ調整 + 同じ CV で評価（naive）
│   └── 楽観バイアス発生 ← Nested CV が解決する問題
├── レベル 4：Nested CV
│   ├── 外側：性能評価
│   └── 内側：ハイパラ調整
│       ├── Grid Search
│       ├── Random Search
│       └── Bayesian Optimization
└── レベル 5：Repeated Nested CV / 階層 CV / 時系列 CV
    └── 計算コストとのトレードオフを取りながら更に精密化
  

Cawley & Talbot (2010) "On Over-fitting in Model Selection and Subsequent Selection Bias in Performance Evaluation"（JMLR）が Nested CV の必要性を実証的に示した古典論文。 機械学習論文を書く際は、 ハイパラ調整があるなら必ず Nested CV か Holdout のいずれかで評価する、 が現代の標準作法。

📚 さらに学ぶには

このサイト内

• 論文一覧に戻る — Nested CV を使った再現論文をハンズオン形式で読む
• 関連用語ページ — このページの「🔗 関連用語」から派生

推奨書籍・論文

• Cawley, G. C. & Talbot, N. L. C. (2010) "On Over-fitting in Model Selection and Subsequent Selection Bias in Performance Evaluation", JMLR 11:2079-2107. ── Nested CV の必要性を示した古典
• Hastie, Tibshirani & Friedman The Elements of Statistical Learning (2nd ed.), Springer, Ch. 7. ── モデル選択と評価の理論
• Raschka, S. (2018) "Model Evaluation, Model Selection, and Algorithm Selection in Machine Learning", arXiv:1811.12808. ── 実用的ガイド
• 『データサイエンスのための統計学入門』（O'Reilly）── CV と nested CV を実用視点で解説

オンライン教材

• scikit-learn 公式ドキュメント： sklearn.model_selection.GridSearchCV, cross_val_score のリファレンス
• StatQuest: Cross Validation Clearly Explained（YouTube）── CV 全般の直感的解説
• Sebastian Raschka のブログ： Nested CV の図解と Python コード
• MLxtend： Nested CV の実装、 paired t 検定での比較等
• Optuna 公式ドキュメント： ベイズ最適化を内側に組み込む例

困ったときは

「Nested CV が遅すぎる」「結果が安定しない」「最終モデルにどの α を使うべきか」など困ったら、 (1) ハイパラ候補を絞る／ベイズ最適化に切替、 (2) Repeated Nested CV で複数乱数試行、 (3) 「Nested CV は評価、 最終モデルは別途全データで再 fit」のフロー確認、 (4) Pipeline でリーク防止、 を順に確認。 Cross Validated（Stack Exchange）の "nested-cross-validation" タグも参考に。

🧠 Nested CV の理論的基盤 — 選択バイアスを数式で見る

Nested Cross-Validation の核心は 「ハイパーパラメータ選択」と「汎化性能評価」を完全に分離する ことにあります。 通常の K-fold CV をハイパーパラメータ選択と性能評価の両方に使うと、 選択バイアス（selection bias）と呼ばれる過大評価が発生します。 これは「複数のコイントスを行い、 最も表が出たコインを選んで、 そのコインの表確率を報告する」のと同じトリックです。

数式で書くと、 ハイパーパラメータの集合 $\Theta$、 各 $\theta \in \Theta$ に対する CV スコア $\hat{R}_{\text{CV}}(\theta)$ について、 $\min_{\theta} \hat{R}_{\text{CV}}(\theta)$ の期待値は、 各 $\theta$ の真のリスク $R(\theta)$ の最小値より小さくなる傾向があります。 これを Jensen の不等式の逆向き効果と呼ぶこともあります。

$$\mathbb{E}\left[\min_{\theta \in \Theta} \hat{R}_{\text{CV}}(\theta)\right] \le \min_{\theta \in \Theta} \mathbb{E}[\hat{R}_{\text{CV}}(\theta)] = \min_{\theta \in \Theta} R(\theta)$$

SSDSE-B-2026 の 47 都道府県データのような小標本では、 $|\Theta|$ が 20 個程度のグリッドでもこのバイアスが顕著に出ます。 Cawley & Talbot (2010) は完全ランダムデータで AUC 0.5 が 0.7+ に「誤って向上」することを示し、 Nested CV の必要性を強く訴えました。

📐 アルゴリズム手順 — 二重ループの詳細

Nested CV は二重ループ構造を取ります。 外側ループで $K_{\text{outer}}$ 個の fold を作り、 各 fold で「テストデータを完全に隔離」。 内側ループで残りの訓練データを $K_{\text{inner}}$ 個に分け、 ハイパーパラメータを選択。 選ばれたハイパーパラメータで訓練データ全体で再学習し、 隔離されたテストデータで評価。 これを $K_{\text{outer}}$ 回繰り返した平均が「不偏」な汎化性能推定値となります。

1. Step 1：データ $D$ を外側 $K_{\text{outer}}$ 分割 → $D_1^{\text{out}}, \ldots, D_{K_{\text{outer}}}^{\text{out}}$
2. Step 2：各外側 fold $k$ について：訓練データ $D \setminus D_k^{\text{out}}$ を取り出す
3. Step 3：訓練データを内側 $K_{\text{inner}}$ 分割 → 内側 CV でハイパーパラメータ $\theta_k^\star$ を選択
4. Step 4：訓練データ全体で $\theta_k^\star$ を用いてモデルを学習し、 $D_k^{\text{out}}$ で性能を測る
5. Step 5：外側 $K_{\text{outer}}$ 個の性能スコアを平均し SE を計算
6. Step 6：最終モデルは全データで再学習（ただし $\theta_k^\star$ は fold 毎に異なるので、 「合意」を取るか全データで再選択）

重要なのは、 外側 fold のテストデータ $D_k^{\text{out}}$ は内側 CV のハイパーパラメータ選択に一切使われないこと。 これにより「データを見てから選んだ」というバイアスが排除されます。

🎯 $K_{\text{outer}}$ と $K_{\text{inner}}$ の選び方

SSDSE-B-2026 ($n=47$) の標準設定は $K_{\text{outer}}=5, K_{\text{inner}}=5$。 この場合 1 fold の訓練データは約 38 サンプル、 内側でさらに 5 分割すると 1 fold 約 30 サンプルでハイパーパラメータを選び、 8 サンプルで内側評価。 「47 都道府県を学習に十分使いつつ過大評価を避ける」バランス点です。

反復 Nested CV（外側分割を複数シードで反復）はさらに分散を下げる王道。 RepeatedKFold で 5-fold × 10 回 = 50 fold 評価を行うと、 SE が約 $1/\sqrt{10} = 0.32$ 倍に縮みます。

🐍 Python 実装 — sklearn での完全ワークフロー

sklearn の `GridSearchCV` を `cross_val_score` で包むのが標準パターン。 内側 CV は GridSearch 内で自動的に走り、 外側は cross_val_score が制御します。

import pandas as pd
import numpy as np
from sklearn.linear_model import Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import KFold, GridSearchCV, cross_val_score

# 1) 実データ読み込み
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1)
X = df.iloc[:, 3:11].values
y = df.iloc[:, 11].values

# 2) Pipeline: 標準化 + Ridge
pipe = Pipeline([('sc', StandardScaler()), ('r', Ridge())])

# 3) 内側 5-fold CV で α 選択
inner = KFold(n_splits=5, shuffle=True, random_state=1)
gs = GridSearchCV(pipe, {'r__alpha': np.logspace(-3, 3, 25)},
                  cv=inner, scoring='r2', n_jobs=-1)

# 4) 外側 5-fold CV で汎化性能
outer = KFold(n_splits=5, shuffle=True, random_state=0)
scores = cross_val_score(gs, X, y, cv=outer, scoring='r2', n_jobs=-1)
print(f'Nested CV R²: {scores.mean():.3f} ± {scores.std():.3f}')

上記コードでは内側 25 個のグリッド × 5 fold = 125 回学習を外側 5 fold で行うので、 計 625 回モデル学習。 SSDSE-B-2026 規模なら 10 秒程度で完了します。

🔁 反復 Nested CV — 分散を下げる王道

1 回の Nested CV では外側 fold の選び方によってスコアがブレます。 これを安定化する標準テクニックが 反復 Nested CV (Repeated Nested CV)。 外側分割を異なる乱数シードで $R$ 回繰り返し、 全 $R \times K_{\text{outer}}$ 個のスコアを平均します。

from sklearn.model_selection import RepeatedKFold

outer_rep = RepeatedKFold(n_splits=5, n_repeats=10, random_state=0)
scores_rep = cross_val_score(gs, X, y, cv=outer_rep, scoring='r2')
print(f'反復 Nested CV R²: {scores_rep.mean():.3f} ± {scores_rep.std():.3f}')
print(f'スコア分布: {np.percentile(scores_rep, [10, 50, 90])}')

反復回数 $R$ の指針：$R=10$ で SE がほぼ $1/\sqrt{R} = 0.32$ 倍に。 $R=30$ なら 0.18 倍。 SSDSE-B のような小標本では $R \ge 10$ を強く推奨します。

📅 時系列・グループ構造での Nested CV

SSDSE-B のような時系列パネルでは「ランダム分割」がリークを生みます。 同じ都道府県の異なる年が学習・テストに分裂すると、 県固定効果がリークするのです。

時系列分割

from sklearn.model_selection import TimeSeriesSplit

# 内外両方を時間順に
inner_ts = TimeSeriesSplit(n_splits=5)
outer_ts = TimeSeriesSplit(n_splits=5)
gs_ts = GridSearchCV(pipe, {'r__alpha': np.logspace(-3, 3, 25)},
                     cv=inner_ts, scoring='neg_mean_squared_error')
scores_ts = cross_val_score(gs_ts, X, y, cv=outer_ts, scoring='neg_mean_squared_error')
print(f'時系列 Nested CV MSE: {-scores_ts.mean():.4f}')

グループ分割

from sklearn.model_selection import GroupKFold

groups = df['Prefecture'].values  # 都道府県名でグルーピング
outer_g = GroupKFold(n_splits=5)
# 同じ都道府県は学習またはテストの片方にのみ出現
for train_idx, test_idx in outer_g.split(X, y, groups):
    print(f'train: {len(train_idx)}, test: {len(test_idx)}')

医療データで「患者 ID 内の複数測定」、 教育データで「同じ学校の複数学生」など、 階層構造を持つデータには GroupKFold が必須です。

⚠️ Nested CV の 10 個の落とし穴

1. 前処理リーク：StandardScaler を CV の外でフィットすると、 テストデータの統計情報が漏れる。 必ず Pipeline 内に組み込む。
2. 標準誤差の過小評価：Bates et al. (2024) は「CV の古典的 SE は真値の $1/\sqrt{2}$ 倍」と指摘。 Nested CV でも信頼区間は広めに見るべき。
3. fold 間のハイパー不一致：外側各 fold で異なる $\theta_k^\star$ が選ばれることが頻発。 「最終モデル」用には全データで再選択するか、 多数決を取る。
4. 計算コストの過小評価：100 グリッド × 5×5 Nested = 2500 回学習。 GPU や `n_jobs=-1` の活用を前提に計画する。
5. 分類タスクで stratification を忘れる：StratifiedKFold を内外両方に。 クラス不均衡で性能が大きく変わる。
6. パイプライン外の特徴量選択：相関フィルタや PCA を Pipeline 外で適用するとリーク。 SelectKBest なども Pipeline に組み込む。
7. 小標本での過信：$n=47$ では Nested CV の分散が大きく、 「真の性能 ± 0.1」程度のブレは普通。
8. 多重比較：複数モデルを Nested CV で比較するとき、 多重比較補正を忘れがち。 paired t-test や Wilcoxon を fold 間で。
9. 外側 LOOCV の過信：分散が最大になり、 安定した推定が得られないことが多い。
10. 最終モデルの再現性：fold 毎に異なるハイパーを使ったので、 「本番モデル」は別途定義が必要。

🌐 代替手法との比較

Nested CV の計算コストが許容できないとき、 以下の代替手法が考えられます。

実務的には「まず Nested CV で性能の上限を測り、 デプロイ用には全データ＋全 fold で最頻出のハイパーを使う」のがバランス良い戦略です。

📑 Nested CV を使った代表論文

• Cawley & Talbot (2010) JMLR: Nested CV の必要性を実証した古典。
• Varma & Simon (2006) BMC Bioinformatics: 遺伝子発現データでの選択バイアス。
• Tsamardinos et al. (2018) Machine Learning: 「Bootstrap Bias-Corrected CV」で安価な代替を提案。
• Bates, Hastie, Tibshirani (2024) JASA: CV の理論的再検討、 Nested CV の分散性質。
• Krstajic et al. (2014) J. Cheminformatics: 創薬 QSAR モデルでの Nested CV ベストプラクティス。
• Vabalas et al. (2019) PLoS ONE: 医療機械学習での Nested CV の必要性検証。
• Wainer & Cawley (2021) Machine Learning: 反復 Nested CV の効果を体系的調査。

🌳 「Nested CV か否か」意思決定フロー

[$n$ サイズは？]
├── $n \ge 10^5$ → Train-Val-Test 分割で十分
└── $n < 10^5$
    ├── [ハイパーパラメータ探索する？]
    │   ├── しない → 通常の CV で OK
    │   └── する
    │       ├── [計算予算は？]
    │       │   ├── 潤沢 → 反復 Nested CV ($R=10$)
    │       │   ├── 中程度 → Nested CV (1 回)
    │       │   └── 限定的 → Hold-out validation + 警告
    │       └── [時系列？]
    │           ├── Yes → TimeSeriesSplit を内外両方に
    │           └── No → KFold (shuffle=True)
    └── [グループ構造あり？]
        ├── Yes → GroupKFold を内外両方に
        └── No → 通常の KFold

🔗 関連用語（拡張版）

• クロスバリデーション：Nested CV の親概念。
• ハイパーパラメータチューニング：内側 CV の主目的。
• 汎化誤差：外側 CV が推定する量。
• 過学習：選択バイアスは過学習の一種。
• バイアス・バリアンス分解：Nested CV の分散性質。
• ブートストラップ：CV の代替リサンプリング法。
• モデル選択：Nested CV の応用先。
• 検証：CV の哲学的基盤。
• ホールドアウト：最もシンプルな代替。
• 正則化：内側で選ぶ典型的ハイパーパラメータ。
• Ridge 回帰：Nested CV の典型応用例。
• Lasso：$\alpha$ を内側で選ぶ。

🚀 Nested CV 実務 Tips（8 選）

• Pipeline 必須：すべての前処理を Pipeline に詰めて CV の中で動かす。 StandardScaler、 SelectKBest、 PCA、 全部 Pipeline に。
• n_jobs=-1 で並列化：sklearn は CV ループを自動並列化できる。 8 コアなら 8 倍速。
• random_state 固定：結果の再現性のため、 KFold の random_state を明示。
• scoring を慎重に：R² か MSE か MAE か。 ビジネス文脈に合わせる。
• fold ごとのスコア分布を可視化：平均だけでなく箱ひげ図で分布を見る。
• 計算時間を予測：1 fold だけ走らせて時間を計り、 全体時間を見積もる。
• 中間結果を保存：joblib.dump でモデルを保存、 後で分析できるように。
• ログを取る：sklearn の `verbose=2` で進捗確認。 長時間ジョブで重要。

🏛 Nested CV の歴史 — 半世紀の歩み

• 1974 年：Stone が CV の原論文を JRSS-B に発表。
• 1995 年：Kohavi が CV の精度を体系的に調査。
• 1997 年：Salzberg が「データマイニング での性能評価」で Nested CV の必要性を提示。
• 2006 年：Varma & Simon が遺伝子発現データで Nested CV を提唱。
• 2010 年：Cawley & Talbot が JMLR で Nested CV を統計機械学習の標準として確立。
• 2014 年：Krstajic et al. が QSAR モデリングでの実践ガイドを公開。
• 2019 年：Vabalas et al. が医療 ML での Nested CV の重要性を再確認。
• 2024 年：Bates, Hastie, Tibshirani が CV の理論的分散を再評価。

📚 関連グループ教材

• 論文一覧トップへ戻る — Nested CV を使った再現論文を実践
• クロスバリデーションページ
• ハイパーパラメータページ
• モデル選択ページ
• ブートストラップページ
• 過学習ページ

🎓 Nested CV の不偏性証明 — 数理的厳密化

Nested CV の不偏性を厳密に証明するには、 「外側 fold のテスト誤差は内側で選択された $\theta^\star$ の真のリスクの不偏推定」という性質を用います。 確率変数として $D \sim P^n$（$n$ 個の i.i.d. サンプル）を考え、 アルゴリズム $\mathcal{A}: D \mapsto (\theta^\star, \hat f)$ を「内側 CV ＋訓練」として定義します。

$$\mathbb{E}_{D_{\text{train}}, D_{\text{test}}} \left[ L(\hat f_{\mathcal{A}(D_{\text{train}})}, D_{\text{test}}) \right] = \mathbb{E}_{D \sim P^n}[R(\mathcal{A}(D))]$$

左辺は Nested CV が推定する量、 右辺は「アルゴリズム $\mathcal{A}$ をサイズ $n(K-1)/K$ のデータで走らせたときの期待リスク」。 ここに「真のテストデータが内側選択に影響しない」という条件が決定的に働きます。

興味深いことに、 Nested CV は「サイズ $n$ のデータで $\mathcal{A}$ を動かしたときのリスク」ではなく、 「サイズ $n(K-1)/K$ のデータで動かしたときのリスク」を推定します。 つまり サンプルサイズが少し小さい場合の性能を返す。 SSDSE-B (n=47) で 5-fold なら 37.6 サンプル時の性能を見ていることに。 この「ペシミズムバイアス」は通常無視できる程度ですが、 学習曲線が立っている領域では注意が必要です。

📈 学習曲線と Nested CV の組合せ

Nested CV と学習曲線 (learning curve) を組合せると、 「サンプルサイズを増やすと性能はどこまで伸びるか」を予測できます。 横軸を訓練サイズ、 縦軸を Nested CV スコアでプロットし、 関数 $R(n) \approx R_\infty + c/n^\alpha$ をフィットすれば、 漸近性能 $R_\infty$ と収束指数 $\alpha$ が得られます。

from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt

sizes, train_sc, val_sc = learning_curve(
    gs, X, y, cv=outer,
    train_sizes=np.linspace(0.2, 1.0, 8),
    scoring='r2')

plt.plot(sizes, train_sc.mean(axis=1), "o-", label="訓練")
plt.plot(sizes, val_sc.mean(axis=1), "s-", label="検証")
plt.xlabel("訓練サンプル数"); plt.ylabel("R²")
plt.legend(); plt.show()

SSDSE-B では訓練サンプルが 10 → 38 と増えるにつれ R² が 0.4 → 0.7 と上昇するパターンが典型。 「もっと県別ミクロデータを収集すべきか？」の意思決定材料になります。

🎯 多目的指標での Nested CV

実務では「予測精度」だけでなく「公平性」「解釈性」「計算速度」など複数の目標を内側 CV で同時最適化したいことがあります。 Nested CV と Pareto 最適化を組合せる方法：

# 複数指標を同時に評価
from sklearn.model_selection import cross_validate

scoring = {
    'r2': 'r2',
    'mse': 'neg_mean_squared_error',
    'mae': 'neg_mean_absolute_error',
}
results = cross_validate(gs, X, y, cv=outer, scoring=scoring,
                          return_train_score=True)
for k in scoring:
    print(f'{k}: {results["test_" + k].mean():.4f}')

複数指標で性能を確認することで、 「R² は良いが MAE は悪い」のような偏ったモデルを早期発見できます。

🤖 ベイズ最適化と Nested CV の統合

内側 CV で大量のグリッドを試すのは非効率。 Optuna や scikit-optimize などのベイズ最適化と Nested CV を組合せることで、 同じ予算でより良いハイパーパラメータが見つかります。

import optuna
from sklearn.model_selection import KFold, cross_val_score

def objective(trial, X_train, y_train):
    alpha = trial.suggest_float('alpha', 1e-4, 1e3, log=True)
    pipe = Pipeline([
        ('sc', StandardScaler()),
        ('r', Ridge(alpha=alpha))])
    return cross_val_score(pipe, X_train, y_train, cv=5, scoring='r2').mean()

# 外側 fold 毎に Optuna を回す
outer_scores = []
for tr, te in outer.split(X):
    X_tr, X_te = X[tr], X[te]
    y_tr, y_te = y[tr], y[te]
    study = optuna.create_study(direction='maximize')
    study.optimize(lambda t: objective(t, X_tr, y_tr), n_trials=30)
    best_alpha = study.best_params['alpha']
    final = Pipeline([
        ('sc', StandardScaler()),
        ('r', Ridge(alpha=best_alpha))]).fit(X_tr, y_tr)
    outer_scores.append(final.score(X_te, y_te))

print(f'ベイズ最適化 Nested CV R²: {np.mean(outer_scores):.4f}')

Optuna の TPE サンプラーは過去の試行から有望な領域に絞り込むので、 30 試行でグリッド 100 と同等性能が得られることが多い。 SSDSE-B のような小データで計算予算を効率化したい場面で重宝します。

📊 不確実性定量化 — Quantile Nested CV

Nested CV のスコア分布から「予測の信頼区間」を構築する手法を Quantile Nested CV と呼びます。 fold 間のスコア分布の 5%, 95% 分位点を取れば 90% CI が得られます。

scores_rep = cross_val_score(gs, X, y, cv=outer_rep,
                              scoring='r2')

# 90% 信頼区間
lo, hi = np.percentile(scores_rep, [5, 95])
print(f'R² 90% CI: [{lo:.3f}, {hi:.3f}]')

# Bootstrap で SE を補正
from scipy import stats
res = stats.bootstrap((scores_rep,), np.mean, n_resamples=9999)
print(f'平均 R² の 95% CI: {res.confidence_interval}')

Bates et al. (2024) の警告通り、 古典的 CI は狭すぎる傾向。 Bootstrap で補正することで実態に近い区間が得られます。

🔥 PyTorch での Nested CV

深層学習でも Nested CV は重要。 ただし PyTorch / TensorFlow には sklearn のような統一 API が無いので、 手作りループが必要です。

import torch
import torch.nn as nn
from sklearn.model_selection import KFold

def train_eval(X_tr, y_tr, X_te, y_te, lr, wd):
    model = nn.Sequential(nn.Linear(8, 32), nn.ReLU(), nn.Linear(32, 1))
    opt = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=wd)
    # ... 学習ループ省略 ...
    return mse_test

# 外側 fold
for tr, te in KFold(5).split(X):
    # 内側でハイパー探索
    best = None
    for lr in [1e-3, 1e-2, 1e-1]:
        for wd in [0, 1e-4, 1e-2]:
            inner_mse = []
            for tr2, te2 in KFold(3).split(X[tr]):
                inner_mse.append(train_eval(
                    X[tr][tr2], y[tr][tr2],
                    X[tr][te2], y[tr][te2], lr, wd))
            if best is None or np.mean(inner_mse) < best[0]:
                best = (np.mean(inner_mse), lr, wd)
    # 外側評価
    outer_mse = train_eval(X[tr], y[tr], X[te], y[te], best[1], best[2])

深層学習では学習率・正則化・バッチサイズ・エポック数など多次元探索が必要で、 Nested CV の計算コストが特に重い。 Optuna + Early Stopping の組合せが定石です。

⚖️ クラス不均衡データでの Nested CV

クラス不均衡（例：99% 正常、 1% 異常）データでの Nested CV では、 fold 内で陽性サンプルが消える「fold corruption」が起きやすい。 StratifiedKFold を内外に強制する必要があります。

from sklearn.model_selection import StratifiedKFold

# 不均衡データ用：層化分割
inner = StratifiedKFold(n_splits=5, shuffle=True, random_state=1)
outer = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)

gs = GridSearchCV(pipe, params, cv=inner, scoring='roc_auc')
scores = cross_val_score(gs, X, y, cv=outer, scoring='roc_auc')

指標も accuracy ではなく ROC-AUC や PR-AUC を使い、 SMOTE などのリサンプリングは Pipeline 内に組み込んでリーク防止。 imbalanced-learn の `Pipeline` を使うと自動的に正しく処理されます。

🆚 複数モデルの Nested CV 比較

複数のモデル（Ridge vs Lasso vs Random Forest）を Nested CV で比較する場合、 各モデルを独立に Nested CV で評価し、 paired t-test や Wilcoxon 符号付き順位検定で差の有意性を確認します。

from scipy.stats import wilcoxon

scores_ridge = cross_val_score(gs_ridge, X, y, cv=outer_rep)
scores_lasso = cross_val_score(gs_lasso, X, y, cv=outer_rep)
scores_rf    = cross_val_score(gs_rf,    X, y, cv=outer_rep)

# Ridge vs Lasso の検定
stat, p = wilcoxon(scores_ridge, scores_lasso)
print(f'Ridge vs Lasso: p={p:.4f}')

# 多重比較補正
from statsmodels.stats.multitest import multipletests
pvals = [p_rl, p_rr, p_lr]  # 3 ペア
reject, p_corr, _, _ = multipletests(pvals, method='holm')

Demšar (2006) は「複数モデル比較に Wilcoxon + Holm 補正」を推奨。 paired t-test は正規性仮定が必要ですが、 fold スコアは概ね正規に近いので両方使ってよいです。

🎯 Nested CV 早見表

⚡ 計算最適化テクニック

Nested CV は計算コストが高い。 以下の最適化テクニックで実用的な時間に収めましょう。

• 並列化：`n_jobs=-1` で sklearn が自動並列化。 8 コアなら 8 倍速。
• warm start：Ridge では `solver='lsqr'` などで前回の解を初期値に使い、 連続的 $\alpha$ 探索を高速化。
• キャッシュ：Pipeline の `memory=` 引数で前処理結果をキャッシュ。
• サブサンプル：内側 CV では一部のサンプルだけ使う「Successive Halving」アプローチ。
• 早期終了：内側でスコアが基準を下回ったらその設定を打ち切る。
• 低精度：探索初期は粗い解像度、 有望領域だけ細かく。
• GPU 活用：cuML や RAPIDS で sklearn 互換 API を GPU で走らせる。
• 分散実行：Dask、 Ray Tune で多ノード実行。

📝 結果の報告フォーマット

Nested CV の結果は論文・レポートで以下のように報告するのが標準です。

この情報があれば再現可能で、 性能の不確実性も伝わります。 Bates et al. (2024) の警告を受けて、 SE は Bootstrap で広めに報告する流儀も広まっています。

💀 Nested CV を怠った失敗事例

• 事例 1：Kaggle の医療 ML コンペで、 患者 ID 単位で GroupKFold を使わなかったチームが、 リーダーボードで 0.95 → 本番 0.70 と暴落。
• 事例 2：株価予測で時間順分割せず、 「未来を見て」過去を予測。 バックテストで 200% 利益 → 実弾運用で 50% 損失。
• 事例 3：マーケティングのレコメンデーション論文で、 ユーザー × 商品 をランダム分割し、 「未来の購買から過去を学習」、 査読で却下。
• 事例 4：ゲノム ML で SNP を CV 外で選別、 内側 CV のスコアが 0.9、 独立検証で 0.5 に。
• 事例 5：時系列の異常検知で「窓全体で」 StandardScaler を fit、 リアルタイム展開で性能崩壊。

📊 ベンチマーク — 通常 CV vs Nested CV

代表的なベンチマークデータでの Nested CV の効果：

一般傾向として、 サンプルが少ないほど、 ハイパーパラメータ次元が高いほど、 通常 CV と Nested CV の差が大きい。 SSDSE-B のような小標本では特に注意が必要です。

🔧 トラブルシューティング

• 「外側 fold 毎にハイパーが全く違う」：データに不安定性。 反復 Nested を試す、 または特徴選択を見直す。
• 「スコアが負」：scoring が neg_xxx 系の場合は正常。 結果を表示時に符号反転を忘れない。
• 「計算が終わらない」：n_jobs=-1、 グリッド縮小、 ベイズ最適化への切替を検討。
• 「メモリ不足」：Pipeline の memory= や、 dtype を float32 に。 LinAlgError ならデータをスケーリング。
• 「分散が大きすぎる」：反復回数を増やす、 K を増やす、 stratification を確認。
• 「スコアが分布の端に偏る」：外れ値が fold に偏在。 GroupKFold やストラタ化で改善。

❓ よくある質問（FAQ）

📊 ベンチマーク実証

🏛 Nested CV の歴史

• 1974：Stone: Cross-validation の原論文を JRSS-B に発表。
• 1995：Kohavi: A Study of Cross-Validation and Bootstrap で CV の精度を体系的に調査。
• 1997：Salzberg: On Comparing Classifiers で CV のバイアス問題を提起。
• 2006：Varma & Simon: Bias in error estimation で遺伝子発現データの Nested CV を提唱。
• 2010：Cawley & Talbot: On Over-fitting in Model Selection を JMLR に発表、 Nested CV の標準化に貢献。
• 2014：Krstajic et al.: 創薬 QSAR モデルの Nested CV ベストプラクティスを公開。
• 2018：Tsamardinos et al.: Bootstrap Bias Corrected Cross-Validation で安価な代替を提案。
• 2019：Vabalas et al.: 医療 ML での Nested CV の必要性を PLoS ONE で再確認。
• 2021：Wainer & Cawley: 反復 Nested CV の効果を体系調査。
• 2024：Bates, Hastie, Tibshirani: CV の理論的分散を再評価し、 古典 SE の過小評価を指摘。

💼 産業応用事例

📚 Nested CV と他評価手法の関係

Nested CV は「データを限られた量しか持たない統計家・データサイエンティスト」の必須ツールです。 大きく以下の流派と関係があります。

• 頻度論者の立場：Nested CV はサンプリング分布の経験的近似。 「サンプルが違えばモデル選択も異なる」変動を直接観測する。
• ベイジアンの立場：Bayesian CV や WAIC、 LOO-PSIS で代替可能。 事後予測分布から汎化誤差を導く。
• 情報理論的立場：AIC、 BIC、 DIC、 WAIC など情報量基準。 計算は軽いが仮定が強い。
• VC 次元・PAC 学習：汎化誤差の上界を解析的に導く。 理論的だが実用に遠い。
• Cross-Conformal Prediction：予測値だけでなく区間を返す。 Nested CV の現代版。

Nested CV は計算コストと一貫性のバランスで現在の標準。 「データから直接性能を測る」という哲学が、 仮定の少なさで最も頑健です。

サンプル効率の比較

🛠 Nested CV パイプライン雛形集

Ridge / Lasso 用

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge

pipe = Pipeline([
    ('sc', StandardScaler()),
    ('r', Ridge())])
params = {'r__alpha': np.logspace(-3, 3, 25)}

Random Forest 用

from sklearn.ensemble import RandomForestRegressor

pipe = Pipeline([('rf', RandomForestRegressor(random_state=0))])
params = {
    'rf__n_estimators': [100, 300, 500],
    'rf__max_depth': [None, 5, 10, 20],
    'rf__min_samples_split': [2, 5, 10]}

XGBoost 用

import xgboost as xgb

pipe = Pipeline([('xgb', xgb.XGBRegressor(random_state=0))])
params = {
    'xgb__n_estimators': [100, 300],
    'xgb__max_depth': [3, 6, 9],
    'xgb__learning_rate': [0.01, 0.1, 0.3]}

SVR (RBF カーネル) 用

from sklearn.svm import SVR

pipe = Pipeline([
    ('sc', StandardScaler()),
    ('svr', SVR())])
params = {
    'svr__C': np.logspace(-2, 2, 10),
    'svr__gamma': np.logspace(-3, 1, 10),
    'svr__epsilon': [0.01, 0.1, 1]}

LightGBM 用

import lightgbm as lgb

pipe = Pipeline([('lgb', lgb.LGBMRegressor(random_state=0))])
params = {
    'lgb__num_leaves': [31, 63, 127],
    'lgb__learning_rate': [0.01, 0.05, 0.1],
    'lgb__feature_fraction': [0.5, 0.8, 1.0]}

これらの雛形を `gs = GridSearchCV(pipe, params, cv=inner)` で包み、 `cross_val_score(gs, X, y, cv=outer)` で評価すれば、 すぐに本格的 Nested CV パイプラインが完成します。 SSDSE-B-2026 のような小データには Ridge と Random Forest を、 大規模データには LightGBM / XGBoost を推奨します。