Create scorer.py

scorer.py

@@ -0,0 +1,387 @@
+import argparse
+import json
+import pandas as pd
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+
+
+ALLOWED_SPLITS = {
+    "train",
+    "in_domain_test",
+    "boundary_trap",
+    "distribution_shift",
+    "counterfactual_intervention"
+}
+
+ALLOWED_TRAPS = {
+    "false_stability",
+    "boundary_masking",
+    "trajectory_aliasing",
+    "temporal_alias",
+    "intervention_decoy"
+}
+
+ALLOWED_DIFFICULTY = {
+    "easy",
+    "medium",
+    "hard"
+}
+
+LOW_BOUNDARY_THRESHOLD = 0.10
+HIGH_DRIFT_THRESHOLD = 0.05
+
+
+def load_csv(path):
+    return pd.read_csv(path)
+
+
+def validate_columns(preds, truth):
+
+    if "scenario_id" not in preds.columns or "prediction" not in preds.columns:
+        raise ValueError("Predictions must contain scenario_id and prediction columns")
+
+    required_truth = {
+        "scenario_id",
+        "split_type",
+        "pair_id",
+        "pair_role",
+        "difficulty_level",
+        "pressure_obs_t0",
+        "pressure_obs_t1",
+        "pressure_obs_t2",
+        "buffer_obs_t0",
+        "buffer_obs_t1",
+        "buffer_obs_t2",
+        "true_label",
+        "trap_type",
+        "trap_active",
+        "boundary_distance",
+        "drift_gradient",
+        "drift_acceleration",
+        "recovery_feasibility",
+        "regime_competition_ratio",
+        "intervention_action",
+        "intervention_magnitude",
+        "boundary_distance_before",
+        "boundary_distance_after",
+        "intervention_effect_direction"
+    }
+
+    missing = required_truth - set(truth.columns)
+
+    if missing:
+        raise ValueError(f"Truth missing required columns: {sorted(missing)}")
+
+
+def validate_values(preds, truth):
+
+    bad_pred = set(preds["prediction"].dropna().unique()) - {0, 1}
+    if bad_pred:
+        raise ValueError("Predictions must contain only 0 or 1")
+
+    bad_label = set(truth["true_label"].dropna().unique()) - {0, 1}
+    if bad_label:
+        raise ValueError("true_label must contain only 0 or 1")
+
+    bad_trap = set(truth["trap_active"].dropna().unique()) - {0, 1}
+    if bad_trap:
+        raise ValueError("trap_active must contain only 0 or 1")
+
+    unknown_splits = set(truth["split_type"].dropna().unique()) - ALLOWED_SPLITS
+    if unknown_splits:
+        raise ValueError(f"Unknown split_type values: {sorted(unknown_splits)}")
+
+    trap_values = set(truth["trap_type"].dropna().unique())
+    unknown_traps = trap_values - ALLOWED_TRAPS
+    if unknown_traps:
+        raise ValueError(f"Unknown trap_type values: {sorted(unknown_traps)}")
+
+    unknown_difficulty = set(truth["difficulty_level"].dropna().unique()) - ALLOWED_DIFFICULTY
+    if unknown_difficulty:
+        raise ValueError(f"Unknown difficulty_level values: {sorted(unknown_difficulty)}")
+
+    if "intervention_effect_direction" in preds.columns:
+        bad_dir = set(preds["intervention_effect_direction"].dropna().unique()) - {-1, 0, 1}
+        if bad_dir:
+            raise ValueError("Predicted intervention_effect_direction must be one of -1, 0, 1")
+
+    valid_pair_roles = {"safe_pair", "unstable_pair"}
+    pair_roles = set(truth["pair_role"].dropna().unique()) - valid_pair_roles
+    if pair_roles:
+        raise ValueError(f"Unknown pair_role values: {sorted(pair_roles)}")
+
+
+def validate_ids(df, name):
+
+    if df["scenario_id"].isna().any():
+        raise ValueError(f"{name} contains missing scenario_id values")
+
+    ids = df["scenario_id"].astype(str).str.strip()
+
+    if (ids == "").any():
+        raise ValueError(f"{name} contains blank scenario_id values")
+
+    if ids.duplicated().any():
+        dupes = ids[ids.duplicated()].unique().tolist()
+        raise ValueError(f"{name} duplicate scenario_id values: {dupes[:10]}")
+
+    df = df.copy()
+    df["scenario_id"] = ids
+
+    return df
+
+
+def compute_basic_metrics(y_true, y_pred):
+
+    return {
+        "accuracy": float(accuracy_score(y_true, y_pred)),
+        "precision": float(precision_score(y_true, y_pred, zero_division=0)),
+        "recall": float(recall_score(y_true, y_pred, zero_division=0)),
+        "f1": float(f1_score(y_true, y_pred, zero_division=0)),
+        "rows_evaluated": int(len(y_true))
+    }
+
+
+def compute_split_accuracy(df, split_name):
+
+    subset = df[df["split_type"] == split_name]
+
+    if subset.empty:
+        return None
+
+    return float(accuracy_score(subset["true_label"], subset["prediction"]))
+
+
+def compute_trap_accuracy(df, trap_type=None):
+
+    subset = df[df["trap_active"] == 1]
+
+    if trap_type:
+        subset = subset[subset["trap_type"] == trap_type]
+
+    if subset.empty:
+        return None
+
+    return float(accuracy_score(subset["true_label"], subset["prediction"]))
+
+
+def compute_difficulty_accuracy(df, difficulty_level):
+
+    subset = df[df["difficulty_level"] == difficulty_level]
+
+    if subset.empty:
+        return None
+
+    return float(accuracy_score(subset["true_label"], subset["prediction"]))
+
+
+def compute_geometry_diagnostics(df):
+
+    results = {}
+
+    low_boundary = df[
+        (df["true_label"] == 1) &
+        (df["boundary_distance"] <= LOW_BOUNDARY_THRESHOLD)
+    ]
+
+    if low_boundary.empty:
+        results["low_boundary_distance_miss_rate"] = None
+    else:
+        misses = (low_boundary["prediction"] == 0).sum()
+        results["low_boundary_distance_miss_rate"] = float(misses / len(low_boundary))
+
+    high_drift = df[
+        (df["true_label"] == 1) &
+        (df["drift_gradient"] >= HIGH_DRIFT_THRESHOLD)
+    ]
+
+    if high_drift.empty:
+        results["high_drift_gradient_miss_rate"] = None
+    else:
+        misses = (high_drift["prediction"] == 0).sum()
+        results["high_drift_gradient_miss_rate"] = float(misses / len(high_drift))
+
+    return results
+
+
+def compute_counterfactual_metrics(df):
+
+    results = {
+        "counterfactual_intervention_accuracy": None,
+        "intervention_effect_direction_accuracy": None
+    }
+
+    subset = df[df["split_type"] == "counterfactual_intervention"]
+
+    if subset.empty:
+        return results
+
+    results["counterfactual_intervention_accuracy"] = float(
+        accuracy_score(subset["true_label"], subset["prediction"])
+    )
+
+    if "predicted_intervention_effect_direction" in subset.columns:
+        valid = subset.dropna(subset=["intervention_effect_direction", "predicted_intervention_effect_direction"])
+
+        if not valid.empty:
+            results["intervention_effect_direction_accuracy"] = float(
+                accuracy_score(
+                    valid["intervention_effect_direction"],
+                    valid["predicted_intervention_effect_direction"]
+                )
+            )
+
+    return results
+
+
+def compute_pair_discrimination_accuracy(df):
+
+    paired = df[df["pair_id"].notna()].copy()
+
+    if paired.empty:
+        return None
+
+    correct = 0
+    total = 0
+
+    for pair_id, group in paired.groupby("pair_id"):
+        if len(group) != 2:
+            continue
+
+        roles = set(group["pair_role"])
+        if roles != {"safe_pair", "unstable_pair"}:
+            continue
+
+        unstable_row = group[group["pair_role"] == "unstable_pair"].iloc[0]
+        safe_row = group[group["pair_role"] == "safe_pair"].iloc[0]
+
+        ok = (unstable_row["prediction"] == 1) and (safe_row["prediction"] == 0)
+
+        correct += int(ok)
+        total += 1
+
+    if total == 0:
+        return None
+
+    return float(correct / total)
+
+
+def compute_support_counts(df):
+
+    return {
+        "train_support": int((df["split_type"] == "train").sum()),
+        "in_domain_test_support": int((df["split_type"] == "in_domain_test").sum()),
+        "boundary_trap_support": int((df["split_type"] == "boundary_trap").sum()),
+        "distribution_shift_support": int((df["split_type"] == "distribution_shift").sum()),
+        "counterfactual_intervention_support": int((df["split_type"] == "counterfactual_intervention").sum()),
+        "trap_support": int((df["trap_active"] == 1).sum())
+    }
+
+
+def compute_casses_score(results):
+
+    weights = {
+        "in_domain_test_accuracy": 0.18,
+        "boundary_trap_accuracy": 0.20,
+        "distribution_shift_accuracy": 0.17,
+        "trap_accuracy": 0.15,
+        "counterfactual_intervention_accuracy": 0.15,
+        "trajectory_pair_discrimination_accuracy": 0.15
+    }
+
+    score = 0
+    weight_sum = 0
+
+    for metric, weight in weights.items():
+        value = results.get(metric)
+        if value is not None:
+            score += value * weight
+            weight_sum += weight
+
+    if weight_sum == 0:
+        return None
+
+    return score / weight_sum
+
+
+def score(predictions_path, truth_path):
+
+    preds = load_csv(predictions_path)
+    truth = load_csv(truth_path)
+
+    validate_columns(preds, truth)
+    validate_values(preds, truth)
+
+    preds = validate_ids(preds, "Predictions")
+    truth = validate_ids(truth, "Truth")
+
+    if "intervention_effect_direction" in preds.columns:
+        preds = preds.rename(columns={
+            "intervention_effect_direction": "predicted_intervention_effect_direction"
+        })
+
+    pred_ids = set(preds["scenario_id"])
+    truth_ids = set(truth["scenario_id"])
+
+    if pred_ids != truth_ids:
+        missing = sorted(list(truth_ids - pred_ids))[:10]
+        extra = sorted(list(pred_ids - truth_ids))[:10]
+        raise ValueError(
+            f"scenario_id mismatch. Missing in predictions: {missing}. Extra in predictions: {extra}"
+        )
+
+    merged = truth.merge(preds, on="scenario_id", how="inner", validate="one_to_one")
+    merged = merged.sort_values("scenario_id").reset_index(drop=True)
+
+    y_true = merged["true_label"]
+    y_pred = merged["prediction"]
+
+    results = compute_basic_metrics(y_true, y_pred)
+
+    results["train_accuracy"] = compute_split_accuracy(merged, "train")
+    results["in_domain_test_accuracy"] = compute_split_accuracy(merged, "in_domain_test")
+    results["boundary_trap_accuracy"] = compute_split_accuracy(merged, "boundary_trap")
+    results["distribution_shift_accuracy"] = compute_split_accuracy(merged, "distribution_shift")
+
+    results["trap_accuracy"] = compute_trap_accuracy(merged)
+    results["false_stability_accuracy"] = compute_trap_accuracy(merged, "false_stability")
+    results["boundary_masking_accuracy"] = compute_trap_accuracy(merged, "boundary_masking")
+    results["trajectory_aliasing_accuracy"] = compute_trap_accuracy(merged, "trajectory_aliasing")
+    results["temporal_alias_accuracy"] = compute_trap_accuracy(merged, "temporal_alias")
+    results["intervention_decoy_accuracy"] = compute_trap_accuracy(merged, "intervention_decoy")
+
+    results["easy_accuracy"] = compute_difficulty_accuracy(merged, "easy")
+    results["medium_accuracy"] = compute_difficulty_accuracy(merged, "medium")
+    results["hard_accuracy"] = compute_difficulty_accuracy(merged, "hard")
+
+    indomain = results["in_domain_test_accuracy"]
+    shift = results["distribution_shift_accuracy"]
+
+    if indomain is not None and shift is not None:
+        results["manifold_generalization_gap"] = float(indomain - shift)
+    else:
+        results["manifold_generalization_gap"] = None
+
+    results.update(compute_geometry_diagnostics(merged))
+    results.update(compute_counterfactual_metrics(merged))
+    results["trajectory_pair_discrimination_accuracy"] = compute_pair_discrimination_accuracy(merged)
+    results.update(compute_support_counts(merged))
+    results["casses_score"] = compute_casses_score(results)
+
+    return results
+
+
+def main():
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--predictions", required=True)
+    parser.add_argument("--truth", required=True)
+
+    args = parser.parse_args()
+
+    results = score(args.predictions, args.truth)
+
+    print(json.dumps(results, indent=2))
+
+
+if __name__ == "__main__":
+    main()