"""Win / tie / loss decomposition of the Alternative Annotator Test (AAT). The AAT headline (``alt_test_pooled.csv``, ANALYSIS.md §3.2) reports the winning rate ω and the advantage probability ρ. Inside the test, an instance is credited to the candidate whenever it scores *at least as well* as the held-out human (the indicator is ``1[s_llm >= s_human]``), so ties count for the candidate. That is the correct convention for the question the AAT asks — *can this model stand in for a human annotator?* — but it makes ρ unusable for the different question *is this model better than a human?*. This script keeps the AAT's leave-one-out comparison and, instead of collapsing it into ρ, writes out the raw counts ρ is built from: for each held-out human j and each instance i = (judgment, variable) s_llm = mean tolerant agreement of the candidate with the 2 remaining humans s_human = mean tolerant agreement of human j with the same 2 humans -> llm_better (s_llm > s_human) tie (s_llm = s_human) human_better(s_llm < s_human) rho_alttest = (llm_better + tie) / n <- the AAT's own definition rho_tiebroken = (llm_better + tie / 2) / n <- ties split evenly A tie only means "same score against the same two references", so it is worth being explicit about what it contains. Ties are split two independent ways: by score level (with two references a score is 0, ½ or 1) tie_at_1 both matched both references — everybody agrees tie_at_half each matched exactly one reference; this can only happen when the two reference experts contradict each other, which caps every possible score at ½ tie_at_0 neither matched either reference — equally wrong, and still credited to the candidate by ρ by whether the candidate actually gave the held-out human's answer tie_same candidate ≈ held-out human (they really do agree) tie_diff candidate ≉ held-out human — they gave *different* answers that happen to be equally close to the references, so ρ records a candidate win on a genuine disagreement ``refs_disagree`` counts, for context, the comparisons whose two reference experts do not agree with each other in the first place. This does not need the upstream AltTest clone: it is a direct, auditable re-implementation of the comparison the reference implementation performs, and it reproduces the reference ρ to within 0.02 on every jurisdiction. Usage ----- uv run python scripts/alt_test_decomposition.py \ [--countries ge,sg,tw] [--out data/analysis/iaa] """ import argparse import csv import sys from collections import defaultdict from pathlib import Path REPO_ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(REPO_ROOT)) from legex.analysis.countries import CORE_COUNTRIES from legex.analysis.iaa import ( FREE_TEXT_FIELDS, load_candidate_annotations, load_human_annotations, ) from legex.evaluation import values_agree # The five released candidates the paper's AAT covers. The AAT was frozen # before the harvey-2 ingest; adding it would change the shipped CSVs and # ANALYSIS.md, so it stays out deliberately. MODELS = ("gpt-5.4-mini", "gemini/gemini-3.1-flash-lite", "harvey", "legora-1", "legora-2") COUNTS = ( "refs_disagree", "llm_better", "human_better", "tie", "tie_same", "tie_diff", "tie_at_1", "tie_at_half", "tie_at_0", ) COLUMNS = [ "candidate", "country", "variant", "n_comparisons", *COUNTS, "rho_alttest", "rho_tiebroken", ] def score(prediction: str, references: list[str], field: str) -> float: """Mean tolerant agreement — the AAT scoring function used in LEGEX.""" return sum(values_agree(prediction, r, field) for r in references) / len(references) def decompose( countries: list[str], model: str, gold_dir: Path | None = None, inference_dir: Path | None = None, ) -> list[dict]: """One row per (country, variant) with the win/tie/loss counts.""" humans = load_human_annotations(countries, gold_dir=gold_dir) candidate = load_candidate_annotations( countries, "v3", "full_text", model, inference_dir=inference_dir ) fields = sorted( {f for fmap in humans.values() for f in fmap if f not in FREE_TEXT_FIELDS} ) # country -> case_id -> annotator -> {field: value} by_case: dict[str, dict[str, dict[str, dict[str, str]]]] = defaultdict( lambda: defaultdict(dict) ) for (annotator, cc, case_id), fmap in humans.items(): by_case[cc][case_id][annotator] = fmap candidate_labels = {(cc, case_id): fmap for (_, cc, case_id), fmap in candidate.items()} rows: list[dict] = [] for cc in countries: annotators = sorted({an for (an, c, _) in humans if c == cc}) if len(annotators) < 3: print(f"[{cc}] only {len(annotators)} annotators — skipped", file=sys.stderr) continue for variant in ("all", "nontrivial"): counts: dict[str, int] = defaultdict(int) for case_id, case_annotators in by_case[cc].items(): # Keep only judgments all three experts labelled, so every # leave-one-out comparison has exactly two reference annotators # (the reference implementation's min_humans_per_instance=2). if len(case_annotators) < 3: continue names = sorted(case_annotators) llm_labels = candidate_labels.get((cc, case_id), {}) # No candidate output for this judgment (e.g. Legora's empty # Georgia export): skip, mirroring the pooled AAT runner. if not llm_labels: continue for field in fields: human_values = {n: case_annotators[n].get(field, "") for n in names} llm_value = llm_labels.get(field, "") for held_out in names: references = [human_values[n] for n in names if n != held_out] # Non-trivial: drop comparisons whose reference is empty # throughout — there is nothing to be right or wrong about. if variant == "nontrivial" and not any(references): continue if not values_agree(references[0], references[1], field): counts["refs_disagree"] += 1 s_human = score(human_values[held_out], references, field) s_llm = score(llm_value, references, field) if s_llm > s_human: counts["llm_better"] += 1 elif s_llm < s_human: counts["human_better"] += 1 else: counts["tie"] += 1 counts[{1.0: "tie_at_1", 0.5: "tie_at_half"}.get(s_llm, "tie_at_0")] += 1 same = values_agree(llm_value, human_values[held_out], field) counts["tie_same" if same else "tie_diff"] += 1 n = counts["llm_better"] + counts["tie"] + counts["human_better"] if not n: continue rows.append({ "candidate": model, "country": cc, "variant": variant, "n_comparisons": n, **{c: counts[c] for c in COUNTS}, "rho_alttest": round((counts["llm_better"] + counts["tie"]) / n, 4), "rho_tiebroken": round((counts["llm_better"] + counts["tie"] / 2) / n, 4), }) return rows def main() -> None: ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) ap.add_argument("--countries", default=",".join(CORE_COUNTRIES), help="comma-separated country codes (default: the 8 core " "jurisdictions, all with 3 independent annotators)") ap.add_argument("--out", type=Path, default=Path("data/analysis/iaa"), help="output directory for alt_test_decomposition.csv") ap.add_argument("--gold-dir", type=Path, default=None, help="read annotations from published goldenset JSONL under " "this directory instead of the XLSX workbooks") ap.add_argument("--inference-dir", type=Path, default=None, help="read candidate predictions from published inference " "JSONL under this directory instead of the working files") args = ap.parse_args() countries = [c.strip() for c in args.countries.split(",") if c.strip()] rows = [ r for model in MODELS for r in decompose(countries, model, args.gold_dir, args.inference_dir) ] if not rows: raise SystemExit("no comparisons — need 3+ annotators in at least one country") out_csv = args.out / "alt_test_decomposition.csv" out_csv.parent.mkdir(parents=True, exist_ok=True) with out_csv.open("w", encoding="utf-8", newline="") as f: writer = csv.DictWriter(f, fieldnames=COLUMNS) writer.writeheader() writer.writerows(rows) for model in MODELS: pooled: dict[str, int] = defaultdict(int) for r in rows: if r["candidate"] == model and r["variant"] == "all": pooled["n_comparisons"] += r["n_comparisons"] for key in COUNTS: pooled[key] += r[key] n = pooled["n_comparisons"] if not n: continue print( f"{model:<30} n={n:<5} " f"better {pooled['llm_better']:>4} ({pooled['llm_better'] / n:.0%}) " f"tie {pooled['tie']:>4} ({pooled['tie'] / n:.0%}) " f"worse {pooled['human_better']:>4} ({pooled['human_better'] / n:.0%}) " f"rho={(pooled['llm_better'] + pooled['tie']) / n:.2f} " f"(ties split {(pooled['llm_better'] + pooled['tie'] / 2) / n:.2f})\n" f"{'':<30} ties: same answer as expert {pooled['tie_same']} " f"({pooled['tie_same'] / pooled['tie']:.0%}), different answer " f"{pooled['tie_diff']} ({pooled['tie_diff'] / pooled['tie']:.0%}); " f"at 1 {pooled['tie_at_1']}, at ½ {pooled['tie_at_half']}, at 0 {pooled['tie_at_0']}; " f"references conflict in {pooled['refs_disagree']} of {n} comparisons " f"({pooled['refs_disagree'] / n:.0%})" ) print(f"decomposition -> {out_csv}") if __name__ == "__main__": main()