scripts/analyze_visual_judges.py

#!/usr/bin/env python3
"""Analyze blinded visual-answerability judgments on the fixed five-view groups."""
from __future__ import annotations

import argparse
import json
import math
import random
import re
from collections import Counter
from fractions import Fraction
from pathlib import Path

STATES = ["FULL", "A_SAME", "A_CHANGED", "U_MISSING", "U_INVALID"]


def ratio(numerator: int, denominator: int) -> dict:
    return {
        "numerator": int(numerator),
        "denominator": int(denominator),
        "value": float(numerator / denominator) if denominator else None,
    }


def number(value):
    """Conservative numeric parser retained from the original pilot analysis."""
    if value is None:
        return None
    text = str(value).strip().replace(",", "")
    match = re.fullmatch(
        r"[$€£]?\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:/\d+)?)\s*(thousand|million|billion|%)?",
        text,
        re.I,
    )
    if not match:
        return None
    try:
        factor = {
            "thousand": 1_000,
            "million": 1_000_000,
            "billion": 1_000_000_000,
        }.get((match[2] or "").lower(), 1)
        return Fraction(match[1]) * factor
    except (ValueError, ZeroDivisionError):
        return None


def wilson_interval(successes: int, total: int, z: float = 1.959963984540054) -> list[float] | None:
    if not total:
        return None
    proportion = successes / total
    denominator = 1 + z * z / total
    center = (proportion + z * z / (2 * total)) / denominator
    margin = z * math.sqrt(proportion * (1 - proportion) / total + z * z / (4 * total * total)) / denominator
    return [max(0.0, center - margin), min(1.0, center + margin)]


def clustered_interval(group_numerators: list[int], group_denominators: list[int], seed: int = 20260914) -> list[float] | None:
    if not group_denominators or not sum(group_denominators):
        return None
    rng = random.Random(seed)
    values = []
    size = len(group_denominators)
    for _ in range(10_000):
        selected = [rng.randrange(size) for _ in range(size)]
        denominator = sum(group_denominators[index] for index in selected)
        if denominator:
            values.append(sum(group_numerators[index] for index in selected) / denominator)
    if not values:
        return None
    values.sort()
    return [values[int(0.025 * (len(values) - 1))], values[int(0.975 * (len(values) - 1))]]


def valid_parsed(row: dict) -> dict | None:
    parsed = row.get("parsed")
    if row.get("status") != "completed" or not isinstance(parsed, dict):
        return None
    if type(parsed.get("answerable")) is not bool:
        return None
    if parsed.get("answer") is not None and not isinstance(parsed.get("answer"), str):
        return None
    if not isinstance(parsed.get("reason"), str) or not parsed["reason"].strip():
        return None
    if not parsed["answerable"] and parsed.get("answer") is not None:
        return None
    return parsed


def analyze(labels: list[dict], model_rows: dict[str, list[dict]]) -> dict:
    if not labels or len({row["item_id"] for row in labels}) != len(labels):
        raise ValueError("expected a non-empty set of unique labels")
    gold = {row["item_id"]: row for row in labels}
    group_ids = sorted({row["group_id"] for row in labels})
    for group_id in group_ids:
        group_rows = [row for row in labels if row["group_id"] == group_id]
        if len(group_rows) != 5 or {row["state"] for row in group_rows} != set(STATES):
            raise ValueError(f"expected one of every state in five-view group {group_id}")
    is_full_primary = len(group_ids) == 1000 and len(labels) == 5000
    output = {
        "schema_version": 1,
        "sample": {
            "groups": len(group_ids),
            "views": len(labels),
            "answerable": sum(bool(row["answerable"]) for row in labels),
            "unanswerable": sum(not bool(row["answerable"]) for row in labels),
            "state_counts": dict(Counter(row["state"] for row in labels)),
        },
        "models": {},
        "pairwise": {},
        "method": {
            "primary": "binary answerability agreement with frozen executable-certificate labels",
            "invalid_outputs": "answerability error is conditional on a valid judgment; full-denominator failure counts invalid or missing judgments as failures without imputing an answerability decision",
            "false_decision_rates": "full-population false-accept/reject fractions are lower bounds when judgments are invalid; conditional rates use only valid judgments in the corresponding truth class",
            "group_success": "all five states in a source group must have the correct answerability decision",
            "item_interval": "Wilson score 95% interval",
            "cluster_interval": "10,000 group bootstrap draws, seed 20260914; all five views resampled together",
            "numeric": "strict rational parse and exact equality; units, explanatory strings, and rounding may remain unparsed, so this is a conservative lower bound",
            "blinding": "labels are loaded only by this analysis after inference; judge runners received no group, state, target, gold, or sibling-view fields",
        },
        "limitations": [
            (
                "This is the complete frozen 1,000-group/5,000-view PlotQA D15 primary split, not a general VLM benchmark."
                if is_full_primary else
                f"This is a fixed {len(group_ids)}-group/{len(labels)}-view PlotQA D15 evaluation, not a general VLM benchmark."
            ),
            "Request interfaces and serving stacks are recorded per model and may differ; outcomes are not a pure architecture comparison.",
            "Certificate agreement measures answerability behavior on this frozen split and does not establish universal visual reliability.",
        ],
    }
    correctness_masks: dict[str, dict[str, bool]] = {}
    predictions: dict[str, dict[str, bool]] = {}

    for name, records in model_rows.items():
        rows = {}
        for row in records:
            item_id = row.get("item_id")
            if item_id not in gold:
                raise ValueError(f"{name}: unknown item {item_id}")
            if item_id in rows:
                raise ValueError(f"{name}: duplicate item {item_id}")
            rows[item_id] = row

        invalid = []
        wrong = []
        false_reject = []
        false_accept = []
        predictions[name] = {}
        correctness_masks[name] = {}
        numeric_parseable = 0
        numeric_correct = 0
        durations = []
        actual_models = Counter()
        image_interfaces = Counter()
        attempts = []
        state_metrics = {}

        for item_id, label in gold.items():
            row = rows.get(item_id, {})
            parsed = valid_parsed(row)
            if parsed is None:
                invalid.append(item_id)
                correctness_masks[name][item_id] = False
                continue
            prediction = parsed["answerable"]
            predictions[name][item_id] = prediction
            correct = prediction == bool(label["answerable"])
            correctness_masks[name][item_id] = correct
            if not correct:
                wrong.append(item_id)
                (false_reject if label["answerable"] else false_accept).append(item_id)
            if label["answerable"] and prediction:
                parsed_number = number(parsed.get("answer"))
                if parsed_number is not None:
                    numeric_parseable += 1
                    if parsed_number == number(label["target"]):
                        numeric_correct += 1
            if isinstance(row.get("duration_seconds"), (int, float)):
                durations.append(float(row["duration_seconds"]))
            actual_models[str(row.get("model_actual") or row.get("actual_model") or "(missing)")] += 1
            image_interfaces[str(row.get("image_interface") or "(missing)")] += 1
            attempts.append(int(row.get("attempts") or row.get("attempt") or 1))

        for state in STATES:
            ids = [item_id for item_id, label in gold.items() if label["state"] == state]
            errors = [item_id for item_id in ids if item_id in wrong]
            invalid_ids = [item_id for item_id in ids if item_id in invalid]
            state_metrics[state] = {
                "total": len(ids),
                "valid": len(ids) - len(invalid_ids),
                "errors": len(errors),
                "answerability_errors_on_valid": ratio(len(errors), len(ids) - len(invalid_ids)),
                "failures_including_invalid": ratio(len(errors) + len(invalid_ids), len(ids)),
                "error_item_ids": errors,
                "invalid_item_ids": invalid_ids,
            }

        group_error_counts = []
        group_valid_counts = []
        group_failure_counts = []
        group_sizes = []
        correct_groups = []
        wrong_groups = []
        for group_id in group_ids:
            ids = [item_id for item_id, label in gold.items() if label["group_id"] == group_id]
            valid_ids = [item_id for item_id in ids if item_id in predictions[name]]
            errors = sum(not correctness_masks[name][item_id] for item_id in valid_ids)
            failures = sum(not correctness_masks[name].get(item_id, False) for item_id in ids)
            group_error_counts.append(errors)
            group_valid_counts.append(len(valid_ids))
            group_failure_counts.append(failures)
            group_sizes.append(len(ids))
            (correct_groups if failures == 0 else wrong_groups).append(group_id)

        valid_count = len(labels) - len(invalid)
        error_count = len(wrong)
        valid_answerable = sum(bool(gold[item_id]["answerable"]) for item_id in predictions[name])
        valid_unanswerable = valid_count - valid_answerable
        output["models"][name] = {
            "attempted_items": len(rows),
            "valid_judgments": valid_count,
            "invalid_or_missing": len(invalid),
            "answerability_errors": ratio(error_count, valid_count),
            "answerability_error_wilson_95": wilson_interval(error_count, valid_count),
            "answerability_error_group_bootstrap_95": clustered_interval(group_error_counts, group_valid_counts),
            "error_fraction_if_invalid_count_wrong": ratio(error_count + len(invalid), len(labels)),
            "failure_group_bootstrap_95": clustered_interval(group_failure_counts, group_sizes),
            "answerability_error_bounds_full_denominator": [
                error_count / len(labels), (error_count + len(invalid)) / len(labels)
            ],
            "false_reject_answerable": ratio(len(false_reject), sum(row["answerable"] for row in labels)),
            "false_accept_unanswerable": ratio(len(false_accept), sum(not row["answerable"] for row in labels)),
            "false_reject_on_valid_answerable": ratio(len(false_reject), valid_answerable),
            "false_accept_on_valid_unanswerable": ratio(len(false_accept), valid_unanswerable),
            "five_view_groups_all_correct": ratio(len(correct_groups), len(group_ids)),
            "answer_correct_on_all_answerable_strict_lower_bound": ratio(numeric_correct, sum(row["answerable"] for row in labels)),
            "numeric_parseable_on_answerable": ratio(numeric_parseable, sum(row["answerable"] for row in labels)),
            "numeric_correct_among_parseable": ratio(numeric_correct, numeric_parseable),
            "state_counts": state_metrics,
            "wrong_item_ids": wrong,
            "wrong_items": [{
                "item_id": item_id,
                "group_id": gold[item_id]["group_id"],
                "state": gold[item_id]["state"],
                "question": rows[item_id].get("question"),
                "predicted_answerable": rows[item_id]["parsed"]["answerable"],
                "predicted_answer": rows[item_id]["parsed"].get("answer"),
                "reason": rows[item_id]["parsed"].get("reason"),
            } for item_id in wrong],
            "wrong_group_ids": wrong_groups,
            "invalid_item_ids": invalid,
            "actual_model_counts": dict(actual_models),
            "image_interface_counts": dict(image_interfaces),
            "retried_items": sum(value > 1 for value in attempts),
            "maximum_attempt_number": max(attempts, default=None),
            "mean_seconds_per_completed_item": sum(durations) / len(durations) if durations else None,
            "total_seconds_summed_across_requests": sum(durations),
        }

    names = list(model_rows)
    for left_index, left in enumerate(names):
        for right in names[left_index + 1 :]:
            both = sorted(set(predictions[left]) & set(predictions[right]))
            disagreement = [item_id for item_id in both if predictions[left][item_id] != predictions[right][item_id]]
            both_wrong = [item_id for item_id in both if not correctness_masks[left][item_id] and not correctness_masks[right][item_id]]
            left_only_wrong = [item_id for item_id in both if not correctness_masks[left][item_id] and correctness_masks[right][item_id]]
            right_only_wrong = [item_id for item_id in both if correctness_masks[left][item_id] and not correctness_masks[right][item_id]]
            output["pairwise"][f"{left}__{right}"] = {
                "models": [left, right],
                "both_valid": len(both),
                "answerability_disagreement": ratio(len(disagreement), len(both)),
                "both_wrong": len(both_wrong),
                "left_only_wrong": len(left_only_wrong),
                "right_only_wrong": len(right_only_wrong),
                "disagreement_item_ids": disagreement,
                "both_wrong_item_ids": both_wrong,
            }
    return output


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


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--labels", type=Path, required=True)
    parser.add_argument("--model", action="append", required=True, help="name=results.jsonl")
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args()
    rows = {}
    for value in args.model:
        name, filename = value.split("=", 1)
        if name in rows:
            raise ValueError(f"duplicate model name: {name}")
        rows[name] = load_jsonl(Path(filename))
    result = analyze(json.loads(args.labels.read_text()), rows)
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(json.dumps(result, ensure_ascii=False, indent=2, allow_nan=False) + "\n")
    print(json.dumps({name: {
        "errors": row["answerability_errors"],
        "groups_all_correct": row["five_view_groups_all_correct"],
        "strict_numeric_lower_bound": row["answer_correct_on_all_answerable_strict_lower_bound"],
    } for name, row in result["models"].items()}))


if __name__ == "__main__":
    main()