XGBoost, LightGBM & CatBoost: Modern Boosting Libraries

# Step 1: Scientific & Model Imports
import time
import numpy as np
import pandas as pd
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.base import clone
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, roc_auc_score, classification_report
)

from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier

# Step 2: Generate Synthetic Imbalanced Tabular Dataset
X, y = make_classification(
    n_samples=3000,
    n_features=12,
    n_informative=7,
    n_redundant=2,
    n_repeated=0,
    n_classes=2,
    weights=[0.85, 0.15],
    random_state=42
)
print(f"Dataset Dimension: {X.shape}, Class 1 Ratio: {np.mean(y):.3f}")

# Step 3: Stratified 70/15/15 Partitioning
X_train, X_temp, y_train, y_temp = train_test_split(
    X, y, test_size=0.30, stratify=y, random_state=42
)
X_val, X_test, y_val, y_test = train_test_split(
    X_temp, y_temp, test_size=0.50, stratify=y_temp, random_state=42
)

# Step 4: Configure Triad with Balanced Production Hyperparameters
models = {
    "XGBoost": XGBClassifier(
        n_estimators=300,
        learning_rate=0.05,
        max_depth=4,
        subsample=0.8,
        colsample_bytree=0.8,
        reg_lambda=1.0,
        tree_method="hist",
        eval_metric="logloss",
        random_state=42,
        n_jobs=-1
    ),
    "LightGBM": LGBMClassifier(
        n_estimators=300,
        learning_rate=0.05,
        num_leaves=15,
        max_depth=-1,
        min_child_samples=20,
        subsample=0.8,
        subsample_freq=1,
        colsample_bytree=0.8,
        reg_lambda=1.0,
        random_state=42,
        n_jobs=-1,
        verbosity=-1
    ),
    "CatBoost": CatBoostClassifier(
        iterations=300,
        learning_rate=0.05,
        depth=6,
        loss_function="Logloss",
        eval_metric="AUC",
        random_seed=42,
        verbose=False,
        allow_writing_files=False
    )
}

# Step 5: Benchmark Validation Performance and Training Latency
results = []
for name, model in models.items():
    t0 = time.perf_counter()
    model.fit(X_train, y_train)
    train_time = time.perf_counter() - t0
    
    y_pred = model.predict(X_val)
    if hasattr(model, "predict_proba"):
        y_proba = model.predict_proba(X_val)[:, 1]
    else:
        y_proba = y_pred

    results.append({
        "Model": name,
        "Train Time (s)": round(train_time, 4),
        "Accuracy": round(accuracy_score(y_val, y_pred), 4),
        "Precision": round(precision_score(y_val, y_pred, zero_division=0), 4),
        "Recall": round(recall_score(y_val, y_pred, zero_division=0), 4),
        "F1-Score": round(f1_score(y_val, y_pred, zero_division=0), 4),
        "ROC-AUC": round(roc_auc_score(y_val, y_proba), 4)
    })

results_df = pd.DataFrame(results)
print("\n=== 3-WAY VALIDATION BENCHMARK RESULTS ===")
print(results_df.sort_values(by="F1-Score", ascending=False).to_string(index=False))

# Step 6: Select Best Performer and Evaluate on Untouched Test Set
best_model_name = results_df.sort_values(by="F1-Score", ascending=False).iloc[0]["Model"]
print(f"\nSelected Optimal Model: {best_model_name}")

X_dev = np.vstack([X_train, X_val])
y_dev = np.concatenate([y_train, y_val])

final_model = clone(models[best_model_name])
final_model.fit(X_dev, y_dev)
y_test_pred = final_model.predict(X_test)
y_test_proba = final_model.predict_proba(X_test)[:, 1]

print(f"Final Test Accuracy : {accuracy_score(y_test, y_test_pred):.4f}")
print(f"Final Test F1-Score : {f1_score(y_test, y_test_pred, zero_division=0):.4f}")
print(f"Final Test ROC-AUC  : {roc_auc_score(y_test, y_test_proba):.4f}")