Upload benchmark/evaluate.py with huggingface_hub

benchmark/evaluate.py

@@ -0,0 +1,270 @@
+"""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()