import csv import json import sys from typing import Any, Dict, List LABEL_COL = "label_sepsis_transition" POSITIVE_LABEL = 1 PRIMARY_METRIC = "recall_optimal_policy_selection" SECONDARY_METRIC = "false_robust_policy_rate" TRAJECTORY_SHIFT_THRESHOLD = -0.10 INTERVENTION_ALIGNMENT_THRESHOLD = 0.60 CONTROL_ALIGNMENT_THRESHOLD = 0.60 RECOVERY_CONSISTENCY_THRESHOLD = 0.60 POLICY_REGRET_THRESHOLD = 0.10 POLICY_ROBUSTNESS_THRESHOLD = 0.60 COUNTERFACTUAL_FAILURE_RISK_THRESHOLD = 0.30 DECEPTIVE_SIGNAL_THRESHOLD = 0.50 HIGH_UNCERTAINTY_THRESHOLD = 0.25 NARROW_WINDOW_THRESHOLD = 0.30 OSCILLATION_THRESHOLD = 0.25 STABLE_MARGIN_THRESHOLD = 0.60 SHORT_TERM_GAIN_THRESHOLD = 0.60 DELAYED_FAILURE_THRESHOLD = 0.50 SIGNAL_CONFLICT_THRESHOLD = 0.50 def _to_float(value: Any, default: float = 0.0) -> float: try: return float(value) except (TypeError, ValueError): return default def _to_int(value: Any, default: int = 0) -> int: try: return int(float(value)) except (TypeError, ValueError): return default def _to_bool(value: Any) -> bool: text = str(value).strip().lower() return text in {"1", "true", "yes", "y"} def _safe_div(numerator: float, denominator: float) -> float: return numerator / denominator if denominator else 0.0 def _normalize_string(value: Any) -> str: if value is None: return "" return str(value).strip().lower() def _read_csv(path: str) -> List[Dict[str, str]]: with open(path, "r", encoding="utf-8", newline="") as f: return list(csv.DictReader(f)) def _normalize_label(row: Dict[str, str]) -> int: if LABEL_COL in row: return _to_int(row[LABEL_COL]) for key, value in row.items(): if key.startswith("label_"): return _to_int(value) raise ValueError( f"No label column found in row. Expected '{LABEL_COL}' or a column starting with 'label_'." ) def _confusion(y_true: List[int], y_pred: List[int]) -> Dict[str, int]: tp = fp = tn = fn = 0 for yt, yp in zip(y_true, y_pred): if yt == 1 and yp == 1: tp += 1 elif yt == 0 and yp == 1: fp += 1 elif yt == 0 and yp == 0: tn += 1 elif yt == 1 and yp == 0: fn += 1 return {"tp": tp, "fp": fp, "tn": tn, "fn": fn} def _accuracy(y_true: List[int], y_pred: List[int]) -> float: return _safe_div(sum(1 for a, b in zip(y_true, y_pred) if a == b), len(y_true)) def _precision(cm: Dict[str, int]) -> float: return _safe_div(cm["tp"], cm["tp"] + cm["fp"]) def _recall(cm: Dict[str, int]) -> float: return _safe_div(cm["tp"], cm["tp"] + cm["fn"]) def _f1(precision: float, recall: float) -> float: return _safe_div(2 * precision * recall, precision + recall) def _mean_abs_error(true_vals: List[float], pred_vals: List[float]) -> float: if not true_vals: return 0.0 return sum(abs(a - b) for a, b in zip(true_vals, pred_vals)) / len(true_vals) def _rate(mask: List[bool], condition: List[bool]) -> float: idx = [i for i, flag in enumerate(mask) if flag] if not idx: return 0.0 return sum(1 for i in idx if condition[i]) / len(idx) def _string_accuracy(true_vals: List[str], pred_vals: List[str]) -> float: if not true_vals: return 0.0 return _safe_div( sum( 1 for a, b in zip(true_vals, pred_vals) if _normalize_string(a) == _normalize_string(b) ), len(true_vals), ) def _threshold_accuracy( gold: List[Dict[str, str]], pred: List[Dict[str, str]], field: str, threshold: float, ) -> float: true_flags = [_to_float(row.get(field, 0.0)) >= threshold for row in gold] pred_flags = [_to_float(row.get(field, 0.0)) >= threshold for row in pred] return _safe_div( sum(1 for a, b in zip(true_flags, pred_flags) if a == b), len(true_flags), ) def _flag_accuracy( gold: List[Dict[str, str]], pred: List[Dict[str, str]], field: str, ) -> float: true_flags = [_to_bool(row.get(field, 0)) for row in gold] pred_flags = [_to_bool(row.get(field, 0)) for row in pred] return _safe_div( sum(1 for a, b in zip(true_flags, pred_flags) if a == b), len(true_flags), ) def _check_duplicate_ids(rows: List[Dict[str, str]], side: str) -> None: if not all("scenario_id" in row for row in rows): return seen = set() duplicates = set() for row in rows: sid = _normalize_string(row.get("scenario_id")) if sid in seen: duplicates.add(sid) seen.add(sid) if duplicates: dup_list = ", ".join(sorted(duplicates)) raise ValueError(f"Duplicate scenario_id values found in {side}: {dup_list}") def _validate_inputs(gold: List[Dict[str, str]], pred: List[Dict[str, str]]) -> None: if len(gold) != len(pred): raise ValueError("Solution and submission row counts do not match.") if not gold: raise ValueError("Solution file is empty.") if not pred: raise ValueError("Submission file is empty.") _check_duplicate_ids(gold, "solution file") _check_duplicate_ids(pred, "submission file") gold_has_id = all("scenario_id" in row for row in gold) pred_has_id = all("scenario_id" in row for row in pred) if gold_has_id and pred_has_id: for i, (g_row, p_row) in enumerate(zip(gold, pred)): if _normalize_string(g_row.get("scenario_id")) != _normalize_string(p_row.get("scenario_id")): raise ValueError( f"Scenario mismatch at row {i + 1}: " f"{g_row.get('scenario_id')} != {p_row.get('scenario_id')}" ) def score(solution_file: str, submission_file: str) -> Dict[str, Any]: gold = _read_csv(solution_file) pred = _read_csv(submission_file) _validate_inputs(gold, pred) y_true = [_normalize_label(row) for row in gold] y_pred = [_normalize_label(row) for row in pred] cm = _confusion(y_true, y_pred) accuracy = _accuracy(y_true, y_pred) precision = _precision(cm) recall = _recall(cm) f1 = _f1(precision, recall) primary_true = [ _to_int(row.get("stabilization_success", 0)) == 1 and _to_float(row.get("trajectory_shift", 0.0)) < TRAJECTORY_SHIFT_THRESHOLD and _to_float(row.get("intervention_alignment_score", 0.0)) >= INTERVENTION_ALIGNMENT_THRESHOLD and _to_float(row.get("control_sequence_alignment_score", 0.0)) >= CONTROL_ALIGNMENT_THRESHOLD and _to_float(row.get("recovery_consistency_score", 0.0)) >= RECOVERY_CONSISTENCY_THRESHOLD and _to_float(row.get("policy_regret", 1.0)) <= POLICY_REGRET_THRESHOLD and _to_float(row.get("policy_robustness", 0.0)) >= POLICY_ROBUSTNESS_THRESHOLD and _to_float(row.get("counterfactual_failure_risk", 1.0)) <= COUNTERFACTUAL_FAILURE_RISK_THRESHOLD and _to_float(row.get("deceptive_signal_score", 1.0)) <= DECEPTIVE_SIGNAL_THRESHOLD for row in gold ] primary_pred = [pred_label == POSITIVE_LABEL for pred_label in y_pred] recall_optimal_policy_selection = _rate(primary_true, primary_pred) false_robust_policy_rate = _rate( primary_pred, [not flag for flag in primary_true] ) optimal_policy_path_accuracy = _string_accuracy( [row.get("minimal_intervention_path", "") for row in gold], [row.get("minimal_intervention_path", "") for row in pred], ) primary_intervention_path_accuracy = _string_accuracy( [row.get("primary_intervention_path", "") for row in gold], [row.get("primary_intervention_path", "") for row in pred], ) secondary_intervention_path_accuracy = _string_accuracy( [row.get("secondary_intervention_path", "") for row in gold], [row.get("secondary_intervention_path", "") for row in pred], ) control_sequence_alignment_accuracy = _threshold_accuracy( gold, pred, "control_sequence_alignment_score", CONTROL_ALIGNMENT_THRESHOLD ) feedback_response_accuracy = _threshold_accuracy( gold, pred, "feedback_response_score", CONTROL_ALIGNMENT_THRESHOLD ) intervention_timing_accuracy = _threshold_accuracy( gold, pred, "intervention_timing_score", CONTROL_ALIGNMENT_THRESHOLD ) policy_regret_error = _mean_abs_error( [_to_float(row.get("policy_regret", 0.0)) for row in gold], [_to_float(row.get("policy_regret", 0.0)) for row in pred], ) policy_robustness_error = _mean_abs_error( [_to_float(row.get("policy_robustness", 0.0)) for row in gold], [_to_float(row.get("policy_robustness", 0.0)) for row in pred], ) policy_fragility_error = _mean_abs_error( [_to_float(row.get("policy_fragility_index", 0.0)) for row in gold], [_to_float(row.get("policy_fragility_index", 0.0)) for row in pred], ) policy_stability_delta_error = _mean_abs_error( [_to_float(row.get("policy_stability_delta", 0.0)) for row in gold], [_to_float(row.get("policy_stability_delta", 0.0)) for row in pred], ) policy_confidence_gap_error = _mean_abs_error( [_to_float(row.get("policy_confidence_gap", 0.0)) for row in gold], [_to_float(row.get("policy_confidence_gap", 0.0)) for row in pred], ) counterfactual_failure_risk_error = _mean_abs_error( [_to_float(row.get("counterfactual_failure_risk", 0.0)) for row in gold], [_to_float(row.get("counterfactual_failure_risk", 0.0)) for row in pred], ) counterfactual_divergence_time_error = _mean_abs_error( [_to_float(row.get("counterfactual_divergence_time", 0.0)) for row in gold], [_to_float(row.get("counterfactual_divergence_time", 0.0)) for row in pred], ) counterfactual_outcome_error = _mean_abs_error( [_to_float(row.get("counterfactual_outcome_score", 0.0)) for row in gold], [_to_float(row.get("counterfactual_outcome_score", 0.0)) for row in pred], ) counterfactual_miss_rate = _rate( [True] * len(gold), [ _to_float(pred[i].get("selected_policy_score", 0.0)) < _to_float(gold[i].get("optimal_policy_score", 0.0)) for i in range(len(gold)) ] ) deceptive_policy_selection_rate = _rate( [True] * len(gold), [ _to_float(gold[i].get("deceptive_signal_score", 0.0)) > DECEPTIVE_SIGNAL_THRESHOLD and _to_float(pred[i].get("policy_regret", 0.0)) > POLICY_REGRET_THRESHOLD for i in range(len(gold)) ] ) short_term_gain_failure_rate = _rate( [True] * len(gold), [ _to_float(gold[i].get("local_improvement_score", 0.0)) >= SHORT_TERM_GAIN_THRESHOLD and _to_float(gold[i].get("delayed_failure_risk", 0.0)) >= DELAYED_FAILURE_THRESHOLD and y_pred[i] == POSITIVE_LABEL for i in range(len(gold)) ] ) signal_conflict_misread_rate = _rate( [True] * len(gold), [ (_to_float(gold[i].get("signal_conflict_score", 0.0)) >= SIGNAL_CONFLICT_THRESHOLD) != (_to_float(pred[i].get("signal_conflict_score", 0.0)) >= SIGNAL_CONFLICT_THRESHOLD) for i in range(len(gold)) ] ) delayed_failure_misread_rate = _rate( [True] * len(gold), [ (_to_float(gold[i].get("delayed_failure_risk", 0.0)) >= DELAYED_FAILURE_THRESHOLD) != (_to_float(pred[i].get("delayed_failure_risk", 0.0)) >= DELAYED_FAILURE_THRESHOLD) for i in range(len(gold)) ] ) adaptation_latency_error = _mean_abs_error( [_to_float(row.get("adaptation_latency", 0.0)) for row in gold], [_to_float(row.get("adaptation_latency", 0.0)) for row in pred], ) control_stability_error = _mean_abs_error( [_to_float(row.get("control_stability_margin", 0.0)) for row in gold], [_to_float(row.get("control_stability_margin", 0.0)) for row in pred], ) recovery_consistency_error = _mean_abs_error( [_to_float(row.get("recovery_consistency_score", 0.0)) for row in gold], [_to_float(row.get("recovery_consistency_score", 0.0)) for row in pred], ) control_horizon_error = _mean_abs_error( [_to_float(row.get("control_horizon", 0.0)) for row in gold], [_to_float(row.get("control_horizon", 0.0)) for row in pred], ) recalibration_overuse_rate = _rate( [True] * len(gold), [ _to_int(pred[i].get("control_recalibration_count", 0)) > _to_int(gold[i].get("control_recalibration_count", 0)) and _to_float(gold[i].get("control_stability_margin", 0.0)) >= STABLE_MARGIN_THRESHOLD for i in range(len(gold)) ] ) controller_oscillation_misread_rate = _rate( [True] * len(gold), [ (_to_float(gold[i].get("controller_oscillation_score", 0.0)) >= OSCILLATION_THRESHOLD) != (_to_float(pred[i].get("controller_oscillation_score", 0.0)) >= OSCILLATION_THRESHOLD) for i in range(len(gold)) ] ) terminal_pathway_state_accuracy = _string_accuracy( [row.get("terminal_pathway_state", "") for row in gold], [row.get("terminal_pathway_state", "") for row in pred], ) missed_optimal_policies = [ primary_true[i] and not primary_pred[i] for i in range(len(primary_true)) ] high_uncertainty_policy_miss_rate = _rate( missed_optimal_policies, [_to_float(row.get("intervention_uncertainty", 0.0)) >= HIGH_UNCERTAINTY_THRESHOLD for row in gold] ) narrow_window_policy_miss_rate = _rate( missed_optimal_policies, [_to_float(row.get("rescue_window_width", 0.0)) <= NARROW_WINDOW_THRESHOLD for row in gold] ) short_term_gain_flag_accuracy = _flag_accuracy( gold, pred, "short_term_gain_long_term_loss_flag" ) positive_class_count = sum(y_true) negative_class_count = len(y_true) - positive_class_count primary_true_count = sum(primary_true) primary_pred_count = sum(primary_pred) missed_optimal_policy_count = sum(missed_optimal_policies) result = { "primary_metric": PRIMARY_METRIC, "secondary_metric": SECONDARY_METRIC, "binary_metrics": { "accuracy": round(accuracy, 6), "precision": round(precision, 6), "recall": round(recall, 6), "f1": round(f1, 6), "confusion_matrix": cm }, "policy_diagnostics": { PRIMARY_METRIC: round(recall_optimal_policy_selection, 6), SECONDARY_METRIC: round(false_robust_policy_rate, 6), "optimal_policy_path_accuracy": round(optimal_policy_path_accuracy, 6), "primary_intervention_path_accuracy": round(primary_intervention_path_accuracy, 6), "secondary_intervention_path_accuracy": round(secondary_intervention_path_accuracy, 6), "policy_regret_error": round(policy_regret_error, 6), "policy_robustness_error": round(policy_robustness_error, 6), "policy_fragility_error": round(policy_fragility_error, 6), "policy_stability_delta_error": round(policy_stability_delta_error, 6), "policy_confidence_gap_error": round(policy_confidence_gap_error, 6) }, "counterfactual_diagnostics": { "counterfactual_miss_rate": round(counterfactual_miss_rate, 6), "counterfactual_failure_risk_error": round(counterfactual_failure_risk_error, 6), "counterfactual_divergence_time_error": round(counterfactual_divergence_time_error, 6), "counterfactual_outcome_error": round(counterfactual_outcome_error, 6), "high_uncertainty_policy_miss_rate": round(high_uncertainty_policy_miss_rate, 6), "narrow_window_policy_miss_rate": round(narrow_window_policy_miss_rate, 6) }, "adversarial_diagnostics": { "deceptive_policy_selection_rate": round(deceptive_policy_selection_rate, 6), "short_term_gain_failure_rate": round(short_term_gain_failure_rate, 6), "signal_conflict_misread_rate": round(signal_conflict_misread_rate, 6), "delayed_failure_misread_rate": round(delayed_failure_misread_rate, 6), "short_term_gain_long_term_loss_flag_accuracy": round(short_term_gain_flag_accuracy, 6) }, "control_diagnostics": { "control_sequence_alignment_accuracy": round(control_sequence_alignment_accuracy, 6), "control_horizon_error": round(control_horizon_error, 6), "feedback_response_accuracy": round(feedback_response_accuracy, 6), "intervention_timing_accuracy": round(intervention_timing_accuracy, 6), "adaptation_latency_error": round(adaptation_latency_error, 6), "control_stability_error": round(control_stability_error, 6), "recovery_consistency_error": round(recovery_consistency_error, 6), "recalibration_overuse_rate": round(recalibration_overuse_rate, 6), "controller_oscillation_misread_rate": round(controller_oscillation_misread_rate, 6), "terminal_pathway_state_accuracy": round(terminal_pathway_state_accuracy, 6) }, "support": { "num_rows": len(gold), "primary_true_count": primary_true_count, "primary_pred_count": primary_pred_count, "missed_optimal_policy_count": missed_optimal_policy_count, "positive_class_count": positive_class_count, "negative_class_count": negative_class_count }, "class_balance": { "positive_rate": round(_safe_div(positive_class_count, len(y_true)), 6), "negative_rate": round(_safe_div(negative_class_count, len(y_true)), 6) }, "thresholds": { "trajectory_shift_threshold": TRAJECTORY_SHIFT_THRESHOLD, "intervention_alignment_threshold": INTERVENTION_ALIGNMENT_THRESHOLD, "control_alignment_threshold": CONTROL_ALIGNMENT_THRESHOLD, "recovery_consistency_threshold": RECOVERY_CONSISTENCY_THRESHOLD, "policy_regret_threshold": POLICY_REGRET_THRESHOLD, "policy_robustness_threshold": POLICY_ROBUSTNESS_THRESHOLD, "counterfactual_failure_risk_threshold": COUNTERFACTUAL_FAILURE_RISK_THRESHOLD, "deceptive_signal_threshold": DECEPTIVE_SIGNAL_THRESHOLD, "high_uncertainty_threshold": HIGH_UNCERTAINTY_THRESHOLD, "narrow_window_threshold": NARROW_WINDOW_THRESHOLD, "oscillation_threshold": OSCILLATION_THRESHOLD, "stable_margin_threshold": STABLE_MARGIN_THRESHOLD, "short_term_gain_threshold": SHORT_TERM_GAIN_THRESHOLD, "delayed_failure_threshold": DELAYED_FAILURE_THRESHOLD, "signal_conflict_threshold": SIGNAL_CONFLICT_THRESHOLD } } return result if __name__ == "__main__": if len(sys.argv) != 3: raise SystemExit("Usage: python scorer.py ") scores = score(sys.argv[1], sys.argv[2]) print(json.dumps(scores, indent=2))