Day 064 — Optuna ハイパーパラメータ最適化 — GBDTの自動チューニング（XGBoost / LightGBM / CatBoost）

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

なぜハイパーパラメータのチューニングが必要か？

チューニング手法の比較

🔄 Optuna の仕組み — study / trial / objective

🎛️ suggest_* メソッド一覧とパラメータ対応

🧠 ベイズ最適化の直感 — 賢く山の頂上を探す

📊 対数スケール vs 線形スケール — なぜ log=True が必要か

チューニング効果の目安（Titanic Accuracy）

🗂️ データスキーマ（Titanic 風 n=5,000）

📝 問題

セットアップコード（最初に実行）

📋 コピーimport numpy as np
import pandas as pd
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder
import warnings
warnings.filterwarnings('ignore')

try:
    import optuna
    optuna.logging.set_verbosity(optuna.logging.WARNING)
    print("Optuna: OK")
except ImportError:
    print("pip install optuna")

try:
    import xgboost as xgb
    print("XGBoost: OK")
except ImportError:
    print("pip install xgboost")

try:
    import lightgbm as lgb
    print("LightGBM: OK")
except ImportError:
    print("pip install lightgbm")

try:
    from catboost import CatBoostClassifier
    print("CatBoost: OK")
except ImportError:
    print("pip install catboost")

# Titanic 風データ生成（n=5000）
np.random.seed(42)
n = 5000
data = pd.DataFrame({
    'Pclass':     np.random.choice([1, 2, 3], n, p=[0.24, 0.21, 0.55]),
    'Sex':        np.random.choice(['male', 'female'], n, p=[0.65, 0.35]),
    'Age':        np.random.normal(29.7, 14.5, n).clip(1, 80),
    'SibSp':      np.random.choice(range(9), n, p=[0.68,0.23,0.04,0.02,0.01,0.01,0.005,0.005,0.01]),
    'Parch':      np.random.choice(range(7), n, p=[0.76,0.13,0.09,0.005,0.005,0.005,0.005]),
    'Fare':       np.abs(np.random.normal(32, 50, n)),
    'Embarked':   np.random.choice(['S', 'C', 'Q'], n, p=[0.72, 0.19, 0.09]),
    'Cabin_type': np.random.choice(['A','B','C','D','E','None'], n,
                                   p=[0.05,0.08,0.12,0.1,0.07,0.58]),
})
data['Survived'] = (
    (data['Sex'] == 'female') * 0.55 + (data['Pclass'] == 1) * 0.25 +
    (data['Age'] < 16) * 0.2 + np.random.normal(0, 0.12, n)
) > 0.4
data['Survived'] = data['Survived'].astype(int)

cat_cols = ['Sex', 'Embarked', 'Cabin_type']
data_enc = data.copy()
for col in cat_cols:
    data_enc[col] = LabelEncoder().fit_transform(data_enc[col])

features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked', 'Cabin_type']
X_raw = data[features]
X_enc = data_enc[features].values
y     = data['Survived'].values
cv    = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

def manual_cv_score(clf, X, y, cv):
    scores = []
    for tr_idx, val_idx in cv.split(X, y):
        if isinstance(X, pd.DataFrame):
            X_tr, X_val = X.iloc[tr_idx], X.iloc[val_idx]
        else:
            X_tr, X_val = X[tr_idx], X[val_idx]
        y_tr, y_val = y[tr_idx], y[val_idx]
        clf.fit(X_tr, y_tr)
        scores.append(accuracy_score(y_val, clf.predict(X_val)))
    return float(np.mean(scores))

print("データ準備完了:", X_raw.shape)

問1 — XGBoost の Optuna チューニング（基本）

1. objective(trial) 関数を定義し、以下のパラメータを最適化せよ
   • n_estimators: 100〜1000（整数）
   • max_depth: 3〜10（整数）
   • learning_rate: 0.01〜0.3（対数スケール浮動小数点）
   • subsample: 0.5〜1.0（浮動小数点）
   • colsample_bytree: 0.5〜1.0（浮動小数点）
2. study.optimize(objective, n_trials=30) で最適化を実行せよ
3. study.best_params と study.best_value を表示せよ
4. デフォルトパラメータとの精度差を表示せよ

問2 — LightGBM の Optuna チューニング

1. LightGBM 向けの objective 関数を定義し、以下を最適化せよ
   • n_estimators: 100〜1000（整数）
   • num_leaves: 20〜300（整数）
   • learning_rate: 0.01〜0.3（対数スケール）
   • min_child_samples: 5〜100（整数）
   • reg_alpha: 0.0〜1.0（浮動小数点）
   • reg_lambda: 0.0〜10.0（浮動小数点）
2. n_trials=30 で最適化し、best_params と best_value を表示せよ
3. デフォルトパラメータとの精度差を表示せよ

問3 — CatBoost の Optuna チューニング

1. CatBoost 向けの objective 関数を定義し、以下を最適化せよ
   • iterations: 100〜500（整数）
   • depth: 4〜10（整数）
   • learning_rate: 0.01〜0.3（対数スケール）
   • l2_leaf_reg: 1.0〜30.0（対数スケール）
2. cat_features=['Sex','Embarked','Cabin_type'] を使用すること
3. n_trials=20 で最適化（CatBoostは遅いため少なめ）し、結果を表示せよ

問4 — 最適化の履歴を可視化（matplotlib）

1. 問1 の study オブジェクトを使い、試行ごとのスコア推移を折れ線グラフで描画せよ
2. 各試行の累積最良スコア（cumulative best）も一緒にプロットせよ
3. グラフのタイトルと軸ラベル、凡例を設定せよ

問5 — パラメータ重要度分析

1. optuna.importance.get_param_importances(study) で問1 のパラメータ重要度を取得せよ
2. 棒グラフで可視化せよ
3. どのパラメータが XGBoost のスコアに最も影響を与えるか考察せよ

💡 ヒント

📋 コピーimport optuna

def objective_xgb(trial):
    params = {
        'n_estimators':     trial.suggest_int('n_estimators', 100, 1000),
        'max_depth':        trial.suggest_int('max_depth', 3, 10),
        'learning_rate':    trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'subsample':        trial.suggest_float('subsample', 0.5, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        'random_state': 42,
        'eval_metric': 'logloss',
    }
    clf = xgb.XGBClassifier(**params)
    score = cross_val_score(clf, X_enc, y, cv=cv, scoring='accuracy').mean()
    return score

study_xgb = optuna.create_study(direction='maximize')
study_xgb.optimize(objective_xgb, n_trials=30)
print(f"Best: {study_xgb.best_value:.4f}")
print(study_xgb.best_params)

📋 コピー# パラメータ重要度
from optuna.importance import get_param_importances

importances = get_param_importances(study_xgb)
print(importances)

# 可視化
import matplotlib.pyplot as plt

# 試行スコア推移
scores = [t.value for t in study_xgb.trials]
best_so_far = [max(scores[:i+1]) for i in range(len(scores))]

plt.figure(figsize=(10, 4))
plt.plot(scores, alpha=0.5, label='各試行スコア')
plt.plot(best_so_far, color='red', label='累積最良スコア')
plt.xlabel('試行番号')
plt.ylabel('CV Accuracy')
plt.title('XGBoost Optuna 最適化 — スコア推移')
plt.legend()
plt.tight_layout()
plt.show()

# 棒グラフ（重要度）
plt.figure(figsize=(8, 4))
plt.barh(list(importances.keys()), list(importances.values()))
plt.xlabel('重要度スコア')
plt.title('パラメータ重要度')
plt.tight_layout()
plt.show()

✅ 模範解答

📋 コピーimport numpy as np
import pandas as pd
import optuna
import xgboost as xgb
import lightgbm as lgb
from catboost import CatBoostClassifier
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
from optuna.importance import get_param_importances
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
optuna.logging.set_verbosity(optuna.logging.WARNING)

# ── データ準備 ──
np.random.seed(42)
n = 5000
data = pd.DataFrame({
    'Pclass':     np.random.choice([1, 2, 3], n, p=[0.24, 0.21, 0.55]),
    'Sex':        np.random.choice(['male', 'female'], n, p=[0.65, 0.35]),
    'Age':        np.random.normal(29.7, 14.5, n).clip(1, 80),
    'SibSp':      np.random.choice(range(9), n, p=[0.68,0.23,0.04,0.02,0.01,0.01,0.005,0.005,0.01]),
    'Parch':      np.random.choice(range(7), n, p=[0.76,0.13,0.09,0.005,0.005,0.005,0.005]),
    'Fare':       np.abs(np.random.normal(32, 50, n)),
    'Embarked':   np.random.choice(['S', 'C', 'Q'], n, p=[0.72, 0.19, 0.09]),
    'Cabin_type': np.random.choice(['A','B','C','D','E','None'], n,
                                   p=[0.05,0.08,0.12,0.1,0.07,0.58]),
})
data['Survived'] = (
    (data['Sex'] == 'female') * 0.55 + (data['Pclass'] == 1) * 0.25 +
    (data['Age'] < 16) * 0.2 + np.random.normal(0, 0.12, n)
) > 0.4
data['Survived'] = data['Survived'].astype(int)

cat_cols = ['Sex', 'Embarked', 'Cabin_type']
data_enc = data.copy()
for col in cat_cols:
    data_enc[col] = LabelEncoder().fit_transform(data_enc[col])

features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked', 'Cabin_type']
X_raw = data[features]
X_enc = data_enc[features].values
y     = data['Survived'].values
cv    = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

def manual_cv_score(clf, X, y, cv):
    scores = []
    for tr_idx, val_idx in cv.split(X, y):
        if isinstance(X, pd.DataFrame):
            X_tr, X_val = X.iloc[tr_idx], X.iloc[val_idx]
        else:
            X_tr, X_val = X[tr_idx], X[val_idx]
        y_tr, y_val = y[tr_idx], y[val_idx]
        clf.fit(X_tr, y_tr)
        scores.append(accuracy_score(y_val, clf.predict(X_val)))
    return float(np.mean(scores))

# ── 問1: XGBoost ──
print("=" * 65)
print("問1: XGBoost Optuna チューニング")
print("=" * 65)

default_xgb_score = cross_val_score(
    xgb.XGBClassifier(random_state=42, eval_metric='logloss'),
    X_enc, y, cv=cv, scoring='accuracy'
).mean()
print(f"デフォルト XGBoost CV: {default_xgb_score:.4f}")

def objective_xgb(trial):
    params = {
        'n_estimators':     trial.suggest_int('n_estimators', 100, 1000),
        'max_depth':        trial.suggest_int('max_depth', 3, 10),
        'learning_rate':    trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'subsample':        trial.suggest_float('subsample', 0.5, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        'random_state': 42, 'eval_metric': 'logloss',
    }
    clf = xgb.XGBClassifier(**params)
    return cross_val_score(clf, X_enc, y, cv=cv, scoring='accuracy').mean()

study_xgb = optuna.create_study(direction='maximize')
study_xgb.optimize(objective_xgb, n_trials=30)
print(f"最適化 XGBoost CV: {study_xgb.best_value:.4f}")
print(f"改善幅: {study_xgb.best_value - default_xgb_score:+.4f}")
print("最良パラメータ:")
for k, v in study_xgb.best_params.items():
    print(f"  {k}: {v}")

# ── 問2: LightGBM ──
print("\n" + "=" * 65)
print("問2: LightGBM Optuna チューニング")
print("=" * 65)

default_lgb_score = cross_val_score(
    lgb.LGBMClassifier(random_state=42, verbose=-1),
    X_enc, y, cv=cv, scoring='accuracy'
).mean()
print(f"デフォルト LightGBM CV: {default_lgb_score:.4f}")

def objective_lgb(trial):
    params = {
        'n_estimators':      trial.suggest_int('n_estimators', 100, 1000),
        'num_leaves':        trial.suggest_int('num_leaves', 20, 300),
        'learning_rate':     trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),
        'reg_alpha':         trial.suggest_float('reg_alpha', 0.0, 1.0),
        'reg_lambda':        trial.suggest_float('reg_lambda', 0.0, 10.0),
        'random_state': 42, 'verbose': -1,
    }
    clf = lgb.LGBMClassifier(**params)
    return cross_val_score(clf, X_enc, y, cv=cv, scoring='accuracy').mean()

study_lgb = optuna.create_study(direction='maximize')
study_lgb.optimize(objective_lgb, n_trials=30)
print(f"最適化 LightGBM CV: {study_lgb.best_value:.4f}")
print(f"改善幅: {study_lgb.best_value - default_lgb_score:+.4f}")
print("最良パラメータ:")
for k, v in study_lgb.best_params.items():
    print(f"  {k}: {v}")

# ── 問3: CatBoost ──
print("\n" + "=" * 65)
print("問3: CatBoost Optuna チューニング")
print("=" * 65)

default_cat_score = manual_cv_score(
    CatBoostClassifier(iterations=200,
                       cat_features=['Sex','Embarked','Cabin_type'],
                       random_seed=42, verbose=0),
    X_raw, y, cv
)
print(f"デフォルト CatBoost CV: {default_cat_score:.4f}")

def objective_cat(trial):
    params = {
        'iterations':    trial.suggest_int('iterations', 100, 500),
        'depth':         trial.suggest_int('depth', 4, 10),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'l2_leaf_reg':   trial.suggest_float('l2_leaf_reg', 1.0, 30.0, log=True),
        'cat_features': ['Sex', 'Embarked', 'Cabin_type'],
        'random_seed': 42, 'verbose': 0,
    }
    clf = CatBoostClassifier(**params)
    return manual_cv_score(clf, X_raw, y, cv)

study_cat = optuna.create_study(direction='maximize')
study_cat.optimize(objective_cat, n_trials=20)
print(f"最適化 CatBoost CV: {study_cat.best_value:.4f}")
print(f"改善幅: {study_cat.best_value - default_cat_score:+.4f}")
print("最良パラメータ:")
for k, v in study_cat.best_params.items():
    print(f"  {k}: {v}")

# ── 問4: スコア推移可視化 ──
print("\n" + "=" * 65)
print("問4: スコア推移可視化")
print("=" * 65)

scores = [t.value for t in study_xgb.trials]
best_so_far = [max(scores[:i+1]) for i in range(len(scores))]

plt.figure(figsize=(10, 4))
plt.plot(scores, alpha=0.4, marker='o', markersize=4, label='各試行スコア', color='#38bdf8')
plt.plot(best_so_far, color='#f0c419', linewidth=2, label='累積最良スコア')
plt.axhline(default_xgb_score, color='#ef4444', linestyle='--', linewidth=1,
            label=f'デフォルト ({default_xgb_score:.4f})')
plt.xlabel('試行番号')
plt.ylabel('CV Accuracy (5-Fold)')
plt.title('XGBoost Optuna 最適化 — スコア推移 (n_trials=30)')
plt.legend()
plt.tight_layout()
plt.show()

# ── 問5: パラメータ重要度 ──
print("\n" + "=" * 65)
print("問5: パラメータ重要度分析")
print("=" * 65)

importances = get_param_importances(study_xgb)
print("パラメータ重要度:")
for k, v in importances.items():
    bar = "█" * int(v * 40)
    print(f"  {k:20s}: {v:.4f} {bar}")

plt.figure(figsize=(8, 4))
params_list = list(importances.keys())
values_list = list(importances.values())
colors = ['#22c55e' if v == max(values_list) else '#38bdf8' for v in values_list]
plt.barh(params_list, values_list, color=colors)
plt.xlabel('重要度スコア')
plt.title('XGBoost ハイパーパラメータ重要度 (Optuna)')
plt.tight_layout()
plt.show()

max_param = max(importances, key=importances.get)
print(f"\n考察: 最重要パラメータは '{max_param}'")
print("→ このパラメータのチューニングに注力すると効率的にスコアが改善できる")

🪜 Step-by-Step 解説

1Optuna の基本概念 — study と trial

📋 コピーimport optuna
optuna.logging.set_verbosity(optuna.logging.WARNING)  # ログ抑制（必須）

# study = 1回の最適化セッション（記録帳）
study = optuna.create_study(direction='maximize')  # スコアを最大化

# trial = 1回の試行（パラメータ1セットの実験）
# objective 関数内で trial.suggest_* を使う

study は「最適化の記録帳」、trial は「今回試す1つの実験」のイメージ。direction='maximize' でスコアを上げる方向に最適化。

2suggest_* の使い分け

📋 コピーdef objective(trial):
    # 整数: n_estimators, max_depth, num_leaves など
    n = trial.suggest_int('n_estimators', 100, 1000)

    # 浮動小数点（線形スケール）: subsample, colsample_bytree など
    sub = trial.suggest_float('subsample', 0.5, 1.0)

    # 浮動小数点（対数スケール）: learning_rate, l2 正則化係数
    # → 0.001 〜 0.1 のような小さい値の探索に使う
    lr = trial.suggest_float('learning_rate', 0.01, 0.3, log=True)

    # カテゴリ選択
    booster = trial.suggest_categorical('booster', ['gbtree', 'dart'])

3CatBoost の注意点 — cross_val_score が使えない問題

📋 コピー# NG: cross_val_score は cat_features を保持しない
score = cross_val_score(
    CatBoostClassifier(cat_features=['Sex', ...], verbose=0),
    X_raw, y, cv=cv
).mean()  # エラーまたは精度が低い

# OK: 手動CVで DataFrame を iloc でスライスする
def manual_cv_score(clf, X, y, cv):
    scores = []
    for tr_idx, val_idx in cv.split(X, y):
        X_tr, X_val = X.iloc[tr_idx], X.iloc[val_idx]
        y_tr, y_val = y[tr_idx], y[val_idx]
        clf.fit(X_tr, y_tr)
        scores.append(accuracy_score(y_val, clf.predict(X_val)))
    return np.mean(scores)

4累積最良スコアの計算

📋 コピーscores = [t.value for t in study.trials]
# t.value = その試行のスコア

best_so_far = [max(scores[:i+1]) for i in range(len(scores))]
# i 番目まで（含む）のスコアの最大値
# → グラフにすると「何回目でベストが更新されたか」が一目でわかる

5パラメータ重要度の読み方

📋 コピーfrom optuna.importance import get_param_importances

importances = get_param_importances(study)
# {'learning_rate': 0.45, 'max_depth': 0.30, 'n_estimators': 0.15, ...}
# → 合計が1になる相対的な重要度
# → 重要度が高いほど「そのパラメータがスコアに与える影響が大きい」

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

ベイズ最適化を直感的に理解する

対数スケールが必要な理由

🏆 Kaggleでの実践的な使い方

📋 コピー# Kaggle 本番パターン: 二段階チューニング
# Phase 1: 粗い探索（n_trials=20）
study = optuna.create_study(direction='maximize')
study.optimize(objective_xgb, n_trials=20)

# Phase 2: best_params 周辺を精密探索
best_lr = study.best_params['learning_rate']
best_depth = study.best_params['max_depth']

def objective_fine(trial):
    params = {
        'n_estimators': trial.suggest_int('n_estimators', 300, 800),
        'max_depth':    trial.suggest_int('max_depth',
                                          max(3, best_depth-2),
                                          min(12, best_depth+2)),
        'learning_rate': trial.suggest_float('learning_rate',
                                              best_lr*0.5, best_lr*2.0, log=True),
        'subsample':        trial.suggest_float('subsample', 0.5, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        'random_state': 42, 'eval_metric': 'logloss',
    }
    return cross_val_score(xgb.XGBClassifier(**params), X_enc, y,
                           cv=cv, scoring='accuracy').mean()

study2 = optuna.create_study(direction='maximize')
study2.optimize(objective_fine, n_trials=30)
print(f"最終 Best: {study2.best_value:.4f}")

🚫 よくある誤解・ミス

🚀 次のステップ

• 発展: optuna.integration.OptunaSearchCV で sklearn の GridSearchCV と同じ使い方ができる。early_stopping_rounds との組み合わせも試すこと
• 次回予告（Day 065）: スタッキング（Stacking Ensemble）— ベースモデルのOOF予測をメタモデルで統合する

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