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