Day 102 — アンサンブル①（Averaging）— Simple Average・Rank Average・重み最適化

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

🧩 Averagingの3つの原則

🎯 問題

銀行の顧客離反予測（Churn予測）の合成データを使います。年齢×契約商品数、契約期間×契約商品数にあえて非線形な相互作用を仕込み、線形モデルと木ベースのモデルが互いに異なる間違え方をするように設計しています。

import numpy as np
import pandas as pd

np.random.seed(42)
n = 2000

age = np.random.normal(40, 12, n).clip(18, 80)
income = np.random.lognormal(10.5, 0.4, n)
tenure_months = np.random.exponential(24, n).clip(0, 120)
num_products = np.random.randint(1, 5, n)      # 1〜4種類の契約商品数
is_active = np.random.binomial(1, 0.6, n)      # アクティブ顧客フラグ

logit = (
    -0.05 * age
    + 0.00003 * income
    - 0.03 * tenure_months
    - 1.2 * is_active
    + 2.2 * ((age > 55) & (num_products == 1)).astype(float)      # 高齢×契約1種類 → 離反しやすい（非線形）
    + 2.0 * ((tenure_months < 6) & (num_products >= 3)).astype(float)  # 新規×多契約 → 離反しやすい（非線形）
    + np.random.normal(0, 0.5, n)
)
prob = 1 / (1 + np.exp(-logit))
churn = np.random.binomial(1, prob)

df = pd.DataFrame({
    'Age': age, 'Income': income, 'TenureMonths': tenure_months,
    'NumProducts': num_products, 'IsActive': is_active, 'Churn': churn,
})

タスク

🔀 Averagingの全体フロー

モデルの中身には一切触れず、3モデルそれぞれの「出力（予測確率）」だけを混ぜ合わせる。混ぜ方が3種類（Simple / Rank / 重み最適化）ある。

📊 AUC比較（実行結果）

実際にコードを実行して得た値（乱数シード固定・環境により多少前後する）。バーの軸は差を見やすくするため0.70始まり（切り捨て軸）。多様性のあるモデルを混ぜると、単独最強モデルより改善する。

モデル間の予測相関（実行結果）: LogisticRegression–GradientBoosting = 0.735（最も低い＝多様性が高い）、RandomForest–GradientBoosting = 0.877（最も高い＝似た間違え方をしがち）。相関が低い組み合わせほどAveragingの改善幅が大きい。

💡 ヒント

from sklearn.base import clone
from sklearn.model_selection import KFold
from sklearn.metrics import roc_auc_score
from scipy.stats import rankdata

def get_oof_proba(model, X, y, n_splits=5, random_state=42):
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=random_state)
    oof = np.zeros(len(X))
    for tr_idx, val_idx in kf.split(X):
        m = clone(model)
        m.fit(X[tr_idx], y[___])
        oof[val_idx] = m.predict_proba(X[val_idx])[:, ___]
    return oof

# タスク2: 3モデルのOOF予測
oof_preds = {}
for name, model in models.items():
    oof_preds[name] = get_oof_proba(___, X, y)
    print(name, roc_auc_score(y, oof_preds[name]))

# タスク3: Simple Average
simple_avg = np.mean(list(oof_preds.values()), axis=___)

# タスク4: Rank Average
def to_rank01(pred):
    return (rankdata(pred) - 1) / (len(pred) - ___)

rank_avg = np.mean([to_rank01(p) for p in oof_preds.values()], axis=0)

# タスク5: 重み最適化（グリッドサーチ）
best_auc, best_weights = -1, None
for w1 in np.arange(0, 1.01, 0.05):
    for w2 in np.arange(0, 1.01 - w1, 0.05):
        w3 = 1 - w1 - w2
        blend = w1 * oof_preds['LogisticRegression'] + w2 * oof_preds['RandomForest'] + w3 * oof_preds['___']
        auc = roc_auc_score(y, blend)
        if auc > best_auc:
            best_auc, best_weights = auc, (w1, w2, w3)

✅ 模範解答

import numpy as np
import pandas as pd
from sklearn.base import clone
from sklearn.model_selection import KFold
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score
from scipy.stats import rankdata

# ====== データ準備（Churn予測、非線形な相互作用を仕込んだ合成データ） ======
np.random.seed(42)
n = 2000
# age / income / tenure_months / num_products / is_active は上記と同一（省略）

logit = (
    -0.05 * age + 0.00003 * income - 0.03 * tenure_months - 1.2 * is_active
    + 2.2 * ((age > 55) & (num_products == 1)).astype(float)
    + 2.0 * ((tenure_months < 6) & (num_products >= 3)).astype(float)
    + np.random.normal(0, 0.5, n)
)
prob = 1 / (1 + np.exp(-logit))
churn = np.random.binomial(1, prob)

df = pd.DataFrame({'Age': age, 'Income': income, 'TenureMonths': tenure_months,
                    'NumProducts': num_products, 'IsActive': is_active, 'Churn': churn})

FEATURES = ['Age', 'Income', 'TenureMonths', 'NumProducts', 'IsActive']
X = df[FEATURES].values
y = df['Churn'].values

# ====== タスク2: 3モデルのOOF予測確率を作成 ======
def get_oof_proba(model, X, y, n_splits=5, random_state=42):
    """5-Fold CVで、まだ見ていないFoldの予測確率だけを集めてOOF配列を作る"""
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=random_state)
    oof = np.zeros(len(X))
    for tr_idx, val_idx in kf.split(X):
        m = clone(model)  # 前Foldの学習状態を持ち越さないよう、毎回まっさらなモデルを作る
        m.fit(X[tr_idx], y[tr_idx])
        oof[val_idx] = m.predict_proba(X[val_idx])[:, 1]
    return oof

models = {
    'LogisticRegression': make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
    'RandomForest': RandomForestClassifier(n_estimators=200, max_depth=5, random_state=42),
    'GradientBoosting': GradientBoostingClassifier(n_estimators=150, max_depth=3, random_state=42),
}

oof_preds = {}
print("--- タスク2: モデルごとのOOF AUC ---")
for name, model in models.items():
    oof_preds[name] = get_oof_proba(model, X, y)
    auc = roc_auc_score(y, oof_preds[name])
    print(f"  {name:20s}: AUC = {auc:.4f}")

corr = pd.DataFrame(oof_preds).corr()  # 多様性の目安（低いほど良い）

# ====== タスク3: Simple Average ======
simple_avg = np.mean(list(oof_preds.values()), axis=0)
simple_avg_auc = roc_auc_score(y, simple_avg)

# ====== タスク4: Rank Average ======
def to_rank01(pred):
    """予測値を0〜1の順位（パーセンタイル）に変換する"""
    return (rankdata(pred) - 1) / (len(pred) - 1)

rank_preds = {name: to_rank01(p) for name, p in oof_preds.items()}
rank_avg = np.mean(list(rank_preds.values()), axis=0)
rank_avg_auc = roc_auc_score(y, rank_avg)

print(f"\nSimple Average AUC : {simple_avg_auc:.4f}")
print(f"Rank Average AUC   : {rank_avg_auc:.4f}")

# ====== タスク5: 重み最適化（グリッドサーチ、w1+w2+w3=1, w>=0） ======
model_names = list(oof_preds.keys())
best_auc, best_weights = -1.0, None
step = 0.05
for w1 in np.arange(0, 1.0001, step):
    for w2 in np.arange(0, 1.0001 - w1, step):
        w3 = 1 - w1 - w2
        if w3 < -1e-9:
            continue
        w3 = max(w3, 0.0)
        blend = (w1 * oof_preds[model_names[0]]
                 + w2 * oof_preds[model_names[1]]
                 + w3 * oof_preds[model_names[2]])
        auc = roc_auc_score(y, blend)
        if auc > best_auc:
            best_auc, best_weights = auc, (round(w1,2), round(w2,2), round(w3,2))

print(f"\n最適重み {dict(zip(model_names, best_weights))}")
print(f"重み最適化後のAUC: {best_auc:.4f}")

出力イメージ（実際に実行して確認した値。乱数・環境により多少前後する）:

--- タスク2: モデルごとのOOF AUC ---
  LogisticRegression  : AUC = 0.7305   ← 非線形な相互作用を拾えず、やや弱い
  RandomForest        : AUC = 0.7480
  GradientBoosting    : AUC = 0.7433

Simple Average AUC : 0.7539  ← 個別最強モデル(RandomForest)より改善
Rank Average AUC   : 0.7540  ← Simple Averageとほぼ同等〜わずかに良い

最適重み {'LogisticRegression': 0.25, 'RandomForest': 0.55, 'GradientBoosting': 0.2}
重み最適化後のAUC: 0.7547  ← 3手法の中で最良（ただし選択バイアスに注意）

🪜 Step-by-Step 解説

1あえて「多様性」が生まれるデータを設計する

logit = (
    ...
    + 2.2 * ((age > 55) & (num_products == 1)).astype(float)
    + 2.0 * ((tenure_months < 6) & (num_products >= 3)).astype(float)
    + ...
)

2clone()で毎Fold「まっさら」なモデルを使う

m = clone(model)
m.fit(X[tr_idx], y[tr_idx])

3Simple Averageは「まず最初に試す」ベースライン

simple_avg = np.mean(list(oof_preds.values()), axis=0)

4Rank Averageで「スケールの違い」を無効化する

def to_rank01(pred):
    return (rankdata(pred) - 1) / (len(pred) - 1)

5重みは「非負・合計1」のグリッドで探す

for w1 in np.arange(0, 1.0001, step):
    for w2 in np.arange(0, 1.0001 - w1, step):
        w3 = 1 - w1 - w2
        ...

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

数式を見たら

🏆 Kaggleでの実践的な使い方

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

• AUC系コンペでのRank Average: IEEE-CIS Fraud Detection・Home Credit Default Riskなど、AUCで評価される不正検知・与信系コンペの上位解法では「複数モデルのOOF/テスト予測をRank Averageでブレンドした」という記述が非常に頻繁に登場する
• 「公開Notebookのサブミッションをブレンドする」戦略: モデルの中身が分からない公開カーネルのサブミッションCSVでも、予測値だけがあればRank Average/Simple Averageで自分のモデルと混ぜられる。Kaggle特有の実務的なテクニック
• 相関行列によるモデル選定: 今日のコードのcorr()のように、アンサンブルに加える前に各モデルのOOF予測どうしの相関を確認し、相関が高すぎるモデルは候補から外す・重みを下げるのが上位陣の定石
• 重み最適化の発展形: モデル数が増えるとscipy.optimize.minimize（method='SLSQP'、等式制約Σw=1を指定）や、Optunaで重みを探索する手法もよく使われる

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: w≥0の非負制約を外し負の重みを許した場合にOOF AUCがどう変化するか、また未知データ（別シードのhold-out）で評価するとどうなるかを比較してみる
• 次回予告: Day 103「アンサンブル②（Stacking）」 — Level-1/Level-2・リーク防止。今日は「予測を単純に混ぜる」ところまでだったが、次回は「予測を新しい特徴量として、別のモデル（メタモデル）に学習させる」スタッキングに進む

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