🔖 キーワード索引

「交差検証 (cross-validation)」はデータを K 分割し、 学習用と検証用を入れ替えて K 回評価することで汎化性能を推定する手法。 ホールドアウトより低分散の推定が得られ、 ハイパーパラメータ調整・モデル選択の標準ツール。 本ページでは K-fold・Stratified K-fold・LOO・Group K-fold・時系列 CV の使い分けと、 leakage を起こさない pipeline 設計を整理する。

これらのキーワードは「データ分割の戦略 → 学習/検証の反復 → スコアの平均と分散 → ハイパーパラメータ調整」という CV の標準フローを構成する。

🎨 直感で掴む

「テスト勉強」に例えるなら：

• train/test 1回分割：模試を1回だけ受けて偏差値を出す。 たまたま得意な分野が出れば高得点
• 5-fold CV：模試を5回受けて平均する。 偶然の影響を平均化
• LOOCV：問題集の全問を1問ずつテストとして使う極端版。 計算は重いが推定は安定

SSDSE-B-2026 で考えると分かりやすい。 47 都道府県データで「総人口ほか → 出生数」を回帰したいとき、 単純に 32 県で学習・15 県でテストすると、 偶然どの県がテスト側に入るかで $R^2$ が 0.92 にも 1.00 にもブレる。 5-fold CV なら 9〜10 県ずつテストを 5 回回し、 全 47 県が必ず 1 回テストに使われるため、 1 回分割より未知データ汎化性能の推定が安定する（例: $R^2 = 0.98 \pm 0.01$）。

選択指針として、 サンプル数 $n$ が小さい (たとえば $n < 100$) なら LOOCV か 10-fold、 中程度なら 5-fold、 時系列データなら TimeSeriesSplit (未来を未学習で守る)、 クラス分布が偏っているなら StratifiedKFold (各 fold のラベル比率を揃える) が定石。 また、 同一被験者から複数サンプルがある場合は GroupKFold で被験者単位に分け、 リークを防ぐ。

📐 定義／数式

標準誤差も算出できる：$SE = \sigma_{\text{folds}} / \sqrt{k}$。 これで信頼区間付きで「精度 = $0.85 \pm 0.02$」と報告可能。

📐 統計検定との接続 — モデル比較を統計的に語る

「モデルA より B が良い」と言うには、 単なる CV スコアの差だけでなく統計的有意性を見るのが望ましい。 Wilcoxon 符号付き順位検定や Friedman 検定が定番。

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

from sklearn.model_selection import KFold, cross_val_score
from sklearn.linear_model import Ridge, Lasso
from scipy.stats import wilcoxon

cv = KFold(5, shuffle=True, random_state=42)
score_A = cross_val_score(Pipeline([('s',StandardScaler()),('m',Ridge())]), X, y, cv=cv, scoring='neg_root_mean_squared_error')
score_B = cross_val_score(Pipeline([('s',StandardScaler()),('m',Lasso())]), X, y, cv=cv, scoring='neg_root_mean_squared_error')

# fold ごとに対応のあるサンプル(同じ分割)
stat, p = wilcoxon(score_A, score_B)
print(f'Ridge vs Lasso: stat={stat:.2f}, p={p:.4f}')
if p < 0.05:
    print('差は統計的に有意')

5 fold だけでは検定力が弱いので、 Repeated CV (30 fold 程度) を使うのが現実的。

🛠 MLOps と CV — 再現性と監査

本番運用では CV の結果を MLflow や Weights & Biases に記録するのが標準。 「いつ、 どのデータで、 どんなハイパーパラメータで、 CV スコアいくつだったか」が追跡可能になります。

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

import mlflow
mlflow.set_experiment('ssdse-b-prediction')
with mlflow.start_run(run_name='ridge-5fold'):
    cv = KFold(5, shuffle=True, random_state=42)
    pipe = Pipeline([('s',StandardScaler()),('m',Ridge(alpha=1.0))])
    scores = cross_val_score(pipe, X, y, cv=cv, scoring='r2')
    mlflow.log_param('model','Ridge')
    mlflow.log_param('alpha', 1.0)
    mlflow.log_param('cv_k', 5)
    mlflow.log_metric('r2_mean', scores.mean())
    mlflow.log_metric('r2_std', scores.std())
    for i,s in enumerate(scores):
        mlflow.log_metric(f'fold_{i}_r2', s)

監査・規制対応・論文付録のいずれにも有用。 CV 結果は「再現可能な数値」であるべき。

🎯 データ品質と CV — 何を信用するか

CV スコアが優秀でも、 元データの品質が低ければ意味がありません。 SSDSE-B のような公的統計データでも以下に注意：

• 欠損のパターン: ランダム欠損(MCAR) か系統的欠損(MNAR) かで補完戦略が変わる。 補完を CV 内で行う必要がある。
• 定義の年度間変更: 「高齢者」の定義が変わると時間的検証が崩れる。 メタデータを必ず確認。
• サンプリングバイアス: SSDSE-B は全数 (47都道府県) なのでバイアスは小さいが、 一部の項目は標本調査のため誤差あり。
• 外れ値: 東京都が常に外れ値。 CV のスコアに大きく影響するので、 外れ値の扱いは fold 内で決定。
• 従属性: 47都道府県は独立ではなく、 隣県の経済活動が干渉する。 完全な independence 仮定は近似に過ぎない。

📖 さらに学ぶ — 入門〜上級

入門

• scikit-learn 公式ドキュメントの "Cross-validation" 章
• Aurélien Géron (2022) Hands-On Machine Learning 2nd ed., Chapter 2

中級

• Hastie et al. The Elements of Statistical Learning, Chapter 7
• Kohavi (1995) IJCAI 論文（CV 手法比較の決定版）

上級

• Arlot & Celisse (2010) "A survey of cross-validation procedures for model selection"
• Bates et al. (2023) "Cross-validation: what does it estimate and how well does it do it?" JASA
• Bengio & Grandvalet (2004) "No Unbiased Estimator of the Variance of K-Fold Cross-Validation"

🔬 数式を言葉で読み解く

k-fold CV のスコア式 $\text{CV score} = \dfrac{1}{k}\sum_{i=1}^{k} \text{Score}(f_i, D_{\text{test},i})$ に登場する記号を 1 つずつ確認します。 SSDSE-B-2026 の 47 都道府県データを $k=5$ で分割する文脈で具体化します。

式の読み下し: 「$k$ 個ある fold それぞれについて、 (a) その fold を除いた残りで学習し ($f_i$ を得る)、 (b) 学習に使わなかった $D_{\text{test},i}$ で予測しスコアを取り、 (c) $k$ 個のスコアを単純平均する」。 これにより全データが過不足なく 1 回ずつ検証に使われ、 汎化誤差の不偏推定が得られます。

🔬 数式を言葉で読み解く（4要素構造／1200字以上）

交差検証 (Cross-Validation) の核心は、 「学習に使わなかったデータでモデルの性能を測る」ことです。 k-fold CV は数学的には次のように定式化されます：$$\widehat{\mathrm{CV}}(f) = \frac{1}{k} \sum_{j=1}^{k} \frac{1}{|V_j|} \sum_{i \in V_j} L\bigl(y_i,\ \hat{f}^{(-j)}(x_i)\bigr)$$ ここで $V_j$ は $j$ 番目の検証 fold（インデックス集合）、 $\hat{f}^{(-j)}$ は $V_j$ を除いた残り全データで学習されたモデル、 $L$ は損失関数（回帰なら $L(y,\hat y) = (y-\hat y)^2$、 分類なら 0-1 損失や交差エントロピー）です。 これは「汎化誤差 $\mathbb{E}_{(x,y) \sim p}[L(y,f(x))]$ の不偏推定量」として、 単純な訓練誤差より遥かに信頼できる指標になります。

要素1: 分割 $V_1, V_2, \dots, V_k$ — 「どう分けるか」

データ集合 $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^{n}$ を互いに素な $k$ 個の fold $V_1, \dots, V_k$ に分けます（$\bigcup_j V_j = \{1,\dots,n\}$ かつ $j \neq j'$ なら $V_j \cap V_{j'} = \emptyset$）。 各 fold のサイズは $|V_j| \approx n/k$。 SSDSE-B-2026 (47都道府県) を $k=5$ で分ければ各 fold は約 9〜10 県。 重要な性質は(a) 全データが必ず一度だけ検証に使われる、 (b) 学習・検証は完全に分離されること。 これによりホールドアウト法 (単一の train/test 分割) と比べて、 推定の分散が大幅に減ります。 ただし都道府県データのように地理的相関がある場合は単純ランダム分割が偏ることもあり、 層化 (Stratified) や地域別 (Group K-Fold) を選びます。

要素2: 学習 $\hat{f}^{(-j)}$ — 「fold ごとに別モデル」

$j$ 番目の fold では、 検証セット $V_j$ を除いた残り $\mathcal{D} \setminus V_j$（約 $\frac{k-1}{k}n$ サンプル） を学習に使い、 モデル $\hat{f}^{(-j)}$ を得ます。 ここでの重要点は「fold ごとに完全に別のモデルを訓練する」こと。 ハイパーパラメータ調整や前処理（標準化・特徴量選択）も各 fold 内で完結させなければ、 検証セットの情報が学習にリークします（典型的な落とし穴）。 scikit-learn では Pipeline + cross_val_score を使うことでリーク防止が自動化されます。

要素3: 損失関数 $L$ — 「何を測るか」

損失関数 $L(y, \hat{y})$ はタスクで変えます。 回帰なら MSE = $(y-\hat y)^2$、 RMSE = $\sqrt{\mathrm{MSE}}$、 MAE = $|y-\hat y|$、 MAPE = $|y-\hat y|/|y|$ など。 分類なら 0-1 損失（誤分類率）、 交差エントロピー、 log-loss など。 SSDSE-B で「出生数を総人口・高齢化率・年平均気温で予測」する回帰タスクなら RMSE か MAE を CV スコアにします。 損失の選択は意思決定の損失構造を反映すべきです（外れ値に頑健にしたいなら MAE、 大きな誤りを強くペナルティするなら MSE）。

要素4: 平均と分散 — 「k 個の値をどう要約するか」

$k$ 個の fold ごとの誤差 $e_j = \frac{1}{|V_j|} \sum_{i \in V_j} L(y_i, \hat{f}^{(-j)}(x_i))$ を平均して $\widehat{\mathrm{CV}} = \frac{1}{k}\sum_j e_j$ を得ます。 同時に分散 $s^2 = \frac{1}{k-1}\sum_j (e_j - \widehat{\mathrm{CV}})^2$ も計算し、 「誤差の平均 ± 標準偏差」を報告するのが標準。 $k$ が大きい（LOOCV: $k=n$）と平均は不偏に近いが計算コストが高く、 $k=5$ や $10$ が経験的に良いバランス。 同じ実験を複数回の反復 (repeated) CVで行い、 分散をさらに減らす手法もあります。

🔬 理論的背景 — バイアス・分散・k の影響

CV 推定量 $\widehat{\mathrm{CV}}_k$ には統計的に重要な性質があります：

• バイアス: $\widehat{\mathrm{CV}}_k$ は真の汎化誤差を悲観的に推定する傾向（学習データが $(k-1)/k \cdot n$ と少ないため）。 k が大きいほどバイアスは小。
• 分散: k が大きいと fold 同士の学習データが重複し、 fold 間相関が高まり分散が増大することがある。 LOOCV は典型例。
• 計算量: k 倍。 LOOCV は n 倍で大規模データでは非現実的。 一部の手法 (Ridge regression など) は LOOCV を解析的に計算できる近道がある。

経験的に k=5 や k=10 が「バイアス・分散・計算量」のスイートスポット。 SSDSE-B のような小データでは LOOCV のバイアスの優位が分散の悪化を上回ることもあり、 ケースバイケースで比較すべきです。

📝 さらに学ぶ — CV と隣接トピック

CV はモデル評価の基礎ですが、 隣接する技術と組み合わせるとさらに強力になります。 Out-Of-Fold (OOF) 予測は CV の各 fold で得た予測値を全データ分つなげたもので、 Stacking（メタ学習）の入力になります。 Permutation Importance は CV 内で特徴量をシャッフルして性能低下を測る重要度指標。 SHAP（説明可能AI）も OOF 予測上で計算するとリークを防げます。

Kaggle 等の競技では「CV と LB (Leaderboard) の相関」を重視します。 CV が改善しても LB が下がるなら、 CV 設計が public test に偏っている可能性。 逆に CV が安定していて LB と相関しているなら、 そのモデル選択は信頼できる、 という判断が経験的に使われます。 公的統計データでも、 「年度間の汎化」（2023年で学習 → 2024年で検証）は実務的に重要な評価軸です。

🧪 CV の種類を実装で見る

KFold

1
2
3
4
5
6

from sklearn.model_selection import KFold
import numpy as np
X = np.arange(20).reshape(20,1); y = np.arange(20)
kf = KFold(n_splits=5, shuffle=True, random_state=42)
for i,(tr,te) in enumerate(kf.split(X)):
    print(f'fold {i}: train={tr[:5]}...{tr[-3:]}  test={te}')

StratifiedKFold

1
2
3
4
5
6

from sklearn.model_selection import StratifiedKFold
y = np.array([0]*15 + [1]*5)  # 不均衡 (3:1)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for i,(tr,te) in enumerate(skf.split(np.zeros(20), y)):
    print(f'fold {i}: train pos={y[tr].sum()}/15  test pos={y[te].sum()}/{len(te)}')
# 各fold で陽性比率 (~25%) が保たれる

GroupKFold

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from sklearn.model_selection import GroupKFold
# 都道府県を「地域」グループでまとめる
# 47 都道府県それぞれに 8 地方区分を割り当てる
# （3 種類しか無いと n_splits=4 の分割ができない）
regions = np.array(
    ['北海道']*1 + ['東北']*6 + ['関東']*7 + ['中部']*9
    + ['近畿']*7 + ['中国']*5 + ['四国']*4 + ['九州・沖縄']*8)
gkf = GroupKFold(n_splits=4)
for i,(tr,te) in enumerate(gkf.split(np.zeros(47), groups=regions)):
    print(f'fold {i}: train regions = {set(regions[tr])}  test regions = {set(regions[te])}')
# 同じ地域が train と test に分散しない

TimeSeriesSplit

1
2
3
4
5

from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)
for i,(tr,te) in enumerate(tscv.split(np.zeros(60))):
    print(f'fold {i}: train [{tr.min():2d},{tr.max():2d}]  test [{te.min():2d},{te.max():2d}]')
# 過去で学習→未来で検証 を順次拡大

RepeatedKFold

1
2
3
4
5

from sklearn.model_selection import RepeatedKFold
rkf = RepeatedKFold(n_splits=5, n_repeats=3, random_state=42)
scores = cross_val_score(pipe, X, y, cv=rkf, scoring='r2')
print(f'R² over {len(scores)} folds = {scores.mean():.3f} ± {scores.std():.3f}')
# 5×3=15 fold での平均(分散が下がる)

🔍 CV + ハイパーパラメータ探索

「最良のハイパーパラメータ + そのモデルの汎化性能」を同時に出すには Nested CV が原則です。

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

from sklearn.model_selection import GridSearchCV, cross_val_score, KFold
from sklearn.ensemble import RandomForestRegressor

inner_cv = KFold(n_splits=3, shuffle=True, random_state=0)
outer_cv = KFold(n_splits=5, shuffle=True, random_state=42)

param_grid = {'n_estimators':[100,300,500], 'max_depth':[3,5,10,None]}
search = GridSearchCV(RandomForestRegressor(random_state=42),
                      param_grid=param_grid, cv=inner_cv, scoring='r2', n_jobs=-1)

# 外側 CV: 各 outer fold で内側にハイパー探索
nested = cross_val_score(search, X, y, cv=outer_cv, scoring='r2')
print(f'Nested R² = {nested.mean():.3f} ± {nested.std():.3f}')

# 最終モデル: 全データで再探索
search.fit(X, y)
print('best params:', search.best_params_)

5 × 3 × 12 (param 組合せ) = 180 回学習。 SSDSE-B (n=47) なら数秒で終わる。 大規模データなら RandomizedSearchCV や Optuna へ。

🎭 CV と Stacking（メタ学習）

CV の出力 (OOF 予測) を集めて、 もう一段別のモデルを乗せるのが Stacking。 Kaggle の上位解法の常套手段。

 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

from sklearn.ensemble import StackingRegressor
from sklearn.linear_model import Ridge
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor

estimators = [
    ('ridge', Ridge(alpha=1.0)),
    ('rf', RandomForestRegressor(n_estimators=200, random_state=42)),
    ('gbm', GradientBoostingRegressor(n_estimators=200, random_state=42)),
]
stack = StackingRegressor(
    estimators=estimators,
    final_estimator=Ridge(),
    cv=5,                # 内部で 5-fold CV → OOF 予測 → メタモデルへ
)
# ── この抜粋で使うデータと分割を用意します ──
# outer_cv を GroupKFold（群＝都道府県）のまま使うと 1 群 1 標本になり、
# R² が負になってしまう。ここは通常の KFold で評価する。
import pandas as pd
from sklearn.model_selection import cross_val_score, KFold

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023].copy()
X = df[['A1101', 'A1303', 'L3221']].to_numpy(dtype=float)
y = df['A4101'].to_numpy(dtype=float)     # 出生数を予測する

scores = cross_val_score(stack, X, y,
                         cv=KFold(n_splits=5, shuffle=True, random_state=42),
                         scoring='r2')
print(f'Stacking R² = {scores.mean():.3f} ± {scores.std():.3f}')

🧮 実値で計算してみる

47都道府県データを 5-fold で分割すると：

• 各 fold のテストは約 9〜10 県、 訓練は約 37〜38 県
• fold ごとに R² を計算 → 5個の値（例：0.81, 0.78, 0.85, 0.79, 0.83）
• 平均 = 0.812、 標準偏差 = 0.027 → 「R² ≈ 0.81 ± 0.01」と報告

1回だけ test=北海道〜青森とランダムに引いて R²=0.85 が出るより、 はるかに信頼性が高い数値です。

🧮 数式に値を入れて手で計算する

合成 4-fold エラー値 $\mathrm{Error}=[0.20, 0.15, 0.30, 0.25]$ を k-fold CV の数式に代入し、 Step 1〜3 で手計算する。 同じ計算を Python (numpy / sklearn) で再現し、 結果が一致することを確認する。

📐 k-fold 交差検証の平均エラー (再掲)

$$ \mathrm{CV}_k = \frac{1}{k} \sum_{i=1}^{k} \mathrm{Error}_i $$

k は fold 数、 $\mathrm{Error}_i$ は i 番目の fold をテストに用いたときの誤差 (RMSE, MSE, 1-R² など)。

Step 1: データ準備 (合成 4-fold、 8 サンプル分割)

Step 2: 総和と除算

Step 3: CV 平均と標準偏差

🐍 同じ計算を Python で再現

 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

import numpy as np
from sklearn.model_selection import KFold
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Step 1: 合成 4-fold のエラー値 (各 fold の Error_i)
errors = np.array([0.20, 0.15, 0.30, 0.25])

# Step 2 & 3: k-fold CV の平均と標準偏差
k = len(errors)
cv_mean = errors.sum() / k       # = np.mean(errors)
cv_std = errors.std(ddof=0)      # 母集団標準偏差

print(f"k       = {k}")
print(f"sum     = {errors.sum():.4f}")
print(f"CV 平均 = {cv_mean:.4f}")
print(f"CV 標準偏差 = {cv_std:.4f}")
print(f"報告値 = Error = {cv_mean:.3f} ± {cv_std:.3f}")

# 参考: KFold が同じ平均化を内部でやっていることの確認
# (実際の学習を sklearn 流に組むときの最小スケルトン)
X = np.arange(8).reshape(-1, 1).astype(float)
y = np.array([1.0, 2.1, 2.9, 4.2, 5.0, 5.9, 7.1, 8.0])
kf = KFold(n_splits=4)
fold_errs = []
for tr, te in kf.split(X):
    m = LinearRegression().fit(X[tr], y[tr])
    fold_errs.append(mean_squared_error(y[te], m.predict(X[te])))
print(f"sklearn 例 fold MSE = {np.round(fold_errs, 4).tolist()}")
print(f"sklearn 例 CV 平均  = {np.mean(fold_errs):.4f}")

📤 実行結果

💬 手計算 (Step 3 の 0.225) と Python の numpy 平均 (0.2250) が完全一致。 標準偏差 0.056 は fold 間のばらつきが小さいことを意味し、 「特定の fold で運よく良い結果が出ただけ」ではないと言える。 sklearn 例はあくまでパイプラインの確認用で、 k-fold CV は「fold ごとのエラーを平均する」という単純な数式に帰着することがポイント。

🧮 SSDSE-B-2026 で 5-fold CV を実行する（用語固有計算）

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

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import KFold, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026']==2023].dropna(subset=['A4101','A1101','A1303']).reset_index(drop=True)
df['高齢化率'] = df['A1303'] / df['A1101'] * 100

X = df[['A1101','高齢化率']].values
y = df['A4101'].values

# Pipeline: 標準化 + 線形回帰（各fold内でfitされる→リーク防止）
pipe = make_pipeline(StandardScaler(), LinearRegression())

# 5-fold CV
kf = KFold(n_splits=5, shuffle=True, random_state=42)
neg_mse = cross_val_score(pipe, X, y, cv=kf, scoring='neg_mean_squared_error')
rmse = np.sqrt(-neg_mse)
print('Fold RMSE  :', np.round(rmse, 2))
print(f'平均 RMSE = {rmse.mean():.2f} ± {rmse.std():.2f}')

🏭 産業事例 6 件 — 交差検証が現場でどう使われるか

📊 比較表 — CV 手法の選び方

✏️ 演習 5 問（SSDSE-B-2026 で）

1. 演習1: 2023年 47都道府県を 5-fold CV で線形回帰(目的：出生数、 説明：総人口・高齢化率)。 RMSE の平均と標準偏差を報告せよ。
2. 演習2: 同じデータを LOOCV (k=47) に変えると RMSE の平均・分散はどう変わるか比較せよ。
3. 演習3: shuffle=False と shuffle=True で結果が変わる理由を、 SSDSE のデータが「都道府県コード順に並んでいる」事実から説明せよ。
4. 演習4: 5-fold CV を 30 回繰り返して RMSE の分布をヒストグラム化し、 単一 5-fold の結果がどれくらい運に依存するかを示せ。
5. 演習5: 説明変数を増やして k-NN 回帰モデルを CV で評価し、 線形回帰と性能を比較せよ（同じ fold 分割で）。

💀 失敗例ケーススタディ — 交差検証の事故

事例1: 全データで標準化してから CV → リーク

「先に StandardScaler でデータ全体を標準化してから cross_val_score」とすると、 検証セットの平均・分散が学習に漏れる。 結果として CV スコアが楽観的（実運用より良い数値）になる。 対策: 必ず Pipeline で前処理を内側に入れる。

事例2: 時系列データに通常 k-Fold

株価や売上の時系列を通常 k-Fold で評価すると、 未来データで学習し過去データで検証することになり、 現実とは逆。 オフラインで高 R² でも本番で全く動かない。 対策: TimeSeriesSplit を使う。

事例3: 患者単位の漏れ（医療データ）

同じ患者の異なる検査が train と test に分散すると「同じ人」を覚えてしまい AUC が異常に高い。 対策: GroupKFold(group=patient_id) で患者単位分割。

事例4: ハイパーパラメータ調整したスコアを最終評価に流用

同じ CV ループ内でハイパーパラメータをグリッド探索し、 そのベストスコアを「汎化性能」として報告する → 楽観バイアス。 対策: Nested CV（外側 fold で評価、 内側 fold で調整）。

事例5: k が小さすぎて分散が高すぎ結論不能

k=2 など極端に小さい k だと fold ごとの差が大きく、 「モデルAがB より良い」と言えるか判断できない。 対策: k=5 か 10 を基本に、 さらに Repeated CV で分散を下げる。

📖 用語ミニ辞典（10語）

Hold-out

データを train/test に 1 回だけ分ける最も単純な方法。 推定の分散が高い。

k-Fold

k 個の互いに素な fold に分け、 各 fold を順に検証用にする CV の標準形。

LOOCV

Leave-One-Out CV。 k=n の極端版。 小データで使う。

Stratified

クラス比率を各 fold で保つ層化分割。 不均衡分類で必須。

Group K-Fold

同一グループ（患者・ユーザー）が train/test に分散しないよう分割。

Time-Series CV

時間順に学習窓を拡大しながら検証する。 未来は学習に使わない。

Repeated CV

k-Fold を異なる seed で複数回繰り返して分散を下げる。

Nested CV

外側で評価、 内側でハイパー調整。 厳密だが計算量大。

Pipeline

前処理 + モデルを1つのオブジェクトにまとめ、 リークを防ぐ scikit-learn の仕組み。

Data Leakage

検証セットの情報が学習に漏れること。 CV 設計の最大の敵。

🕰 歴史的背景 — Stone (1974) から AutoML まで

交差検証の概念は、 Stone (1974) と Geisser (1975) によって統計学的に整備されました。 それ以前にも「データを分割して検証する」という発想はありましたが、 数学的な性質（不偏性、 一致性）が証明されたのはこの時期です。

機械学習の文脈では Kohavi (1995) の論文 "A Study of Cross-Validation and Bootstrap for Accuracy Estimation and Model Selection" が決定版で、 「k=10 が経験的に良い」という現代の慣習はここに由来します。 2000年代以降、 Kaggle 等のコンペで CV 設計が直接スコアに響くようになり、 「leaky CV」「shake-up」などの実務知見が蓄積。 2010年代後半からは AutoML が CV を組み込みで実行するようになり、 ユーザーが手書きする頻度は減りましたが、 結果を読み取るには CV の理論理解が依然必須です。

🔧 高度なレシピ — Pipeline・Nested CV・予測の保存

レシピ1: Pipeline でリーク防止

1
2
3
4
5
6
7
8
9

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score, KFold

pipe = Pipeline([('scaler', StandardScaler()), ('reg', Ridge(alpha=1.0))])
cv = KFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(pipe, X, y, cv=cv, scoring='r2')
print(f'R² = {scores.mean():.3f} ± {scores.std():.3f}')

レシピ2: GridSearchCV と Nested CV

1
2
3
4
5
6
7

from sklearn.model_selection import GridSearchCV, cross_val_score, KFold

inner = KFold(n_splits=3, shuffle=True, random_state=0)
outer = KFold(n_splits=5, shuffle=True, random_state=42)
grid = GridSearchCV(pipe, param_grid={'reg__alpha':[0.1,1,10,100]}, cv=inner, scoring='r2')
nested_scores = cross_val_score(grid, X, y, cv=outer, scoring='r2')
print(f'Nested CV R² = {nested_scores.mean():.3f} ± {nested_scores.std():.3f}')

レシピ3: 予測値を保存して fold ごとに解析

1
2
3
4
5
6
7
8

from sklearn.model_selection import cross_val_predict
y_pred = cross_val_predict(pipe, X, y, cv=cv)
# 47県の予測値が得られる(OOF prediction)
import pandas as pd
result = pd.DataFrame({'都道府県':df['Prefecture'], 'y_true':y, 'y_pred':y_pred})
result['residual'] = result['y_true'] - result['y_pred']
print(result.sort_values('residual').head())   # 最も過小予測の県
print(result.sort_values('residual').tail())   # 最も過大予測の県(東京など)

レシピ4: TimeSeriesSplit（時系列用）

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

import pandas as pd
from sklearn.model_selection import TimeSeriesSplit

# ── この抜粋だけで動くように、時間順に並んだパネルデータを用意する ──
panel_data = (pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
                .sort_values(['SSDSE-B-2026', 'Prefecture'])
                .reset_index(drop=True))

tscv = TimeSeriesSplit(n_splits=5)
for train_idx, test_idx in tscv.split(panel_data):
    print(f'train: {train_idx.min()}-{train_idx.max()}, test: {test_idx.min()}-{test_idx.max()}')
# 時系列では「過去で学習 → 未来で検証」の順序を必ず守る

レシピ5: 評価指標を複数同時に

1
2
3
4
5
6

from sklearn.model_selection import cross_validate
scoring = ['neg_root_mean_squared_error','neg_mean_absolute_error','r2']
res = cross_validate(pipe, X, y, cv=cv, scoring=scoring, return_train_score=True)
for k,v in res.items():
    if k.startswith('test_') or k.startswith('train_'):
        print(f'{k:32s}: {v.mean():.3f} ± {v.std():.3f}')

🚫 アンチパターン集

1. StandardScaler を CV の外側で fit → 検証セットの情報漏れ。 必ず Pipeline 内で。
2. SMOTE などのオーバーサンプリングを外側で実行 → 同じく漏れ。 imbalanced-learn の Pipeline を使う。
3. 時系列を shuffle=True で k-Fold → 未来から学習する非現実シナリオ。 TimeSeriesSplit へ。
4. 同じユーザー/患者を train/test に分散 → 個人認識の暗黙学習。 GroupKFold へ。
5. k=2 や k=3 でモデル比較 → 分散が大きすぎて差を検出できない。 k=10 + Repeated。
6. 同一の CV スコアでハイパー選択とモデル評価 → 楽観バイアス。 Nested CV へ。
7. 外れ値除去を CV の外で実行 → どの fold で外れ値が外れたか不明。 内側で。
8. 特徴量選択を CV の外で実行 → 同じく漏れ。 SelectKBest も Pipeline 内へ。

❓ FAQ — 受講生からの頻出質問

🐍 Python 実装

🎯 このコードでやること：SSDSE-B-2026 の都道府県データ（X = 総人口・65歳以上人口・年平均気温など、 y = 出生数）に対して sklearn.model_selection.KFold で 5-fold 交差検証を行い、 Ridge 回帰の R² の平均と分散を取得する。 47 都道府県を 5 分割し、 各 fold で「学習 38 県 → 評価 9 県」を入れ替えて合計 5 回モデルを学習・評価する。

📥 入力データ（SSDSE-B-2026 抜粋）：

 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

# このコードでやること: SSDSE-B-2026 を読み込んで KFold で 5-fold CV → R² 平均±SD と fold 別バーチャート
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import cross_val_score, KFold
from sklearn.linear_model import Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# 1) SSDSE-B-2026 を読み込む (1 行目=列コード、 2 行目=日本語見出しを読み飛ばす)
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == 2023].copy()                       # 47 県 × 1 年に絞る
features = ['A1101', 'A1303', 'B4101']
X = df[features].to_numpy()
y = df['A4101'].to_numpy()
print('X shape', X.shape, 'y shape', y.shape)

# 2) Pipeline で fold 内に標準化を閉じ込めてリーケージ防止
pipe = Pipeline([('scaler', StandardScaler()), ('ridge', Ridge(alpha=1.0))])
kf = KFold(n_splits=5, shuffle=True, random_state=0)
scores = cross_val_score(pipe, X, y, cv=kf, scoring='r2')

# 3) fold 別 R² と平均±SD を出力
print(f"R² = {scores.mean():.3f} ± {scores.std():.3f}")
for i, s in enumerate(scores, 1):
    print(f"  fold {i}: R² = {s:.3f}")

# 4) fold 別 R² を可視化 (平均線で過大評価リスクを直感化)
plt.bar(range(1, 6), scores)
plt.axhline(scores.mean(), color='red', linestyle='--', label='mean')
plt.xlabel('fold'); plt.ylabel('R²'); plt.legend(); plt.savefig('cv_r2.png')

📤 実行すると次の出力が得られる：

💬 結果の読み方：5 つの fold の R² は 0.887〜0.995 と幅があり、 平均 0.970 ± 標準偏差 0.042。 → fold 5（R²=0.887）では「東京・大阪」のような外れ値県を含む可能性が高く、 そこだけ予測精度が落ちている。 単一の train/test 分割（例：8:2）で評価すると 偶然 fold 2 を test に選んで R²=0.995 と過大評価 していたかもしれない。 KFold で fold 間ばらつきを見ることで「モデル性能の信頼区間」を把握できる。 ばらつきが大きい場合は StratifiedKFold（クラス層別）や GroupKFold（同一グループの漏れ防止）の検討対象。

⚠️ よくある落とし穴

⚠️ 実務でハマる罠 — 詳細版

罠1: ターゲットエンコーディングのリーク

カテゴリ変数を「そのカテゴリの目的変数平均」で置き換える Target Encoding は、 CV の外で実行すると検証セットの y が学習にリーク。 対策: category_encoders の TargetEncoder を Pipeline 内で使う。

罠2: 欠損値補完のリーク

中央値補完を CV 外で行うと、 検証セットの中央値情報も学習に含まれる。 対策: SimpleImputer を Pipeline 内に。

罠3: 特徴量選択のリーク

相関の高い列を CV 外で選んで → CV で評価すると、 「選別段階で y を見てしまった」分のリーク。 対策: SelectKBest を Pipeline 内に。

罠4: SMOTE のリーク

不均衡データで SMOTE オーバーサンプリングを CV 外で行うと、 合成サンプルが train/test に分散。 対策: imbalanced-learn の Pipeline を使い、 SMOTE を内側へ。

罠5: 時間順を無視した shuffle=True

株価予測などで shuffle=True にすると、 「未来から学んで過去を当てる」非現実シナリオ。 対策: TimeSeriesSplit。

📜 論文で CV を報告するときの書き方

• 分割方式の明示: 「stratified 5-fold CV」「LOOCV」など。
• random seed の固定: 再現性のため random_state=42 を明記。
• fold 数の根拠: なぜ k=5 か k=10 か。 サンプル数との整合。
• 前処理が CV 内で完結していることを明示（Pipeline 使用）。
• 平均 ± 標準偏差を報告（または 95% 信頼区間）。
• ハイパーパラメータ調整は Nested CV または別途検証セットを使ったこと。
• fold 間の独立性（時系列・グループ性）への対応。

これを守らない論文はリジェクトされる確率が高い（特に NeurIPS, ICML, KDD）。 公的統計分析でも同じ厳密性を期待される時代です。

📌 拡張チートシート

 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

import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge

# pipe / X / y / params をここで用意する
_d = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
_d = _d[_d['SSDSE-B-2026'] == 2023].reset_index(drop=True)
X = _d[['A1101', 'A1301', 'A1303', 'A9101']].astype(float).values
y = _d['A4101'].astype(float).values
pipe = Pipeline([('imp', SimpleImputer(strategy='median')),
                 ('sc', StandardScaler()), ('m', Ridge(alpha=1.0))])
params = {'m__alpha': [0.1, 1.0, 10.0]}   # 上の Pipeline の step 名 'm' に合わせる

# 基本パターン
from sklearn.model_selection import cross_val_score, KFold
cv = KFold(5, shuffle=True, random_state=42)
scores = cross_val_score(pipe, X, y, cv=cv, scoring='r2')

# 複数指標
from sklearn.model_selection import cross_validate
res = cross_validate(pipe, X, y, cv=cv,
                     scoring=['r2','neg_root_mean_squared_error'])

# OOF 予測
from sklearn.model_selection import cross_val_predict
y_oof = cross_val_predict(pipe, X, y, cv=cv)

# ハイパー探索付き
from sklearn.model_selection import GridSearchCV
gs = GridSearchCV(pipe, params, cv=cv, scoring='r2')   # model ではなく pipe を渡す
gs.fit(X, y); print(gs.best_params_, gs.best_score_)

# 並列実行
scores = cross_val_score(pipe, X, y, cv=cv, n_jobs=-1)

# Pipeline で前処理込み
from sklearn.pipeline import Pipeline
pipe = Pipeline([('imputer', SimpleImputer()),
                 ('scaler', StandardScaler()),
                 ('model', Ridge())])

🎓 学習ロードマップ — CV を完全に使いこなす

1. Week 1: train_test_split から KFold へ移行。 cross_val_score を使えるように。
2. Week 2: Pipeline でリーク防止を体得。 StandardScaler を内側に。
3. Week 3: StratifiedKFold, GroupKFold, TimeSeriesSplit を場面で使い分け。
4. Week 4: GridSearchCV と Nested CV でハイパー調整。
5. Week 5: cross_val_predict で OOF 予測を取り、 残差分析。
6. Week 6: Stacking / Bagging で CV を組み込んだアンサンブル。
7. Week 7: 学習曲線・検証曲線で診断を読み解く。
8. Week 8: Repeated CV や Bootstrap CV で正式報告レベル。

交差検証は「保険」ではなく「設計」です。 SSDSE-B-2026 のような小サンプルデータでこそ、 CV を正しく使いこなせるかが分析の信頼性を左右します。

🌍 実例ケーススタディ — 47都道府県の予測精度を年度横断で確かめる

「2013-2020年で学習 → 2021-2023年で検証」のような時間的 hold-out を、 SSDSE-B-2026 の多年データで実施します。 これは公的統計の実務に近い評価方法です。

 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, numpy as np
from sklearn.linear_model import Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_absolute_error, r2_score

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1]).dropna()
df['高齢化率'] = df['A1303']/df['A1101']*100
features = ['A1101','高齢化率','B4101','L3221']
target = 'A4101'

# 時間的 hold-out (パネル化)
train = df[df['SSDSE-B-2026'].between(2013, 2020)]
test  = df[df['SSDSE-B-2026'].between(2021, 2023)]

pipe = Pipeline([('s', StandardScaler()), ('m', Ridge(alpha=1.0))])
pipe.fit(train[features], train[target])
pred = pipe.predict(test[features])
print(f'時間的検証 MAE = {mean_absolute_error(test[target], pred):.2f}')
print(f'時間的検証 R²  = {r2_score(test[target], pred):.3f}')

# 比較: 通常 5-fold CV
from sklearn.model_selection import KFold, cross_val_score
cv = KFold(5, shuffle=True, random_state=42)
cv_r2 = cross_val_score(pipe, df[features], df[target], cv=cv, scoring='r2')
print(f'通常 5-fold R² = {cv_r2.mean():.3f} ± {cv_r2.std():.3f}')

時間的 hold-out の方が「現実的な汎化性能」を反映するが、 fold 数が 1 しかなく分散がわからない。 両者を併報するのがベストプラクティス。

⚠️ 条件・限界・誤解回避 — 交差検証の運用ポイント

交差検証（CV）は機械学習・統計学習の汎化誤差推定における標準ツールだが、 データ構造・分割設計・指標選択を誤ると CV の結果が「本番性能の信頼できる推定」にならない。 SSDSE-B-2026（N=47）のような小サンプルでは特に CV の使い方が結果を大きく左右する。 ここでは適用条件・限界・誤解回避を整理する。

📐 適用条件（CV の結果を信頼できる前提）

1. iid（独立同分布）の仮定: 通常の k-fold CV は観測が iid を仮定。 時系列・空間・パネルデータでは破れるため、 専用 CV（時系列 CV、 ブロック CV、 グループ k-fold）が必要。
2. 標本サイズが分割数 k に対して十分: k-fold CV は各 fold に十分なデータがある前提。 N=47, k=5 なら各 fold 約 9 件で、 評価指標の分散が大きくなる。
3. クラス分布の維持: 分類問題では各 fold のクラス分布が全体と近い必要があり、 stratified k-fold で確保する。 不均衡データでは特に重要。
4. 前処理の漏れ防止: 標準化・特徴選択・ターゲットエンコーディングは「fold 内で fit、 fold 外に transform」する。 全データで fit すると leakage が起き CV 誤差が楽観バイアスを受ける。
5. ハイパーパラメータ選択は nested CV で: ハイパーパラメータ調整と汎化誤差推定を同じ CV で兼ねると、 楽観バイアスが乗る。 外側 CV で誤差推定、 内側 CV で調整。

🚧 限界（CV でも分からないこと）

1. 分布シフト下では信頼できない: 訓練分布と本番分布が違う（共変量シフト、 ラベルシフト）と、 CV 誤差は本番誤差を過小評価する。 本番に近い時期のデータでホールドアウト検証が必要。
2. 小サンプルでの分散が大きい: N=47, k=5 では、 fold の選び方次第で CV 誤差が ±20% 程度ぶれることがある。 繰り返し CV（repeated k-fold）で安定化を図る。
3. LOO は分散が大きく時間がかかる: Leave-One-Out は不偏に近いが分散が大きく、 N 回の学習が必要。 k=10〜20 の k-fold が実務的にはバランスがよい。
4. モデル選択バイアス: 多数のモデルを CV で比較し、 最良のものだけ報告すると、 CV 誤差が楽観バイアスを受ける。 nested CV または事前登録で対処。
5. 計算コスト: k×（モデル学習コスト）が必要。 深層学習や大規模 GBDT では現実的に k=3 や hold-out + early stopping に縮退することがある。

💡 誤解回避（CV 運用で頻発する勘違い）

1. 「CV 誤差が低ければ本番でも低い」は誤解: 分布シフトがあれば CV 誤差は楽観的。 「CV → ホールドアウト → 本番」の 3 段検証が原則。
2. 「k が大きいほど良い」も誤解: k が大きいと訓練サイズが本番に近づく利点はあるが、 fold 間の独立性が崩れて分散推定が不正確になる。 k=5〜10 が標準。
3. 「Stratified k-fold は回帰では不要」は誤解: 回帰でも目的変数の分布が偏っていれば（例: 多くの 0 と少数の極端値）、 stratified-by-bin で分布を保つほうが安定する。
4. 「時系列でも k-fold で OK」は最悪パターン: 時系列データに通常の k-fold を使うと、 未来の情報で過去を予測することになり、 完全な leakage。 必ず TimeSeriesSplit を使う。
5. 「CV の標準偏差は無視してよい」も誤解: モデル比較では CV 誤差の平均だけでなく、 fold 間の標準偏差・最悪 fold も見る。 「平均は良いが分散が大」は本番でのリスク。

✅ 実務でのチェックリスト

• □ データの構造（iid / 時系列 / 空間 / グループ）に合った CV を選んだか
• □ 分類なら stratified k-fold を使ったか
• □ 前処理を fold 内で fit するパイプラインにしているか（leakage 防止）
• □ k を 5〜10 の範囲で選んだか（小サンプルなら repeated k-fold）
• □ ハイパーパラメータ調整は nested CV か別ホールドアウトで行ったか
• □ CV 誤差の平均だけでなく標準偏差も報告したか
• □ 最終的に未使用のホールドアウトで本番想定の評価を行ったか
• □ ベースラインモデル（定数予測・最頻クラス）と比較したか

💬 CV は「データを賢く使い回す」テクニックだが、 同時に「自分の楽観バイアスを増幅する道具」にもなる。 データ構造の確認、 leakage の遮断、 nested 構造、 ホールドアウト併用 — この 4 つを毎回チェックすることが、 CV 結果を信頼できる汎化誤差推定に保つ最短路。

🎮 触って理解する

スライダーを動かすと、 図と数値がその場で更新されます。 分割数 k を変えると各 fold の訓練（青）／検証（橙）の割り当てがどう変わるか、 多項式の次数を変えると交差検証スコア（平均 R²）が最適次数で最大化し、 それを超えると過学習で落ちる様子を体感できます。

※ このデモの計算：説明用の擬似データ（真の関数 y = sin(2πx) にノイズを加えた 16 点、 乱数シード固定）に対し、 多項式回帰＋k-fold CV を ブラウザ内で正確に計算しています。 実データ（SSDSE-B-2026）での分析は上の「🐍 Python 実装」を参照してください。

💡 直感

k を増やすと各 fold の訓練データが増えて（＝より本番に近いデータ量で学習でき）バイアスは下がりますが、 検証セットが小さくなり fold ごとのスコアのばらつき（標準偏差）は大きくなります。 k = n（＝ LOOCV）の極端では、 検証は毎回 1 点だけ。 このとき fold 単位の R² は「1 点では平均が定義できない」ため計算不能になり、 全 n 個の予測をまとめた プール R² で評価するのが実務の作法です（デモでも自動でそう切り替わります）。 一方 次数を上げると訓練 R²（青線）は 1 に張り付いていきますが、 CV R²（橙線）は最適次数でピークを打ち、 その先は過学習で急落します。 この「青は上がり続け・橙は途中で折り返す」ギャップこそ過学習のサインです。

⚠️ よくある落とし穴

• データリーク：標準化・欠損補完・特徴選択・ターゲットエンコーディングを CV の外で全データに対して行うと、 検証セットの情報が訓練に漏れて楽観的なスコアになります。 前処理は必ず Pipeline に入れて fold 内で fit しましょう。
• 層化を忘れる：クラスが不均衡な分類では通常の KFold だと、 ある fold に少数派クラスが 0 件になり評価が壊れます。 StratifiedKFold で各 fold のクラス比率を揃えます。
• 時系列でシャッフル禁止：時間順序のあるデータで shuffle=True にすると「未来で学習して過去を当てる」非現実的な評価になり、 本番で崩れます。 TimeSeriesSplit や年度ホールドアウトを使います。

🚀 発展: ネストCV

上のデモでは「次数を選ぶ」ことと「スコアを測る」ことを同じ CV で行っていますが、 実務でこれをやるとハイパラを検証セットに合わせ込んでしまい、 汎化性能を過大評価します。 これを避けるのが ネストCV（入れ子交差検証）で、 外側 CV で汎化性能を測り、 その各 fold の内部で内側 CV により次数などのハイパラを選びます。 「調整」と「評価」を別々のデータで行うことで、 デモの橙線ピークが持つ楽観バイアスを取り除けます。

関連ページ: 過学習 ／ バイアスバリアンス分解 ／ train-test 分割 ／ データリーケージ ／ ハイパラ調整

🌐 関連手法・派生

• KFold — 標準のk-fold分割
• StratifiedKFold — クラス比率を保つ
• GroupKFold — 同グループを同foldへ
• TimeSeriesSplit — 時系列の正しい分割
• LeaveOneOut — n-1個で学習、 1個でテスト

📊 CV 変種の比較表（計算量・前提・適用例）

CV の選択はデータ特性（独立性・時系列性・群構造・クラス分布）でほぼ決まる。 以下は実務で頻出する 5 変種を 3 列で比較した早見表。

🌳 いつどの CV を選ぶか（判断基準）

迷ったら次のフローチャートで絞り込める。

1. 時間順序があるか？ Yes → TimeSeriesSplit（過去で学習、 未来でテスト）。 KFold を使うと未来の情報が漏れて楽観バイアスになる。
2. 群構造があるか？（同一患者の複数受診、 同一店舗の複数日など） Yes → GroupKFold。 通常 KFold だと同じ群が train/test 両方に入りリーケージが起きる。
3. クラス不均衡か？（陽性 ≤ 10%） Yes → StratifiedKFold。 KFold だと test fold に陽性が 1 件も入らない可能性がある。
4. サンプル数 n が少ない？（n < 50） Yes → LOOCV。 そうでなければ KFold (k=5 or 10)が標準。
5. ハイパラ調整も同時にやるか？ Yes → Nested CV（外側で評価、 内側で調整）で楽観バイアスを除く。

🌐 周辺エコシステム

• 過学習 — CV は過学習を検出する道具。 学習誤差 ≪ 検証誤差なら過学習サイン。
• バイアスバリアンス分解 — k の選択はバイアス-分散のトレードオフ。
• ハイパーパラメータ調整 — Grid/Random/Bayesian Search の評価指標として CV。
• train/test 分割 — CV の単純化版（Hold-out）。
• ブートストラップ — 復元抽出による別系統の検証手法。
• 汎化誤差 — CV が推定したい量。

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

役割で色分け：前提／上位／並列／発展／応用

cross validation を学ぶ際に併読すると理解が深まる関連用語を「前提・並列・発展」の 3 区分で整理する。

• 前提概念: train-test 分割 / 検証データ / 汎化誤差・過学習の理解、 fold 内 i.i.d. を支える確率論の独立性
• 並列概念: ホールドアウト / ブートストラップ / OOB スコア (Random Forest) / time series split (時系列)、 いずれも汎化性能推定の別系統
• 発展概念: Nested CV (調整と評価の分離) / Stratified KFold (不均衡対応) / GroupKFold (リーケージ防止) / Repeated KFold / 学習曲線によるサンプル設計

各概念は交差検証の関連用語ページにリンクしている。 関連用語を横断的に学ぶことで、 cross validation の位置付けが明確になる。

📚 関連グループ教材

この用語の全体像を学ぶには、 横断的な教材で文脈を掴むのが効率的です。

• 📚 機械学習基礎 — 評価設計の基本
• 📚 MLOps — 自動評価パイプライン
• 📚 ハイパーパラメータ調整 — Nested CV と組合せ
• 📚 バイアス・バリアンス — CV で測る対象
• 📚 過学習グループ — CV が解決する問題

• scikit-learn 公式 Cross-validation ガイド（https://scikit-learn.org/stable/modules/cross_validation.html）— KFold / StratifiedKFold / GroupKFold / TimeSeriesSplit の使い分け
• scikit-learn cross_val_score API（https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_val_score.html）— 引数 scoring・cv の指定方法
• Kohavi (1995) オリジナル論文（https://www.ijcai.org/Proceedings/95-2/Papers/016.pdf）— k=10 が標準になった根拠論文
• Hastie『The Elements of Statistical Learning』7 章（https://hastie.su.domains/ElemStatLearn/）— CV の理論的位置づけ（無料公開）
• SSDSE-B-2026 教育用標準データセット（https://www.nstac.go.jp/use/literacy/ssdse/）— 47 都道府県データで 5-fold CV を実演

🔎 深掘り解説

主要なCV変種一覧

Nested CV：「評価」と「調整」の正しい分離

ハイパラ調整したCVスコアをそのまま報告すると楽観バイアス。 Nested CV では外側で評価、 内側で調整：

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

import pandas as pd
from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score, GridSearchCV, KFold

# ── この抜粋だけで動くように、estimator・param_grid・X・y を用意する ──
_d = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
_d = _d[_d['SSDSE-B-2026'] == 2023]
X = _d[['A1101', 'A1301', 'A1303', 'A9101']].astype(float).values
y = _d['A4101'].astype(float).values
estimator = Ridge()
param_grid = {'alpha': [0.01, 0.1, 1, 10, 100]}

# 入れ子交差検証: 内側でハイパラを選び、外側で汎化性能を測る
inner = KFold(n_splits=3)
outer = KFold(n_splits=5)
grid  = GridSearchCV(estimator, param_grid, cv=inner)
scores = cross_val_score(grid, X, y, cv=outer)
print(scores.mean(), scores.std())

外側5fold × 内側3fold = 15回学習。 計算重いが評価信頼性が桁違いに上がる。

k の選び方

• k=5：実務で最も使われる。 分散と計算量のバランスが良い
• k=10：n が大きいときの標準。 Kohavi(1995) が経験的に推奨
• k=n（LOOCV）：n が小さい（<30）ときに使用。 計算重
• k=2：基本的に避ける。 trainサイズが半減し精度低下

✅ 使う前のチェックリスト

• ☐ 交差検証 が今のタスクに本当に適切か再確認した
• ☐ 前提条件（独立性、 正規性、 サンプル数等）を満たしているか確認した
• ☐ データの尺度・分布・欠損・外れ値を確認した
• ☐ 結果だけでなく「不確実性」（CI、 標準誤差）も把握した
• ☐ 解釈と限界を区別して文書化した
• ☐ 関連する別の手法（hold-out / bootstrap / OOB）と比較したうえで交差検証を選んだ
• ☐ 落とし穴（このページの ⚠️ セクション）に該当しないか確認した
• ☐ 関連グループ教材で全体像と位置付けを把握した

📖 さらに学ぶには

本サイト内

• 論文一覧に戻る — 交差検証 を実際に使った再現論文をハンズオン形式で読む
• このページ上部の「🔗 関連用語」から派生概念へ
• 「📚 関連グループ教材」で横断的な学習教材へ

外部リソース

• scikit-learn 公式ドキュメント — 標準実装と例
• StatQuest with Josh Starmer (YouTube) — 直感的な統計／ML 解説
• Cross Validated (Stack Exchange) — 統計／ML の質問サイト
• arXiv — 最新の手法論文プレプリント

困ったときは

1. データの可視化（散布図、 ヒストグラム、 箱ひげ図）で異常を確認
2. サンプルサイズ・欠損・外れ値を確認
3. 仮定が満たされているか診断（正規性検定、 等分散性検定など）
4. 類似研究での標準的な手法を確認
5. 結果を複数手法でクロスチェック（頑健性確認）

🔗 同カテゴリの他用語

📚 参考文献

• Stone, M. (1974). "Cross-validatory choice and assessment of statistical predictions." JRSS-B.
• Kohavi, R. (1995). "A Study of Cross-Validation and Bootstrap for Accuracy Estimation and Model Selection." IJCAI.
• Hastie, T., Tibshirani, R., Friedman, J. (2009). The Elements of Statistical Learning. Chapter 7.
• Arlot, S., Celisse, A. (2010). "A survey of cross-validation procedures for model selection." Statistics Surveys.
• Bengio, Y., Grandvalet, Y. (2004). "No Unbiased Estimator of the Variance of K-Fold Cross-Validation." JMLR.
• scikit-learn ドキュメント: scikit-learn.org/stable/modules/cross_validation.html

📋 ワンページ・チートシート

📌 まとめ — 交差検証を「保険」として身につける

1. 汎化誤差の不偏推定: CV は「未知データでの予測精度」を最も実用的に近似する方法。
2. Pipeline 必須: 前処理は必ず CV の内側で。 リークを防ぐ最重要習慣。
3. 分割は問題依存: 時系列・グループ・不均衡など、 データの性質に合わせて分割方式を選ぶ。
4. k=5 or 10 が基本: 計算コストと推定分散の妥協点。 小データなら LOOCV、 厳密なら Repeated CV。
5. Nested CV で評価: ハイパー調整と最終評価を分離。 これを怠ると論文がリジェクトされる。

SSDSE-B-2026 のような小規模公的統計データでも、 CV を組み合わせれば「47県の中での一般化性能」を定量化できます。 単一の R² や RMSE で語るより、 CV の平均±標準偏差で語る習慣を持つことで、 結果の信頼性が桁違いに上がります。

🚀 エンドツーエンド・パイプライン例 — SSDSE-B-2026 で 6 モデル比較

「47都道府県の出生数を 5 つの説明変数（総人口・高齢化率・年平均気温・消費支出・65歳以上人口）から予測」する課題で、 線形回帰・Ridge・Lasso・k-NN・ランダムフォレスト・勾配ブースティングの 6 モデルを 5-fold 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
32
33
34
35
36

import pandas as pd, numpy as np
from sklearn.model_selection import KFold, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.neighbors import KNeighborsRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026']==2023].dropna().reset_index(drop=True)
df['高齢化率'] = df['A1303']/df['A1101']*100

features = ['A1101','高齢化率','B4101','L3221','A1303']
target = 'A4101'
X = df[features].values
y = df[target].values

models = {
    'LinearRegression': LinearRegression(),
    'Ridge':            Ridge(alpha=1.0),
    'Lasso':            Lasso(alpha=0.1),
    'k-NN':             KNeighborsRegressor(n_neighbors=5),
    'RandomForest':     RandomForestRegressor(n_estimators=200, random_state=42),
    'GradientBoosting': GradientBoostingRegressor(n_estimators=200, random_state=42),
}

cv = KFold(n_splits=5, shuffle=True, random_state=42)
results = {}
for name, model in models.items():
    pipe = Pipeline([('scaler', StandardScaler()), ('model', model)])
    rmse = -cross_val_score(pipe, X, y, cv=cv, scoring='neg_root_mean_squared_error')
    results[name] = (rmse.mean(), rmse.std())
    print(f'{name:18s}: RMSE = {rmse.mean():.2f} ± {rmse.std():.2f}')

best = min(results, key=lambda k: results[k][0])
print(f'\nベストモデル: {best} (RMSE={results[best][0]:.2f})')

SSDSE-B のような小データ (n=47) では複雑なモデル (RandomForest, GBM) が過学習しがち。 CV の標準偏差が大きい場合は注意。

🔁 LOOCV で各県の予測誤差を可視化

SSDSE-B では n=47 と小さいので Leave-One-Out CV (k=n) が現実的に実行可能。 各県を 1 つずつ除外して残り 46 県で学習 → その県を予測 → 誤差を記録。

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

from sklearn.model_selection import LeaveOneOut, cross_val_predict

loo = LeaveOneOut()
pipe = Pipeline([('scaler', StandardScaler()), ('model', Ridge(alpha=1.0))])
y_oof = cross_val_predict(pipe, X, y, cv=loo)
errors = y - y_oof

result = pd.DataFrame({
    '都道府県': df['Prefecture'],
    '実測値':  y,
    '予測値':  y_oof,
    '誤差':    errors,
    '相対誤差(%)': errors/y*100,
}).sort_values('誤差')

print('予測が大幅に外れた県(上下5県):')
print(pd.concat([result.head(5), result.tail(5)]).to_string())
print(f'\nLOOCV RMSE = {np.sqrt((errors**2).mean()):.2f}')
print(f'LOOCV MAE  = {np.abs(errors).mean():.2f}')

東京都が極端な外れ値として「学習なしで予測される」と大きく過小予測されやすい。 これが LOOCV の透明性の利点。

📈 学習曲線と検証曲線 — CV を可視化する

学習曲線 (Learning Curve) は「データ量を増やすと CV スコアがどう変わるか」、 検証曲線 (Validation Curve) は「ハイパーパラメータを動かすと 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

import os
os.makedirs('outputs', exist_ok=True)  # 保存先のフォルダを作っておく

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

# 学習曲線
train_sizes, train_scores, val_scores = learning_curve(
    Ridge(alpha=1.0), X, y, cv=5,
    train_sizes=np.linspace(0.2, 1.0, 5),
    scoring='neg_root_mean_squared_error',
)
plt.plot(train_sizes, -train_scores.mean(axis=1), 'o-', label='Train RMSE')
plt.plot(train_sizes, -val_scores.mean(axis=1), 's-', label='CV RMSE')
plt.xlabel('学習サンプル数'); plt.ylabel('RMSE'); plt.legend()
plt.title('Learning Curve - SSDSE-B Ridge')
plt.savefig('outputs/learning_curve.png', dpi=120)

# 検証曲線(alpha を変化)
param_range = np.logspace(-3, 3, 7)
train_s, val_s = validation_curve(
    Ridge(), X, y, param_name='alpha', param_range=param_range,
    cv=5, scoring='neg_root_mean_squared_error',
)
plt.figure()
plt.semilogx(param_range, -train_s.mean(axis=1), 'o-', label='Train')
plt.semilogx(param_range, -val_s.mean(axis=1), 's-', label='CV')
plt.xlabel('alpha (正則化強度)'); plt.ylabel('RMSE'); plt.legend()
plt.title('Validation Curve - Ridge alpha')
plt.savefig('outputs/validation_curve.png', dpi=120)

学習曲線で「データを増やせば改善するか」が判定できる。 検証曲線でハイパーパラメータの良い値域が見える。

🗺 概念マップ — 交差検証の位置づけ

                  ┌─────────────────────────┐
                  │  モデル選択の枠組み(Model Selection) │
                  └────────────┬────────────────┘
                               │
            ┌──────────────────┼──────────────────┐
            ▼                  ▼                  ▼
       ┌─────────┐        ┌─────────┐        ┌─────────┐
       │ AIC/BIC │        │ Hold-out│        │   CV    │
       │  情報量   │        │ (1回分割) │        │ (k回分割)│
       └─────────┘        └─────────┘        └────┬────┘
                                                   │
                  ┌────────────────┬───────────────┼────────────┐
                  ▼                ▼               ▼            ▼
            ┌─────────┐    ┌─────────┐   ┌─────────────┐ ┌────────┐
            │ k-Fold  │    │ LOOCV   │   │Stratified k │ │Group K │
            │ (k=5,10)│    │ (k=n)   │   │  (分類用)    │ │(個人別) │
            └─────────┘    └─────────┘   └─────────────┘ └────────┘
                                                              │
                                                              ▼
                                                       ┌──────────┐
                                                       │TimeSeries│
                                                       │  (時系列)  │
                                                       └──────────┘

   応用:
     - ハイパーパラメータ調整 ← GridSearchCV
     - モデル比較           ← Nested CV
     - 予測値の集約          ← cross_val_predict (OOF)
  

🔗 隣接手法への橋渡し

交差検証は単純分割の上位、 ハイパラ調整の前処理として機能する。 本章では「接続 (どこから繋がるか)」「統合 (どう組み合わせるか)」「比較 (何と使い分けるか)」の 3 視点で隣接手法を整理する。

① 接続: CV を巡る上流・下流の関係

CV は train/test 分割の発展形であり、 ハイパラ調整・モデル選択・性能報告の中核をなす。

• 上流: 訓練・テスト分割 — 単純 holdout の「データ使用効率の低さ」「fold バリエーション不足」を補うのが CV。 適用シーン: n=200 で 1 回 holdout だと評価分散が大きい時。
• 上流 2: 層化抽出 — クラス比率を fold 間で揃え、 不均衡データでの評価安定化。
• 並列: ブートストラップ — 復元抽出で標本を増やす別系統の汎化推定。 OOB スコアは CV に類似。
• 下流: ハイパラ調整 — CV スコアを目的関数とする grid / Bayes 探索。
• 下流 2: モデル選択 — 異種モデル (線形 / 木 / NN) の CV スコアを比較して最終モデル決定。
• 下流 3: 信頼区間 — fold ごとのスコアから mean ± 1.96σ/√k で性能の不確実性を報告。

② 統合: CV を組み込んだ実務パイプライン

CV 単独より、 前処理・特徴量選択・ハイパラ探索とパイプライン化した時に真価を発揮する。 SSDSE-B 規模の中規模データでの定番ワークフロー 3 種。

③ 比較: CV vs 隣接評価法の使い分け判断

「CV を回すべきか、 holdout で十分か、 bootstrap が向くか」の判断基準。 実務で迷うポイントを比較表に整理。