Day 061 — 勾配ブースティング入門 — XGBoost の仕組みと基本パラメータ

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

ランダムフォレスト vs 勾配ブースティング

XGBoost の「X」に込められた改良点

🔁 ブースティングの流れ（反復的な誤差補正）

📐 学習率（learning_rate / eta）の効果

📊 3モデルの過学習比較（訓練精度 vs CV精度）

⚙️ 主要パラメータ

🗂️ データスキーマ（Titanic 疑似データ）

📝 問題

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

try:
    import xgboost as xgb
    print(f"XGBoost version: {xgb.__version__}")
except ImportError:
    print("xgboost がインストールされていません: pip install xgboost")

np.random.seed(42)
n = 891
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]),
    'Fare':   np.abs(np.random.normal(32, 50, n)),
})
data['Survived'] = (
    (data['Sex'] == 'female') * 0.5 +
    (data['Pclass'] == 1) * 0.3 +
    (data['Age'] < 16) * 0.2 +
    np.random.normal(0, 0.15, n)
) > 0.4
data['Survived'] = data['Survived'].astype(int)
data['Sex_enc'] = LabelEncoder().fit_transform(data['Sex'])
features = ['Pclass', 'Sex_enc', 'Age', 'SibSp', 'Fare']
X = data[features].values
y = data['Survived'].values

問1 — RF vs sklearn GradientBoosting vs XGBoost の比較

1. RandomForestClassifier・GradientBoostingClassifier・XGBClassifier（各 n_estimators=100）を StratifiedKFold(5) で CV 比較せよ
2. 訓練精度と CV 精度の差（過学習度）を算出せよ
3. 3モデルの特徴を一言で説明せよ

問2 — 学習率 (learning_rate) の効果

1. learning_rate を [0.001, 0.01, 0.05, 0.1, 0.3, 1.0] で変化させ CV スコアを記録せよ（n_estimators=100 固定）
2. 学習率が低い・高い場合の挙動を説明せよ
3. 学習率と n_estimators がトレードオフである理由を説明せよ

問3 — n_estimators × learning_rate の組み合わせ

1. 以下の組み合わせで CV スコアを比較せよ: (50, 0.3) / (100, 0.1) / (300, 0.05) / (500, 0.01)
2. n_estimators × learning_rate = 一定 という経験則を確認せよ

問4 — max_depth と min_child_weight の効果

1. max_depth を [2, 3, 4, 6, 8] で変えながら CV スコアと学習時間を記録せよ
2. XGBoost で max_depth が深いと何が起こるかを RF と比較して説明せよ
3. min_child_weight の役割を説明せよ

問5 — 特徴量重要度と欠損値処理

1. XGBoost の feature_importances_（importance_type='gain'）を取得せよ
2. Titanic データに欠損値（NaN）を 20% 注入し、XGBoost が NaN を自動処理することを確認せよ
3. RF と XGBoost の欠損値に対する挙動の違いを述べよ

💡 ヒント

📋 コピーimport xgboost as xgb

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

for name, clf in [
    ("RF",  RandomForestClassifier(n_estimators=100, random_state=42)),
    ("GBM", GradientBoostingClassifier(n_estimators=100, random_state=42)),
    ("XGB", xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')),
]:
    clf.fit(X, y)
    tr = clf.score(X, y)
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    print(f"[{name}] 訓練: {tr:.4f}, CV: {cv_s:.4f}, 差: {tr-cv_s:.4f}")

📋 コピー# 学習率の比較
for lr in [0.001, 0.01, 0.05, 0.1, 0.3, 1.0]:
    clf = xgb.XGBClassifier(n_estimators=100, learning_rate=lr,
                             random_state=42, eval_metric='logloss')
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    print(f"lr={lr:.3f}: CV={cv_s:.4f}")

# n×lr トレードオフ
for n_est, lr in [(50, 0.3), (100, 0.1), (300, 0.05), (500, 0.01)]:
    clf = xgb.XGBClassifier(n_estimators=n_est, learning_rate=lr,
                             random_state=42, eval_metric='logloss')
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    print(f"n={n_est}, lr={lr}, n×lr={n_est*lr:.1f}: CV={cv_s:.4f}")

# 欠損値注入
X_nan = X.copy().astype(float)
mask = np.random.rand(*X_nan.shape) < 0.2
X_nan[mask] = np.nan

✅ 模範解答

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

# データ準備
np.random.seed(42)
n = 891
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]),
    'Fare':   np.abs(np.random.normal(32, 50, n)),
})
data['Survived'] = (
    (data['Sex'] == 'female') * 0.5 + (data['Pclass'] == 1) * 0.3 +
    (data['Age'] < 16) * 0.2 + np.random.normal(0, 0.15, n)
) > 0.4
data['Survived'] = data['Survived'].astype(int)
data['Sex_enc'] = LabelEncoder().fit_transform(data['Sex'])
features = ['Pclass', 'Sex_enc', 'Age', 'SibSp', 'Fare']
X = data[features].values
y = data['Survived'].values
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# ── 問1: 3モデル比較 ──
print("=" * 60)
print("問1: RF vs GradientBoosting vs XGBoost")
print("=" * 60)
for name, clf in [
    ("RandomForest(n=100)",     RandomForestClassifier(n_estimators=100, random_state=42)),
    ("GradientBoosting(n=100)", GradientBoostingClassifier(n_estimators=100, random_state=42)),
    ("XGBoost(n=100)",          xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')),
]:
    clf.fit(X, y)
    tr = clf.score(X, y)
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    print(f"[{name}] 訓練:{tr:.4f}, CV:{cv_s:.4f}, 過学習度:{tr-cv_s:.4f}")

# ── 問2: 学習率 ──
print("\n" + "=" * 60)
print("問2: learning_rate の効果")
print("=" * 60)
for lr in [0.001, 0.01, 0.05, 0.1, 0.3, 1.0]:
    clf = xgb.XGBClassifier(n_estimators=100, learning_rate=lr,
                             random_state=42, eval_metric='logloss')
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    bar = "█" * int(cv_s * 40)
    print(f"  lr={lr:.3f}: CV={cv_s:.4f} {bar}")

# ── 問3: n×lr トレードオフ ──
print("\n" + "=" * 60)
print("問3: n_estimators × learning_rate のトレードオフ")
print("=" * 60)
for n_est, lr in [(50, 0.3), (100, 0.1), (300, 0.05), (500, 0.01)]:
    clf = xgb.XGBClassifier(n_estimators=n_est, learning_rate=lr,
                             random_state=42, eval_metric='logloss')
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    print(f"  n={n_est:4d}, lr={lr:.2f}, n×lr={n_est*lr:5.1f}: CV={cv_s:.4f}")

# ── 問4: max_depth ──
print("\n" + "=" * 60)
print("問4: max_depth の効果")
print("=" * 60)
for depth in [2, 3, 4, 6, 8]:
    clf = xgb.XGBClassifier(n_estimators=100, max_depth=depth,
                             random_state=42, eval_metric='logloss')
    t0 = time.time()
    clf.fit(X, y)
    tr = clf.score(X, y)
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    print(f"  depth={depth}: 訓練={tr:.4f}, CV={cv_s:.4f}, 差={tr-cv_s:.4f}, 時間={time.time()-t0:.2f}s")

# ── 問5: 重要度と欠損値 ──
print("\n" + "=" * 60)
print("問5: 特徴量重要度と欠損値")
print("=" * 60)
clf_xgb = xgb.XGBClassifier(n_estimators=100, random_state=42,
                              eval_metric='logloss', importance_type='gain')
clf_xgb.fit(X, y)
for f, imp in sorted(zip(features, clf_xgb.feature_importances_), key=lambda x: -x[1]):
    bar = "█" * int(imp / max(clf_xgb.feature_importances_) * 30)
    print(f"  {f:10s}: {imp:.4f} {bar}")

np.random.seed(0)
X_nan = X.copy().astype(float)
X_nan[np.random.rand(*X_nan.shape) < 0.2] = np.nan
cv_nan = cross_val_score(
    xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss'),
    X_nan, y, cv=cv, scoring='accuracy').mean()
print(f"\n  XGBoost (20% NaN): CV={cv_nan:.4f}  ← NaN を自動処理")
print("  RandomForest (NaN): ValueError（fillna が必要）")

🪜 Step-by-Step 解説

1勾配ブースティングの動作をシミュレーション

📋 コピーimport numpy as np
from sklearn.tree import DecisionTreeRegressor

# 簡単な回帰問題でブースティングの動作を確認
np.random.seed(42)
X_reg = np.linspace(0, 10, 50).reshape(-1, 1)
y_reg = np.sin(X_reg.ravel()) + np.random.normal(0, 0.1, 50)

# 初期予測（全て平均値）
F = np.full(len(y_reg), y_reg.mean())
print(f"初期MSE: {np.mean((y_reg - F) ** 2):.4f}")

lr = 0.3
for i in range(5):
    residuals = y_reg - F          # 残差 = 正解 - 現在の予測
    h = DecisionTreeRegressor(max_depth=2)
    h.fit(X_reg, residuals)        # 残差を学習
    F += lr * h.predict(X_reg)    # 学習率分だけ補正
    mse = np.mean((y_reg - F) ** 2)
    print(f"  ブースト{i+1}回目: MSE={mse:.4f}, 残差最大={abs(residuals).max():.4f}")

2early_stopping の使い方（Kaggle 最重要テクニック）

📋 コピーimport xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X_train, X_val, y_train, y_val = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

clf = xgb.XGBClassifier(
    n_estimators=1000,             # 多めに設定
    learning_rate=0.05,
    max_depth=4,
    eval_metric='logloss',
    early_stopping_rounds=20,      # 20ラウンド改善なければ停止
    random_state=42,
    verbosity=0
)
clf.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],    # バリデーションセットを渡す
    verbose=False
)
print(f"最適な n_estimators: {clf.best_iteration}")
print(f"バリデーション精度: {accuracy_score(y_val, clf.predict(X_val)):.4f}")

3正則化パラメータの比較

📋 コピーcv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

print("正則化パラメータの比較:")
for l2, l1 in [(0, 0), (1, 0), (1, 0.1), (10, 1)]:
    clf = xgb.XGBClassifier(
        n_estimators=100, reg_lambda=l2, reg_alpha=l1,
        random_state=42, eval_metric='logloss'
    )
    cv_s = cross_val_score(clf, X, y, cv=cv, scoring='accuracy').mean()
    print(f"  L2={l2:2d}, L1={l1}: CV={cv_s:.4f}")
# L2 (Ridge): 葉の重みを全体的に縮小 → 過学習抑制
# L1 (Lasso): 不要特徴量への寄与をゼロに近づける

4Kaggle 標準 XGBoost テンプレート

📋 コピーfrom sklearn.model_selection import cross_val_predict
from sklearn.metrics import accuracy_score

xgb_params = {
    'n_estimators':    1000,
    'learning_rate':   0.05,
    'max_depth':       4,
    'min_child_weight': 1,
    'subsample':       0.8,        # 行サブサンプリング
    'colsample_bytree': 0.8,       # 列サブサンプリング（max_features 相当）
    'reg_alpha':       0.1,
    'reg_lambda':      1.0,
    'eval_metric':     'logloss',
    'random_state':    42,
    'n_jobs':          -1,
}

clf = xgb.XGBClassifier(**xgb_params)
cv  = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

oof = cross_val_predict(clf, X, y, cv=cv)
print(f"OOF精度: {accuracy_score(y, oof):.4f}")

clf.fit(X, y)
# 特徴量重要度（gain ベース）
for f, imp in sorted(zip(features, clf.feature_importances_), key=lambda x: -x[1]):
    print(f"  {f}: {imp:.4f}")

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

「残差を学習する」を試験で例える

学習率 η の役割

🏆 Kaggleでの実践的な使い方

📋 コピー# Optuna で XGBoost をチューニングする例
# （Day 064 で詳しく学ぶ予告）
import optuna
optuna.logging.set_verbosity(optuna.logging.WARNING)

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

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=30)
print(f"最良スコア: {study.best_value:.4f}")
print(f"最良パラメータ: {study.best_params}")

🚫 よくある誤解・ミス

🚀 次のステップ

• 発展: subsample / colsample_bytree の過学習抑制効果を実験する。Optuna での自動チューニングを試す
• 次回予告（Day 062）: LightGBM 入門 — leaf-wise 成長・カテゴリカル特徴量の直接処理・XGBoost との速度/精度比較

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