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"])