benchmark/run_baselines.py

"""Fast sklearn baselines across all splits and tier configurations.
Uses RandomForest + Ridge ensemble on composition features (minutes not hours).

Usage:
    python benchmark/run_baselines.py --all
    python benchmark/run_baselines.py --split random_80_10_10 --tier gold
"""

import json, os, sys, time, argparse, warnings
from pathlib import Path
from collections import defaultdict

import numpy as np

warnings.filterwarnings("ignore")

sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
from src.evaluation.metrics import compute_metrics

from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import Ridge
from sklearn.preprocessing import StandardScaler

BASE_DIR = Path(__file__).resolve().parent.parent
DATASET_PATH = BASE_DIR / "dataset" / "entries_final_v3.json"
SPLITS_DIR = BASE_DIR / "benchmark" / "splits"
RESULTS_DIR = BASE_DIR / "benchmark" / "results"
RESULTS_DIR.mkdir(parents=True, exist_ok=True)

TARGETS = ["formation_energy_per_atom", "energy_above_hull", "band_gap"]
TARGET_LABELS = dict(zip(TARGETS, ["FE", "EaH", "BG"]))

ELEMENT_SYMBOLS = [
    "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne",
    "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca",
    "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn",
    "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr",
    "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn",
    "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
    "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb",
    "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg",
    "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac",
]
ELEMENT_INDEX = {sym: i for i, sym in enumerate(ELEMENT_SYMBOLS)}
NUM_ELEMENTS = len(ELEMENT_SYMBOLS)


def formula_to_vector(elements_list):
    vec = np.zeros(NUM_ELEMENTS, dtype=np.float32)
    if elements_list:
        for el in elements_list:
            idx = ELEMENT_INDEX.get(el)
            if idx is not None:
                vec[idx] += 1.0
    total = vec.sum()
    if total > 0:
        vec /= total
    return vec


def run_experiment(entries, split_name, tier_filter):
    split_path = SPLITS_DIR / f"{split_name}.json"
    with open(split_path) as f:
        split = json.load(f)

    train_idx = split["train"]
    val_idx = split["val"]
    test_idx = split["test"]

    if tier_filter:
        train_idx = [i for i in train_idx if entries[i].get("tier") == tier_filter]
        val_idx = [i for i in val_idx if entries[i].get("tier") == tier_filter]
        test_idx = [i for i in test_idx if entries[i].get("tier") == tier_filter]
        print(f"    {tier_filter} filter: {len(train_idx)} train, {len(val_idx)} val, {len(test_idx)} test")

    if len(train_idx) < 100:
        print(f"    Skipping: too few training examples ({len(train_idx)})")
        return None

    def build_features(indices):
        X_list = []
        y_dict = {t: [] for t in TARGETS}
        for i in indices:
            e = entries[i]
            vec = formula_to_vector(e.get("elements", []))
            X_list.append(vec)
            for t in TARGETS:
                v = e.get(t)
                if v is not None:
                    y_dict[t].append(v)
                else:
                    y_dict[t].append(np.nan)
        return np.array(X_list), {t: np.array(y_dict[t]) for t in TARGETS}

    print(f"    Building features...")
    X_train, y_train = build_features(train_idx)
    X_val, y_val = build_features(val_idx)
    X_test, y_test = build_features(test_idx)

    scaler = StandardScaler()
    X_train_s = scaler.fit_transform(X_train)
    X_val_s = scaler.transform(X_val)
    X_test_s = scaler.transform(X_test)

    results = {}
    families_data = defaultdict(lambda: {t: {"y_true": [], "y_pred": []} for t in TARGETS})
    sources_data = defaultdict(lambda: {t: {"y_true": [], "y_pred": []} for t in TARGETS})

    for t in TARGETS:
        label = TARGET_LABELS[t]
        print(f"    Training {label}...")

        train_mask = ~np.isnan(y_train[t])
        val_mask = ~np.isnan(y_val[t])
        test_mask_orig = ~np.isnan(y_test[t])

        if train_mask.sum() < 50:
            results[label] = {"n": int(train_mask.sum()), "error": "insufficient training data"}
            continue

        rf = RandomForestRegressor(n_estimators=200, max_depth=20, n_jobs=-1, random_state=42, verbose=0)
        rf.fit(X_train_s[train_mask], y_train[t][train_mask])

        ridge = Ridge(alpha=1.0, random_state=42)
        ridge.fit(X_train_s[train_mask], y_train[t][train_mask])

        rf_preds = rf.predict(X_test_s)
        ridge_preds = ridge.predict(X_test_s)
        ensemble = 0.5 * rf_preds + 0.5 * ridge_preds

        mask = test_mask_orig
        yt = y_test[t][mask]
        yp = ensemble[mask]
        results[label] = compute_metrics(yt, yp)

        for i, idx in enumerate(test_idx):
            if test_mask_orig[i]:
                e = entries[idx]
                fams = e.get("families", ["unknown"])
                pf = fams[0] if fams else "unknown"
                src = e.get("source", "unknown")
                families_data[pf][t]["y_true"].append(y_test[t][i])
                families_data[pf][t]["y_pred"].append(float(ensemble[i]))
                sources_data[src][t]["y_true"].append(y_test[t][i])
                sources_data[src][t]["y_pred"].append(float(ensemble[i]))

    per_family_results = {}
    for fam, td in families_data.items():
        per_family_results[fam] = {}
        for t in TARGETS:
            yt_f = np.array(td[t]["y_true"])
            yp_f = np.array(td[t]["y_pred"])
            if len(yt_f) >= 5:
                per_family_results[fam][TARGET_LABELS[t]] = compute_metrics(yt_f, yp_f)
            else:
                per_family_results[fam][TARGET_LABELS[t]] = {"n": len(yt_f), "error": "insufficient data"}

    per_source_results = {}
    for src, td in sources_data.items():
        per_source_results[src] = {}
        for t in TARGETS:
            yt_s = np.array(td[t]["y_true"])
            yp_s = np.array(td[t]["y_pred"])
            if len(yt_s) >= 5:
                per_source_results[src][TARGET_LABELS[t]] = compute_metrics(yt_s, yp_s)
            else:
                per_source_results[src][TARGET_LABELS[t]] = {"n": len(yt_s), "error": "insufficient data"}

    return {
        "model": "RF+Ridge_ensemble",
        "split": split_name,
        "tier_filter": tier_filter or "all",
        "overall": results,
        "per_family": per_family_results,
        "per_source": per_source_results,
        "test_size": len(test_idx),
    }


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--all", action="store_true")
    parser.add_argument("--split", type=str, default="random_80_10_10")
    parser.add_argument("--tier", type=str, default=None, choices=["gold", "validated", None])
    args = parser.parse_args()

    print("=" * 60)
    print("  SCANDIUM BENCHMARK — RF+Ridge Composition Baseline")
    print("=" * 60)

    print("\nLoading dataset...")
    with open(DATASET_PATH) as f:
        entries = json.load(f)
    print(f"  {len(entries):,} entries loaded")

    all_results = {}

    if args.all:
        splits = ["random_80_10_10", "composition_held_out", "family_held_out", "chemistry_held_out"]
        tier_filters = [None, "gold"]
    else:
        splits = [args.split]
        tier_filters = [args.tier] if args.tier else [None]

    for split_name in splits:
        for tier_filter in tier_filters:
            label = f"{split_name}_{tier_filter or 'full'}"
            print(f"\n{'─' * 50}")
            print(f"  {label}")
            print(f"{'─' * 50}")
            t0 = time.time()
            result = run_experiment(entries, split_name, tier_filter)
            elapsed = time.time() - t0
            if result:
                print(f"\n  Overall ({label}):")
                for t in TARGETS:
                    lbl = TARGET_LABELS[t]
                    m = result["overall"].get(lbl, {})
                    if "error" in m:
                        print(f"    {lbl:5s}: {m['error']}")
                    else:
                        print(f"    {lbl:5s}: MAE={m['mae']:.4f}  RMSE={m['rmse']:.4f}  R²={m['r2']:.4f}  N={m['n']:,}")
                result["elapsed_seconds"] = elapsed
                all_results[label] = result

    if all_results:
        timestamp = time.strftime("%Y%m%d_%H%M%S")
        out_path = RESULTS_DIR / f"results_rf_ridge_baseline_{timestamp}.json"
        with open(out_path, "w") as f:
            json.dump(all_results, f, indent=2, default=str)
        print(f"\nResults saved: {out_path}")
        print_summary(all_results)


def print_summary(results):
    print("\n" + "=" * 85)
    print("  BENCHMARK SUMMARY — RF+Ridge Composition Baseline")
    print("=" * 85)
    h = f"  {'Experiment':45s} {'FE MAE':>8s} {'EaH MAE':>8s} {'BG MAE':>8s} {'N':>8s}"
    print(h)
    print("  " + "-" * 82)
    for label in sorted(results.keys()):
        r = results[label]
        o = r.get("overall", {})
        fe = o.get("FE", {})
        eah = o.get("EaH", {})
        bg = o.get("BG", {})
        fe_m = f"{fe['mae']:.4f}" if "mae" in fe else "N/A"
        eah_m = f"{eah['mae']:.4f}" if "mae" in eah else "N/A"
        bg_m = f"{bg['mae']:.4f}" if "mae" in bg else "N/A"
        n = fe.get("n", 0)
        print(f"  {label:45s} {fe_m:>8s} {eah_m:>8s} {bg_m:>8s} {n:>8,}")
    print("=" * 85)


if __name__ == "__main__":
    main()