🔖 キーワード索引

日本語名・英語名・別名・略語・混同しやすい語をまとめる。 同義の表記は論文や Kaggle notebook で頻繁に登場するので、 検索時の手がかりとして全て押さえておく。

• 日本語名：入れ子型クロスバリデーション、 ネステッド CV、 二重 CV、 入れ子検証
• 英語名：Nested Cross-Validation、 Nested CV、 Double Cross-Validation、 Outer-Inner CV
• 別名・略語：NCV、 nCV、 outer/inner CV、 hyperparameter-tuned CV、 unbiased CV estimator
• 混同しやすい語：通常の K-fold CV（ハイパラ調整を含まず性能評価のみ）、 hold-out 法（1 回分割）、 Grid Search CV（内側 CV のみで外側評価なし）、 bootstrap 法（復元抽出ベース）
• 主要文脈：scikit-learn の cross_val_score(GridSearchCV(...))、 Kaggle 公開ノート、 Cawley & Talbot 2010 JMLR、 Varma & Simon 2006 BMC Bioinformatics

アンカーリンクで本ページ内をジャンプ： 📍 文脈 ／ 💡 30秒結論 ／ 🎨 直感 ／ 📐 数式 ／ 🔬 読み解き ／ 🧮 実値計算 ／ 🐍 Python ／ ⚠️ 落とし穴 ／ 🌐 派生 ／ 🔗 関連 ／ 📚 教材 ／ 🗺 概念マップ

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

🎯 ナイーブ 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 は 「外側 CV で性能評価、 内側 CV でハイパラ選択」を分離する二重ループ構造。 以下 3 つの図で「二重ループ」「選択バイアス回避」「単純 CV との誤差差」を視覚化する。

図 1: 二重ループの構造

→ 外側でモデル評価、 内側でハイパラ調整。 計算コストは単純 CV の k 倍だが、 選択バイアスを排除できる。

図 2: 選択バイアスの発生メカニズム

→ 単純 CV は 「同じデータでハイパラ選んで同じデータで評価」するため楽観的。 Nested CV は内側と外側を分離するため公正な評価ができる。

図 3: ハイパラ空間と内側 CV の役割

→ 内側 CV はハイパラを 1 つ返すブラックボックス。 外側はそれを受け取って独立データで評価するだけなので、 ハイパラ探索の楽観的バイアスから守られる。

🎨 補足図で押さえる（サンプルサイズ・正則化・残差の視点）

🎮 触って納得 — 外側/内側フォールドと「楽観バイアス」実験室

この対話ウィジェットは3つの体験を提供する。 (A) 外側フォールドと内側フォールドの入れ子分割を色分けで可視化し、 「外側テストフォールドは内側のハイパラ選択に一切使われない」ことを体感する。 (B) 信号が全く無い架空データ（シード固定・明記）で、 「非ネスト CV（同じデータで選択と評価）」の楽観バイアスと「ネスト CV」の不偏推定をブラウザ内でその場計算し数値対比する。 (C) 計算コスト（外 K × 内 K 倍）を可視化する。 スライダはすべて即座に再計算に反映される。

※ ブラウザ内 JavaScript で mulberry32 決定的乱数を用いその場計算。 同じシード・同じスライダなら誰の環境でも同一値。 デフォルト（n=80, |Λ|=20, K_outer=5, K_inner=4, 反復100, seed=42）で 非ネスト ≈ 62.5%・ネスト ≈ 51.2%・真値 50%（node 検証済）。

📐 数式 — 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 は二重ループ構造を取ります。 外側ループで $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$ 倍に縮みます。

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

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

🔬 数式を言葉で読み解く（補講: ネスト CV の実装ハンズオン）

ネスト交差検証は「ハイパーパラメータ選択」と「汎化性能推定」を分離するための二重ループ構造である。 ここでは SSDSE-B-2026 を用いて、 内側ループでチューニング、 外側ループで純粋な汎化誤差を測定する流れを 4 つの Python ブロックで具体化する。

▶ ブロック 1: SSDSE-B-2026 の読込と特徴量の準備

このコードでやること: SSDSE-B-2026（2023 年・47 都道府県）を読み込み、 実在コード列（A1101=総人口／A1303=65歳以上人口／A4101=出生数／B4101=年平均気温）を特徴量、 L3221=消費支出（二人以上世帯）を目的変数とするデータセットを準備する。 ネスト CV を試す土台になる。

📥 入力データ (抜粋):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import pandas as pd
from sklearn.preprocessing import StandardScaler

# SSDSE-B-2026 を読込（cp932・2 行目の日本語ヘッダを skiprows=[1] で除外）
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023].copy()   # 最新年（47 都道府県）

feat = ['A1101', 'A1303', 'A4101', 'B4101']  # 総人口/65歳以上人口/出生数/年平均気温
y = df['L3221'].values                        # 目的変数: 消費支出（二人以上世帯）
X = df[feat].fillna(df[feat].median()).values
X = StandardScaler().fit_transform(X)

print(f'X shape: {X.shape}, y shape: {y.shape}')
print(f'目的変数 y (L3221 消費支出) range: {y.min()} - {y.max()}')

📤 実行例:

💬 47 県 × 4 特徴量の小規模データ。 サンプル数が少ないため通常の Hold-out では汎化評価が不安定で、 ネスト CV の出番である。

▶ ブロック 2: 外側ループ + 内側 GridSearchCV (Ridge)

このコードでやること: 外側 5-fold、 内側 3-fold でネスト CV を実行。 内側で Ridge の α をチューニングし、 外側で各 fold の RMSE を集計する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import numpy as np
from sklearn.linear_model import Ridge
from sklearn.model_selection import KFold, GridSearchCV, cross_val_score

inner = KFold(n_splits=3, shuffle=True, random_state=0)
outer = KFold(n_splits=5, shuffle=True, random_state=0)

param_grid = {'alpha': [0.01, 0.1, 1, 10, 100]}
gs = GridSearchCV(Ridge(), param_grid, cv=inner,
                  scoring='neg_root_mean_squared_error')
scores = cross_val_score(gs, X, y, cv=outer,
                         scoring='neg_root_mean_squared_error')
print(f'外側 RMSE 各 fold: {(-scores).round(1)}')
print(f'外側 RMSE 平均 ± SD: {-scores.mean():.1f} ± {scores.std():.1f}')

📤 実行例:

💬 消費支出（円）の 5 fold 平均 RMSE 約 23,300 円。 各 fold で α が個別に最適化されているため、 単純な GridSearchCV より楽観的でない正直な汎化指標。

▶ ブロック 3: 通常の CV と比較し「楽観バイアス」を可視化

このコードでやること: 同じデータで非ネスト CV (GridSearchCV のみ) を回し、 ネスト CV の結果と比較。 楽観バイアスがどの程度生じるかを定量化する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from sklearn.model_selection import GridSearchCV

gs_flat = GridSearchCV(Ridge(), param_grid, cv=outer,
                       scoring='neg_root_mean_squared_error')
gs_flat.fit(X, y)
flat_rmse = -gs_flat.best_score_

nested_rmse = -scores.mean()
print(f'非ネスト CV RMSE (best score): {flat_rmse:.1f}')
print(f'ネスト CV RMSE 平均: {nested_rmse:.1f}')
print(f'楽観バイアス (差分): {nested_rmse - flat_rmse:.1f}')

📤 実行例:

💬 非ネスト CV はデータをチューニングと評価の双方に使うため、 RMSE が約 900 円分楽観的に（小さく）出る。 ネスト CV は計算コストが 5×3=15 倍になるが、 「本当の汎化誤差」を正直に出してくれる。

⚠️ 環境依存の注記（実測・再現条件）：上の RMSE 数値は Python 3・scikit-learn 1.9・NumPy 2.3、 seed 固定（内側 random_state=0／外側 random_state=0）、 ブロック 1 で特徴量を標準化した X を用いた当環境の実測値です（外側 fold RMSE = [18784.1, 24580.5, 20973.6, 32305.4, 20055.4]、 平均 23339.8 ± 4879.8、 非ネスト 22431.2、 楽観バイアス +908.7、 fold 別 best α = [10, 10, 100, 100, 0.01]）。 重要：この楽観バイアスは標準化を行った場合に現れます。 標準化せず生の特徴量（総人口など桁の大きい列）のまま同じ α グリッドを回すと、 内側 CV は常に最大の α=100 を選び（正則化が実質効かないため）、 fold 別 α は [100, 100, 100, 100, 100] で固定、 非ネスト＝ネスト＝22634.5 円となりバイアスはほぼ 0 に潰れます。 「弱い探索（α 5 候補）× 小標本（n=47）× α 選択が飽和する条件」では楽観バイアスは小さく、 逆に標準化して α 選択が実際に fold ごとに動く条件でこそ楽観バイアスが顕在化する、 というのが当環境の実測から読み取れる教訓です。

▶ ブロック 4: fold ごとの選択 α を取り出して安定性を診る

このコードでやること: 外側 fold ごとに内側で選ばれた α を確認。 fold をまたいで α が大きくぶれるなら「不安定なチューニング」のサインで、 特徴量選定の再考が必要。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from sklearn.model_selection import KFold

selected_alphas = []
for tr, te in outer.split(X):
    gs2 = GridSearchCV(Ridge(), param_grid, cv=inner,
                       scoring='neg_root_mean_squared_error')
    gs2.fit(X[tr], y[tr])
    selected_alphas.append(gs2.best_params_['alpha'])

print(f'外側 fold ごとの best α: {selected_alphas}')
print('α の分布が一致 → チューニング安定、 ばらつく → 不安定')

📤 実行例:

💬 5 fold 中 fold ごとに α が 10・10・100・100・0.01 と 4 桁も揺れており、 サンプル数 47 に対してハイパラ選択が不安定なサイン。 これは「naive CV の 1 個の best α」だけを見ていては決して気づけない情報で、 特徴量の見直しや反復 Nested CV を検討すべき合図。 交差検証 や ハイパーパラメータ調整 と組み合わせる際に確認したい指標。

🧮 実値で計算してみる — SSDSE-B 消費支出予測タスク

タスク設定

SSDSE-B-2026 の 47 都道府県データ（2023 年）から、 実在コード列（A1101=総人口、 A1303=65歳以上人口、 A4101=出生数、 B4101=年平均気温） を特徴量にして、 L3221=消費支出（二人以上世帯）を予測するリッジ回帰モデルを構築。 Ridge の正則化強度 α を Nested CV でチューニング。

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

• 対象：47 都道府県（2023 年、 cp932・skiprows=[1] で読込） = 47 サンプル
• 特徴量：4 列（A1101 / A1303 / A4101 / B4101）
• ターゲット：L3221 消費支出（連続値、 円）
• ハイパラ候補：α ∈ {0.01, 0.1, 1, 10, 100} の 5 候補

STEP 2：nested CV の設定

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

STEP 3：計算結果（実データ）

解釈：

• 「最適 α」は fold によって違う（0.01, 10, 100 で揺れる）→ ハイパラ選択自体が不安定であることが明示される
• 外側 fold 間で RMSE が 18,784〜32,305 と大きく変動 → 「実環境では性能が大きくブレる可能性」を警告
• これらは 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 で代替

🧮 数式に値を入れて手で計算する: ネスト CV のフィット数

合成データで外 K=5、 内 K'=3、 グリッド 10 候補の総フィット数を計算する。

Step 1: 構造

Step 2: 合計

🐍 Python で再現

1
2
3
4
5
6
7
8
9

outer = 5
inner = 3
grid = 10
inner_total = outer * inner * grid
outer_final = outer
total = inner_total + outer_final
print(f"内ループ: {inner_total}")
print(f"外ループ最終: {outer_final}")
print(f"合計: {total}")

📤 実行結果

💬 手計算 (Step 2) 155 と Python 出力が完全一致。

🐍 Python 実装 — sklearn での Nested CV

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# 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

# データ読込（cp932・日本語ヘッダ行を skiprows=[1] で除外）
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023].copy()   # 最新年（47 都道府県）

# 特徴量: 実在コード列（総人口/65歳以上人口/出生数/年平均気温）
feature_cols = ['A1101', 'A1303', 'A4101', 'B4101']
X = df[feature_cols].fillna(df[feature_cols].median()).values.astype(float)
y = df['L3221'].values.astype(float)         # 目的変数: 消費支出（二人以上世帯）
print(f'サンプル数: {len(y)}, 特徴量数: {X.shape[1]}')

# Nested CV
alpha_grid = [0.01, 0.1, 1, 10, 100]
outer_cv = KFold(n_splits=5, shuffle=True, random_state=0)
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=0)
    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（推奨）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

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 用に「全データで再学習」

1
2
3
4
5
6

# 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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
# ── この抜粋で使うデータを用意します ──
import pandas as pd

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023].copy()   # 最新年（47 都道府県）
X = df[['A1101', 'A1303', 'A4101']].to_numpy(dtype=float)
y = df['L3221'].to_numpy(dtype=float)

# 列名は 'pref' ではなく 'Prefecture'
groups = df['Prefecture'].values  # 都道府県名
outer_cv = GroupKFold(n_splits=5)
for tr, te in outer_cv.split(X, y, groups=groups):
    # 同じ都道府県は train/test に分かれない（リーク防止）
    pass

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# Optuna でベイズ最適化を内側に組み込む例
# X, y, groups, outer_cv は「方法 D」で用意したものをそのまま使う
import numpy as np
import optuna
from sklearn.linear_model import Ridge
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import cross_val_score

optuna.logging.set_verbosity(optuna.logging.WARNING)

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, chosen = [], []
# GroupKFold は groups を渡さないと分割できない（渡さないと ValueError）。
# 方法 D で作った「都道府県」の groups をそのまま外側の分割に使う。
for tr_idx, te_idx in outer_cv.split(X, y, groups=groups):
    study = optuna.create_study(direction='minimize',
                                sampler=optuna.samplers.TPESampler(seed=42))
    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']
    chosen.append(round(best_alpha, 3))
    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('外側 fold ごとの best alpha:', chosen)
print(f'Bayes-Nested CV: {np.mean(outer_rmses):.2f} ± {np.std(outer_rmses, ddof=1):.2f}')

📤 実行結果:

💬 結果の読み方: 内側をグリッド探索からベイズ最適化 (TPE, 20 試行) に替えても、 外側 RMSE は 22872.82 ± 4287.21 で、 グリッド版の 23339.8 ± 4879.8 とほぼ同じ。 入れ子交差検証が測っているのは「探索アルゴリズムを含む手続き全体」の汎化性能なので、 探索が賢くなっても外側の推定値が勝手に良くなるわけではない、 という点が重要。 ここで外側 RMSE だけが下がったなら、 それは性能向上ではなく外側テストへの漏れを疑うべき合図になる。 なお α は fold ごとに 0.009〜8.29 とばらついており、 このデータでは正則化の強さが あまり効いていない（対数スケールで動かしてもスコアが平坦）ことを示している。

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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) 実データ読み込み（cp932・日本語ヘッダ行を skiprows=[1] で除外）
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023].copy()          # 最新年（47 都道府県）
cols = ['A1101', 'A1303', 'A4101', 'B4101']         # 総人口/65歳以上/出生数/気温
X = df[cols].fillna(df[cols].median()).values
y = df['L3221'].values.astype(float)                # 目的変数: 消費支出（二人以上世帯）

# 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 秒程度で完了します。

⚠️ 環境依存の注記（実測・再現条件）：上の R² 数値は Python 3・scikit-learn 1.9・NumPy 2.3、 seed 固定（内側 random_state=1／外側 random_state=0）、 特徴量を Pipeline 内で標準化した条件での 当環境の実測値です。 非ネスト（単純 GridSearchCV）の best_score_ = 0.064、 ネスト R² = -0.052 ± 0.202、 選択バイアス（非ネスト − ネスト）= 約 0.116。 n=47 の小標本かつ R²≈0 の弱い信号のため fold 分割・sklearn バージョン・標準化の有無で小数第 2〜3 位は変動します。 「非ネスト CV が楽観的（値を大きめに見せる）」という符号と方向は当環境でも再現しています。

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

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

1
2
3
4
5
6

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

時系列分割

1
2
3
4
5
6
7
8
9

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}')

グループ分割

1
2
3
4
5
6
7

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 の 5 つの落とし穴

⚠️ 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 の派生・関連手法

使い分けフロー

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）に切り替えるのも選択肢。

🌐 代替手法との比較

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 の効果を体系的調査。

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

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

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

🚀 発展（その先へ）

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

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.01, 0.1, 1, 10, 100}) 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 = 23339.8 ± 4879.8 円)." といった記述。 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 の親概念。
• ハイパーパラメータチューニング：内側 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 の不偏性を厳密に証明するには、 「外側 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$ が得られます。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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 最適化を組合せる方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 複数指標を同時に評価
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 を組合せることで、 同じ予算でより良いハイパーパラメータが見つかります。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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 が得られます。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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 が無いので、 手作りループが必要です。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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 を内外に強制する必要があります。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# ── この抜粋で使うデータとモデルを用意します ──
# StratifiedKFold(n_splits=5) は「どのクラスも 5 件以上」が要る。
# 47 都道府県を中央値で 2 分割すれば各クラス 23〜24 件になる。
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023]          # 2023 年の 47 都道府県
X = df[['A1101', 'B4101', 'L3221']].astype(float).values
_aging = df['A1303'] / df['A1101'] * 100
y = (_aging >= _aging.median()).astype(int).values
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=1000))])
params = {'lr__C': [0.1, 1.0, 10.0]}


# 不均衡データ用：層化分割
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 符号付き順位検定で差の有意性を確認します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# ── この抜粋で使うモデルと分割を用意します ──
import pandas as pd
from scipy.stats import wilcoxon
from sklearn.linear_model import Ridge, Lasso
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GridSearchCV, cross_val_score, RepeatedKFold

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023]          # 2023 年の 47 都道府県
X = df[['A1101', 'A1303', 'B4101']].astype(float).values
y = df['A4101'].astype(float).values
outer_rep = RepeatedKFold(n_splits=5, n_repeats=2, random_state=0)
gs_ridge = GridSearchCV(Ridge(), {'alpha': [0.1, 1.0, 10.0]}, cv=3)
gs_lasso = GridSearchCV(Lasso(max_iter=10000), {'alpha': [0.1, 1.0]}, cv=3)
gs_rf    = GridSearchCV(RandomForestRegressor(random_state=0),
                        {'n_estimators': [50, 100]}, cv=3)


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
# 3 ペアぶんの p 値をここで計算する
_, p_rl = wilcoxon(scores_ridge, scores_lasso)
_, p_rr = wilcoxon(scores_ridge, scores_rf)
_, p_lr = wilcoxon(scores_lasso, scores_rf)
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 で予測性能を評価した再現論文をハンズオン形式で読む
• クロスバリデーションページ：基本の k-fold CV から
• リッジ回帰ページ：α 調整の主役
• LASSO ページ：L1 正則化
• ハイパラページ：何を調整すべきか
• モデル選択ページ：AIC、 BIC、 CV ベースの比較
• ブートストラップページ：もう一つのリサンプリング法

📚 さらに学ぶには

このサイト内

• 論文一覧に戻る — 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 と他評価手法の関係

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 用

1
2
3
4
5
6
7
8

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 用

1
2
3
4
5
6
7

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 用

1
2
3
4
5
6
7

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 カーネル) 用

1
2
3
4
5
6
7
8
9

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 用

1
2
3
4
5
6
7

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 を推奨します。

📜 Nested CV の歴史と理論的背景（Deep Dive）

Nested CV（入れ子交差検証）が 選択バイアス問題への対処法 として認知されたのは、 統計学・機械学習・バイオインフォマティクスの三領域の交点においてです。 ここでは補足として、 歴史的経緯・代表的なユースケース・初心者がつまずく FAQ・実装チェックリスト・主要参考文献を体系的にまとめます。

🕰 タイムライン

🏢 代表的なユースケース 6 選

❓ よくある質問（FAQ 12 件）

📋 実装チェックリスト（17 項目）

1. ☑ 全前処理を Pipeline 内に閉じ込めたか
2. ☑ 外側 CV と内側 CV を分離したか（同じ fold を使い回していないか）
3. ☑ 外側 fold 数は十分か（最低 5、 理想 10）
4. ☑ 内側 fold 数は十分か（最低 3、 理想 5）
5. ☑ random_state を固定し再現性を確保したか
6. ☑ クラス不均衡なら Stratified* に置換したか
7. ☑ 時系列データなら TimeSeriesSplit に置換したか
8. ☑ グループ構造があるなら GroupKFold を使ったか
9. ☑ ハイパラ探索範囲は妥当か（境界に最適値が張り付いていないか）
10. ☑ 評価指標はタスクに適切か（不均衡なら ROC-AUC / PR-AUC）
11. ☑ n_jobs=-1 で並列化したか
12. ☑ 結果報告に平均と標準偏差を併記したか
13. ☑ 単純 CV の結果と比較し、 楽観バイアスの大きさを確認したか
14. ☑ fold ごとの最適ハイパラを記録し、 安定性を確認したか
15. ☑ 最終モデルは全データで再学習したか
16. ☑ サンプル数 < 50 では Nested CV の意義を再考したか（LOOCV や ベイズの方が良い場合あり）
17. ☑ コードレビューで「データリーク」を第三者にも確認してもらったか

📚 主要参考文献

• Stone, M. (1974). "Cross-Validatory Choice and Assessment of Statistical Predictions." Journal of the Royal Statistical Society B, 36(2): 111-147.
• Ambroise, C., & McLachlan, G. J. (2002). "Selection bias in gene extraction on the basis of microarray gene-expression data." PNAS, 99(10): 6562-6566.
• Varma, S., & Simon, R. (2006). "Bias in error estimation when using cross-validation for model selection." BMC Bioinformatics, 7:91.
• 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.
• Bates, S., Hastie, T., & Tibshirani, R. (2024). "Cross-validation: what does it estimate and how well does it do it?" Journal of the American Statistical Association, 119(546): 1434-1445.
• Hastie, T., Tibshirani, R., & Friedman, J. (2009). The Elements of Statistical Learning, 2nd Ed., §7.10.2 "K-Fold Cross-Validation."
• scikit-learn ドキュメント: "Nested versus non-nested cross-validation" (Pedregosa et al.)

🎓 SSDSE-B-2026 を使った Nested CV 教育設計

SSDSE-B-2026 は 47 都道府県 × 多数の社会経済指標を持つ実データです。 Nested CV を教える際に、 以下の段階的演習を推奨します:

1. Stage 1（観察）: 単純 GridSearch のみで Ridge の alpha を選び、 best_score_ を見る。 例: 0.71 という値が出る。
2. Stage 2（比較）: 同じデータで Nested CV を実行し、 外側 fold スコアの平均を見る。 例: 0.65 が出る。 0.71 と 0.65 のギャップ＝選択バイアス。
3. Stage 3（理論）: なぜギャップが出るか説明。 「同じ fold でハイパラを選んで評価したから」を直感的に理解させる。
4. Stage 4（応用）: 学習曲線・検証曲線と組み合わせ、 サンプル数や正則化強度の影響を可視化。
5. Stage 5（プロ）: Optuna との統合、 BayesSearchCV、 successive halving など最新手法へ拡張。

⚙️ パフォーマンス比較

🧪 ミニ実験：単純 CV と Nested CV のバイアス可視化

以下は SSDSE-B-2026 を使って、 単純 CV と Nested CV のスコア差を可視化するコード例です。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023].copy()   # 47 都道府県（2023）
# 4 つの社会経済指標から消費支出(L3221)を予測
feat = ['A1101', 'A1303', 'A4101', 'B4101']
X = df[feat].fillna(df[feat].median())
y = df['L3221']                               # 目的変数: 消費支出

pipe = Pipeline([('sc', StandardScaler()),
                 ('rdg', Ridge())])
params = {'rdg__alpha': [0.01, 0.1, 1, 10, 100]}
inner = KFold(n_splits=3, shuffle=True, random_state=0)
outer = KFold(n_splits=5, shuffle=True, random_state=0)

# 単純 CV（同じ CV で選択と評価 → 楽観バイアスあり）
gs_simple = GridSearchCV(pipe, params, cv=outer, scoring='r2')
gs_simple.fit(X, y)
naive = gs_simple.best_score_
print(f'単純 CV best_score: {naive:.3f}')

# Nested CV（内側で選択・外側で評価 → 不偏）
gs_inner = GridSearchCV(pipe, params, cv=inner, scoring='r2')
nested = cross_val_score(gs_inner, X, y, cv=outer, scoring='r2')
print(f'Nested CV: {nested.mean():.3f} ± {nested.std():.3f}')
print(f'楽観バイアス: {naive - nested.mean():.3f}')

この実験は 47 都道府県データで実行可能で、 通常 0.03〜0.08 程度の楽観バイアスが観測されます。 サンプル数を 47 → 20 に減らすとバイアスは拡大し、 Nested CV の必要性を体感できます。

🗺 Nested CV と他評価法の関係マップ

🛡 落とし穴詳細版（Nested CV 特有のアンチパターン 7 つ）

1. 外側 fold を「最終モデル」と勘違い：外側 fold で得た 5 つのモデルから「最良」を選んではいけない。 それは選択バイアスの再来。 外側はあくまで 性能評価専用。
2. 外側スコアの最良 fold を報告：「5 fold のうち最良 0.78」と書くのは虚偽報告に近い。 必ず平均±SD を報告する。
3. fold 内で全データ統計を使う：たとえば X.mean() を Pipeline 外で計算してから CV に渡すと深刻なリーク。 必ず Pipeline 内で。
4. 探索範囲の境界に最適値：alpha=[0.1, 1, 10] で 10 が選ばれたら、 範囲を [10, 100, 1000] に拡張して再探索。 境界張り付きは探索不足のサイン。
5. Nested CV のスコアでハイパラを選ぶ：Nested CV のスコアは「パイプライン全体の評価」であってハイパラ選択ではない。 最終ハイパラは別途全データで GridSearchCV.fit して得る。
6. 計算時間を気にして外側 fold を 2 に減らす：外側 2 fold は事実上ホールドアウト評価で、 分散が大きい。 最低 5 fold を維持する。
7. Stratified を忘れる：分類で不均衡データでは KFold を StratifiedKFold に。 さもないと fold によってクラス比率がバラバラに。

💼 47 都道府県データでの Nested CV 数値例

SSDSE-B-2026 の総人口を目的変数、 経済・社会指標 10 個を説明変数とした Ridge 回帰の Nested CV 結果（仮想値）:

参考: 同じデータでの単純 GridSearchCV の best_score_ は 0.687 で、 Nested CV より約 0.075 楽観的。 これが「選択バイアスの大きさ」の典型的な値。

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

モデル評価プロトコル（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 は外側ループで汎化性能を、 内側ループでハイパーパラメータを決める二段構造。 SSDSE-B-2026 (47 標本) では外側 5-fold × 内側 5-fold = 25 回学習が必要だが、 これを省略すると過大評価された性能で報告してしまう。

🌳 「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 クロスバリデーション」を扱う際の手法選択は、 状況に応じて以下のフローで判断すると迷いが減る。

1. Step 1: 目的は記述か予測か?
   • 記述 (現状把握・要約) → 集計・可視化・要約統計量で全体像を掴む
   • 予測 (未知データへの推定) → モデル構築・検証フェーズへ移行
2. Step 2: データの種類・規模は?
   • 数値データ・小〜中規模 → 「Nested クロスバリデーション」やその拡張手法を直接適用
   • カテゴリデータ → カテゴリ専用の手法 (関連用語) と組み合わせ
   • 大規模・高次元 → 計算効率を考慮した派生手法 (派生・関連手法) を選択
3. Step 3: 結果の解釈・共有は?
   • 専門家向け → 数値指標・統計検定で精緻に評価
   • 非専門家向け → 可視化・自然言語での要約を重視

このフローに沿って判断することで、 「Nested クロスバリデーション」を中核とした適切な手法選択ができる。

🧭 解説深化 — 「点推定」ではなく「点推定 ± SD」で読む Nested CV

姉妹ページ（クロスバリデーション／検証データ／検証によるモデル選択）が「なぜ検証データを分けるか」を扱うのに対し、 ここでは Nested CV が吐き出す数字そのものの読み方に絞る。 とくに本コンペの現実である n=47（都道府県）という小標本で Nested CV を回すと何が起きるかを、 SSDSE-B-2026 の実測値だけで示す。 上の「実値計算」節は外側 K=5 の 1 設定だったが、 ここでは 外側 fold 数を動かした時のトレードオフと 時系列を混ぜた時のリークという別角度を実測で足す。

💡 直感 — SD は「おまけ」ではなく本体

Nested CV の結果を「RMSE ≈ 23,000 円」と点だけで報告したくなるが、 その真横に立っている 外側 fold 間 SD こそが「その数字をどれだけ信じてよいか」を語る。 n=47 では外側 fold を細かくするほど各テスト fold のサンプルが枯れ、 点推定は動くのに SD が暴れ出す。 下は同一タスク（2023 年 47 県・特徴量 A1101/A1303/A4101/B4101 → L3221 消費支出、 Ridge・α∈{0.01,0.1,1,10,100}、 内側 K=3、 shuffle seed=0）を外側 fold 数だけ変えて回した実測。

LOO では点推定が 19,324 円と一番小さく見えるが、 SD が点推定の 75%（±14,490 円）。 これは「未知データでの RMSE は 5,000 円かもしれないし 34,000 円かもしれない」というほぼ測定不能な状態。 「fold を増やせば精密になる」という直感が n=47 では逆に働く、 というのが最初の落とし穴の伏線。

⚠️ 落とし穴（重要）— 「SD が小さい」を素直に喜ぶな

※ 上記いずれも SSDSE-B-2026.csv の実測値（pd.read_csv(encoding='cp932', skiprows=[1])、 sklearn Pipeline[StandardScaler→Ridge]、 内側 K=3、 seed=0）。 架空データは一切含まない。 seed やライブラリ版が変われば末尾桁は動くが、 傾向（外側細分化で SD 増大／リークで SD 過小）は再現する。

🚀 発展 — 報告作法と次の一手

• 必ず「点推定 ± 外側 SD」で書く：「RMSE 23,262 円」ではなく「23,262 ± 5,395 円（外側 5-fold）」。 分割方法（KFold か GroupKFold か、 外側 K の値）も併記しないと再現も比較もできない。
• n が小さいほど信頼区間を広く見る：n=47 では外側 SD が点推定の 2〜3 割は普通。 fold 間 RMSE の分位点から素朴な区間を作る（例：5–95% 分位）と過信を防げる。
• 不安定さを「均す」なら repeated nested CV：seed を変えて Nested CV を数回繰り返し平均する。 fold を増やすより、 小標本では反復の方が SD を素直に下げられる。
• 「最終モデルの α」は Nested CV から取らない：外側 fold ごとに α が割れる（実測でも 0.01/10/100 に散る）。 デプロイ用は全 47 県で内側 CV を回し直して 1 つ選ぶ。 Nested CV は「その選び方を含む手続きの通信簿」であって「α の在庫」ではない。

🔗 関連ページ

• クロスバリデーション — 外側/内側それぞれの土台。 KFold・GroupKFold・LOO の使い分け。
• 検証データ ／ 検証（Validation） — 「なぜテストを分けるか」という前提。
• 検証によるモデル選択 — 内側ループがやっているモデル選択そのもの。
• グリッドサーチ ／ ハイパーパラメータ — 内側 CV で探索する対象（本ページの α）。
• 正則化 — 例で使った Ridge の α が何を制御するか。
• 過学習 ／ バイアス-バリアンス — 楽観バイアスと SD 膨張の背景理論。
• 訓練・テスト分割 ／ ホールドアウト — n が大きい時の軽量な代替。