File size: 10,842 Bytes
d9aaa5c 9f3fd8a a72b4b4 9f3fd8a cc4f445 d9aaa5c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | """Aggregate all runs -> data/results.json (feeds the Space + README) and print the pre-registered verdicts."""
import json, os, statistics as st
from collections import defaultdict
R = {}
mean = lambda xs: round(st.mean(xs), 3) if xs else None
def load(p):
return [json.loads(l) for l in open(p, encoding="utf-8")] if os.path.exists(p) else []
def agg(rows, key):
g = defaultdict(list)
for r in rows:
g[key(r)].append(r)
out = {}
for k, rs in g.items():
t = [r["lid"]["target_share"] for r in rs if r["lid"]["target_share"] is not None]
e = [r["lid"]["eng_share"] for r in rs if r["lid"]["eng_share"] is not None]
out["|".join(map(str, k))] = {
"n": len(rs), "acc": round(100 * sum(r["correct"] for r in rs) / len(rs), 1),
"target_share": mean(t), "eng_share": mean(e),
"pct_mostly_target": round(100 * sum(x >= 0.5 for x in t) / len(t), 1) if t else None,
"no_reasoning_signal": len(rs) - len(t),
"empty_or_truncated": sum(r["finish_reason"] == "length" or not r.get("content") for r in rs),
"reasoning_tokens": mean([(r["usage"].get("completion_tokens_details") or {}).get("reasoning_tokens", 0)
for r in rs]),
"completion_tokens": mean([r["usage"].get("completion_tokens", 0) for r in rs])}
return out
atlas = load("data/atlas/runs_low.jsonl") + load("data/atlas/runs_high.jsonl")
math_ = load("data/math/runs_low.jsonl") + load("data/math/runs_high.jsonl")
R["atlas"] = agg(atlas, lambda r: (r["lang"], r["cond"], r["effort"]))
R["math"] = agg(math_, lambda r: (r["lang"], r["cond"], r["effort"]))
R["replication"] = json.load(open("data/replication/profiled_summary.json")) if os.path.exists(
"data/replication/profiled_summary.json") else []
if os.path.exists("data/bugis/results.json"):
R["grammar"] = json.load(open("data/bugis/results.json", encoding="utf-8"))["results"]
R["lid_calibration"] = json.load(open("data/lid_calibration.json"))
# ---- pre-registered verdicts (thresholds copied verbatim from PREREGISTRATION.md) ----
A = R["atlas"]; langs = sorted({k.split("|")[0] for k in A}); non_en = [l for l in langs if l != "eng_Latn"]
get = lambda l, c, f, e="low": (A.get(f"{l}|{c}|{e}") or {}).get(f)
V = {}
h1 = [l for l in non_en if (get(l, "C0", "eng_share") or 0) >= 0.5]
V["H1"] = {"pass": len(h1) >= 10, "detail": f"{len(h1)}/{len(non_en)} languages with C0 eng_share >= 0.5", "langs": h1}
up = [l for l in non_en if (get(l, "C2", "target_share") or 0) > (get(l, "C0", "target_share") or 0)]
below = [l for l in up if (get(l, "C2", "target_share") or 0) < 0.8]
V["H2"] = {"pass": len(up) >= 12 and len(below) >= len(up) / 2,
"detail": f"C2 > C0 in {len(up)}/{len(non_en)}; of those {len(below)} still < 0.8"}
h3 = [l for l in non_en if (get(l, "C3", "target_share") or 0) > (get(l, "C2", "target_share") or 0)]
V["H3"] = {"pass": len(h3) >= 12, "detail": f"C3 > C2 in {len(h3)}/{len(non_en)}"}
M = R["math"]
diffs = [(M[f"{l}|C2|low"]["acc"] - M[f"{l}|C0|low"]["acc"]) for l in {k.split("|")[0] for k in M}
if f"{l}|C2|low" in M and f"{l}|C0|low" in M]
V["H5"] = {"pass": bool(diffs) and abs(st.mean(diffs)) <= 3,
"detail": f"mean acc(C2)-acc(C0) = {round(st.mean(diffs), 2) if diffs else None} pts over {len(diffs)} langs"}
if "grammar" in R:
g = R["grammar"]; ok = True; det = []
for d in ("x2ind", "ind2x"):
s = [g.get(f"{k}/{d}", {}).get("chrf++") for k in ("K0", "K1", "K2", "K3")]
det.append(f"{d}: {s}")
ok &= None not in s and s[0] < min(s[1], s[2]) and max(s[1], s[2]) < s[3]
V["H6"] = {"pass": ok, "detail": "; ".join(det)}
t = (g.get("K3/think") or {}).get("target_share")
V["H7"] = {"pass": t is not None and 0 < t < 0.5, "detail": f"K3 think target_share = {t}"}
# H4: resource tier (Joshi et al. 2020 taxonomy, microsoft.github.io/linguisticdiversity/assets/lang2tax.txt)
TAX_NAME = {"ind_Latn": "indonesian", "jav_Latn": "javanese", "sun_Latn": "sundanese", "zsm_Latn": "malay",
"tgl_Latn": "tagalog", "ceb_Latn": "cebuano", "vie_Latn": "vietnamese", "tha_Thai": "thai",
"khm_Khmr": "khmer", "lao_Laoo": "lao", "mya_Mymr": "burmese", "hin_Deva": "hindi", "tam_Taml": "tamil",
"kor_Hang": "korean", "jpn_Jpan": "japanese", "arb_Arab": "arabic", "yor_Latn": "yoruba",
"plt_Latn": "malagasy", "eng_Latn": "english", "bug_Latn": "buginese"}
tax = dict(l.strip().rsplit(",", 1) for l in open("data/external/lang2tax.txt", encoding="utf-8") if "," in l)
tier = {c: int(tax[n]) for c, n in TAX_NAME.items() if n in tax}
def rank(xs):
o = sorted(range(len(xs)), key=lambda i: xs[i]); r = [0.0] * len(xs); i = 0
while i < len(o):
j = i
while j + 1 < len(o) and xs[o[j + 1]] == xs[o[i]]:
j += 1
for k in range(i, j + 1):
r[o[k]] = (i + j) / 2 + 1
i = j + 1
return r
def spearman(a, b):
ra, rb = rank(a), rank(b); ma, mb = st.mean(ra), st.mean(rb)
num = sum((x - ma) * (y - mb) for x, y in zip(ra, rb))
den = (sum((x - ma) ** 2 for x in ra) * sum((y - mb) ** 2 for y in rb)) ** 0.5
return round(num / den, 3) if den else None
h4 = [(tier[l], get(l, "C2", "target_share")) for l in non_en if l in tier and get(l, "C2", "target_share") is not None]
rho = spearman([t for t, _ in h4], [s for _, s in h4]) if len(h4) > 2 else None
# H4 as written: lower-resource -> less compliance, i.e. compliance rises with tier -> rho(tier, share) > 0
V["H4"] = {"pass": rho is not None and rho > 0, "detail": f"Spearman(Joshi tier, C2 target_share) = {rho} over {len(h4)} languages "
"(pre-registration phrased it as a negative correlation with 'low-resource-ness'; tier is ordered high=5)"}
if rho is not None: # exact-ish permutation p-value (two-sided) for the weak correlation
prng = __import__("random").Random(1); ts_ = [t for t, _ in h4]; ss = [s for _, s in h4]; hits = 0
for _ in range(5000):
prng.shuffle(ss)
hits += abs(spearman(ts_, ss) or 0) >= abs(rho)
V["H4"]["detail"] += f"; permutation p = {hits / 5000:.3f} (direction as predicted, not significant)"
R["tiers"] = tier
# Grammar 'think in Buginese' probe, quote-stripped: the x2ind probe quotes Buginese input sentences in its reasoning
if "grammar" in R:
from lid import profile as _prof
gtest = [json.loads(l) for l in open("data/bugis/test.jsonl", encoding="utf-8")]
for r in json.load(open("data/bugis/results.json", encoding="utf-8"))["rows"]:
if r["think"]:
src = "\n".join(s["bug"] for s in gtest[r["batch"] * 50:(r["batch"] + 1) * 50])
R["grammar"][f"{r['cond']}/think_noquote"] = _prof(r["reasoning"], "bug_Latn", exclude=src)
if os.path.exists("data/routecheck/results.json"):
R["route_check"] = json.load(open("data/routecheck/results.json", encoding="utf-8"))["summary"]
if os.path.exists("data/reward_by_cond.json"):
R["reward_by_cond"] = json.load(open("data/reward_by_cond.json"))
if os.path.exists("data/distill/summary_baseline.json"):
R["distill"] = {t: json.load(open(f"data/distill/summary_{t}.json")) for t in ("baseline", "after", "after_rp")
if os.path.exists(f"data/distill/summary_{t}.json")}
if os.path.exists("data/distill/stats.json"):
R["distill_stats"] = json.load(open("data/distill/stats.json"))
R["verdicts"] = dict(sorted(V.items()))
V = R["verdicts"]
# ---- exploratory / robustness ----
import random
rng = random.Random(0)
def boot(xs, n=2000):
xs = [x for x in xs if x is not None]
if len(xs) < 3:
return None
ms = sorted(st.mean(rng.choices(xs, k=len(xs))) for _ in range(n))
return [round(ms[int(.025 * n)], 3), round(ms[int(.975 * n)], 3)]
low = [r for r in atlas if r["effort"] == "low"]
ci, rob = {}, {}
for l in langs:
for c in ("C0", "C1", "C2", "C3"):
rs = [r for r in low if r["lang"] == l and r["cond"] == c]
if not rs:
continue
ci[f"{l}|{c}"] = boot([r["lid"]["eng_share"] for r in rs])
rob[f"{l}|{c}"] = {
"eng_share_prereg": mean([r["lid"]["eng_share"] for r in rs if r["lid"]["eng_share"] is not None]),
"eng_share_noquote": mean([r["lid_noquote"]["eng_share"] for r in rs if r.get("lid_noquote", {}).get("eng_share") is not None]),
"target_share_noquote": mean([r["lid_noquote"]["target_share"] for r in rs if r.get("lid_noquote", {}).get("target_share") is not None]),
"lingua_eng": mean([r["lingua_eng"] for r in rs if r.get("lingua_eng") is not None]),
"lingua_eng_noquote": mean([r["lingua_eng_noquote"] for r in rs if r.get("lingua_eng_noquote") is not None])}
R["atlas_eng_share_ci95"] = ci
R["robustness"] = rob
pairs = [(r["lid"]["eng_share"], r["lingua_eng"]) for r in low if r["lid"]["eng_share"] is not None and r.get("lingua_eng") is not None]
if pairs:
R["detector_agreement"] = {"n": len(pairs), "mean_abs_diff": round(st.mean(abs(a - b) for a, b in pairs), 3),
"same_majority": round(sum((a >= .5) == (b >= .5) for a, b in pairs) / len(pairs), 3)}
# condition means across non-English languages (each language weighted equally)
R["condition_means"] = {c: {"eng_share": mean([get(l, c, "eng_share") for l in non_en if get(l, c, "eng_share") is not None]),
"target_share": mean([get(l, c, "target_share") for l in non_en if get(l, c, "target_share") is not None]),
"acc": mean([get(l, c, "acc") for l in non_en if get(l, c, "acc") is not None])}
for c in ("C0", "C1", "C2", "C3")}
# McNemar (exact, two-sided) on paired math items: C0 vs C2 correctness per (problem, language)
from math import comb
mm = {}
for r in math_:
if r["effort"] == "low":
mm.setdefault((r["id"], r["lang"]), {})[r["cond"]] = r["correct"]
b = sum(1 for v in mm.values() if v.get("C0") is True and v.get("C2") is False)
c_ = sum(1 for v in mm.values() if v.get("C0") is False and v.get("C2") is True)
p = min(1.0, 2 * sum(comb(b + c_, k) for k in range(0, min(b, c_) + 1)) / 2 ** (b + c_)) if b + c_ else None
R["math_mcnemar_C0_vs_C2"] = {"C0_only_correct": b, "C2_only_correct": c_, "p_exact": round(p, 4) if p is not None else None}
R["routes"] = {k: sum(1 for r in atlas + math_ if k in r.get("route", "")) for k in ("reflection.ai", "huggingface")}
R["verdicts"] = V
json.dump(R, open("data/results.json", "w", encoding="utf-8"), ensure_ascii=False, indent=1)
for k, v in V.items():
print(k, "PASS" if v["pass"] else "FAIL", "-", v["detail"])
|