Day 100 — 高度なTargetEncoding — LeaveOneOut・Smoothing係数最適化

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

🧩 今日の2つの発展ポイント

🎯 問題

Day 076 と全く同じ合成データ（House Prices風、Neighborhood 25種類・出現数が極端に偏る）を使います。同じデータに対して、より高度なLOO + SmoothingのTargetEncodingを実装し、Day 076の手法と直接比較します。

import numpy as np
import pandas as pd

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と同一

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)

タスク

⚠️ なぜ出現数1件のカテゴリが自動的に global_mean になるのか

smoothed_loo_i = (group_sum - y_i + k×global_mean) / (group_count - 1 + k) に、出現数1件（group_count=1）を代入すると、特別な分岐を書かなくても式が自然に収束する。

📊 4手法のRMSE比較（イメージ）

実際の数値は乱数・データに依存するため、ここでは相対的な傾向のイメージを示す。ナイーブTEはリークにより見かけ上小さく出るが信用できない点に注意。

💡 ヒント

group_sum = df.groupby('Neighborhood')['SalePrice'].transform('sum')
group_count = df.groupby('Neighborhood')['SalePrice'].transform('count')
global_mean = df['SalePrice'].mean()

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

df['te_loo_k0']  = smoothed_loo_te(df['SalePrice'], group_sum, group_count, global_mean, k=___)
df['te_loo_k10'] = smoothed_loo_te(df['SalePrice'], group_sum, group_count, global_mean, k=___)

# タスク3: Optunaでkを探索
import optuna

def objective(trial):
    k = trial.suggest_float("k", ___, ___, log=True)
    te = smoothed_loo_te(df['SalePrice'], group_sum, group_count, global_mean, k)
    X = te.values.reshape(-1, 1)
    y = df['SalePrice'].values
    kf = KFold(n_splits=5, shuffle=True, random_state=42)
    scores = cross_val_score(LinearRegression(), X, y, cv=kf, scoring=___)
    return -scores.mean()

study = optuna.create_study(direction=___)
study.optimize(objective, n_trials=30)

✅ 模範解答

import numpy as np
import pandas as pd
import optuna
from sklearn.model_selection import KFold, cross_val_score
from sklearn.linear_model import LinearRegression

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

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)

global_mean = df['SalePrice'].mean()
group_sum = df.groupby('Neighborhood')['SalePrice'].transform('sum')
group_count = df.groupby('Neighborhood')['SalePrice'].transform('count')

# ====== タスク2: Smoothed LOO Target Encoding（ベクトル化・ループなし） ======
def smoothed_loo_te(y, group_sum, group_count, global_mean, k):
    """smoothed_loo_i = (group_sum_i - y_i + k*global_mean) / (group_count_i - 1 + k)"""
    return (group_sum - y + k * global_mean) / (group_count - 1 + k)

df['te_loo_k0']  = smoothed_loo_te(df['SalePrice'], group_sum, group_count, global_mean, k=0)
df['te_loo_k10'] = smoothed_loo_te(df['SalePrice'], group_sum, group_count, global_mean, k=10)

print("--- タスク2: Landmrk（出現数1件）でのLOOの挙動 ---")
print(df[df['Neighborhood'] == 'Landmrk'][
    ['Neighborhood', 'SalePrice', 'te_loo_k0', 'te_loo_k10']
])
print(f"te_loo_k0 のNaN件数: {df['te_loo_k0'].isna().sum()} 件")

# ====== タスク3: Optunaでスムージング係数kを最適化 ======
def objective(trial):
    k = trial.suggest_float("k", 1, 300, log=True)
    te = smoothed_loo_te(df['SalePrice'], group_sum, group_count, global_mean, k)
    X = te.values.reshape(-1, 1)
    y = df['SalePrice'].values
    kf = KFold(n_splits=5, shuffle=True, random_state=42)
    scores = cross_val_score(
        LinearRegression(), X, y, cv=kf,
        scoring='neg_root_mean_squared_error'
    )
    return -scores.mean()

optuna.logging.set_verbosity(optuna.logging.WARNING)
study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=30)

best_k = study.best_params['k']
best_rmse = study.best_value
print(f"\nbest_k: {best_k:.1f} / best_rmse: {best_rmse:,.0f}")

df['te_loo_best'] = smoothed_loo_te(df['SalePrice'], group_sum, group_count, global_mean, best_k)

# ====== タスク4: Day076の2手法 + 今日の2手法、計4手法を比較 ======
kf = KFold(n_splits=5, shuffle=True, random_state=42)
model = LinearRegression()
y = df['SalePrice'].values

def cv_rmse(feature_col):
    X = df[[feature_col]].values
    scores = cross_val_score(model, X, y, cv=kf, scoring='neg_root_mean_squared_error')
    return -scores.mean()

df['te_naive'] = df.groupby('Neighborhood')['SalePrice'].transform('mean')

def target_encode_oof_smooth(frame, col, target, n_splits=5, k=10, random_state=42):
    kf_inner = KFold(n_splits=n_splits, shuffle=True, random_state=random_state)
    te_col = np.zeros(len(frame))
    gm = frame[target].mean()
    for train_idx, val_idx in kf_inner.split(frame):
        train_fold = frame.iloc[train_idx]
        val_fold = frame.iloc[val_idx]
        stats = train_fold.groupby(col)[target].agg(['mean', 'count'])
        stats['smoothed'] = (stats['count'] * stats['mean'] + k * gm) / (stats['count'] + k)
        te_col[val_idx] = val_fold[col].map(stats['smoothed']).fillna(gm).values
    return te_col

df['te_oof_smooth10'] = target_encode_oof_smooth(df, 'Neighborhood', 'SalePrice', k=10)

results = {
    "① Naive TE（Day076・参考値）":                       cv_rmse('te_naive'),
    "② OOF K-Fold TE + Smoothing k=10（Day076）":       cv_rmse('te_oof_smooth10'),
    "③ LOO + Smoothing k=10 固定（今日）":                cv_rmse('te_loo_k10'),
    f"④ LOO + Smoothing k={best_k:.0f} Optuna最適化（今日）": cv_rmse('te_loo_best'),
}

print("\n--- タスク4: 4手法のRMSE比較 ---")
for name, rmse in results.items():
    bar = '█' * int(rmse / 3000)
    print(f"  {name:48s}: {rmse:>10,.0f}  {bar}")

🪜 Step-by-Step 解説

1group_sum/group_countを先に作っておく

group_sum = df.groupby('Neighborhood')['SalePrice'].transform('sum')
group_count = df.groupby('Neighborhood')['SalePrice'].transform('count')

2LOOの生の式を組み立てる

loo_i = (group_sum - y) / (group_count - 1)

3Smoothingを1つの式に統合する

(group_sum - y + k * global_mean) / (group_count - 1 + k)

4k=0と出現数1件のカテゴリの相性を確認する

5Optunaでkを探索する

study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=30)

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

数式を見たら

🏆 Kaggleでの実践的な使い方

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

• category_encoders.LeaveOneOutEncoder: 今日実装したロジックをそのまま使えるライブラリ実装。sigmaパラメータで学習データにさらに小さなランダムノイズを加え、出現数の少ないカテゴリでの過学習をさらに抑えられる
• 与信・不正検知コンペ（Home Credit, American Express Default Prediction, IEEE-CIS Fraud Detection）: 顧客ID・カード種別・端末IDなど高カーディナリティな変数が大量にあるコンペでは、K-Fold OOFとLOOの両方を試しCVスコアで採用を決めるのが定石
• Optunaでのkチューニング: LightGBM/XGBoostのハイパーパラメータと同様に、Target Encodingのk自体もOptunaの探索対象に含める上位解法が多い

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: category_encoders.LeaveOneOutEncoder(sigma=0.05)を使い、ノイズ付加ありとなしでCVスコアがどう変わるか比較してみる
• 次回予告: Day 101「NestedCV」 — チューニングとCV評価の分離。今日タスク5で触れた「Optunaで探したkを同じデータで評価してしまう」問題を、外側CVと内側CVを分離することで解消する手法に進みます

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