GCI優秀生・SIGNATE MASTERが考えるコンペのスコア向上Tips #機械学習 – Qiita

import warnings

import lightgbm as lgb
import numpy as np
import seaborn as sns
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import LabelEncoder

warnings.filterwarnings("ignore")

# Titanicデータの読み込み
titanic = sns.load_dataset("titanic")


# 前処理関数
def create_features(df):
    df_processed = df.copy()

    df_processed["age"].fillna(df_processed["age"].median(), inplace=True)
    df_processed["fare"].fillna(df_processed["fare"].median(), inplace=True)
    df_processed["embarked"].fillna(df_processed["embarked"].mode()[0], inplace=True)

    df_processed["family_size"] = df_processed["sibsp"] + df_processed["parch"] + 1
    df_processed["is_alone"] = (df_processed["family_size"] == 1).astype(int)
    df_processed["fare_per_person"] = df_processed["fare"] / df_processed["family_size"]
    df_processed["is_child"] = (df_processed["age"]  18).astype(int)
    df_processed["age_squared"] = df_processed["age"] ** 2
    df_processed["fare_log"] = np.log1p(df_processed["fare"])

    le_sex = LabelEncoder()
    df_processed["sex_encoded"] = le_sex.fit_transform(df_processed["sex"])

    le_embarked = LabelEncoder()
    df_processed["embarked_encoded"] = le_embarked.fit_transform(
        df_processed["embarked"]
    )

    features = [
        "pclass",
        "sex_encoded",
        "age",
        "sibsp",
        "parch",
        "fare",
        "embarked_encoded",
        "family_size",
        "is_alone",
        "fare_per_person",
        "is_child",
        "age_squared",
        "fare_log",
    ]

    return df_processed[features], df_processed["survived"]


# データ準備
X, y = create_features(titanic)

# LightGBMパラメータ
base_params = {
    "objective": "binary",
    "metric": "binary_logloss",
    "boosting_type": "gbdt",
    "num_leaves": 31,
    "learning_rate": 0.05,
    "feature_fraction": 0.8,
    "bagging_fraction": 0.8,
    "bagging_freq": 5,
    "min_data_in_leaf": 10,
    "max_depth": 6,
    "verbosity": -1,
}


# モデル学習
def train_single_seed(X_train, y_train, X_valid, y_valid, params, seed):
    params_with_seed = params.copy()
    params_with_seed["random_state"] = seed
    params_with_seed["bagging_seed"] = seed
    params_with_seed["feature_fraction_seed"] = seed

    train_data = lgb.Dataset(X_train, label=y_train)
    model = lgb.train(
        params_with_seed,
        train_data,
        num_boost_round=300,
        callbacks=[lgb.log_evaluation(0)],
    )
    y_pred_proba = model.predict(X_valid)
    auc = roc_auc_score(y_valid, y_pred_proba)
    return y_pred_proba, auc


# シードとKFold設定
seeds = [42, 713, 2025]
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)

# 評価スコア格納
seed_aucs = {seed: [] for seed in seeds}
ensemble_aucs = []

for fold, (train_idx, valid_idx) in enumerate(skf.split(X, y), 1):
    X_train, X_valid = X.iloc[train_idx], X.iloc[valid_idx]
    y_train, y_valid = y.iloc[train_idx], y.iloc[valid_idx]

    fold_preds = []
    print(f"Fold {fold}:")

    for seed in seeds:
        y_pred_proba, auc = train_single_seed(
            X_train, y_train, X_valid, y_valid, base_params, seed
        )
        seed_aucs[seed].append(auc)
        fold_preds.append(y_pred_proba)
        print(f"  Seed {seed}: AUC = {auc:.4f}")

    # アンサンブル予測
    ensemble_pred_proba = np.mean(fold_preds, axis=0)
    ensemble_auc = roc_auc_score(y_valid, ensemble_pred_proba)
    ensemble_aucs.append(ensemble_auc)
    print(f"  Ensemble: AUC = {ensemble_auc:.4f}\n")

# 平均AUCの出力
print("全Foldの平均AUC:")
for seed in seeds:
    mean_auc = np.mean(seed_aucs[seed])
    std_auc = np.std(seed_aucs[seed])
    print(f"  Seed {seed}: Mean AUC = {mean_auc:.4f} (+/- {std_auc:.4f})")

mean_ens_auc = np.mean(ensemble_aucs)
std_ens_auc = np.std(ensemble_aucs)
print(f"  Ensemble: Mean AUC = {mean_ens_auc:.4f} (+/- {std_ens_auc:.4f})")