Day 101 — NestedCV — チューニングとCV評価の分離

📚 背景知識（読んでから問題へ）

🧩 NestedCVの3つの原則

🎯 問題

Day 076・Day 100と全く同じ合成データ（House Prices風、Neighborhood 25種類、Landmrkは出現数1件）を使います。今日はDay 100の「Optunaで探したkのCVスコアをそのまま報告する」やり方（素朴な1段階CV）と、NestedCVで測った公正な性能推定値を直接比較します。

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

np.random.seed(42)
neighborhoods = ['NridgHt', 'Crawfor', 'Mitchel', 'Somerst', 'NWAmes',
                 'OldTown', 'BrkSide', 'Sawyer', 'NAmes', 'SawyerW',
                 'IDOTRR', 'MeadowV', 'Edwards', 'Timber', 'Gilbert',
                 'StoneBr', 'ClearCr', 'NPkVill', 'Blmngtn', 'BrDale',
                 'SWISU', 'Blueste', 'Greens', 'GrnHill', 'Landmrk']

# base_prices（各地区の真のベース価格）・counts（出現数、Landmrkは1件）はDay076・Day100と同一

rows = []
for nbr, cnt, base in zip(neighborhoods, counts, [base_prices[n] for n in neighborhoods]):
    prices = np.random.normal(base, base * 0.15, cnt)
    prices = np.clip(prices, 50000, 700000)
    rows.extend([(nbr, p) for p in prices])

df = pd.DataFrame(rows, columns=['Neighborhood', 'SalePrice'])
df = df.sample(frac=1, random_state=42).reset_index(drop=True)

タスク

🪆 外側CV × 内側CVの入れ子構造

外側テストFold（赤）は、内側CV（緑の内側の箱）の処理に一切登場しない。この「見えない」状態を守ることが、NestedCVが公正である理由のすべて。

📊 NestedCVスコア vs 素朴な1段階CV（イメージ）

実際の数値は乱数・データに依存するため、ここでは相対的な傾向のイメージを示す。素朴な1段階CVはRMSEが小さく（良く）見えるが、これは選択バイアスによる楽観であり信用できない。

外側Foldごとに選ばれるベストkの例（イメージ）: [30, 100, 30, 10, 100] — ばらつきが大きいほど、そのハイパーパラメータの選択自体が不安定であることを示唆する。

💡 ヒント

def smoothed_loo_te(y, group_sum, group_count, global_mean, k):
    return (group_sum - y + k * global_mean) / (group_count - 1 + k)

def fit_apply_smoothed_te(train_df, holdout_df, col, target, k):
    stats = train_df.groupby(col)[target].agg(['mean', 'count'])
    global_mean = train_df[target].mean()
    smoothed_map = (stats['count'] * stats['___'] + k * global_mean) / (stats['count'] + ___)
    return holdout_df[col].map(smoothed_map).fillna(___).values

def inner_cv_best_k(train_df, col, target, k_candidates, n_inner_splits=3, random_state=0):
    inner_kf = KFold(n_splits=___, shuffle=True, random_state=random_state)
    mean_scores = {}
    for k in k_candidates:
        fold_rmses = []
        for tr_idx, val_idx in inner_kf.split(train_df):
            # tr_foldはLOO、val_foldはfit_apply_smoothed_teでエンコード
            ...
        mean_scores[k] = np.mean(fold_rmses)
    best_k = min(mean_scores, key=mean_scores.get)
    return best_k, mean_scores

outer_kf = KFold(n_splits=5, shuffle=True, random_state=1)
outer_scores, outer_best_ks = [], []
for outer_tr_idx, outer_te_idx in outer_kf.split(df):
    outer_train = df.iloc[outer_tr_idx].reset_index(drop=True)
    outer_test = df.iloc[outer_te_idx].reset_index(drop=True)
    best_k, _ = inner_cv_best_k(outer_train, 'Neighborhood', 'SalePrice', ___)
    outer_best_ks.append(best_k)
    # best_kで外側訓練データ全体を学習し、外側テストデータで評価
    ...

✅ 模範解答

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

# ====== データ準備（Day076・Day100と完全同一） ======
np.random.seed(42)
# neighborhoods / base_prices / counts はDay076・Day100と同一（省略）

rows = []
for nbr, cnt, base in zip(neighborhoods, counts, [base_prices[n] for n in neighborhoods]):
    prices = np.random.normal(base, base * 0.15, cnt)
    prices = np.clip(prices, 50000, 700000)
    rows.extend([(nbr, p) for p in prices])

df = pd.DataFrame(rows, columns=['Neighborhood', 'SalePrice'])
df = df.sample(frac=1, random_state=42).reset_index(drop=True)

K_CANDIDATES = [1, 3, 10, 30, 100, 300, 1000]

# ====== タスク2: 訓練統計だけでholdoutをエンコードする関数 ======
def smoothed_loo_te(y, group_sum, group_count, global_mean, k):
    """外側/内側 訓練データ“自身”の特徴量を作るときに使う（Day100と同じ関数）"""
    return (group_sum - y + k * global_mean) / (group_count - 1 + k)

def fit_apply_smoothed_te(train_df, holdout_df, col, target, k):
    """train_dfの統計だけを使い、holdout_dfにSmoothed TEを適用する。holdoutの情報は一切使わない"""
    stats = train_df.groupby(col)[target].agg(['mean', 'count'])
    global_mean = train_df[target].mean()
    smoothed_map = (stats['count'] * stats['mean'] + k * global_mean) / (stats['count'] + k)
    return holdout_df[col].map(smoothed_map).fillna(global_mean).values

def rmse_for_k(train_df, holdout_df, col, target, k):
    """train_dfでLOOエンコード→LinearRegression学習→holdout_dfで評価しRMSEを返す共通処理"""
    tr_group_sum = train_df.groupby(col)[target].transform('sum')
    tr_group_count = train_df.groupby(col)[target].transform('count')
    tr_global_mean = train_df[target].mean()
    tr_te = smoothed_loo_te(train_df[target], tr_group_sum, tr_group_count, tr_global_mean, k)
    ho_te = fit_apply_smoothed_te(train_df, holdout_df, col, target, k)

    model = LinearRegression().fit(tr_te.values.reshape(-1, 1), train_df[target].values)
    pred = model.predict(ho_te.reshape(-1, 1))
    return np.sqrt(mean_squared_error(holdout_df[target].values, pred))

# ====== タスク3: NestedCV（外側5-Fold × 内側3-Fold） ======
def inner_cv_best_k(train_df, col, target, k_candidates, n_inner_splits=3, random_state=0):
    inner_kf = KFold(n_splits=n_inner_splits, shuffle=True, random_state=random_state)
    mean_scores = {k: [] for k in k_candidates}
    for tr_idx, val_idx in inner_kf.split(train_df):
        inner_train = train_df.iloc[tr_idx].reset_index(drop=True)
        inner_val = train_df.iloc[val_idx].reset_index(drop=True)
        for k in k_candidates:
            mean_scores[k].append(rmse_for_k(inner_train, inner_val, col, target, k))
    mean_scores = {k: np.mean(v) for k, v in mean_scores.items()}
    best_k = min(mean_scores, key=mean_scores.get)
    return best_k, mean_scores

outer_kf = KFold(n_splits=5, shuffle=True, random_state=1)
outer_scores, outer_best_ks = [], []

for outer_tr_idx, outer_te_idx in outer_kf.split(df):
    outer_train = df.iloc[outer_tr_idx].reset_index(drop=True)
    outer_test = df.iloc[outer_te_idx].reset_index(drop=True)

    # 内側CV: 外側テストデータには一切触れず、外側訓練データの中だけでkを選ぶ
    best_k, _ = inner_cv_best_k(outer_train, 'Neighborhood', 'SalePrice', K_CANDIDATES)
    outer_best_ks.append(best_k)

    # 選ばれたkで外側訓練データ全体を学習し、初めて外側テストデータで評価する
    rmse = rmse_for_k(outer_train, outer_test, 'Neighborhood', 'SalePrice', best_k)
    outer_scores.append(rmse)

nested_cv_score = np.mean(outer_scores)

print("--- タスク3: NestedCV ---")
print(f"外側Foldごとの選択k : {outer_best_ks}")
print(f"NestedCVスコア（平均）: {nested_cv_score:,.0f}")

# ====== タスク4: 素朴な1段階CV（内側CVを挟まず、そのままベストkのスコアを報告） ======
naive_kf = KFold(n_splits=5, shuffle=True, random_state=1)  # 外側CVと同じ分割方法（比較を公平にするため）
naive_scores = {k: [] for k in K_CANDIDATES}

for tr_idx, te_idx in naive_kf.split(df):
    tr_fold = df.iloc[tr_idx].reset_index(drop=True)
    te_fold = df.iloc[te_idx].reset_index(drop=True)
    for k in K_CANDIDATES:
        naive_scores[k].append(rmse_for_k(tr_fold, te_fold, 'Neighborhood', 'SalePrice', k))

naive_mean_scores = {k: np.mean(v) for k, v in naive_scores.items()}
naive_best_k = min(naive_mean_scores, key=naive_mean_scores.get)
naive_best_rmse = naive_mean_scores[naive_best_k]  # ←これを「性能」として報告するのが素朴なやり方

print("\n--- タスク4: 素朴な1段階CV ---")
print(f"素朴な1段階CVのベストスコア: {naive_best_rmse:,.0f}")
print(f"NestedCVスコア           : {nested_cv_score:,.0f}")
gap = nested_cv_score - naive_best_rmse
print(f"ギャップ（楽観バイアスの目安）: {gap:,.0f}")

出力イメージ（乱数依存のため相対的な傾向として見る）:

--- タスク3: NestedCV ---
外側Foldごとの選択k : [30, 100, 30, 10, 100]
NestedCVスコア（平均）: 1x,xxx

--- タスク4: 素朴な1段階CV ---
素朴な1段階CVのベストスコア: 1x,xxx
NestedCVスコア           : 1x,xxx
ギャップ（楽観バイアスの目安）: xxx  ← NestedCVの方がRMSEが大きい＝素朴な方法は楽観的だった

🪜 Step-by-Step 解説

1「訓練統計だけでholdoutを塗る」関数を独立させる

def fit_apply_smoothed_te(train_df, holdout_df, col, target, k):
    stats = train_df.groupby(col)[target].agg(['mean', 'count'])
    global_mean = train_df[target].mean()
    smoothed_map = (stats['count'] * stats['mean'] + k * global_mean) / (stats['count'] + k)
    return holdout_df[col].map(smoothed_map).fillna(global_mean).values

2訓練データ自身のエンコードにはLOOを使う

tr_te = smoothed_loo_te(train_df[target], tr_group_sum, tr_group_count, tr_global_mean, k)

3内側CVで「外側テストを一切見ずに」kを選ぶ

def inner_cv_best_k(train_df, col, target, k_candidates, n_inner_splits=3, random_state=0):
    inner_kf = KFold(n_splits=n_inner_splits, shuffle=True, random_state=random_state)
    ...

4外側ループで「選ぶ→学習する→初めて見る」を1セットにする

for outer_tr_idx, outer_te_idx in outer_kf.split(df):
    outer_train = df.iloc[outer_tr_idx].reset_index(drop=True)
    outer_test = df.iloc[outer_te_idx].reset_index(drop=True)
    best_k, _ = inner_cv_best_k(outer_train, 'Neighborhood', 'SalePrice', K_CANDIDATES)
    rmse = rmse_for_k(outer_train, outer_test, 'Neighborhood', 'SalePrice', best_k)

5素朴な1段階CVと並べて、ギャップを可視化する

gap = nested_cv_score - naive_best_rmse

🧮 数学・統計の補足（文系向け）

数式を見たら

🏆 Kaggleでの実践的な使い方

よく使われるコンペカテゴリ: ☑ 表形式データ（Tabular） / ☐ 自然言語処理（NLP） / ☐ 画像認識（CV） / ☐ 時系列（Time Series）

• 上位解法の「CV戦略」セクション: Kaggleの上位解法解説記事では必ず「どうCVを組んだか」が説明される。強いチームほど「ハイパーパラメータ探索用のCV」と「モデル選択・最終アンサンブル評価用のCV」を意識的に分けている記述が見られる
• cross_val_score + 手動の外側ループ: sklearnには専用のNestedCV関数はないが、内側CVのobjective関数の中でcross_val_scoreを呼び出し、外側は自前のforループで回すのが定番の書き方（今日のコードもこのパターン）
• Optunaでの実務的な妥協: フルNestedCVは重すぎるため、実務では「train/validで探索、held-out testで1回だけ最終確認」という簡略版がよく使われる。これは「内側CV1本・外側Fold1本」に相当するNestedCVの最小構成と見ることができる
• 時系列コンペでの重要性: 時系列データ（Day 099のRolling/Lag特徴量が絡むコンペ）では、外側・内側のいずれも「未来のデータで訓練しない」時系列分割（TimeSeriesSplit）にする必要があり、通常のKFold以上にリーク対策が絡み合う

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: 内側CVの中身をグリッドサーチではなくOptuna（n_trials=20程度）に置き換え、より広いk候補・計算コストの増加を体感してみる
• 次回予告: Day 102「アンサンブル①（Averaging）」 — 複数モデルの予測を組み合わせるSimple Average・Rank Average・重み最適化。今日まで1つのモデルの中でのチューニングを厳密化してきましたが、次は「複数のモデルをどう組み合わせるか」という新しいテーマに進みます

📝 自己評価（解いた後に記入）