| """Analyze the frozen CLEVR/GQA views without assuming five-state groups.""" |
| import argparse |
| import json |
| import unicodedata |
| from collections import Counter, defaultdict |
| from fractions import Fraction |
| from pathlib import Path |
|
|
| import numpy as np |
| from analyze_visual_judges import ratio, valid_parsed |
|
|
| STATES = {"clevr": {"FULL", "A_SAME", "A_CHANGED", "U_MISSING"}, |
| "gqa": {"FULL", "A_SAME", "U_MISSING"}} |
|
|
|
|
| def strict_answer_match(answer, target): |
| if answer is None or target is None: |
| return False |
| try: |
| return Fraction(str(answer).strip()) == Fraction(str(target).strip()) |
| except (ValueError, ZeroDivisionError): |
| pass |
| normalize = lambda value: " ".join(unicodedata.normalize("NFKC", str(value)).lower().split()) |
| return normalize(answer) == normalize(target) |
|
|
|
|
| def validate_inputs(labels, items): |
| gold = {r["item_id"]: r for r in labels} |
| blind = {r["item_id"]: r for r in items} |
| expected = {f"cross-{i:05d}" for i in range(7000)} |
| if len(labels) != 7000 or len(items) != 7000 or set(gold) != expected or set(blind) != expected: |
| raise ValueError("expected the same 7,000 distinct frozen input IDs") |
| groups = defaultdict(list) |
| for row in labels: |
| groups[(row["source"], row["group_id"])].append(row) |
| if type(row["answerable"]) is not bool or row["answerable"] != (not row["state"].startswith("U_")): |
| raise ValueError("inconsistent frozen answerability label") |
| if Counter(source for source, _ in groups) != {"clevr": 1000, "gqa": 1000}: |
| raise ValueError("expected 1,000 groups from each source") |
| for (source, _), rows in groups.items(): |
| if len(rows) != len(STATES[source]) or {r["state"] for r in rows} != STATES[source]: |
| raise ValueError("source-specific state coverage mismatch") |
| return gold, blind |
|
|
|
|
| def group_interval(numerators, denominators, draws=10000): |
| if not draws or not sum(denominators): |
| return None |
| rng = np.random.default_rng(20260915) |
| n, d = np.asarray(numerators), np.asarray(denominators) |
| values = [] |
| for start in range(0, draws, 250): |
| indices = rng.integers(0, len(n), size=(min(250, draws-start), len(n))) |
| sums = d[indices].sum(axis=1) |
| valid = sums > 0 |
| values.extend((n[indices].sum(axis=1)[valid] / sums[valid]).tolist()) |
| return [float(x) for x in np.quantile(values, [.025, .975])] if values else None |
|
|
|
|
| def summarize(labels, records, draws=10000): |
| groups = defaultdict(list) |
| state_metrics = {} |
| wrong, invalid, rejected, accepted = [], [], [], [] |
| answer_correct = 0 |
| for row in labels: |
| item_id = row["item_id"] |
| parsed = valid_parsed(records[item_id]) |
| bad_output = parsed is None |
| error = not bad_output and parsed["answerable"] != row["answerable"] |
| groups[(row["source"], row["group_id"])].append((int(error), int(bad_output))) |
| if bad_output: |
| invalid.append(item_id) |
| elif error: |
| wrong.append(item_id) |
| (rejected if row["answerable"] else accepted).append(item_id) |
| if parsed and row["answerable"] and parsed["answerable"]: |
| answer_correct += strict_answer_match(parsed["answer"], row["target"]) |
| for state in sorted({r["state"] for r in labels}): |
| ids = {r["item_id"] for r in labels if r["state"] == state} |
| n_bad = len(ids & set(invalid)) |
| n_wrong = len(ids & set(wrong)) |
| state_metrics[state] = dict(total=len(ids), invalid=n_bad, |
| errors_on_valid=ratio(n_wrong, len(ids)-n_bad), |
| failures_full_denominator=ratio(n_wrong+n_bad, len(ids))) |
| group_errors = [sum(x[0] for x in rows) for rows in groups.values()] |
| group_bad = [sum(x[1] for x in rows) for rows in groups.values()] |
| group_sizes = [len(rows) for rows in groups.values()] |
| answerable = sum(r["answerable"] for r in labels) |
| valid_answerable = sum(r["answerable"] and r["item_id"] not in set(invalid) for r in labels) |
| valid_unanswerable = len(labels)-len(invalid)-valid_answerable |
| return dict(views=len(labels), groups=len(groups), valid_judgments=len(labels)-len(invalid), |
| invalid_outputs=len(invalid), answerability_errors=ratio(len(wrong),len(labels)-len(invalid)), |
| failures_full_denominator=ratio(len(wrong)+len(invalid),len(labels)), |
| answerability_error_group_bootstrap_95=group_interval(group_errors, |
| [n-b for n,b in zip(group_sizes,group_bad)],draws), |
| failure_group_bootstrap_95=group_interval( |
| [e+b for e,b in zip(group_errors,group_bad)],group_sizes,draws), |
| false_reject_on_valid_answerable=ratio(len(rejected),valid_answerable), |
| false_accept_on_valid_unanswerable=ratio(len(accepted),valid_unanswerable), |
| groups_all_states_correct=ratio(sum(e+b==0 for e,b in zip(group_errors,group_bad)),len(groups)), |
| answer_correct_on_all_answerable_strict_lower_bound=ratio(answer_correct,answerable), |
| states=state_metrics, wrong_item_ids=wrong, invalid_item_ids=invalid) |
|
|
|
|
| def analyze(labels, items, model_rows, draws=10000): |
| gold, blind = validate_inputs(labels, items) |
| models = {} |
| for name, rows in model_rows.items(): |
| records = {} |
| for row in rows: |
| item_id = row.get("item_id") |
| if item_id not in gold or item_id in records: |
| raise ValueError(f"{name}: unknown or duplicate output ID") |
| if row.get("question") != blind[item_id]["question"]: |
| raise ValueError(f"{name}: output question differs from frozen input") |
| if row.get("status") != "completed" and not ( |
| row.get("status") == "invalid_schema" and row.get("terminal_invalid") is True): |
| raise ValueError(f"{name}: unfinished request {item_id}") |
| records[item_id] = row |
| if set(records) != set(gold): |
| raise ValueError(f"{name}: incomplete output coverage") |
| model = dict(actual_model_counts=dict(Counter(r.get("model_actual") or r.get("actual_model") for r in rows)), |
| overall=summarize(labels, records, draws), by_source={}) |
| for source in STATES: |
| model["by_source"][source] = summarize( |
| [r for r in labels if r["source"] == source], records, draws) |
| models[name] = model |
| return dict(schema_version=1, sample=dict(views=7000, groups=2000, |
| source_views=dict(Counter(r["source"] for r in labels))), models=models, |
| method=dict(primary="agreement with frozen source-derived answerability labels", |
| output_failures="invalid outputs count as failures on the full denominator and are excluded from conditional decision-error rates", |
| group_success="all available states in each CLEVR four-view or GQA three-view group must be correct", |
| intervals="10,000 group-level bootstrap draws, seed 20260915; source-specific intervals keep sibling views together", |
| answers="strict rational equality for numeric answers; otherwise Unicode normalization, case and whitespace normalization followed by exact match", |
| new_mask_controls_included=False), |
| limitations=["GQA labels derive from scene annotations and do not establish that every visual clue in the photograph is exhausted.", |
| "Existing CLEVR/GQA validation views were reused; no new matched-mask control was performed.", |
| "Serving stacks differ between bridge APIs and Simflow vLLM."]) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--labels", type=Path, required=True) |
| parser.add_argument("--manifest", type=Path, required=True) |
| parser.add_argument("--model", action="append", required=True) |
| parser.add_argument("--output", type=Path, required=True) |
| args = parser.parse_args() |
| read_rows = lambda p: [json.loads(line) for line in Path(p).read_text().splitlines() if line.strip()] |
| rows = {} |
| for entry in args.model: |
| name, filename = entry.split("=",1) |
| if name in rows: |
| raise ValueError("duplicate model key") |
| rows[name] = read_rows(filename) |
| result = analyze(json.loads(args.labels.read_text()), read_rows(args.manifest), 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:{s:{"errors":v["answerability_errors"], |
| "groups_correct":v["groups_all_states_correct"]} for s,v in m["by_source"].items()} |
| for name,m in result["models"].items()})) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
