| |
| """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() |
|
|
|
|
