analysis/analyze_2x2.py

#!/usr/bin/env python3
"""2x2 quantization-regime study analysis (QAT Q4_0 vs PTQ Q4_K_M
across Gemma 4 12B dense and 26B MoE, governance routing tasks).

Reads operate-fr-bench row-level results + labels + suite datasets
(authoritative per-task family and smoke-stem ids); writes CSVs and a JSON
summary into ../data/. All routing statistics are recomputed from row
level. Exception: the safety-rate metrics (stale_commitment,
unsupported_current_claim, over_verification) quoted in the paper come
from the harness scorer's *_summary.json outputs, not from this script.
"""
import csv
import json
import random
from math import comb
from pathlib import Path

import os
R = Path(os.environ.get("OPFR_BENCH_ROOT", "."))  # root of a local operate-fr-bench checkout with reports/
OUT = Path(os.environ.get("STUDY_DATA_OUT", Path(__file__).resolve().parent.parent / "data"))
OUT.mkdir(exist_ok=True)

CELLS = {
    # (size, regime) -> {suite: results file}
    ("12B", "PTQ"): {
        "smoke": "gemma4_12b_route_transformer_plus_validator_v3_1_rerun_2026-08-10.jsonl",
        "core500": "gemma4_12b_core500_candidate_rerun_2026-08-10.jsonl",
    },
    ("12B", "QAT"): {
        "smoke": "gemma4_12b_qat_route_transformer_plus_validator_v3_1.jsonl",
        "core500": "gemma4_12b_qat_core500_candidate.jsonl",
    },
    ("26B", "PTQ"): {
        "smoke": "gemma4_26b_route_transformer_plus_validator_v3_1_rerun_2026-08-10.jsonl",
        "core500": "gemma4_26b_core500_candidate_rerun_2026-08-10.jsonl",
    },
    ("26B", "QAT"): {
        "smoke": "gemma4_26b_a4b_qat_route_transformer_plus_validator_v3_1.jsonl",
        "core500": "gemma4_26b_a4b_qat_core500_candidate.jsonl",
    },
}
LABELS = {
    "smoke": "data/labels/smoke100_route_labels.jsonl",
    "core500": "data/labels/core500_route_labels.jsonl",
}
DATASETS = {  # authoritative per-task family + stem ids
    "smoke": "data/smoke100.jsonl",
    "core500": "data/core500.jsonl",
}
REPEATS = {  # same-day second runs for ordinary-nondeterminism baseline
    ("12B", "PTQ"): "gemma4_12b_route_transformer_plus_validator_v3_1_repeat2.jsonl",
    ("12B", "QAT"): "gemma4_12b_qat_route_transformer_plus_validator_v3_1_repeat2.jsonl",
    ("26B", "QAT"): "gemma4_26b_a4b_qat_route_transformer_plus_validator_v3_1_repeat2.jsonl",
    ("26B", "PTQ"): "gemma4_26b_route_transformer_plus_validator_v3_1_repeat2.jsonl",
}


def load_labels(suite):
    out = {}
    for ln in open(R / LABELS[suite], encoding="utf-8"):
        d = json.loads(ln)
        out[d["task_id"]] = d
    return out


def load_dataset_meta(suite):
    """Authoritative task metadata: family + smoke stem id (for clustering)."""
    meta = {}
    for ln in open(R / DATASETS[suite], encoding="utf-8"):
        d = json.loads(ln)
        meta[d["id"]] = {
            "family": d["family"],
            "stem": d.get("source_smoke100_id") or d["id"],
        }
    return meta


def load_cell(fname, suite):
    rows = {}
    p = R / "reports" / fname
    for ln in open(p, encoding="utf-8"):
        d = json.loads(ln)
        rows[d["task_id"]] = d
    return rows


def correct(row, lab):
    return row["classified_route"] in lab["allowed_routes"]


def mcnemar_exact(n01, n10):
    n = n01 + n10
    if n == 0:
        return 1.0
    k = min(n01, n10)
    p = sum(comb(n, i) for i in range(0, k + 1)) * 2 / 2 ** n
    return min(1.0, p)


def main():
    labels = {s: load_labels(s) for s in ("smoke", "core500")}
    metas = {s: load_dataset_meta(s) for s in ("smoke", "core500")}
    cells = {}
    for key, files in CELLS.items():
        cells[key] = {s: load_cell(f, s) for s, f in files.items()}

    summary = {"cells": {}, "paired": {}, "interaction": {}, "divergence": {},
               "repeats": {}}

    # ── per-cell metrics ──
    cell_csv = [["size", "regime", "suite", "n", "errored",
                 "route_correct", "rate", "preferred_match",
                 "mean_latency_ms", "mean_resp_chars"]]
    fam_csv = [["size", "regime", "suite", "family", "n", "correct", "rate"]]
    for (size, regime), suites in cells.items():
        for suite, rows in suites.items():
            lab = labels[suite]
            ids = sorted(lab)
            nerr = sum(1 for t in ids if rows[t].get("error"))
            ncor = sum(1 for t in ids if correct(rows[t], lab[t]))
            npref = sum(1 for t in ids
                        if rows[t]["classified_route"] == lab[t].get("preferred_route"))
            lat = [rows[t].get("latency_ms") or 0 for t in ids]
            rl = [len(rows[t].get("response_text") or "") for t in ids]
            cell_csv.append([size, regime, suite, len(ids), nerr, ncor,
                             round(ncor / len(ids), 4), round(npref / len(ids), 4),
                             round(sum(lat) / len(lat), 1), round(sum(rl) / len(rl), 1)])
            summary["cells"][f"{size}_{regime}_{suite}"] = {
                "n": len(ids), "errored": nerr,
                "route_correctness": round(ncor / len(ids), 4),
                "preferred_match": round(npref / len(ids), 4),
                "mean_latency_ms": round(sum(lat) / len(lat), 1),
            }
            meta = metas[suite]
            fams = {}
            for t in ids:
                fams.setdefault(meta[t]["family"], []).append(t)
            for f, tt in sorted(fams.items()):
                c = sum(1 for t in tt if correct(rows[t], lab[t]))
                fam_csv.append([size, regime, suite, f, len(tt), c,
                                round(c / len(tt), 4)])

    # ── paired quant effect within size (core500 primary; smoke secondary) ──
    paired_csv = [["suite", "size", "n_pairs", "qat_only_correct",
                   "ptq_only_correct", "delta_rate", "mcnemar_p"]]
    deltas = {}
    for suite in ("core500", "smoke"):
        lab = labels[suite]
        ids = sorted(lab)
        for size in ("12B", "26B"):
            q, p_ = cells[(size, "QAT")][suite], cells[(size, "PTQ")][suite]
            n10 = sum(1 for t in ids if correct(q[t], lab[t]) and not correct(p_[t], lab[t]))
            n01 = sum(1 for t in ids if correct(p_[t], lab[t]) and not correct(q[t], lab[t]))
            delta = (n10 - n01) / len(ids)
            pv = mcnemar_exact(n01, n10)
            paired_csv.append([suite, size, len(ids), n10, n01,
                               round(delta, 4), round(pv, 4)])
            summary["paired"][f"{suite}_{size}"] = {
                "qat_only": n10, "ptq_only": n01,
                "delta_rate": round(delta, 4), "mcnemar_p": round(pv, 4)}
            if suite == "core500":
                deltas[size] = [
                    (1 if correct(q[t], lab[t]) else 0) -
                    (1 if correct(p_[t], lab[t]) else 0) for t in ids]

    # ── interaction (delta-of-deltas, task bootstrap, core500) ──
    rng = random.Random(20260810)
    obs = sum(deltas["26B"]) / len(deltas["26B"]) - sum(deltas["12B"]) / len(deltas["12B"])
    n = len(deltas["12B"])
    ids_c = sorted(labels["core500"])
    boots = []
    for _ in range(10000):
        idx = [rng.randrange(n) for _ in range(n)]
        boots.append((sum(deltas["26B"][i] for i in idx)
                      - sum(deltas["12B"][i] for i in idx)) / n)
    boots.sort()
    # stem-clustered bootstrap: Core-500 is 100 smoke stems x 5 paraphrase
    # variants, so tasks are NOT independent. Resample the 100 stems.
    meta_c = metas["core500"]
    stems = {}
    for i, t_ in enumerate(ids_c):
        stems.setdefault(meta_c[t_]["stem"], []).append(i)
    stem_keys = sorted(stems)
    rng2 = random.Random(20260810)
    cboots = []
    for _ in range(10000):
        picks = [stem_keys[rng2.randrange(len(stem_keys))] for _ in stem_keys]
        tot26 = tot12 = cnt = 0
        for s in picks:
            for i in stems[s]:
                tot26 += deltas["26B"][i]
                tot12 += deltas["12B"][i]
                cnt += 1
        cboots.append((tot26 - tot12) / cnt)
    cboots.sort()
    summary["interaction"]["core500"] = {
        "delta_of_deltas": round(obs, 4),
        "ci95_task_iid": [round(boots[249], 4), round(boots[9749], 4)],
        "ci95_stem_clustered": [round(cboots[249], 4), round(cboots[9749], 4)],
        "n_stems": len(stem_keys),
        "note": ("positive = QAT helps 26B more than 12B; stem-clustered CI "
                 "is primary (5x paraphrase dependence)"),
    }

    # ── exact-output divergence between regimes (same size, same task) ──
    div_csv = [["suite", "size", "n", "exact_match", "rate",
                "median_first_divergence_char"]]
    for suite in ("core500", "smoke"):
        lab = labels[suite]
        ids = sorted(lab)
        for size in ("12B", "26B"):
            q, p_ = cells[(size, "QAT")][suite], cells[(size, "PTQ")][suite]
            same = 0
            first = []
            for t in ids:
                a = q[t].get("response_text") or ""
                b = p_[t].get("response_text") or ""
                if a == b:
                    same += 1
                else:
                    k = next((i for i, (x, y) in enumerate(zip(a, b)) if x != y),
                             min(len(a), len(b)))
                    first.append(k)
            first.sort()
            med = first[len(first) // 2] if first else None
            div_csv.append([suite, size, len(ids), same,
                            round(same / len(ids), 4), med])
            summary["divergence"][f"{suite}_{size}"] = {
                "exact_match": same, "rate": round(same / len(ids), 4),
                "median_first_divergence_char": med}

    # ── ordinary-nondeterminism baseline (same profile, same day, rerun) ──
    for (size, regime), fname in REPEATS.items():
        p = R / "reports" / fname
        if not p.exists():
            continue
        rep = load_cell(fname, "smoke")
        base = cells[(size, regime)]["smoke"]
        lab = labels["smoke"]
        same = sum(1 for t in sorted(lab)
                   if (rep[t].get("response_text") or "") ==
                      (base[t].get("response_text") or ""))
        summary["repeats"][f"{size}_{regime}_smoke"] = {
            "exact_match": same, "n": len(lab)}

    for name, rows in [("cell_metrics.csv", cell_csv),
                       ("family_rates.csv", fam_csv),
                       ("paired_quant_effect.csv", paired_csv),
                       ("regime_output_divergence.csv", div_csv)]:
        with open(OUT / name, "w", newline="", encoding="utf-8") as fh:
            csv.writer(fh).writerows(rows)
    (OUT / "analysis_summary.json").write_text(
        json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8")
    print(json.dumps(summary, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()