Initial release: anonymized evaluation analysis scripts for Repair-First paper

README.md

@@ -0,0 +1,67 @@
+---
+license: apache-2.0
+language:
+- en
+tags:
+- pretraining
+- data-curation
+- evaluation
+- llm
+- common-crawl
+pretty_name: ProseOnlyRepair — Evaluation Analysis Scripts
+---
+
+# ProseOnlyRepair — Evaluation Analysis Scripts
+
+Anonymized evaluation/analysis scripts that reproduce the tables and
+figures in the *Repair-First* paper (under double-blind review).
+
+## Contents
+
+| File | Purpose |
+|------|---------|
+| `build_paper_tables.py` | Headline tables (per-task accuracy, Paloma BPB, repair deltas) |
+| `build_8variant_analysis.py` | 8-variant repair-effect-by-tier analysis (POST-only excluded) |
+| `build_12variant_analysis.py` | 12-variant superset including POST-only (used in appendix) |
+| `make_paper_figures.py` | Regenerates Figures 1 and 2 from eval JSONs |
+| `requirements.txt` | Python dependencies (lm-evaluation-harness 0.4.12, datasets <4.0, etc.) |
+
+## Variant naming
+
+Each evaluation result directory follows
+`{cluster}_{tier}_new[_repaired[_upsampled]]_results`:
+
+| Token | Meaning |
+|---|---|
+| `clusterA_` | Pretrained on Cluster A (anonymous identifier) |
+| `clusterB_` | Pretrained on Cluster B (anonymous identifier) |
+| `_lq` / `_mq` / `_hq` | Low / Medium / High quality CommonCrawl tier |
+| `_new` | PRE: pre-repair baseline |
+| `_new_repaired` | POST: post-repair, token budget held by truncation |
+| `_new_repaired_upsampled` | POST+UP: post-repair + upsampled to original token budget |
+
+## How to use
+
+```bash
+pip install -r requirements.txt
+# Place evaluation result JSONs under ./eval_results/{prose,paloma}/
+python3 build_paper_tables.py
+python3 build_8variant_analysis.py
+python3 build_12variant_analysis.py
+python3 make_paper_figures.py
+```
+
+The accompanying evaluation result JSONs (12 variants × prose + paloma
+suites) are released in the paper's supplementary materials zip.
+
+## Notes
+
+- All scripts are CPU-only Python and require no GPU.
+- Scripts are deterministic: identical inputs → identical outputs.
+- The 28-task prose suite + 11-corpus Paloma BPB panel are evaluated
+  with `lm-evaluation-harness==0.4.12` (vLLM backend).
+- Decoding: greedy, max-len 256 except CoQA/SQuADv2 (512).
+
+This release is anonymous for double-blind review and will be
+re-released with author and affiliation metadata after the review
+period.

build_12variant_analysis.py

@@ -0,0 +1,402 @@
+#!/usr/bin/env python3
+"""Full 12-variant analysis: 3 Cluster A MQ + 9 Cluster B (mq/hq/lq × new/repaired/repaired_upsampled).
+
+Outputs (all to stdout, suitable for paper appendix):
+  Table 1 — Headline 13-metric × 12-variant matrix
+  Table 2 — POST+UP vs PRE within each tier (3 tier-deltas)
+  Table 3 — Tier ordering at each treatment (3 ordering rows × 13 metrics)
+  Table 4 — Repair-effect comparison across tiers (does repair help HQ as much as it helps MQ?)
+  Table 5 — Paloma-BPB 11-corpus × 12-variant matrix
+  Table 6 — Seed-variance noise floor (3 pairs: Cluster A MQ {PRE,POST,POST+UP} vs Cluster B MQ {same})
+
+All deltas reported with per-task SE-based significance against the empirical
+seed-variance noise floor measured in Table 6.
+"""
+from __future__ import annotations
+import json, glob, math, statistics
+
+BASE = './eval_results'
+
+# Variant naming convention:
+#  - Cluster A MQ stored without prefix: 'clusterA_mq_new', 'clusterA_mq_new_repaired', 'clusterA_mq_new_repaired_upsampled'
+#  - Cluster B all prefixed:                 'clusterB_mq_new', 'clusterB_hq_new', 'clusterB_lq_new', etc.
+VARIANTS = [
+    # (label, suite_filename_prefix, display_name, cluster, tier, treatment)
+    ('clusterA_mq_new',                          'clusterA_mq_new',                          'A-MQ-PRE',   'A', 'mq', 'pre'),
+    ('clusterA_mq_new_repaired',                 'clusterA_mq_new_repaired',                 'A-MQ-POST',  'A', 'mq', 'post'),
+    ('clusterA_mq_new_repaired_upsampled',       'clusterA_mq_new_repaired_upsampled',       'A-MQ-UP',    'A', 'mq', 'ups'),
+    ('clusterB_mq_new',                      'clusterB_mq_new',                      'B-MQ-PRE',   'B', 'mq', 'pre'),
+    ('clusterB_mq_new_repaired',             'clusterB_mq_new_repaired',             'B-MQ-POST',  'B', 'mq', 'post'),
+    ('clusterB_mq_new_repaired_upsampled',   'clusterB_mq_new_repaired_upsampled',   'B-MQ-UP',    'B', 'mq', 'ups'),
+    ('clusterB_hq_new',                      'clusterB_hq_new',                      'B-HQ-PRE',   'B', 'hq', 'pre'),
+    ('clusterB_hq_new_repaired',             'clusterB_hq_new_repaired',             'B-HQ-POST',  'B', 'hq', 'post'),
+    ('clusterB_hq_new_repaired_upsampled',   'clusterB_hq_new_repaired_upsampled',   'B-HQ-UP',    'B', 'hq', 'ups'),
+    ('clusterB_lq_new',                      'clusterB_lq_new',                      'B-LQ-PRE',   'B', 'lq', 'pre'),
+    ('clusterB_lq_new_repaired',             'clusterB_lq_new_repaired',             'B-LQ-POST',  'B', 'lq', 'post'),
+    ('clusterB_lq_new_repaired_upsampled',   'clusterB_lq_new_repaired_upsampled',   'B-LQ-UP',    'B', 'lq', 'ups'),
+]
+
+METRIC_KEYS = {
+    'hellaswag':'acc_norm,none','piqa':'acc_norm,none','winogrande':'acc,none',
+    'commonsense_qa':'acc,none','social_iqa':'acc,none','openbookqa':'acc_norm,none',
+    'sciq':'acc_norm,none','arc_easy':'acc_norm,none','arc_challenge':'acc_norm,none',
+    'logiqa':'acc,none','pubmedqa':'acc,none','boolq':'acc,none','race':'acc,none',
+    'squadv2':'best_f1,none','coqa':'f1,none','copa':'acc,none','cb':'acc,none',
+    'rte':'acc,none','anli_r1':'acc,none','anli_r2':'acc,none','anli_r3':'acc,none',
+    'truthfulqa_mc2':'acc,none','triviaqa':'exact_match,remove_whitespace',
+    'nq_open':'exact_match,remove_whitespace','lambada_openai':'acc,none',
+}
+SCALE = {'squadv2':0.01}
+
+def load(suite, label):
+    f = glob.glob(f'{BASE}/{suite}/{label}_results/results_*.json')
+    if not f: return {}
+    return json.load(open(f[0]))['results']
+
+def numeric(x):
+    return x if isinstance(x,(int,float)) else 0.0
+
+def task_value(results, task):
+    if task == 'mmlu_mean':
+        accs = [v.get('acc,none') for k,v in results.items() if k.startswith('mmlu_') and k != 'mmlu']
+        accs = [a for a in accs if isinstance(a,(int,float))]
+        return statistics.mean(accs) if accs else None
+    if task == 'blimp_mean':
+        accs = [v.get('acc,none') for k,v in results.items() if k.startswith('blimp_') and k != 'blimp']
+        accs = [a for a in accs if isinstance(a,(int,float))]
+        return statistics.mean(accs) if accs else None
+    key = METRIC_KEYS.get(task)
+    if key is None or task not in results: return None
+    v = results[task].get(key)
+    if not isinstance(v,(int,float)): return None
+    return v * SCALE.get(task, 1.0)
+
+def task_se(results, task):
+    key = METRIC_KEYS.get(task)
+    if key is None or task not in results: return 0.0
+    se_key = key.replace(',', '_stderr,', 1)
+    return numeric(results[task].get(se_key)) * SCALE.get(task,1.0)
+
+# ---- Load all data ----
+data = {}        # data[label_for_lookup][suite] = results dict
+for lookup, prefix, _, _, _, _ in VARIANTS:
+    data[lookup] = {
+        'prose':  load('prose',  prefix),
+        'paloma': load('paloma', prefix),
+    }
+
+# ---- Headline metrics list ----
+HEADLINE = [
+    # (metric_id, display, group)
+    ('hellaswag',      'HellaSwag',   'CS'),
+    ('piqa',           'PIQA',        'CS'),
+    ('winogrande',     'WinoGrande',  'CS'),
+    ('commonsense_qa', 'CSQA',        'CS'),
+    ('social_iqa',     'SIQA',        'CS'),
+    ('arc_easy',       'ARC-E',       'KR'),
+    ('arc_challenge',  'ARC-C',       'KR'),
+    ('openbookqa',     'OpenBookQA',  'KR'),
+    ('sciq',           'SciQ',        'KR'),
+    ('mmlu_mean',      'MMLU-57',     'KR'),
+    ('pubmedqa',       'PubMedQA',    'KR'),
+    ('boolq',          'BoolQ',       'RC'),
+    ('race',           'RACE',        'RC'),
+    ('lambada_openai', 'LAMBADA',     'LM'),
+    ('blimp_mean',     'BLiMP-67',    'L'),
+]
+
+def pct(v, n=2):
+    if v is None: return '   -- '
+    return f"{v*100:>{n+5}.{n}f}"
+
+def short(label_name):
+    return label_name
+
+# ============================================================================
+# TABLE 1 — Headline 13-metric × 12-variant matrix
+# ============================================================================
+print("="*200)
+print(" Table 1 — Per-variant zero-shot accuracy (%) on 15 headline prose metrics")
+print(" Qwen3-1.7B, 1 epoch (iter 16 406, ~34.4 B tokens), BF16, H100, eval on standard NeMo 26.04 container, lm-eval 0.4.12")
+print("="*200)
+hdr = f"  {'metric':<13}"
+for _, _, disp, _, _, _ in VARIANTS:
+    hdr += f"  {disp:>9}"
+print(hdr)
+print('-'*200)
+for mid, disp, grp in HEADLINE:
+    line = f"  {disp:<13}"
+    for lookup, _, _, _, _, _ in VARIANTS:
+        v = task_value(data[lookup]['prose'], mid)
+        if v is None:
+            line += f"  {'--':>9}"
+        else:
+            line += f"  {v*100:>9.2f}"
+    print(line)
+
+# Paper-aligned aggregates
+print('-'*200)
+def fineweb_agg(results):
+    tasks = ['commonsense_qa','hellaswag','openbookqa','piqa','social_iqa','winogrande']
+    vs = [task_value(results,t) for t in tasks]
+    vs = [v for v in vs if v is not None]
+    # add arc_mean and mmlu_mean
+    arc_e = task_value(results,'arc_easy'); arc_c = task_value(results,'arc_challenge')
+    if arc_e is not None and arc_c is not None: vs.append((arc_e+arc_c)/2)
+    mmlu = task_value(results,'mmlu_mean')
+    if mmlu is not None: vs.append(mmlu)
+    return statistics.mean(vs) if vs else None
+
+def dolma8_agg(results):
+    tasks = ['hellaswag','piqa','winogrande','openbookqa','arc_easy','arc_challenge','sciq','boolq']
+    vs = [task_value(results,t) for t in tasks]
+    vs = [v for v in vs if v is not None]
+    return statistics.mean(vs) if vs else None
+
+def knowledge_agg(results):
+    tasks_acc = ['arc_challenge','openbookqa']
+    vs = [task_value(results,t) for t in tasks_acc]
+    mmlu = task_value(results,'mmlu_mean')
+    if mmlu is not None: vs.append(mmlu)
+    triv = task_value(results,'triviaqa')
+    if triv is not None: vs.append(triv)
+    nq = task_value(results,'nq_open')
+    if nq is not None: vs.append(nq)
+    return statistics.mean(vs) if vs else None
+
+line = f"  {'FineWeb-Agg-8':<13}"
+for lookup, _, _, _, _, _ in VARIANTS:
+    v = fineweb_agg(data[lookup]['prose']);
+    line += f"  {v*100:>9.2f}" if v else f"  {'--':>9}"
+print(line)
+line = f"  {'Dolma-Hdln-8':<13}"
+for lookup, _, _, _, _, _ in VARIANTS:
+    v = dolma8_agg(data[lookup]['prose'])
+    line += f"  {v*100:>9.2f}" if v else f"  {'--':>9}"
+print(line)
+line = f"  {'Knowledge-Agg':<13}"
+for lookup, _, _, _, _, _ in VARIANTS:
+    v = knowledge_agg(data[lookup]['prose'])
+    line += f"  {v*100:>9.2f}" if v else f"  {'--':>9}"
+print(line)
+# Paloma BPB-11 mean (lower = better)
+line = f"  {'Paloma-BPB ↓':<13}"
+for lookup, _, _, _, _, _ in VARIANTS:
+    palo = data[lookup]['paloma']
+    bpbs = [palo[t]['bits_per_byte,none'] for t in palo if 'bits_per_byte,none' in palo[t]]
+    v = statistics.mean(bpbs) if bpbs else None
+    line += f"  {v:>9.4f}" if v else f"  {'--':>9}"
+print(line)
+
+# ============================================================================
+# TABLE 2 — Within-tier POST+UP vs PRE deltas (3 tier rows × 15 metric cols)
+# ============================================================================
+print()
+print("="*200)
+print(" Table 2 — Within-tier Δ (POST+UP − PRE) in percentage points")
+print(" Each row is one data tier; positive Δ = POST+UP outperforms PRE; bold-able if |Δ| > 3 × seed_floor on that task")
+print("="*200)
+# Compute seed-variance noise floor per task from Cluster A MQ vs Cluster B MQ (PRE)
+seed_floor = {}
+for mid, disp, _ in HEADLINE:
+    mv = task_value(data['clusterA_mq_new']['prose'], mid)
+    hv = task_value(data['clusterB_mq_new']['prose'], mid)
+    if mv is not None and hv is not None:
+        seed_floor[mid] = abs(hv - mv) * 100
+    else:
+        seed_floor[mid] = 0.0
+# also for paloma
+seed_floor_bpb = {}
+for corpus in data['clusterA_mq_new']['paloma']:
+    mv = data['clusterA_mq_new']['paloma'][corpus]['bits_per_byte,none']
+    hv = data['clusterB_mq_new']['paloma'][corpus]['bits_per_byte,none']
+    seed_floor_bpb[corpus] = abs(hv - mv)
+
+tiers = [
+    ('B-MQ', 'clusterB_mq_new', 'clusterB_mq_new_repaired_upsampled'),
+    ('A-MQ', 'clusterA_mq_new',     'clusterA_mq_new_repaired_upsampled'),
+    ('B-HQ', 'clusterB_hq_new', 'clusterB_hq_new_repaired_upsampled'),
+    ('B-LQ', 'clusterB_lq_new', 'clusterB_lq_new_repaired_upsampled'),
+]
+hdr = f"  {'tier':<10} "
+for mid, disp, _ in HEADLINE: hdr += f"  {disp:>9}"
+hdr += f"  {'FineWeb-8':>10}  {'Dolma-8':>9}  {'Know-Agg':>9}  {'Paloma↓':>9}"
+print(hdr)
+print('-'*200)
+for tname, pre, ups in tiers:
+    line = f"  {tname:<10} "
+    for mid, _, _ in HEADLINE:
+        pv = task_value(data[pre]['prose'], mid); uv = task_value(data[ups]['prose'], mid)
+        if pv is None or uv is None:
+            line += f"  {'--':>9}"
+        else:
+            d_pp = (uv-pv)*100
+            line += f"  {d_pp:>+9.2f}"
+    # Aggregates
+    fw_pre = fineweb_agg(data[pre]['prose']); fw_ups = fineweb_agg(data[ups]['prose'])
+    do_pre = dolma8_agg(data[pre]['prose']);  do_ups = dolma8_agg(data[ups]['prose'])
+    kn_pre = knowledge_agg(data[pre]['prose']);kn_ups = knowledge_agg(data[ups]['prose'])
+    # paloma mean (delta sign-inverted for "improvement" direction: lower bpb is better, so we report PRE - UP so positive = improvement)
+    palo_pre = statistics.mean([data[pre]['paloma'][c]['bits_per_byte,none'] for c in data[pre]['paloma']])
+    palo_ups = statistics.mean([data[ups]['paloma'][c]['bits_per_byte,none'] for c in data[ups]['paloma']])
+    line += f"  {(fw_ups-fw_pre)*100:>+10.2f}  {(do_ups-do_pre)*100:>+9.2f}  {(kn_ups-kn_pre)*100:>+9.2f}  {(palo_ups-palo_pre):>+9.4f}"
+    print(line)
+
+# ============================================================================
+# TABLE 3 — Tier ordering at each treatment (HQ vs MQ vs LQ at each of PRE/POST/POST+UP)
+# ============================================================================
+print()
+print("="*200)
+print(" Table 3 — Tier ordering at each treatment (Cluster B cluster; A-MQ shown as cross-cluster anchor)")
+print(" Each cell = absolute zero-shot accuracy %; columns are data tier; row groups by treatment")
+print("="*200)
+TREATMENTS = ['PRE', 'POST', 'POST+UP']
+tierset = [('LQ','clusterB_lq'), ('MQ','clusterB_mq'), ('HQ','clusterB_hq')]
+sfx = {'PRE':'new', 'POST':'new_repaired', 'POST+UP':'new_repaired_upsampled'}
+hdr = f"  {'metric':<13}  {'treat':<7}  "
+for tname, _ in tierset: hdr += f"  {tname:>7}"
+hdr += f"  {'spread':>9}"
+print(hdr)
+print('-'*120)
+for mid, disp, _ in HEADLINE:
+    for trt in TREATMENTS:
+        vals=[]
+        line = f"  {disp:<13}  {trt:<7}  "
+        for tname, prefix in tierset:
+            label = f"{prefix}_{sfx[trt]}"
+            v = task_value(data[label]['prose'], mid)
+            vals.append(v)
+            line += f"  {v*100:>7.2f}" if v is not None else f"  {'--':>7}"
+        # spread
+        if all(v is not None for v in vals):
+            spread = (max(vals)-min(vals))*100
+            line += f"  {spread:>9.2f}"
+        else:
+            line += f"  {'--':>9}"
+        print(line)
+    print()
+
+# ============================================================================
+# TABLE 4 — Repair-effect by tier  (POST+UP − PRE within each tier)
+# ============================================================================
+print("="*200)
+print(" Table 4 — Repair-effect by tier (Δ in pp from PRE to POST+UP within each tier)")
+print(" Compares whether repair is more/less effective at higher vs lower data quality")
+print("="*200)
+hdr = f"  {'metric':<13}  "
+for tname in ['LQ','MQ','HQ']: hdr += f"  {'Δ '+tname:>10}"
+hdr += f"  {'monotone?':>12}"
+print(hdr)
+print('-'*100)
+for mid, disp, _ in HEADLINE:
+    line = f"  {disp:<13}  "
+    deltas = {}
+    for tname, prefix in [('LQ','clusterB_lq'), ('MQ','clusterB_mq'), ('HQ','clusterB_hq')]:
+        pre_lab = f"{prefix}_new"; ups_lab = f"{prefix}_new_repaired_upsampled"
+        pv = task_value(data[pre_lab]['prose'], mid); uv = task_value(data[ups_lab]['prose'], mid)
+        if pv is None or uv is None:
+            line += f"  {'--':>10}"; deltas[tname] = None
+        else:
+            d = (uv-pv)*100
+            line += f"  {d:>+10.2f}"
+            deltas[tname] = d
+    # monotone?  (does Δ shrink/grow monotonically with tier quality?)
+    if all(deltas[t] is not None for t in ['LQ','MQ','HQ']):
+        if deltas['LQ'] >= deltas['MQ'] >= deltas['HQ']:
+            mono = 'LQ>MQ>HQ (repair helps lower-quality data more)'
+        elif deltas['LQ'] <= deltas['MQ'] <= deltas['HQ']:
+            mono = 'HQ>MQ>LQ'
+        else:
+            mono = 'non-monotone'
+        line += f"  {mono:>40}"
+    print(line)
+
+# ============================================================================
+# TABLE 5 — Paloma-BPB 11-corpus × 12-variant matrix
+# ============================================================================
+print()
+print("="*200)
+print(" Table 5 — Paloma-11 BPB (bits-per-byte, lower=better) by variant")
+print("="*200)
+corpora = sorted(data['clusterA_mq_new']['paloma'].keys())
+hdr = f"  {'corpus':<32}"
+for _, _, disp, _, _, _ in VARIANTS: hdr += f"  {disp:>9}"
+print(hdr)
+print('-'*200)
+for c in corpora:
+    name = data['clusterA_mq_new']['paloma'][c].get('alias', c)
+    line = f"  {name:<32}"
+    for lookup, _, _, _, _, _ in VARIANTS:
+        v = data[lookup]['paloma'][c].get('bits_per_byte,none')
+        line += f"  {v:>9.4f}" if v is not None else f"  {'--':>9}"
+    print(line)
+print('-'*200)
+# Mean BPB
+line = f"  {'Paloma-BPB-11 mean ↓':<32}"
+for lookup, _, _, _, _, _ in VARIANTS:
+    bpbs = [data[lookup]['paloma'][c]['bits_per_byte,none'] for c in corpora]
+    v = statistics.mean(bpbs)
+    line += f"  {v:>9.4f}"
+print(line)
+
+# ============================================================================
+# TABLE 6 — Seed-variance noise floor (Cluster A MQ vs Cluster B MQ at each treatment)
+# ============================================================================
+print()
+print("="*200)
+print(" Table 6 — Seed-variance noise floor measurement")
+print(" Each comparison is same-tier same-treatment, different cluster + training seed.")
+print(" |Δ| values are the empirical noise floor for interpreting cross-tier deltas above.")
+print("="*200)
+pairs = [
+    ('PRE',     'clusterA_mq_new',                          'clusterB_mq_new'),
+    ('POST',    'clusterA_mq_new_repaired',                 'clusterB_mq_new_repaired'),
+    ('POST+UP', 'clusterA_mq_new_repaired_upsampled',       'clusterB_mq_new_repaired_upsampled'),
+]
+hdr = f"  {'metric':<13}"
+for trt,_,_ in pairs: hdr += f"  |Δ| {trt:>8}"
+hdr += f"  {'median':>9}"
+print(hdr)
+print('-'*100)
+all_floors = []
+for mid, disp, _ in HEADLINE:
+    line = f"  {disp:<13}"
+    vals=[]
+    for trt, mlab, hlab in pairs:
+        mv = task_value(data[mlab]['prose'], mid); hv = task_value(data[hlab]['prose'], mid)
+        if mv is None or hv is None:
+            line += f"  {'--':>12}"
+        else:
+            d = abs(hv - mv) * 100
+            vals.append(d)
+            line += f"  {d:>10.3f}pp"
+    med = statistics.median(vals) if vals else None
+    line += f"  {med:>9.3f}" if med is not None else f"  {'--':>9}"
+    print(line)
+    if vals: all_floors.extend(vals)
+
+# Overall summary
+print('-'*100)
+print(f"  Overall seed-variance noise floor on 15 headline metrics × 3 treatments:")
+all_floors.sort()
+print(f"    median |Δ| = {statistics.median(all_floors):.3f} pp")
+print(f"    p75 |Δ|    = {all_floors[int(len(all_floors)*0.75)]:.3f} pp")
+print(f"    p95 |Δ|    = {all_floors[int(len(all_floors)*0.95)]:.3f} pp")
+print(f"    max |Δ|    = {all_floors[-1]:.3f} pp")
+
+# Paloma seed-variance
+print()
+print(f"  Paloma BPB seed-variance (3 PRE/POST/POST+UP × 11 corpora):")
+palo_floors = []
+for trt, mlab, hlab in pairs:
+    for c in corpora:
+        d = abs(data[mlab]['paloma'][c]['bits_per_byte,none'] - data[hlab]['paloma'][c]['bits_per_byte,none'])
+        palo_floors.append(d)
+palo_floors.sort()
+print(f"    median |Δ BPB| = {statistics.median(palo_floors):.5f}")
+print(f"    max    |Δ BPB| = {palo_floors[-1]:.5f}")
+
+print()
+print("="*200)
+print("END")
+print("="*200)

build_8variant_analysis.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""8-variant analysis (POST-only EXCLUDED): focus on PRE vs POST+UP across tiers.
+
+Variants:
+  - Cluster A MQ-PRE, Cluster A MQ-POST+UP
+  - Cluster B MQ-PRE, Cluster B MQ-POST+UP, Cluster B HQ-PRE, Cluster B HQ-POST+UP, Cluster B LQ-PRE, Cluster B LQ-POST+UP
+
+Tables produced:
+  Table 1  — 8-variant headline accuracy matrix (15 metrics + 4 aggregates)
+  Table 2  — Tier ordering at PRE and at POST+UP, with HQ-vs-LQ spread
+  Table 3  — Repair effect (POST+UP - PRE) by tier, with seed-variance floor
+  Table 4  — Cross-cluster seed-variance noise floor (Cluster A MQ vs Cluster B MQ, PRE and POST+UP only)
+  Table 5  — Paloma-11 BPB by variant + distributional split
+"""
+from __future__ import annotations
+import json, glob, math, statistics
+
+BASE = './eval_results'
+
+VARIANTS = [
+    # (lookup_label, display_name, cluster, tier, treatment)
+    ('clusterA_mq_new',                          'A-MQ-PRE',   'A', 'mq', 'pre'),
+    ('clusterA_mq_new_repaired_upsampled',       'A-MQ-UP',    'A', 'mq', 'ups'),
+    ('clusterB_mq_new',                      'B-MQ-PRE',   'B', 'mq', 'pre'),
+    ('clusterB_mq_new_repaired_upsampled',   'B-MQ-UP',    'B', 'mq', 'ups'),
+    ('clusterB_hq_new',                      'B-HQ-PRE',   'B', 'hq', 'pre'),
+    ('clusterB_hq_new_repaired_upsampled',   'B-HQ-UP',    'B', 'hq', 'ups'),
+    ('clusterB_lq_new',                      'B-LQ-PRE',   'B', 'lq', 'pre'),
+    ('clusterB_lq_new_repaired_upsampled',   'B-LQ-UP',    'B', 'lq', 'ups'),
+]
+
+METRIC_KEYS = {
+    'hellaswag':'acc_norm,none','piqa':'acc_norm,none','winogrande':'acc,none',
+    'commonsense_qa':'acc,none','social_iqa':'acc,none','openbookqa':'acc_norm,none',
+    'sciq':'acc_norm,none','arc_easy':'acc_norm,none','arc_challenge':'acc_norm,none',
+    'logiqa':'acc,none','pubmedqa':'acc,none','boolq':'acc,none','race':'acc,none',
+    'squadv2':'best_f1,none','coqa':'f1,none','copa':'acc,none','cb':'acc,none',
+    'rte':'acc,none','anli_r1':'acc,none','anli_r2':'acc,none','anli_r3':'acc,none',
+    'truthfulqa_mc2':'acc,none','triviaqa':'exact_match,remove_whitespace',
+    'nq_open':'exact_match,remove_whitespace','lambada_openai':'acc,none',
+}
+SCALE = {'squadv2':0.01}
+
+HEADLINE = [
+    ('hellaswag','HellaSwag','CS'),
+    ('piqa','PIQA','CS'),
+    ('winogrande','WinoGrande','CS'),
+    ('commonsense_qa','CSQA','CS'),
+    ('social_iqa','SIQA','CS'),
+    ('arc_easy','ARC-E','KR'),
+    ('arc_challenge','ARC-C','KR'),
+    ('openbookqa','OpenBookQA','KR'),
+    ('sciq','SciQ','KR'),
+    ('mmlu_mean','MMLU-57','KR'),
+    ('pubmedqa','PubMedQA','KR'),
+    ('boolq','BoolQ','RC'),
+    ('race','RACE','RC'),
+    ('lambada_openai','LAMBADA','LM'),
+    ('blimp_mean','BLiMP-67','L'),
+]
+
+def load(suite, label):
+    f = glob.glob(f'{BASE}/{suite}/{label}_results/results_*.json')
+    return json.load(open(f[0]))['results'] if f else {}
+
+def task_value(results, task):
+    if task == 'mmlu_mean':
+        accs = [v.get('acc,none') for k,v in results.items() if k.startswith('mmlu_') and k != 'mmlu']
+        accs = [a for a in accs if isinstance(a,(int,float))]
+        return statistics.mean(accs) if accs else None
+    if task == 'blimp_mean':
+        accs = [v.get('acc,none') for k,v in results.items() if k.startswith('blimp_') and k != 'blimp']
+        accs = [a for a in accs if isinstance(a,(int,float))]
+        return statistics.mean(accs) if accs else None
+    key = METRIC_KEYS.get(task)
+    if key is None or task not in results: return None
+    v = results[task].get(key)
+    return v * SCALE.get(task,1.0) if isinstance(v,(int,float)) else None
+
+# Load
+data = {}
+for lookup, *_ in VARIANTS:
+    data[lookup] = {'prose': load('prose', lookup), 'paloma': load('paloma', lookup)}
+
+def fineweb_agg(results):
+    vs = [task_value(results,t) for t in ['commonsense_qa','hellaswag','openbookqa','piqa','social_iqa','winogrande']]
+    vs = [v for v in vs if v is not None]
+    arc_e = task_value(results,'arc_easy'); arc_c = task_value(results,'arc_challenge')
+    if arc_e is not None and arc_c is not None: vs.append((arc_e+arc_c)/2)
+    mmlu = task_value(results,'mmlu_mean')
+    if mmlu is not None: vs.append(mmlu)
+    return statistics.mean(vs) if vs else None
+
+def dolma8_agg(results):
+    vs = [task_value(results,t) for t in ['hellaswag','piqa','winogrande','openbookqa','arc_easy','arc_challenge','sciq','boolq']]
+    vs = [v for v in vs if v is not None]
+    return statistics.mean(vs) if vs else None
+
+def knowledge_agg(results):
+    vs = [task_value(results,t) for t in ['arc_challenge','openbookqa']]
+    for t in ['mmlu_mean','triviaqa','nq_open']:
+        v = task_value(results,t)
+        if v is not None: vs.append(v)
+    vs = [v for v in vs if v is not None]
+    return statistics.mean(vs) if vs else None
+
+# ============================================================================
+# TABLE 1 — 8-variant accuracy matrix
+# ============================================================================
+print("="*150)
+print(" Table 1 — Per-variant zero-shot accuracy (%) — POST-only EXCLUDED (PRE vs POST+UP only)")
+print(" Qwen3-1.7B, 1 epoch (≈ 34.4 B tokens), BF16, all eval on Cluster A H100 + NeMo 26.04 + lm-eval 0.4.12")
+print("="*150)
+hdr = f"  {'metric':<14}"
+for _, disp, *_ in VARIANTS:
+    hdr += f"  {disp:>10}"
+print(hdr)
+print('-'*150)
+for mid, disp, grp in HEADLINE:
+    line = f"  {disp:<14}"
+    for lookup, *_ in VARIANTS:
+        v = task_value(data[lookup]['prose'], mid)
+        line += f"  {v*100:>10.2f}" if v is not None else f"  {'--':>10}"
+    print(line)
+print('-'*150)
+for agg_name, agg_fn in [('FineWeb-Agg-8', fineweb_agg), ('Dolma-Hdln-8', dolma8_agg), ('Knowledge-Agg', knowledge_agg)]:
+    line = f"  {agg_name:<14}"
+    for lookup, *_ in VARIANTS:
+        v = agg_fn(data[lookup]['prose'])
+        line += f"  {v*100:>10.2f}" if v is not None else f"  {'--':>10}"
+    print(line)
+# Paloma BPB
+line = f"  {'Paloma-BPB ↓':<14}"
+for lookup, *_ in VARIANTS:
+    palo = data[lookup]['paloma']
+    bpbs = [palo[t]['bits_per_byte,none'] for t in palo if 'bits_per_byte,none' in palo[t]]
+    v = statistics.mean(bpbs)
+    line += f"  {v:>10.4f}"
+print(line)
+
+# ============================================================================
+# TABLE 2 — Tier ordering at PRE and at POST+UP
+# ============================================================================
+print()
+print("="*150)
+print(" Table 2 — Tier ordering at each treatment (Cluster B cluster; A-MQ is cross-cluster anchor)")
+print(" Spread = HQ − LQ (positive = expected HQ-best ordering; negative = inverted)")
+print("="*150)
+hdr = f"  {'metric':<14}  {'treat':<8}  {'LQ':>7}  {'MQ':>7}  {'HQ':>7}  {'spread':>8}  {'order':<12}"
+print(hdr)
+print('-'*100)
+for mid, disp, _ in HEADLINE:
+    for trt, sfx in [('PRE','new'), ('POST+UP','new_repaired_upsampled')]:
+        lq = task_value(data[f'clusterB_lq_{sfx}']['prose'], mid)
+        mq = task_value(data[f'clusterB_mq_{sfx}']['prose'], mid)
+        hq = task_value(data[f'clusterB_hq_{sfx}']['prose'], mid)
+        if lq is None or mq is None or hq is None: continue
+        spread = (hq - lq) * 100
+        # Determine ordering
+        triple = [('LQ',lq),('MQ',mq),('HQ',hq)]
+        triple_sorted = sorted(triple, key=lambda r:-r[1])
+        order = '>'.join(t[0] for t in triple_sorted)
+        line = f"  {disp:<14}  {trt:<8}  {lq*100:>7.2f}  {mq*100:>7.2f}  {hq*100:>7.2f}  {spread:>+7.2f}  {order:<12}"
+        print(line)
+    print()
+
+# ============================================================================
+# TABLE 3 — Repair effect (POST+UP − PRE) by tier  +  seed-variance noise floor
+# ============================================================================
+print("="*150)
+print(" Table 3 — Repair effect Δ (POST+UP − PRE) by tier  +  cross-cluster seed-variance floor")
+print(" Floor is |Cluster B MQ - Cluster A MQ| paired delta at the same treatment.")
+print(" S/N column = |best tier delta| / floor.")
+print("="*150)
+hdr = f"  {'metric':<14}  {'Δ LQ':>9}  {'Δ MQ-A':>9}  {'Δ MQ-B':>9}  {'Δ HQ':>9}    {'seed-floor':>11}  {'best-S/N':>10}"
+print(hdr)
+print('-'*120)
+def delta(lab_pre, lab_ups, mid):
+    pv = task_value(data[lab_pre]['prose'], mid)
+    uv = task_value(data[lab_ups]['prose'], mid)
+    return (uv-pv)*100 if (pv is not None and uv is not None) else None
+
+floor_results = {}
+for mid, disp, _ in HEADLINE:
+    d_lq = delta('clusterB_lq_new','clusterB_lq_new_repaired_upsampled', mid)
+    d_mq_a = delta('clusterA_mq_new','clusterA_mq_new_repaired_upsampled', mid)
+    d_mq_b = delta('clusterB_mq_new','clusterB_mq_new_repaired_upsampled', mid)
+    d_hq = delta('clusterB_hq_new','clusterB_hq_new_repaired_upsampled', mid)
+    # Seed-variance floor = median of |Cluster A MQ vs Cluster B MQ| at PRE and POST+UP
+    a_pre = task_value(data['clusterA_mq_new']['prose'], mid)
+    b_pre = task_value(data['clusterB_mq_new']['prose'], mid)
+    a_ups = task_value(data['clusterA_mq_new_repaired_upsampled']['prose'], mid)
+    b_ups = task_value(data['clusterB_mq_new_repaired_upsampled']['prose'], mid)
+    floor_vals = []
+    if a_pre is not None and b_pre is not None:
+        floor_vals.append(abs(b_pre - a_pre) * 100)
+    if a_ups is not None and b_ups is not None:
+        floor_vals.append(abs(b_ups - a_ups) * 100)
+    floor = statistics.median(floor_vals) if floor_vals else 0.0
+    floor_results[mid] = floor
+    # Best tier signal
+    deltas_pp = [d for d in [d_lq, d_mq_a, d_mq_b, d_hq] if d is not None]
+    best = max(deltas_pp, key=abs) if deltas_pp else 0.0
+    sn = abs(best)/floor if floor > 0.001 else float('inf')
+    sn_str = f"{sn:>6.1f}×" if sn != float('inf') else "   ∞"
+    def fmt(d):
+        return f"{d:>+8.2f}pp" if d is not None else f"  {'--':>7}"
+    print(f"  {disp:<14}  {fmt(d_lq):>9}  {fmt(d_mq_a):>9}  {fmt(d_mq_b):>9}  {fmt(d_hq):>9}    {floor:>9.3f}pp  {sn_str:>10}")
+
+# Aggregate deltas
+print('-'*120)
+def agg_delta(agg_fn, pre, ups):
+    p = agg_fn(data[pre]['prose']); u = agg_fn(data[ups]['prose'])
+    return (u-p)*100 if (p is not None and u is not None) else None
+for name, agg_fn in [('FineWeb-Agg-8', fineweb_agg), ('Dolma-Hdln-8', dolma8_agg), ('Knowledge-Agg', knowledge_agg)]:
+    d_lq = agg_delta(agg_fn,'clusterB_lq_new','clusterB_lq_new_repaired_upsampled')
+    d_mq_a = agg_delta(agg_fn,'clusterA_mq_new','clusterA_mq_new_repaired_upsampled')
+    d_mq_b = agg_delta(agg_fn,'clusterB_mq_new','clusterB_mq_new_repaired_upsampled')
+    d_hq = agg_delta(agg_fn,'clusterB_hq_new','clusterB_hq_new_repaired_upsampled')
+    def fmt(d):
+        return f"{d:>+8.2f}pp" if d is not None else f"  {'--':>7}"
+    print(f"  {name:<14}  {fmt(d_lq):>9}  {fmt(d_mq_a):>9}  {fmt(d_mq_b):>9}  {fmt(d_hq):>9}")
+
+# Paloma BPB Δ
+def palo_mean_delta(pre, ups):
+    p = statistics.mean([data[pre]['paloma'][c]['bits_per_byte,none'] for c in data[pre]['paloma']])
+    u = statistics.mean([data[ups]['paloma'][c]['bits_per_byte,none'] for c in data[ups]['paloma']])
+    return u - p
+d_lq = palo_mean_delta('clusterB_lq_new','clusterB_lq_new_repaired_upsampled')
+d_mq_a = palo_mean_delta('clusterA_mq_new','clusterA_mq_new_repaired_upsampled')
+d_mq_b = palo_mean_delta('clusterB_mq_new','clusterB_mq_new_repaired_upsampled')
+d_hq = palo_mean_delta('clusterB_hq_new','clusterB_hq_new_repaired_upsampled')
+print(f"  {'Paloma-BPB Δ ↓':<14}  {d_lq:>+8.4f}  {d_mq_a:>+8.4f}  {d_mq_b:>+8.4f}  {d_hq:>+8.4f}     (lower = improvement)")
+
+# ============================================================================
+# TABLE 4 — Cross-cluster seed-variance noise floor (PRE and POST+UP only)
+# ============================================================================
+print()
+print("="*150)
+print(" Table 4 — Seed-variance noise floor (Cluster A MQ vs Cluster B MQ, same treatment)")
+print(" Excludes POST-only (Cluster B MQ-POST was anomalous: BoolQ +7.6pp, PubMedQA +15.2pp)")
+print("="*150)
+print(f"  {'metric':<14}  {'|Δ| PRE':>10}  {'|Δ| POST+UP':>14}  {'median':>9}")
+print('-'*60)
+floors = []
+for mid, disp, _ in HEADLINE:
+    mp = task_value(data['clusterA_mq_new']['prose'], mid)
+    hp = task_value(data['clusterB_mq_new']['prose'], mid)
+    mu = task_value(data['clusterA_mq_new_repaired_upsampled']['prose'], mid)
+    hu = task_value(data['clusterB_mq_new_repaired_upsampled']['prose'], mid)
+    vs = []
+    if mp is not None and hp is not None: vs.append(abs(hp-mp)*100)
+    if mu is not None and hu is not None: vs.append(abs(hu-mu)*100)
+    med = statistics.median(vs) if vs else 0
+    print(f"  {disp:<14}  {vs[0]:>10.3f}pp  {vs[1]:>13.3f}pp  {med:>8.3f}pp")
+    floors.extend(vs)
+print('-'*60)
+floors.sort()
+print(f"\n  Overall noise floor (15 metrics × 2 treatments = 30 deltas):")
+print(f"    median = {statistics.median(floors):.3f} pp")
+print(f"    p75    = {floors[int(len(floors)*0.75)]:.3f} pp")
+print(f"    p95    = {floors[int(len(floors)*0.95)]:.3f} pp")
+print(f"    max    = {floors[-1]:.3f} pp")
+
+# Paloma seed floor
+palo_floors = []
+for trt_label, mlab, hlab in [('PRE','clusterA_mq_new','clusterB_mq_new'),('POST+UP','clusterA_mq_new_repaired_upsampled','clusterB_mq_new_repaired_upsampled')]:
+    for c in data[mlab]['paloma']:
+        m = data[mlab]['paloma'][c]['bits_per_byte,none']
+        h = data[hlab]['paloma'][c]['bits_per_byte,none']
+        palo_floors.append(abs(h-m))
+palo_floors.sort()
+print(f"\n  Paloma seed floor (22 deltas):  median = {statistics.median(palo_floors):.5f}  max = {palo_floors[-1]:.5f}")
+
+# ============================================================================
+# TABLE 5 — Paloma per-corpus 8-variant matrix + distributional split
+# ============================================================================
+print()
+print("="*150)
+print(" Table 5 — Paloma-11 bits-per-byte per corpus (lower=better)")
+print("="*150)
+corpora = sorted(data['clusterA_mq_new']['paloma'].keys())
+hdr = f"  {'corpus':<32}"
+for _, disp, *_ in VARIANTS: hdr += f"  {disp:>10}"
+print(hdr)
+print('-'*150)
+for c in corpora:
+    name = data['clusterA_mq_new']['paloma'][c].get('alias', c)
+    line = f"  {name:<32}"
+    for lookup, *_ in VARIANTS:
+        v = data[lookup]['paloma'][c]['bits_per_byte,none']
+        line += f"  {v:>10.4f}"
+    print(line)
+print('-'*150)
+line = f"  {'Paloma-BPB-11 mean ↓':<32}"
+for lookup, *_ in VARIANTS:
+    v = statistics.mean([data[lookup]['paloma'][c]['bits_per_byte,none'] for c in corpora])
+    line += f"  {v:>10.4f}"
+print(line)
+
+# Per-corpus repair delta by tier (POST+UP - PRE)
+print()
+print(" Repair Δ on Paloma BPB (POST+UP − PRE), by tier")
+print(" Negative = repair improves on that corpus; positive = repair regresses")
+print(" Distributional-specialization signature: web-y corpora improve, literary corpora regress")
+print('-'*100)
+print(f"  {'corpus':<32}  {'Δ LQ':>9}  {'Δ MQ-A':>9}  {'Δ MQ-B':>9}  {'Δ HQ':>9}")
+for c in corpora:
+    name = data['clusterA_mq_new']['paloma'][c].get('alias', c)
+    def palo_d(pre, ups):
+        return data[ups]['paloma'][c]['bits_per_byte,none'] - data[pre]['paloma'][c]['bits_per_byte,none']
+    d_lq = palo_d('clusterB_lq_new','clusterB_lq_new_repaired_upsampled')
+    d_mq_a = palo_d('clusterA_mq_new','clusterA_mq_new_repaired_upsampled')
+    d_mq_b = palo_d('clusterB_mq_new','clusterB_mq_new_repaired_upsampled')
+    d_hq = palo_d('clusterB_hq_new','clusterB_hq_new_repaired_upsampled')
+    print(f"  {name:<32}  {d_lq:>+9.4f}  {d_mq_a:>+9.4f}  {d_mq_b:>+9.4f}  {d_hq:>+9.4f}")
+
+print()
+print("="*150)
+print("END")
+print("="*150)

build_paper_tables.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""Build paper-aligned aggregate tables from prose-28 + Paloma-11 evaluation JSONs.
+
+Produces:
+  - Per-task table with correct metric extraction (POST+UP vs PRE, with SE / Z)
+  - Five paper-aligned aggregates: FineWeb-8, DCLM-Core-18, Dolma-Headline,
+    Nemotron-CC, Paloma-BPB-11
+  - Three hypothesis-aligned diagnostic aggregates: Knowledge, Fluency,
+    Narrative-Tax
+"""
+from __future__ import annotations
+import json
+import glob
+import math
+import statistics
+import sys
+
+BASE = './eval_results'
+PROSE_DIR = f'{BASE}/prose'
+PALOMA_DIR = f'{BASE}/paloma'
+
+# ---- Per-task metric & random-baseline map ---------------------------------
+# (primary_key, fallback_key_or_None, scale_to_01, random_baseline_for_centered_acc)
+TASK_SPEC = {
+    'hellaswag':       ('acc_norm,none', None,           1.0, 0.25),
+    'piqa':            ('acc_norm,none', None,           1.0, 0.50),
+    'winogrande':      ('acc,none',      None,           1.0, 0.50),
+    'commonsense_qa':  ('acc,none',      None,           1.0, 0.20),
+    'social_iqa':      ('acc,none',      None,           1.0, 1/3),
+    'openbookqa':      ('acc_norm,none', None,           1.0, 0.25),
+    'sciq':            ('acc_norm,none', None,           1.0, 0.25),
+    'arc_easy':        ('acc_norm,none', None,           1.0, 0.25),
+    'arc_challenge':   ('acc_norm,none', None,           1.0, 0.25),
+    'logiqa':          ('acc,none',      None,           1.0, 0.25),
+    'pubmedqa':        ('acc,none',      None,           1.0, 1/3),
+    'boolq':           ('acc,none',      None,           1.0, 0.50),
+    'race':            ('acc,none',      None,           1.0, 0.25),
+    'squadv2':         ('best_f1,none',  None,           0.01, 0.0),  # already 0-100
+    'coqa':            ('f1,none',       None,           1.0, 0.0),
+    'copa':            ('acc,none',      None,           1.0, 0.50),
+    'cb':              ('acc,none',      None,           1.0, 1/3),
+    'rte':             ('acc,none',      None,           1.0, 0.50),
+    'anli_r1':         ('acc,none',      None,           1.0, 1/3),
+    'anli_r2':         ('acc,none',      None,           1.0, 1/3),
+    'anli_r3':         ('acc,none',      None,           1.0, 1/3),
+    'truthfulqa_mc2':  ('acc,none',      None,           1.0, 0.50),
+    'triviaqa':        ('exact_match,remove_whitespace', None, 1.0, 0.0),
+    'nq_open':         ('exact_match,remove_whitespace', None, 1.0, 0.0),
+    'lambada_openai':  ('acc,none',      None,           1.0, 0.0),
+    'wikitext':        ('word_perplexity,none', None,    1.0, None),  # ppl, no centered
+    # MMLU sub-tasks (57) — handled as group
+    # BLiMP sub-tasks (67) — handled as group
+}
+STDERR_SUFFIX = '_stderr'
+
+# Paper aggregates — list of task IDs (mmlu = mean of mmlu_*; arc_mean = mean of E/C)
+FINEWEB_8 = ['commonsense_qa','hellaswag','openbookqa','piqa','social_iqa','winogrande',
+             '__arc_mean__','__mmlu_mean__']
+DCLM_CORE_PROSE_18 = ['arc_easy','arc_challenge','hellaswag','piqa','winogrande','openbookqa',
+                      'commonsense_qa','social_iqa','boolq','sciq','race','lambada_openai',
+                      'truthfulqa_mc2','copa','cb','rte','logiqa','pubmedqa']
+DOLMA_HEADLINE_8 = ['hellaswag','piqa','winogrande','openbookqa','arc_easy','arc_challenge',
+                    'sciq','boolq']  # + paloma_bpb_11 as separate column
+NEMOTRON_CC = FINEWEB_8 + ['race','boolq','__anli_mean__']
+
+KNOWLEDGE_AGG = ['__mmlu_mean__','triviaqa','nq_open','arc_challenge','openbookqa']
+FLUENCY_TASKS = ['lambada_openai']   # plus -wikitext_bpb and -paloma_bpb (handled separately)
+NARRATIVE_TAX = ['hellaswag','piqa','winogrande','__blimp_mean__']
+
+
+# ---- Load -------------------------------------------------------------------
+def load_results(d, label):
+    f = glob.glob(f'{d}/{label}_results/results_*.json')
+    if not f:
+        sys.exit(f"No results file in {d}/{label}_results/")
+    return json.load(open(f[0]))['results']
+
+def get_metric(task_results, key, scale=1.0):
+    if key in task_results:
+        return task_results[key] * scale
+    return None
+
+def get_stderr(task_results, key, scale=1.0):
+    se_key = key.replace(',', '_stderr,', 1)
+    if se_key in task_results:
+        v = task_results[se_key]
+        if isinstance(v, (int, float)):
+            return v * scale
+    return None
+
+def extract(results, task):
+    """Return (value_in_0_1, stderr_in_0_1) for the named task, or (None, None)."""
+    if task == '__mmlu_mean__':
+        sub = [k for k in results if k.startswith('mmlu_') and k != 'mmlu']
+        if not sub: return (None, None)
+        accs = [results[k].get('acc,none') for k in sub]
+        accs = [a for a in accs if isinstance(a,(int,float))]
+        if not accs: return (None, None)
+        return (statistics.mean(accs), statistics.pstdev(accs)/math.sqrt(len(accs)))
+    if task == '__blimp_mean__':
+        sub = [k for k in results if k.startswith('blimp_') and k != 'blimp']
+        if not sub: return (None, None)
+        accs = [results[k].get('acc,none') for k in sub]
+        accs = [a for a in accs if isinstance(a,(int,float))]
+        return (statistics.mean(accs), statistics.pstdev(accs)/math.sqrt(len(accs)))
+    if task == '__arc_mean__':
+        a = results.get('arc_easy',{}).get('acc_norm,none')
+        b = results.get('arc_challenge',{}).get('acc_norm,none')
+        if a is None or b is None: return (None, None)
+        return ((a+b)/2, None)
+    if task == '__anli_mean__':
+        accs=[results.get(t,{}).get('acc,none') for t in ['anli_r1','anli_r2','anli_r3']]
+        accs=[a for a in accs if isinstance(a,(int,float))]
+        if not accs: return (None,None)
+        return (statistics.mean(accs), None)
+    spec = TASK_SPEC.get(task)
+    if spec is None: return (None, None)
+    key, _, scale, _ = spec
+    return get_metric(results.get(task,{}), key, scale), get_stderr(results.get(task,{}), key, scale)
+
+
+# ---- Load all three variants ----
+labels = ['clusterA_mq_new', 'clusterA_mq_new_repaired', 'clusterA_mq_new_repaired_upsampled']
+display = {'clusterA_mq_new':'PRE', 'clusterA_mq_new_repaired':'POST', 'clusterA_mq_new_repaired_upsampled':'POST+UP'}
+
+prose = {lab: load_results(PROSE_DIR, lab) for lab in labels}
+paloma = {lab: load_results(PALOMA_DIR, lab) for lab in labels}
+
+# ---- Per-task table (POST+UP vs PRE, with significance) ---------------------
+print("="*86)
+print("Table 1: Per-task results — POST+UP vs PRE  (Qwen3-1.7B, 1 epoch, iter 16 406)")
+print("="*86)
+print(f"{'task':<22} {'PRE':>9} {'POST':>9} {'POST+UP':>9} {'Δ+UP':>9} {'SE':>7} {'Z':>6} {'sig':>4}")
+print('-'*86)
+
+all_single = list(TASK_SPEC.keys())
+total_pre, total_ups, n_acc = 0.0, 0.0, 0
+deltas_pp = []
+sig_count = {'***':0,'**':0,'*':0,'-':0}
+
+for t in all_single:
+    if t == 'wikitext': continue  # PPL handled separately
+    p_pre, se_pre = extract(prose['clusterA_mq_new'], t)
+    p_post, _ = extract(prose['clusterA_mq_new_repaired'], t)
+    p_ups, se_ups = extract(prose['clusterA_mq_new_repaired_upsampled'], t)
+    if p_pre is None or p_ups is None: continue
+    d_pp = (p_ups - p_pre) * 100
+    se_p = (se_pre or 0)*100
+    se_u = (se_ups or 0)*100
+    combined_se = math.sqrt(se_p**2 + se_u**2) if (se_pre or se_ups) else 0.0
+    z = d_pp/combined_se if combined_se>0 else 0.0
+    sig = '***' if abs(z)>=2.58 else '**' if abs(z)>=1.96 else '*' if abs(z)>=1.65 else '-'
+    sig_count[sig] = sig_count.get(sig,0)+1
+    print(f"{t:<22} {p_pre*100:>8.2f}% {p_post*100:>8.2f}% {p_ups*100:>8.2f}% {d_pp:>+8.2f}pp {combined_se:>6.2f} {z:>+6.2f} {sig:>4}")
+    deltas_pp.append((t, d_pp, p_pre, p_ups))
+    total_pre += p_pre; total_ups += p_ups; n_acc += 1
+
+# MMLU & BLiMP aggregate rows
+for agg in ['__mmlu_mean__','__blimp_mean__']:
+    p_pre,_=extract(prose['clusterA_mq_new'],agg); p_post,_=extract(prose['clusterA_mq_new_repaired'],agg); p_ups,_=extract(prose['clusterA_mq_new_repaired_upsampled'],agg)
+    if p_pre is None: continue
+    d_pp = (p_ups-p_pre)*100
+    name = 'mmlu-57 (mean)' if agg=='__mmlu_mean__' else 'blimp-67 (mean)'
+    print(f"{name:<22} {p_pre*100:>8.2f}% {p_post*100:>8.2f}% {p_ups*100:>8.2f}% {d_pp:>+8.2f}pp")
+
+# Wikitext PPL
+wp_pre = prose['clusterA_mq_new']['wikitext']['word_perplexity,none']
+wp_post = prose['clusterA_mq_new_repaired']['wikitext']['word_perplexity,none']
+wp_ups  = prose['clusterA_mq_new_repaired_upsampled']['wikitext']['word_perplexity,none']
+print(f"{'wikitext (ppl ↓)':<22} {wp_pre:>9.2f} {wp_post:>9.2f} {wp_ups:>9.2f} {wp_pre-wp_ups:>+9.2f} (lower=better)")
+
+# WikiText BPB for cleaner aggregation
+wb_pre = prose['clusterA_mq_new']['wikitext']['bits_per_byte,none']
+wb_post = prose['clusterA_mq_new_repaired']['wikitext']['bits_per_byte,none']
+wb_ups  = prose['clusterA_mq_new_repaired_upsampled']['wikitext']['bits_per_byte,none']
+print(f"{'wikitext (bpb ↓)':<22} {wb_pre:>9.4f} {wb_post:>9.4f} {wb_ups:>9.4f} {wb_pre-wb_ups:>+9.4f} (lower=better)")
+
+print('-'*86)
+print(f"\nSignificance tally (z-test, two-sided): *** p<0.01: {sig_count['***']},  ** p<0.05: {sig_count['**']},  * p<0.10: {sig_count['*']},  ns: {sig_count['-']}")
+
+# ---- Paloma-11 BPB table ----
+print(f"\n{'='*86}")
+print("Table 2: Paloma-11 bits-per-byte (lower=better) — POST+UP vs PRE")
+print(f"{'='*86}")
+print(f"{'corpus':<32} {'PRE':>9} {'POST':>9} {'POST+UP':>9} {'Δ+UP':>9}")
+print('-'*86)
+ptasks = sorted(paloma['clusterA_mq_new'].keys())
+bpb = {lab: [] for lab in labels}
+for pt in ptasks:
+    name = paloma['clusterA_mq_new'][pt].get('alias', pt)
+    pre_b = paloma['clusterA_mq_new'][pt]['bits_per_byte,none']
+    pos_b = paloma['clusterA_mq_new_repaired'][pt]['bits_per_byte,none']
+    ups_b = paloma['clusterA_mq_new_repaired_upsampled'][pt]['bits_per_byte,none']
+    bpb['clusterA_mq_new'].append(pre_b); bpb['clusterA_mq_new_repaired'].append(pos_b); bpb['clusterA_mq_new_repaired_upsampled'].append(ups_b)
+    print(f"{name:<32} {pre_b:>9.4f} {pos_b:>9.4f} {ups_b:>9.4f} {pre_b-ups_b:>+9.4f}")
+print('-'*86)
+for lab in labels: bpb[lab+'_mean'] = statistics.mean(bpb[lab])
+print(f"{'Paloma-BPB-11 (mean)':<32} {bpb['clusterA_mq_new_mean']:>9.4f} {bpb['clusterA_mq_new_repaired_mean']:>9.4f} {bpb['clusterA_mq_new_repaired_upsampled_mean']:>9.4f} {bpb['clusterA_mq_new_mean']-bpb['clusterA_mq_new_repaired_upsampled_mean']:>+9.4f}")
+
+# ---- Paper-aligned aggregates ----
+def mean_acc(results, tasks):
+    vs=[]
+    for t in tasks:
+        v,_=extract(results,t)
+        if v is not None: vs.append(v)
+    return statistics.mean(vs) if vs else None
+
+def centered_mean(results, tasks_with_rand):
+    vs=[]
+    for t, rand in tasks_with_rand:
+        v,_=extract(results,t)
+        if v is None: continue
+        if rand is None or rand>=1.0: continue
+        cv = (v - rand) / (1.0 - rand)
+        vs.append(cv)
+    return statistics.mean(vs) if vs else None
+
+print(f"\n{'='*86}")
+print("Table 3: Paper-aligned aggregates")
+print(f"{'='*86}")
+print(f"{'aggregate':<36} {'PRE':>9} {'POST':>9} {'POST+UP':>9} {'Δ+UP':>9}")
+print('-'*86)
+
+# FineWeb-8 (unweighted mean of acc)
+fw8 = {lab: mean_acc(prose[lab], FINEWEB_8) for lab in labels}
+print(f"{'(a) FineWeb-Aggregate-8 (acc)':<36} {fw8['clusterA_mq_new']*100:>8.2f}% {fw8['clusterA_mq_new_repaired']*100:>8.2f}% {fw8['clusterA_mq_new_repaired_upsampled']*100:>8.2f}% {(fw8['clusterA_mq_new_repaired_upsampled']-fw8['clusterA_mq_new'])*100:>+8.2f}pp")
+
+# DCLM-Core-prose-18 (centered)
+def rand_for(t):
+    return TASK_SPEC[t][3] if t in TASK_SPEC and TASK_SPEC[t][3] is not None else 0.0
+dclm_set = [(t, rand_for(t)) for t in DCLM_CORE_PROSE_18]
+dclm = {lab: centered_mean(prose[lab], dclm_set) for lab in labels}
+print(f"{'(b) DCLM-Core-prose-18 (centered)':<36} {dclm['clusterA_mq_new']*100:>8.2f}% {dclm['clusterA_mq_new_repaired']*100:>8.2f}% {dclm['clusterA_mq_new_repaired_upsampled']*100:>8.2f}% {(dclm['clusterA_mq_new_repaired_upsampled']-dclm['clusterA_mq_new'])*100:>+8.2f}pp")
+
+# Dolma-Headline-8
+do8 = {lab: mean_acc(prose[lab], DOLMA_HEADLINE_8) for lab in labels}
+print(f"{'(c) Dolma-Headline-8 (acc)':<36} {do8['clusterA_mq_new']*100:>8.2f}% {do8['clusterA_mq_new_repaired']*100:>8.2f}% {do8['clusterA_mq_new_repaired_upsampled']*100:>8.2f}% {(do8['clusterA_mq_new_repaired_upsampled']-do8['clusterA_mq_new'])*100:>+8.2f}pp")
+
+# Nemotron-CC
+nem = {lab: mean_acc(prose[lab], NEMOTRON_CC) for lab in labels}
+print(f"{'(d) Nemotron-CC-Headline (acc)':<36} {nem['clusterA_mq_new']*100:>8.2f}% {nem['clusterA_mq_new_repaired']*100:>8.2f}% {nem['clusterA_mq_new_repaired_upsampled']*100:>8.2f}% {(nem['clusterA_mq_new_repaired_upsampled']-nem['clusterA_mq_new'])*100:>+8.2f}pp")
+
+# Paloma-BPB-11 (lower=better)
+print(f"{'(e) Paloma-BPB-11 (bpb ↓)':<36} {bpb['clusterA_mq_new_mean']:>9.4f} {bpb['clusterA_mq_new_repaired_mean']:>9.4f} {bpb['clusterA_mq_new_repaired_upsampled_mean']:>9.4f} {bpb['clusterA_mq_new_mean']-bpb['clusterA_mq_new_repaired_upsampled_mean']:>+9.4f}")
+
+# Diagnostic aggregates
+print(f"\n{'='*86}")
+print("Table 4: Hypothesis-aligned diagnostic aggregates")
+print(f"{'='*86}")
+print(f"{'aggregate':<36} {'PRE':>9} {'POST':>9} {'POST+UP':>9} {'Δ+UP':>9}")
+print('-'*86)
+kn = {lab: mean_acc(prose[lab], KNOWLEDGE_AGG) for lab in labels}
+print(f"{'(f) Knowledge-Agg (acc)':<36} {kn['clusterA_mq_new']*100:>8.2f}% {kn['clusterA_mq_new_repaired']*100:>8.2f}% {kn['clusterA_mq_new_repaired_upsampled']*100:>8.2f}% {(kn['clusterA_mq_new_repaired_upsampled']-kn['clusterA_mq_new'])*100:>+8.2f}pp")
+
+# Fluency: LAMBADA acc (higher=better) +  −WikiText-BPB +  −Paloma-BPB-mean (both lower=better, so we invert)
+def fluency(lab, prose_d, paloma_bpb_mean):
+    lam,_ = extract(prose_d, 'lambada_openai')
+    wb = prose_d['wikitext']['bits_per_byte,none']
+    pb = paloma_bpb_mean
+    # Construct as 3-component: lam (0-1) + (1-wb_normed) + (1-pb_normed)
+    # For an interpretable single number, just print all three.
+    return lam, wb, pb
+
+print()
+print(f"(g) Fluency-Agg diagnostic (3 numbers): LAMBADA-acc (↑), WikiText-BPB (↓), Paloma-BPB (↓)")
+for lab in labels:
+    l, wb, pb = fluency(lab, prose[lab], bpb[lab+'_mean'])
+    print(f"   {display[lab]:<10}  LAMBADA={l*100:.2f}%   WikiText-BPB={wb:.4f}   Paloma-BPB={pb:.4f}")
+
+print()
+nt = {lab: mean_acc(prose[lab], NARRATIVE_TAX) for lab in labels}
+print(f"{'(h) Narrative-Tax-Canary (acc)':<36} {nt['clusterA_mq_new']*100:>8.2f}% {nt['clusterA_mq_new_repaired']*100:>8.2f}% {nt['clusterA_mq_new_repaired_upsampled']*100:>8.2f}% {(nt['clusterA_mq_new_repaired_upsampled']-nt['clusterA_mq_new'])*100:>+8.2f}pp")
+
+# Top deltas
+deltas_pp.sort(key=lambda r:-r[1])
+print(f"\n=== Top-10 task gains (POST+UP vs PRE) ===")
+for t,d,vp,vq in deltas_pp[:10]: print(f"  {t:<24} {vp*100:>6.2f}% → {vq*100:>6.2f}%  {d:>+6.2f}pp")
+print(f"\n=== Top-10 task losses ===")
+for t,d,vp,vq in deltas_pp[-10:][::-1]: print(f"  {t:<24} {vp*100:>6.2f}% → {vq*100:>6.2f}%  {d:>+6.2f}pp")

make_paper_figures.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""Generate Figures 1 and 2 for the EMNLP 2026 paper.
+
+Figure 1 — Repair effect (POST+UP − PRE) by tier on five robust benchmarks.
+Figure 2 — Per-corpus Paloma BPB delta under repair (heatmap).
+
+Outputs PDF (vector, for LaTeX inclusion) and PNG (for previewing).
+"""
+from __future__ import annotations
+import json
+import glob
+import statistics
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from matplotlib.colors import LinearSegmentedColormap, TwoSlopeNorm
+import numpy as np
+
+BASE = './eval_results'
+OUTDIR = './figures'
+
+import os
+os.makedirs(OUTDIR, exist_ok=True)
+
+
+def load(suite, label):
+    f = glob.glob(f'{BASE}/{suite}/{label}_results/results_*.json')
+    return json.load(open(f[0]))['results'] if f else {}
+
+
+# Variant lookup → anonymized display label (cluster A = Cluster A, cluster B = Cluster B)
+PAIRS = {
+    'LQ-A':  None,                                                   # no Cluster A LQ runs
+    'LQ-B':  ('clusterB_lq_new', 'clusterB_lq_new_repaired_upsampled'),
+    'MQ-A':  ('clusterA_mq_new',     'clusterA_mq_new_repaired_upsampled'),
+    'MQ-B':  ('clusterB_mq_new', 'clusterB_mq_new_repaired_upsampled'),
+    'HQ-A':  None,
+    'HQ-B':  ('clusterB_hq_new', 'clusterB_hq_new_repaired_upsampled'),
+}
+
+
+def task_value(results, task, key=None):
+    """Get accuracy in [0,1] for a task. Handles mmlu_/blimp_ aggregation."""
+    if task == 'mmlu_mean':
+        accs = [v.get('acc,none') for k, v in results.items() if k.startswith('mmlu_') and k != 'mmlu']
+        accs = [a for a in accs if isinstance(a, (int, float))]
+        return statistics.mean(accs) if accs else None
+    if task == 'blimp_mean':
+        accs = [v.get('acc,none') for k, v in results.items() if k.startswith('blimp_') and k != 'blimp']
+        accs = [a for a in accs if isinstance(a, (int, float))]
+        return statistics.mean(accs) if accs else None
+    if key is None:
+        key_map = {
+            'hellaswag': 'acc_norm,none', 'piqa': 'acc_norm,none', 'winogrande': 'acc,none',
+            'commonsense_qa': 'acc,none', 'social_iqa': 'acc,none', 'openbookqa': 'acc_norm,none',
+            'sciq': 'acc_norm,none', 'arc_easy': 'acc_norm,none', 'arc_challenge': 'acc_norm,none',
+            'boolq': 'acc,none', 'race': 'acc,none', 'lambada_openai': 'acc,none',
+        }
+        key = key_map.get(task)
+    if key is None or task not in results:
+        return None
+    v = results[task].get(key)
+    return v if isinstance(v, (int, float)) else None
+
+
+# ============================================================================
+# FIGURE 1 — Repair effect by tier on five robust benchmarks
+# ============================================================================
+print("[fig1] computing repair-effect deltas by tier ...")
+
+# 5 benchmarks (the S/N >= 4× headline set)
+BENCHMARKS = [
+    ('lambada_openai', 'LAMBADA-OpenAI'),
+    ('boolq',          'BoolQ'),
+    ('race',           'RACE'),
+    ('hellaswag',      'HellaSwag'),
+    ('openbookqa',     'OpenBookQA'),
+]
+
+# 4 tier × cluster bars per benchmark, in the visual order LQ → MQ-A → MQ-B → HQ
+BAR_KEYS = [('LQ-B', 'LQ'), ('MQ-A', 'MQ-A'), ('MQ-B', 'MQ-B'), ('HQ-B', 'HQ')]
+SIGMA_SEED = 0.6  # per-task noise floor in pp (median from Table 2)
+
+# Load all data once
+RAW = {}
+for k, pair in PAIRS.items():
+    if pair is None:
+        continue
+    pre_lab, ups_lab = pair
+    RAW[k] = {
+        'pre':  load('prose', pre_lab),
+        'ups':  load('prose', ups_lab),
+    }
+
+fig, axes = plt.subplots(1, 5, figsize=(14, 3.4), sharey=False)
+colors_per_tier = {'LQ-B':'#c0392b', 'MQ-A':'#f39c12', 'MQ-B':'#27ae60', 'HQ-B':'#2980b9'}
+tier_labels = {'LQ-B':'LQ', 'MQ-A':'MQ-A', 'MQ-B':'MQ-B', 'HQ-B':'HQ'}
+
+for ax, (task_id, task_disp) in zip(axes, BENCHMARKS):
+    deltas = []
+    bar_colors = []
+    bar_labels = []
+    for k, lab in BAR_KEYS:
+        if k not in RAW:
+            deltas.append(0.0); bar_colors.append('#cccccc'); bar_labels.append(lab); continue
+        pv = task_value(RAW[k]['pre'], task_id)
+        uv = task_value(RAW[k]['ups'], task_id)
+        if pv is None or uv is None:
+            deltas.append(0.0)
+        else:
+            deltas.append((uv - pv) * 100)
+        bar_colors.append(colors_per_tier[k])
+        bar_labels.append(tier_labels[k])
+
+    x = np.arange(len(deltas))
+    bars = ax.bar(x, deltas, color=bar_colors, edgecolor='black', linewidth=0.4, width=0.7)
+    ax.errorbar(x, deltas, yerr=SIGMA_SEED, fmt='none', ecolor='black', lw=0.7, capsize=2)
+    # ±3σ significance lines
+    ax.axhline(y= 3*SIGMA_SEED, ls='--', lw=0.5, color='gray')
+    ax.axhline(y=-3*SIGMA_SEED, ls='--', lw=0.5, color='gray')
+    ax.axhline(y=0, color='black', lw=0.5)
+    ax.set_xticks(x); ax.set_xticklabels(bar_labels, fontsize=8)
+    ax.set_title(task_disp, fontsize=10)
+    ax.tick_params(axis='y', labelsize=8)
+    # annotate bars with delta values
+    for xi, di in zip(x, deltas):
+        ax.text(xi, di + (0.15 if di >= 0 else -0.45), f'{di:+.1f}',
+                ha='center', va='bottom' if di >= 0 else 'top', fontsize=7)
+    ax.set_ylim(min(min(deltas) - 1.0, -4.0), max(max(deltas) + 1.0, 6.0))
+
+axes[0].set_ylabel('Δ accuracy (POST+UP − PRE), pp', fontsize=9)
+fig.suptitle('Repair effect by tier on the five robust benchmarks (S/N ≥ 4×)',
+             fontsize=11, y=1.00)
+# Add legend below figures
+proxies = [mpatches.Patch(color=c, label=tier_labels[k]) for k, c in colors_per_tier.items()]
+proxies.append(mpatches.Patch(color='gray', alpha=0.3, label=f'±3σ noise (={3*SIGMA_SEED:.1f} pp)'))
+fig.legend(handles=proxies, loc='lower center', ncol=5, fontsize=8, frameon=False,
+           bbox_to_anchor=(0.5, -0.05))
+plt.tight_layout()
+plt.subplots_adjust(bottom=0.15)
+plt.savefig(f'{OUTDIR}/fig1_repair_by_tier.pdf', bbox_inches='tight', dpi=300)
+plt.savefig(f'{OUTDIR}/fig1_repair_by_tier.png', bbox_inches='tight', dpi=200)
+print(f"[fig1] saved to {OUTDIR}/fig1_repair_by_tier.{{pdf,png}}")
+plt.close()
+
+
+# ============================================================================
+# FIGURE 2 — Paloma per-corpus BPB delta heatmap
+# ============================================================================
+print("[fig2] computing Paloma per-corpus deltas ...")
+
+ROWS = [
+    ('LQ-B', 'LQ',   'clusterB_lq_new', 'clusterB_lq_new_repaired_upsampled'),
+    ('MQ-A', 'MQ-A', 'clusterA_mq_new',     'clusterA_mq_new_repaired_upsampled'),
+    ('MQ-B', 'MQ-B', 'clusterB_mq_new', 'clusterB_mq_new_repaired_upsampled'),
+    ('HQ-B', 'HQ',   'clusterB_hq_new', 'clusterB_hq_new_repaired_upsampled'),
+]
+# Web → mixed → literary column ordering
+COL_ORDER = [
+    ('paloma_c4_100_domains',     'C4-100',  'web'),
+    ('paloma_c4_en',              'C4-en',   'web'),
+    ('paloma_falcon-refinedweb',  'Falcon',  'web'),
+    ('paloma_mc4',                'mC4',     'web'),
+    ('paloma_m2d2_s2orc_unsplit', 'S2ORC',   'mixed'),
+    ('paloma_m2d2_wikipedia_unsplit', 'M2D2-Wiki', 'mixed'),
+    ('paloma_dolma_100_subreddits', 'Subreddit', 'mixed'),
+    ('paloma_dolma-v1_5',         'Dolma',   'lit'),
+    ('paloma_wikitext_103',       'WikiText','lit'),
+    ('paloma_redpajama',          'RedPajama','lit'),
+    ('paloma_ptb',                'PTB',     'lit'),
+]
+
+# Compute delta matrix
+matrix = np.zeros((len(ROWS), len(COL_ORDER)))
+for i, (key, _label, pre_lab, ups_lab) in enumerate(ROWS):
+    pre_palo = load('paloma', pre_lab)
+    ups_palo = load('paloma', ups_lab)
+    for j, (corpus, _name, _kind) in enumerate(COL_ORDER):
+        p = pre_palo[corpus]['bits_per_byte,none']
+        u = ups_palo[corpus]['bits_per_byte,none']
+        matrix[i, j] = u - p
+
+fig2, ax2 = plt.subplots(figsize=(9.5, 3.0))
+# Diverging colormap: red for positive (regression), blue for negative (improvement)
+vmax = max(abs(matrix.min()), abs(matrix.max()))
+cmap = plt.get_cmap('RdBu_r')
+norm = TwoSlopeNorm(vmin=-vmax, vcenter=0.0, vmax=vmax)
+im = ax2.imshow(matrix, cmap=cmap, norm=norm, aspect='auto')
+
+# Tick labels
+ax2.set_xticks(range(len(COL_ORDER)))
+ax2.set_xticklabels([n[1] for n in COL_ORDER], rotation=25, ha='right', fontsize=8)
+ax2.set_yticks(range(len(ROWS)))
+ax2.set_yticklabels([r[1] for r in ROWS], fontsize=9)
+
+# Annotate cells
+for i in range(matrix.shape[0]):
+    for j in range(matrix.shape[1]):
+        v = matrix[i, j]
+        col = 'white' if abs(v) > 0.06 else 'black'
+        ax2.text(j, i, f'{v:+.3f}', ha='center', va='center', fontsize=7, color=col)
+
+# Vertical dividers between web/mixed/literary blocks
+boundary_indices = []
+kinds = [c[2] for c in COL_ORDER]
+for j in range(1, len(kinds)):
+    if kinds[j] != kinds[j-1]:
+        boundary_indices.append(j - 0.5)
+for x in boundary_indices:
+    ax2.axvline(x=x, color='black', lw=1.2)
+
+# Region annotations under x-axis
+kind_labels = {'web':'WEB (improvement)', 'mixed':'NEUTRAL', 'lit':'LITERARY (regression)'}
+# Find midpoints of each block
+from itertools import groupby
+groups = []
+idx = 0
+for kind, group in groupby(kinds):
+    g = list(group)
+    groups.append((kind, idx, idx + len(g) - 1))
+    idx += len(g)
+for kind, lo, hi in groups:
+    mid = (lo + hi) / 2
+    ax2.text(mid, len(ROWS) + 0.15, kind_labels[kind],
+             ha='center', va='top', fontsize=8, style='italic',
+             transform=ax2.transData)
+
+# Colorbar
+cbar = fig2.colorbar(im, ax=ax2, fraction=0.025, pad=0.02)
+cbar.set_label('Δ BPB (POST+UP − PRE)', fontsize=8)
+cbar.ax.tick_params(labelsize=7)
+
+ax2.set_title('Paloma-11 per-corpus repair Δ — universal web/literary split across tiers',
+              fontsize=10, pad=10)
+plt.tight_layout()
+plt.subplots_adjust(bottom=0.30, right=0.92)
+plt.savefig(f'{OUTDIR}/fig2_paloma_split.pdf', bbox_inches='tight', dpi=300)
+plt.savefig(f'{OUTDIR}/fig2_paloma_split.png', bbox_inches='tight', dpi=200)
+print(f"[fig2] saved to {OUTDIR}/fig2_paloma_split.{{pdf,png}}")
+plt.close()
+
+print("Done.")

requirements.txt

@@ -0,0 +1,9 @@
+# Supplementary materials — analysis-script dependencies
+# Match versions used in the paper's evaluation pipeline (see Appendix D)
+
+lm-evaluation-harness==0.4.12
+datasets>=3.0,<4.0
+transformers>=4.50,<6.0
+vllm>=0.10
+numpy
+matplotlib