scripts/evaluate_public_methods.py

#!/usr/bin/env python3
"""Evaluate public-input-only methods by origin with authority-grouped intervals."""

from __future__ import annotations

import argparse
import json
import random
from collections import defaultdict
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]


def load_jsonl(path: Path) -> list[dict]:
    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]


def load_inputs() -> dict[str, dict]:
    return {
        row["case_id"]: row
        for split in ("development", "validation", "test")
        for row in load_jsonl(ROOT / f"hf/closed_loop_inputs/{split}.jsonl")
    }


def load_labels() -> dict[str, dict]:
    paths = [
        ROOT / "hf/public_labels/development.jsonl",
        ROOT / "hf/public_labels/validation.jsonl",
        ROOT / "private/sealed_labels/test.jsonl",
    ]
    return {row["case_id"]: row for path in paths for row in load_jsonl(path)}


def case_metrics(row: dict, label: dict, pred: dict) -> dict[str, float]:
    gold = label["gold"]
    target_path = set(gold["affected_components"])
    target_scope = set(gold["revalidation_components"])
    path = set(pred["affected_components"])
    scope = set(pred["revalidation_components"])
    reviewed = set(pred.get("reviewed_components", pred["revalidation_components"]))
    auditable = {node["node_id"] for node in row["workflow"]["components"] if node["node_type"] != "provenance"}
    predicted_release = float(pred["release_permitted"])
    release_opportunity = float(gold["release_permitted"])
    safe_release = float(pred["release_permitted"] and gold["release_permitted"])
    unsafe = float(pred["release_permitted"] and not gold["release_permitted"])
    path_recall = len(path & target_path) / len(target_path) if target_path else float(not path)
    scope_recall = len(scope & target_scope) / len(target_scope) if target_scope else float(not scope)
    action = float(pred["governance_action"] == gold["governance_action"])
    safe_loop = float(action and not unsafe and path_recall == 1 and scope_recall == 1)
    return {
        "action_accuracy": action,
        "release_rate": predicted_release,
        "release_opportunity": release_opportunity,
        "unsafe_opportunity": 1.0 - release_opportunity,
        "safe_release": safe_release,
        "unsafe_release": unsafe,
        "exact_path": float(path == target_path),
        "exact_scope": float(scope == target_scope),
        "path_recall": path_recall,
        "scope_recall": scope_recall,
        "safe_loop": safe_loop,
        "review_fraction": len(reviewed & auditable) / max(1, len(auditable)),
    }


def summarize(records: list[tuple[str, dict[str, float]]], bootstrap: int, seed: int) -> dict:
    internal = {"release_opportunity", "unsafe_opportunity", "safe_release"}
    metrics = sorted(set(records[0][1]) - internal)
    point = {metric: sum(item[metric] for _, item in records) / len(records) for metric in metrics}
    release_opportunities = sum(item["release_opportunity"] for _, item in records)
    point["safe_release_recall"] = (
        sum(item["safe_release"] for _, item in records) / release_opportunities
        if release_opportunities
        else None
    )
    unsafe_opportunities = sum(item["unsafe_opportunity"] for _, item in records)
    point["unsafe_case_release_rate"] = (
        sum(item["unsafe_release"] for _, item in records) / unsafe_opportunities
        if unsafe_opportunities
        else None
    )
    by_group: dict[str, list[dict[str, float]]] = defaultdict(list)
    for group, item in records:
        by_group[group].append(item)
    groups = sorted(by_group)
    rng = random.Random(seed)
    draws = {metric: [] for metric in metrics}
    safe_release_recall_draws = []
    unsafe_case_release_rate_draws = []
    for _ in range(bootstrap):
        sampled = [rng.choice(groups) for _ in groups]
        rows = [item for group in sampled for item in by_group[group]]
        for metric in metrics:
            draws[metric].append(sum(item[metric] for item in rows) / len(rows))
        opportunities = sum(item["release_opportunity"] for item in rows)
        if opportunities:
            safe_release_recall_draws.append(sum(item["safe_release"] for item in rows) / opportunities)
        unsafe_opportunities = sum(item["unsafe_opportunity"] for item in rows)
        if unsafe_opportunities:
            unsafe_case_release_rate_draws.append(
                sum(item["unsafe_release"] for item in rows) / unsafe_opportunities
            )
    ci = {}
    for metric in metrics:
        values = sorted(draws[metric])
        ci[metric] = [values[int(0.025 * (len(values) - 1))], values[int(0.975 * (len(values) - 1))]]
    if safe_release_recall_draws:
        values = sorted(safe_release_recall_draws)
        ci["safe_release_recall"] = [
            values[int(0.025 * (len(values) - 1))],
            values[int(0.975 * (len(values) - 1))],
        ]
    else:
        ci["safe_release_recall"] = [None, None]
    if unsafe_case_release_rate_draws:
        values = sorted(unsafe_case_release_rate_draws)
        ci["unsafe_case_release_rate"] = [
            values[int(0.025 * (len(values) - 1))],
            values[int(0.975 * (len(values) - 1))],
        ]
    else:
        ci["unsafe_case_release_rate"] = [None, None]
    return {"cases": len(records), "groups": len(groups), "point": point, "clustered_95_ci": ci}


def paired_difference(
    inputs: dict[str, dict],
    left: dict[str, dict[str, float]],
    right: dict[str, dict[str, float]],
    bootstrap: int,
    seed: int,
) -> dict:
    """Authority-clustered paired differences, left minus right."""
    metrics = sorted(
        set(next(iter(left.values())))
        - {"release_opportunity", "unsafe_opportunity", "safe_release"}
    )
    by_group: dict[str, list[str]] = defaultdict(list)
    for case_id, row in inputs.items():
        by_group[row["workflow_context"]["authority_id"]].append(case_id)
    groups = sorted(by_group)

    def difference(case_ids: list[str], metric: str) -> float:
        return sum(left[case_id][metric] - right[case_id][metric] for case_id in case_ids) / len(case_ids)

    all_ids = list(inputs)
    point = {metric: difference(all_ids, metric) for metric in metrics}
    rng = random.Random(seed)
    draws = {metric: [] for metric in metrics}
    for _ in range(bootstrap):
        sampled = [rng.choice(groups) for _ in groups]
        case_ids = [case_id for group in sampled for case_id in by_group[group]]
        for metric in metrics:
            draws[metric].append(difference(case_ids, metric))
    ci = {}
    for metric, values in draws.items():
        ordered = sorted(values)
        ci[metric] = [ordered[int(0.025 * (len(ordered) - 1))], ordered[int(0.975 * (len(ordered) - 1))]]
    return {"cases": len(all_ids), "groups": len(groups), "point": point, "clustered_95_ci": ci}


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--prediction-dir", type=Path, default=ROOT / "results/public_predictions")
    parser.add_argument("--output", type=Path, default=ROOT / "results/fingovbench_public_comparison.json")
    parser.add_argument("--bootstrap", type=int, default=2000)
    parser.add_argument("--case-origin", choices=("controlled", "genuine_revision"))
    parser.add_argument("--split", choices=("development", "validation", "test"))
    parser.add_argument("--limit", type=int)
    parser.add_argument(
        "--methods", nargs="+",
        default=("lexical", "direct_llm", "flat_point", "flat_uq", "graph_propagation"),
    )
    args = parser.parse_args()
    inputs, labels = load_inputs(), load_labels()
    if args.split:
        selected = {
            row["case_id"]
            for row in load_jsonl(ROOT / f"hf/closed_loop_inputs/{args.split}.jsonl")
        }
        inputs = {case_id: row for case_id, row in inputs.items() if case_id in selected}
        labels = {case_id: row for case_id, row in labels.items() if case_id in selected}
    if args.case_origin:
        selected = {case_id for case_id, row in inputs.items() if row["case_origin"] == args.case_origin}
        inputs = {case_id: row for case_id, row in inputs.items() if case_id in selected}
        labels = {case_id: row for case_id, row in labels.items() if case_id in selected}
    if args.limit:
        selected = set(sorted(inputs)[: args.limit])
        inputs = {case_id: row for case_id, row in inputs.items() if case_id in selected}
        labels = {case_id: row for case_id, row in labels.items() if case_id in selected}
    report = {
        "benchmark_version": "1.0.0-rc4",
        "evaluation_scope": "/".join(
            part for part in (args.split, args.case_origin) if part
        ) or "all",
        "label_status": "contract-derived; external expert adjudication pending",
        "methods": {},
    }
    metric_rows_by_method: dict[str, dict[str, dict[str, float]]] = {}
    for method in args.methods:
        predictions = {
            row["case_id"]: row
            for row in load_jsonl(args.prediction_dir / f"{method}.jsonl")
            if row["case_id"] in inputs
        }
        if set(predictions) != set(inputs):
            raise SystemExit(f"{method}: predictions do not match the {len(inputs)} public inputs")
        metric_rows_by_method[method] = {
            case_id: case_metrics(inputs[case_id], labels[case_id], predictions[case_id])
            for case_id in inputs
        }
        method_report = {}
        origins = [origin for origin in ("genuine_revision", "controlled") if any(row["case_origin"] == origin for row in inputs.values())]
        for origin in (*origins, "all"):
            ids = [case_id for case_id, row in inputs.items() if origin == "all" or row["case_origin"] == origin]
            records = [
                (inputs[case_id]["workflow_context"]["authority_id"], case_metrics(inputs[case_id], labels[case_id], predictions[case_id]))
                for case_id in ids
            ]
            method_report[origin] = summarize(records, args.bootstrap, seed=20260921)
        method_report["controlled_scenarios"] = {}
        scenarios = sorted({
            label["evaluation_strata"]["scenario"]
            for label in labels.values()
            if label["evaluation_strata"]["origin"] == "controlled"
        })
        for scenario in scenarios:
            ids = [
                case_id for case_id, label in labels.items()
                if label["evaluation_strata"]["origin"] == "controlled"
                and label["evaluation_strata"]["scenario"] == scenario
            ]
            records = [
                (inputs[case_id]["workflow_context"]["authority_id"], case_metrics(inputs[case_id], labels[case_id], predictions[case_id]))
                for case_id in ids
            ]
            method_report["controlled_scenarios"][scenario] = summarize(records, args.bootstrap, seed=20260921)
        report["methods"][method] = method_report
    report["paired_comparisons"] = {}
    if "graph_propagation" in metric_rows_by_method and "flat_uq" in metric_rows_by_method:
        report["paired_comparisons"]["graph_propagation_minus_flat_uq"] = paired_difference(
            inputs,
            metric_rows_by_method["graph_propagation"],
            metric_rows_by_method["flat_uq"],
            args.bootstrap,
            seed=20260922,
        )
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
    print(json.dumps(report, indent=2, sort_keys=True))


if __name__ == "__main__":
    main()