import csv import json import sys from typing import Dict, List K = 1.0 BOUNDARY_EPS = 0.02 HIGH_CONTENT_SCORE_THRESHOLD = 0.90 REQUIRED_PRED_COLUMNS = {"scenario_id", "prediction"} REQUIRED_TRUTH_COLUMNS = { "scenario_id", "pressure", "buffer", "lag", "coupling", "content_score", "label_stable", } def load_csv(path: str) -> List[Dict[str, str]]: with open(path, newline="", encoding="utf-8") as f: return list(csv.DictReader(f)) def validate_columns(rows: List[Dict[str, str]], required_cols: set, name: str) -> None: if not rows: raise ValueError(f"{name} file is empty") cols = set(rows[0].keys()) missing = required_cols - cols if missing: raise ValueError(f"{name} missing required columns: {sorted(missing)}") def index_by_id(rows: List[Dict[str, str]], id_col: str = "scenario_id") -> Dict[str, Dict[str, str]]: index: Dict[str, Dict[str, str]] = {} for row in rows: sid = str(row.get(id_col, "")).strip() if not sid: raise ValueError("Blank or missing scenario_id detected") if sid in index: raise ValueError(f"Duplicate scenario_id detected: {sid}") index[sid] = row return index def parse_binary(value: str, field_name: str, sid: str) -> int: try: parsed = int(value) except ValueError as e: raise ValueError(f"Invalid {field_name} for {sid}: {value}") from e if parsed not in (0, 1): raise ValueError(f"Invalid {field_name} for {sid}: {parsed}") return parsed def compute_surfaces(pressure: float, buffer: float, lag: float, coupling: float) -> Dict[str, float]: s1 = buffer - (pressure * coupling) - (K * lag) s2 = buffer - (pressure * (coupling ** 2)) - (K * lag) s3 = buffer - (pressure * coupling) - (K * (lag ** 2)) return { "baseline_surface": s1, "coupling_surface": s2, "lag_surface": s3, } def compute_manifold_margin(pressure: float, buffer: float, lag: float, coupling: float) -> float: return min(compute_surfaces(pressure, buffer, lag, coupling).values()) def classify_region(manifold_margin: float) -> str: if abs(manifold_margin) <= BOUNDARY_EPS: return "near_boundary" if manifold_margin < 0: return "collapse_zone" return "safe_margin" def evaluate(pred_path: str, truth_path: str) -> Dict[str, object]: preds = load_csv(pred_path) truth = load_csv(truth_path) validate_columns(preds, REQUIRED_PRED_COLUMNS, "prediction") validate_columns(truth, REQUIRED_TRUTH_COLUMNS, "truth") if len(preds) != len(truth): raise ValueError("Prediction and truth row counts do not match") pred_map = index_by_id(preds) truth_map = index_by_id(truth) if set(pred_map.keys()) != set(truth_map.keys()): raise ValueError("scenario_id mismatch between prediction and truth files") total = 0 correct = 0 false_rescue = 0 high_conf_predicted_rescue_total = 0 boundary_total = 0 boundary_errors = 0 surface_distance_sum = 0.0 collapse_zone = 0 near_boundary = 0 safe_margin = 0 tp = tn = fp = fn = 0 regime_counts = { "baseline_surface_active": 0, "coupling_surface_active": 0, "lag_surface_active": 0, } for sid in sorted(truth_map): truth_row = truth_map[sid] pred_row = pred_map[sid] pred = parse_binary(pred_row["prediction"], "prediction", sid) label = parse_binary(truth_row["label_stable"], "label_stable", sid) try: pressure = float(truth_row["pressure"]) buffer = float(truth_row["buffer"]) lag = float(truth_row["lag"]) coupling = float(truth_row["coupling"]) content_score = float(truth_row["content_score"]) except ValueError as e: raise ValueError(f"Invalid numeric field for {sid}: {e}") from e surfaces = compute_surfaces(pressure, buffer, lag, coupling) manifold_margin = min(surfaces.values()) active_surface = min(surfaces, key=surfaces.get) regime_counts[f"{active_surface}_active"] += 1 total += 1 surface_distance_sum += abs(manifold_margin) if pred == label: correct += 1 if label == 1 and pred == 1: tp += 1 elif label == 0 and pred == 0: tn += 1 elif label == 0 and pred == 1: fp += 1 elif label == 1 and pred == 0: fn += 1 if content_score > HIGH_CONTENT_SCORE_THRESHOLD and pred == 1: high_conf_predicted_rescue_total += 1 if manifold_margin < 0: false_rescue += 1 if abs(manifold_margin) <= BOUNDARY_EPS: boundary_total += 1 if pred != label: boundary_errors += 1 region = classify_region(manifold_margin) if region == "collapse_zone": collapse_zone += 1 elif region == "near_boundary": near_boundary += 1 else: safe_margin += 1 accuracy = correct / total if total else 0.0 false_rescue_rate = ( false_rescue / high_conf_predicted_rescue_total if high_conf_predicted_rescue_total else 0.0 ) boundary_error_rate = ( boundary_errors / boundary_total if boundary_total else 0.0 ) surface_distance_mean = surface_distance_sum / total if total else 0.0 return { "accuracy": accuracy, "false_rescue_rate": false_rescue_rate, "boundary_error_rate": boundary_error_rate, "surface_distance_mean": surface_distance_mean, "collapse_margin_distribution": { "collapse_zone": collapse_zone, "near_boundary": near_boundary, "safe_margin": safe_margin, }, "confusion_matrix": { "true_stable_predicted_stable": tp, "true_unstable_predicted_unstable": tn, "false_rescue": fp, "false_collapse": fn, }, "active_surface_counts": regime_counts, "diagnostics": { "total_rows": total, "high_conf_predicted_rescue_total": high_conf_predicted_rescue_total, "boundary_cases": boundary_total, }, "thresholds": { "k": K, "boundary_eps": BOUNDARY_EPS, "high_content_score_threshold": HIGH_CONTENT_SCORE_THRESHOLD, }, } if __name__ == "__main__": if len(sys.argv) != 3: print("Usage: scorer.py predictions.csv truth.csv") sys.exit(1) pred_file = sys.argv[1] truth_file = sys.argv[2] result = evaluate(pred_file, truth_file) print(json.dumps(result, indent=2))