#!/usr/bin/env python3 """Score CausalMedBench prediction JSONL files. The script downloads only benchmark metadata when images are not accessed. Predictions are joined by stable ``record_id`` values, so file order is ignored. """ from __future__ import annotations import argparse import json from collections import Counter, defaultdict from pathlib import Path from typing import Any, Iterable from datasets import load_dataset REPO_ID = "leaf0932/CausalMedBench" VIEWS = ( "forged_original", "authentic_source", "local_restored", "local_forged_only", "authentic_nuisance", ) EXPECTED_REASONING = { "forged_original": ( "fake", {"mixed"}, {"mixed", "local_bbox"}, ), "authentic_source": ("real", {"none"}, {"none"}), "local_restored": ("fake", {"global_forensic"}, {"global_or_outside"}), "local_forged_only": ( "fake", {"local_medical", "local_forensic", "local_medical_and_local_forensic"}, {"local_bbox"}, ), "authentic_nuisance": ("real", {"none"}, {"none"}), } def read_jsonl(path: Path) -> Iterable[dict[str, Any]]: with path.open("r", encoding="utf-8") as stream: for line_number, line in enumerate(stream, start=1): if not line.strip(): continue try: value = json.loads(line) except json.JSONDecodeError as error: raise ValueError(f"Invalid JSON at {path}:{line_number}: {error}") from error if not isinstance(value, dict): raise ValueError(f"Expected an object at {path}:{line_number}") yield value def normalize_label(value: Any) -> str | None: label = str(value or "").strip().lower() if label.startswith("verdict:"): label = label.split(":", 1)[1].strip() return label if label in {"real", "fake"} else None def prediction_index(path: Path) -> dict[str, dict[str, Any]]: result: dict[str, dict[str, Any]] = {} for row in read_jsonl(path): record_id = str(row.get("record_id") or "").strip() if not record_id: raise ValueError(f"Missing record_id in {path}") if record_id in result: raise ValueError(f"Duplicate record_id in {path}: {record_id}") label = normalize_label(row.get("verdict", row.get("label"))) result[record_id] = {**row, "label": label} return result def ground_truth_rows(dataset: Any) -> list[dict[str, Any]]: columns = [name for name in dataset.column_names if name != "image"] return [{name: row[name] for name in columns} for row in dataset] def merge_predictions( truth: list[dict[str, Any]], predictions: dict[str, dict[str, Any]], *, strict: bool, ) -> tuple[list[dict[str, Any]], dict[str, Any]]: truth_ids = {str(row["record_id"]) for row in truth} unknown = sorted(set(predictions) - truth_ids) if unknown: raise ValueError(f"Predictions contain {len(unknown)} unknown record_id values; first: {unknown[0]}") merged = [] missing = [] for row in truth: record_id = str(row["record_id"]) prediction = predictions.get(record_id) if prediction is None: missing.append(record_id) prediction = {"label": None} merged.append({**row, "prediction": prediction}) if strict and missing: raise ValueError(f"Missing {len(missing)} predictions; first: {missing[0]}") return merged, { "expected": len(truth), "submitted": len(predictions), "matched": len(truth) - len(missing), "missing": len(missing), "coverage": (len(truth) - len(missing)) / len(truth) if truth else 0.0, } def binary_metrics(rows: list[dict[str, Any]]) -> dict[str, Any]: matrix: Counter[tuple[str, str]] = Counter() parsed = 0 for row in rows: target = str(row["target_label"]).lower() predicted = row["prediction"].get("label") if predicted in {"real", "fake"}: parsed += 1 matrix[(target, predicted)] += 1 tp = matrix[("fake", "fake")] tn = matrix[("real", "real")] fp = matrix[("real", "fake")] fn = matrix[("fake", "real")] fake_precision = tp / (tp + fp) if tp + fp else 0.0 fake_recall = tp / (tp + fn) if tp + fn else 0.0 fake_f1 = ( 2 * fake_precision * fake_recall / (fake_precision + fake_recall) if fake_precision + fake_recall else 0.0 ) real_precision = tn / (tn + fn) if tn + fn else 0.0 real_recall = tn / (tn + fp) if tn + fp else 0.0 real_f1 = ( 2 * real_precision * real_recall / (real_precision + real_recall) if real_precision + real_recall else 0.0 ) n = len(rows) return { "n": n, "parsed": parsed, "coverage": parsed / n if n else 0.0, "accuracy": (tp + tn) / n if n else 0.0, "fake_precision": fake_precision, "fake_recall": fake_recall, "fake_f1": fake_f1, "macro_f1": (fake_f1 + real_f1) / 2, "confusion": {"tp_fake": tp, "tn_real": tn, "fp_fake": fp, "fn_fake": fn}, } def grouped_metrics(rows: list[dict[str, Any]], field: str) -> dict[str, Any]: groups: dict[str, list[dict[str, Any]]] = defaultdict(list) for row in rows: groups[str(row.get(field) or "unknown")].append(row) return {key: binary_metrics(values) for key, values in sorted(groups.items())} def five_view_metrics(rows: list[dict[str, Any]]) -> dict[str, Any]: by_view: dict[str, list[dict[str, Any]]] = defaultdict(list) by_group: dict[str, dict[str, dict[str, Any]]] = defaultdict(dict) for row in rows: by_view[str(row["view_id"])].append(row) by_group[str(row["group_id"])][str(row["view_id"])] = row complete = 0 all_correct = 0 contrast = Counter() for views in by_group.values(): if not set(VIEWS).issubset(views): continue complete += 1 labels = {view: views[view]["prediction"].get("label") for view in VIEWS} contrast["authentic_recovery"] += int( labels["forged_original"] == "fake" and labels["authentic_source"] == "real" ) contrast["global_evidence_sufficiency"] += int( labels["forged_original"] == "fake" and labels["local_restored"] == "fake" ) contrast["local_evidence_sufficiency"] += int( labels["authentic_source"] == "real" and labels["local_forged_only"] == "fake" ) contrast["benign_nuisance_invariance"] += int( labels["authentic_source"] == "real" and labels["authentic_nuisance"] == "real" ) targets = {view: ("real" if view in {"authentic_source", "authentic_nuisance"} else "fake") for view in VIEWS} all_correct += int(all(labels[view] == targets[view] for view in VIEWS)) return { "overall": binary_metrics(rows), "by_view": {key: binary_metrics(values) for key, values in sorted(by_view.items())}, "complete_groups": complete, "five_view_consistency": all_correct / complete if complete else 0.0, "paired_contrasts": { key: value / complete if complete else 0.0 for key, value in sorted(contrast.items()) }, "by_modality": grouped_metrics(rows, "modality"), "by_forgery_type": grouped_metrics(rows, "forgery_type"), "by_generator": grouped_metrics(rows, "generator"), } def reasoning_metrics(rows: list[dict[str, Any]]) -> dict[str, Any]: totals = Counter() by_view: dict[str, Counter[str]] = defaultdict(Counter) group_checks: dict[str, list[bool]] = defaultdict(list) failures = [] for row in rows: view = str(row["view_id"]) expected_label, expected_types, expected_locations = EXPECTED_REASONING[view] prediction = row["prediction"] evidence_type = str(prediction.get("evidence_type") or "").strip().lower() location = str(prediction.get("evidence_location") or "").strip().lower() label_ok = prediction.get("label") == expected_label type_ok = evidence_type in expected_types location_ok = location in expected_locations joint = label_ok and type_ok and location_ok values = { "n": 1, "verdict_ok": int(label_ok), "evidence_type_ok": int(type_ok), "evidence_location_ok": int(location_ok), "joint_alignment": int(joint), } totals.update(values) by_view[view].update(values) group_checks[str(row["group_id"])].append(joint) if not joint and len(failures) < 20: failures.append({ "record_id": row["record_id"], "expected": { "verdict": expected_label, "evidence_type": sorted(expected_types), "evidence_location": sorted(expected_locations), }, "prediction": prediction, }) def rates(values: Counter[str]) -> dict[str, float | int]: n = values["n"] return {key: (value if key == "n" else value / n if n else 0.0) for key, value in values.items()} return { "overall": rates(totals), "by_view": {key: rates(values) for key, values in sorted(by_view.items())}, "five_view_strict_alignment": ( sum(len(values) == len(VIEWS) and all(values) for values in group_checks.values()) / len(group_checks) if group_checks else 0.0 ), "failure_examples": failures, } def load_truth(repo_id: str, cache_dir: str | None) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: ordinary = load_dataset(repo_id, "ordinary", split="test", cache_dir=cache_dir) five_view = load_dataset(repo_id, "five_view", split="test", cache_dir=cache_dir) return ground_truth_rows(ordinary), ground_truth_rows(five_view) def main() -> None: parser = argparse.ArgumentParser(description="Score a CausalMedBench submission") parser.add_argument("--ordinary-predictions", type=Path) parser.add_argument("--five-view-predictions", type=Path) parser.add_argument("--reasoning-predictions", type=Path) parser.add_argument("--output", type=Path, required=True) parser.add_argument("--repo-id", default=REPO_ID) parser.add_argument("--cache-dir") parser.add_argument("--allow-partial", action="store_true") args = parser.parse_args() if not any((args.ordinary_predictions, args.five_view_predictions, args.reasoning_predictions)): parser.error("provide at least one prediction file") ordinary_truth, five_view_truth = load_truth(args.repo_id, args.cache_dir) report: dict[str, Any] = { "schema_version": "causalmedbench-score-v1.0", "repo_id": args.repo_id, } strict = not args.allow_partial if args.ordinary_predictions: rows, coverage = merge_predictions( ordinary_truth, prediction_index(args.ordinary_predictions), strict=strict ) report["ordinary_submission"] = coverage report["ordinary_task"] = { "overall": binary_metrics(rows), "by_modality": grouped_metrics(rows, "modality"), "by_forgery_type": grouped_metrics(rows, "forgery_type"), "by_generator": grouped_metrics(rows, "generator"), } if args.five_view_predictions: rows, coverage = merge_predictions( five_view_truth, prediction_index(args.five_view_predictions), strict=strict ) report["five_view_submission"] = coverage report["five_view"] = five_view_metrics(rows) if args.reasoning_predictions: reasoning_truth = [row for row in five_view_truth if row.get("is_reasoning_subset")] rows, coverage = merge_predictions( reasoning_truth, prediction_index(args.reasoning_predictions), strict=strict ) report["reasoning_submission"] = coverage report["explanation_alignment"] = reasoning_metrics(rows) args.output.parent.mkdir(parents=True, exist_ok=True) args.output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") print(json.dumps(report, ensure_ascii=False, indent=2)) if __name__ == "__main__": main()