benchmark/evaluate.py

"""Standardized v0.0 benchmark evaluation runner.

Usage:
    # Evaluate predictions on a split
    python dataset_v3/benchmark/evaluate.py \
        --splits random_80_10_10 \
        --predictions results/my_model_preds.json

    # Generate baseline predictions (dummy/no-skill)
    python dataset_v3/benchmark/evaluate.py --baseline mean
"""
import json, os, sys, time, argparse
from pathlib import Path
from collections import Counter, defaultdict

sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

import numpy as np

from src.evaluation.metrics import compute_metrics

BENCHMARK_DIR = Path(__file__).resolve().parent
SPLITS_DIR = BENCHMARK_DIR / "splits"
RESULTS_DIR = BENCHMARK_DIR / "results"
RESULTS_DIR.mkdir(parents=True, exist_ok=True)

DATASET_PATH = os.path.join(os.path.dirname(__file__), "..", "dataset", "entries_final_v3.json")
TARGETS = ["formation_energy_per_atom", "energy_above_hull", "band_gap"]
TARGET_LABELS = dict(zip(TARGETS, ["FE", "EaH", "BG"]))


def load_dataset():
    with open(DATASET_PATH) as f:
        return json.load(f)


def load_split(name):
    path = SPLITS_DIR / f"{name}.json"
    with open(path) as f:
        return json.load(f)


def evaluate_predictions(entries, split, predictions):
    """Compute metrics for each target on each split.

    predictions: dict {entry_index: {target: value, ...}}
    """
    results = {}
    for target in TARGETS:
        label = TARGET_LABELS[target]
        y_true, y_pred = [], []
        for idx in split["test"]:
            e = entries[idx]
            true_val = e.get(target)
            pred_val = predictions.get(str(idx), {}).get(target)
            if true_val is not None and pred_val is not None:
                y_true.append(true_val)
                y_pred.append(pred_val)

        if len(y_true) < 10:
            results[label] = {"n": len(y_true), "error": "insufficient data"}
            continue

        metrics = compute_metrics(np.array(y_true), np.array(y_pred))
        metrics["n"] = len(y_true)
        results[label] = metrics

    return results


def per_family_metrics(entries, split, predictions):
    """Metrics broken down by material family."""
    results = {}
    families = defaultdict(lambda: {t: {"y_true": [], "y_pred": []} for t in TARGETS})

    for idx in split["test"]:
        e = entries[idx]
        fams = e.get("families", ["unknown"])
        primary_fam = fams[0] if fams else "unknown"
        for target in TARGETS:
            true_val = e.get(target)
            pred_val = predictions.get(str(idx), {}).get(target)
            if true_val is not None and pred_val is not None:
                families[primary_fam][target]["y_true"].append(true_val)
                families[primary_fam][target]["y_pred"].append(pred_val)

    for fam, targets_dict in families.items():
        results[fam] = {}
        for target in TARGETS:
            label = TARGET_LABELS[target]
            yt = np.array(targets_dict[target]["y_true"])
            yp = np.array(targets_dict[target]["y_pred"])
            if len(yt) < 5:
                results[fam][label] = {"n": len(yt), "error": "insufficient data"}
            else:
                m = compute_metrics(yt, yp)
                m["n"] = len(yt)
                results[fam][label] = m

    return results


def per_source_metrics(entries, split, predictions):
    """Metrics broken down by source."""
    results = {}
    sources = defaultdict(lambda: {t: {"y_true": [], "y_pred": []} for t in TARGETS})

    for idx in split["test"]:
        e = entries[idx]
        src = e.get("source", "unknown")
        for target in TARGETS:
            tv = e.get(target)
            pv = predictions.get(str(idx), {}).get(target)
            if tv is not None and pv is not None:
                sources[src][target]["y_true"].append(tv)
                sources[src][target]["y_pred"].append(pv)

    for src, targets_dict in sources.items():
        results[src] = {}
        for target in TARGETS:
            label = TARGET_LABELS[target]
            yt = np.array(targets_dict[target]["y_true"])
            yp = np.array(targets_dict[target]["y_pred"])
            if len(yt) < 5:
                results[src][label] = {"n": len(yt), "error": "insufficient data"}
            else:
                m = compute_metrics(yt, yp)
                m["n"] = len(yt)
                results[src][label] = m

    return results


def generate_baseline(entries, split, strategy="mean"):
    """Generate baseline predictions (mean or median).
    
    Useful for measuring how much better models perform than trivial baselines.
    """
    predictions = {}
    targets_values = {t: [] for t in TARGETS}

    for idx in split["train"]:
        e = entries[idx]
        for t in TARGETS:
            v = e.get(t)
            if v is not None:
                targets_values[t].append(v)

    baseline = {}
    for t in TARGETS:
        arr = np.array(targets_values[t])
        if strategy == "mean":
            baseline[t] = float(np.mean(arr))
        elif strategy == "median":
            baseline[t] = float(np.median(arr))

    for idx in split["test"]:
        predictions[str(idx)] = dict(baseline)

    return predictions


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--splits", type=str, nargs="+",
                        default=["random_80_10_10"],
                        help="Split names to evaluate on")
    parser.add_argument("--predictions", type=str, default=None,
                        help="JSON file with predictions {idx: {target: val}}")
    parser.add_argument("--baseline", type=str, default=None,
                        choices=["mean", "median"],
                        help="Generate baseline predictions instead of loading")
    parser.add_argument("--output", type=str, default=None,
                        help="Output path for results")
    parser.add_argument("--model-name", type=str, default="baseline",
                        help="Model name for results")
    args = parser.parse_args()

    print("=" * 60, flush=True)
    print("  V3.0 BENCHMARK EVALUATION", flush=True)
    print("=" * 60, flush=True)

    entries = load_dataset()
    print(f"  Dataset: {len(entries):,} entries", flush=True)

    all_results = {}

    for split_name in args.splits:
        print(f"\n  Split: {split_name}", flush=True)
        split = load_split(split_name)
        print(f"    Train: {len(split['train']):,}  Val: {len(split['val']):,}  "
              f"Test: {len(split['test']):,}", flush=True)

        # Load or generate predictions
        if args.baseline:
            print(f"    Baseline: {args.baseline}", flush=True)
            predictions = generate_baseline(entries, split, args.baseline)
        elif args.predictions:
            with open(args.predictions) as f:
                predictions = json.load(f)
            print(f"    Predictions: {len(predictions)} entries", flush=True)
        else:
            print(f"    No predictions — use --predictions or --baseline", flush=True)
            continue

        # Overall metrics
        overall = evaluate_predictions(entries, split, predictions)
        print(f"\n    Overall:")
        for target, metrics in overall.items():
            if "error" in metrics:
                print(f"      {target:5s}: {metrics['error']}")
            else:
                print(f"      {target:5s}: MAE={metrics['mae']:.4f}  "
                      f"RMSE={metrics['rmse']:.4f}  R²={metrics['r2']:.4f}  "
                      f"N={metrics['n']:,}")

        # Per-family
        pf = per_family_metrics(entries, split, predictions)
        print(f"\n    Per-Family (MAE):")
        for fam in sorted(pf.keys()):
            vals = []
            for t in TARGETS:
                lbl = TARGET_LABELS[t]
                m = pf[fam].get(lbl, {})
                if "error" not in m:
                    vals.append(f"{m['mae']:.4f}")
                else:
                    vals.append("N/A")
            print(f"      {fam:25s}: FE={vals[0]:>8s}  EaH={vals[1]:>8s}  BG={vals[2]:>8s}")

        # Per-source
        ps = per_source_metrics(entries, split, predictions)
        print(f"\n    Per-Source (MAE):")
        for src in sorted(ps.keys()):
            vals = []
            for t in TARGETS:
                lbl = TARGET_LABELS[t]
                m = ps[src].get(lbl, {})
                if "error" not in m:
                    vals.append(f"{m['mae']:.4f}")
                else:
                    vals.append("N/A")
            print(f"      {src:10s}: FE={vals[0]:>8s}  EaH={vals[1]:>8s}  BG={vals[2]:>8s}")

        all_results[split_name] = {
            "model": args.model_name,
            "split": split_name,
            "overall": overall,
            "per_family": pf,
            "per_source": ps,
        }

    # Save
    if args.output:
        with open(args.output, "w") as f:
            json.dump(all_results, f, indent=2)
        print(f"\n  Results saved: {args.output}", flush=True)
    else:
        # Save with default name
        default_name = f"results_{args.model_name}_{time.strftime('%Y%m%d_%H%M%S')}.json"
        out_path = RESULTS_DIR / default_name
        with open(out_path, "w") as f:
            json.dump(all_results, f, indent=2)
        print(f"\n  Results saved: {out_path}", flush=True)

    print(f"\n{'=' * 60}", flush=True)


if __name__ == "__main__":
    main()