#!/usr/bin/env python3 """Recompute every WER aggregate reported in the paper from a single JSON file of per-cell WERs (``wer_results.json``, shipped alongside this script). This script is self-contained: it reads only the per-cell WER values from the JSON and re-derives every table and figure number in the paper that depends on those WERs alone. Quantities that need inputs beyond the per-cell WER table -- the per-utterance paired-bootstrap significance markers in Table~\\ref{tab:main160}, or convergence-epoch counts taken from the training logs -- are out of scope here and are not recomputed. Each check below is keyed to a stable LaTeX ``\\label`` (its ``\\ref`` target), which does not change if the paper is reordered; the ``[N]`` markers are just this script's own output tags, not paper section numbers: [1] tab:main160 FLEURS WER (%) @ 160 ms, per-(lang, hours). [2] sec:hours intro seen / unseen group mean Δ trajectory. [3] tab:latency_effect mean EN-ML gap per (tier, hours), FLEURS. [4] tab:abs_wer mean ML-init absolute WER per (tier, hours). [5] tab:lst per-lang Δ + LST per hours; macro mean. [6] sec:from_pl HR-from-PL pivot vs direct ML, 160 ms. [7] sec:reinitjoint joiner-reinit Δ, 560 ms FLEURS/VP. [8] tab:quant INT4 vs FP32 @ 560 ms FLEURS, paired stats. [9] tab:5000h_es ES 5000h vs 2500h ML deltas, and ES 5000h vs Nemotron-3.5 ML (tab:supp:es5000h). [10] fig:gap_powerlaw fit Δ(h) = a·h^(-β) at 160 ms; language-bootstrap 95% CI on β; R². [11] tab:hybrid hybrid-encoder 100h/560ms FLEURS table. [12] tab:seed + sec:seed HR/PT main-grid seed deltas + 16-cell 100h re-run @ 560 ms (FLEURS + VP); IS-EN excursion. [13] streaming penalty per (tier, hours, init), FLEURS. [14] tab:per_dataset per-dataset 160 ms WER appendix. Usage: # with wer_results.json sitting next to this script: python3 aggregate.py # or pass an explicit path to a results JSON: python3 aggregate.py /path/to/wer_results.json """ from __future__ import annotations import json import statistics import sys from pathlib import Path HERE = Path(__file__).resolve().parent # Default to wer_results.json sitting next to this script; fall back to # the in-repository ``paper/`` layout when run from a full checkout. DEFAULT_JSON = next( (p for p in (HERE / "wer_results.json", HERE.parent / "paper" / "wer_results.json") if p.is_file()), HERE / "wer_results.json", ) LANGS = ["de", "es", "fr", "hr", "is", "nl", "pl", "pt"] SEEN = ["de", "es", "fr", "nl"] UNSEEN = ["pt", "hr", "is", "pl"] HOURS = ["100h", "250h", "500h", "1000h", "2500h"] TIERS = ["160ms", "560ms", "1120ms", "offline"] # --------------------------------------------------------------------------- # JSON helpers # --------------------------------------------------------------------------- def wer(d, lang, hours, init, tier, dataset): """Return the WER (float) at d[lang][hours][init][tier][dataset], or None.""" try: cell = d[lang][hours][init][tier][dataset] if isinstance(cell, dict): v = cell.get("wer") return float(v) if v is not None else None except (KeyError, TypeError): pass return None def delta(d, lang, hours, tier, dataset): """EN - ML WER gap; None if either side missing.""" ml = wer(d, lang, hours, "ml", tier, dataset) en = wer(d, lang, hours, "enc", tier, dataset) if ml is None or en is None: return None return en - ml def fmt(x, signed=False, w=7): if x is None: return f"{'--':>{w}s}" return f"{x:+{w}.2f}" if signed else f"{x:{w}.2f}" def mean(xs): xs = [x for x in xs if x is not None] return statistics.fmean(xs) if xs else None def hr(title): print() print("=" * 78) print(title) print("=" * 78) # --------------------------------------------------------------------------- # [1] Table :main160 — FLEURS WER (%) at 160 ms streaming, per-(lang, hours) # --------------------------------------------------------------------------- def t_main160(d): hr("[1] Table tab:main160 — FLEURS WER (%) @ 160 ms") head = "lang " + "".join(f"{h:>27s}" for h in HOURS) print(head) sub = " " + "".join(f"{'ml':>9s}{'enc':>9s}{'Δ':>9s}" for _ in HOURS) print(sub) for lang in LANGS: row = f"{lang.upper():<6s}" for h in HOURS: ml = wer(d, lang, h, "ml", "160ms", "fleurs") en = wer(d, lang, h, "enc", "160ms", "fleurs") dl = (en - ml) if (ml is not None and en is not None) else None row += fmt(ml, w=9) + fmt(en, w=9) + fmt(dl, signed=True, w=9) print(row) print("-" * len(head)) # macro means row = f"{'mean':<6s}" for h in HOURS: mls = [wer(d, l, h, "ml", "160ms", "fleurs") for l in LANGS] ens = [wer(d, l, h, "enc", "160ms", "fleurs") for l in LANGS] dls = [(e - m) for m, e in zip(mls, ens) if m is not None and e is not None] row += fmt(mean(mls), w=9) + fmt(mean(ens), w=9) \ + fmt(mean(dls) if dls else None, signed=True, w=9) print(row) n_per_h = {h: sum(1 for l in LANGS if wer(d, l, h, "ml", "160ms", "fleurs") is not None and wer(d, l, h, "enc", "160ms", "fleurs") is not None) for h in HOURS} print(" K per hours: " + ", ".join(f"{h}={n_per_h[h]}" for h in HOURS)) # --------------------------------------------------------------------------- # [2] sec:hours — seen / unseen group mean Δ trajectory, FLEURS @ 160 ms # --------------------------------------------------------------------------- def t_seen_unseen(d): hr("[2] sec:hours — seen vs unseen group mean Δ, FLEURS @ 160 ms") print(f" {'group':<10s}" + "".join(f"{h:>10s}" for h in HOURS)) for label, group in (("seen", SEEN), ("unseen", UNSEEN), ("all", LANGS)): row = f" {label:<10s}" for h in HOURS: dls = [delta(d, l, h, "160ms", "fleurs") for l in group] row += fmt(mean(dls), signed=True, w=10) print(row) # --------------------------------------------------------------------------- # [3] Table :latency_effect — mean EN-ML gap per (tier, hours), FLEURS # --------------------------------------------------------------------------- def t_latency_effect(d): hr("[3] Table tab:latency_effect — mean Δ (EN-ML) per (tier, hours), FLEURS") print(f" {'tier':<10s}" + "".join(f"{h:>10s}" for h in HOURS) + f"{'range':>10s}") per_h = {h: [] for h in HOURS} for tier in TIERS: row = f" {tier:<10s}" for h in HOURS: dls = [delta(d, l, h, tier, "fleurs") for l in LANGS] m = mean(dls) per_h[h].append(m) row += fmt(m, signed=True, w=10) print(row) # cross-tier range of mean Δ at each hours (paper sentence) print(f" {'tier-range':<10s}", end="") for h in HOURS: vs = [v for v in per_h[h] if v is not None] rng = max(vs) - min(vs) if vs else None print(fmt(rng, w=10), end="") print() # --------------------------------------------------------------------------- # [4] Table :abs_wer — mean ML-init absolute FLEURS WER per (tier, hours) # --------------------------------------------------------------------------- def t_abs_wer(d): hr("[4] Table tab:abs_wer — mean ML-init FLEURS WER (%) per (tier, hours)") print(f" {'tier':<10s}" + "".join(f"{h:>10s}" for h in HOURS)) for tier in TIERS: row = f" {tier:<10s}" for h in HOURS: mls = [wer(d, l, h, "ml", tier, "fleurs") for l in LANGS] row += fmt(mean(mls), w=10) print(row) # --------------------------------------------------------------------------- # [5] Table :lst — per-lang Δ + LST per hours; macro mean # LST(lang, h) = max_tier Δ_tier(lang, h) - min_tier Δ_tier(lang, h) # Δ(lang, h) = mean_tier Δ_tier(lang, h) # Both are taken over the THREE streaming tiers only (160/560/1120 ms); # offline is excluded by definition (eq. lst / Table tab:lst caption). # --------------------------------------------------------------------------- def t_lst(d): hr("[5] Table tab:lst — per-lang Δ , LST on FLEURS (per hours)") stream_tiers = ["160ms", "560ms", "1120ms"] # LST excludes offline h_show = ["100h", "250h", "500h", "1000h"] # paper omits 2500h here head = f" {'lang':<6s}" + "".join(f"{h:>20s}" for h in h_show) print(head) print(f" {'':<6s}" + "".join(f"{'Δ':>10s}{'LST':>10s}" for _ in h_show)) barD = {h: [] for h in h_show} lst = {h: [] for h in h_show} for lang in LANGS: row = f" {lang.upper():<6s}" for h in h_show: ds = [delta(d, lang, h, t, "fleurs") for t in stream_tiers] ds = [x for x in ds if x is not None] if not ds: row += fmt(None, w=10) + fmt(None, w=10); continue bd = sum(ds) / len(ds) ls = max(ds) - min(ds) barD[h].append(bd); lst[h].append(ls) row += fmt(bd, signed=True, w=10) + fmt(ls, w=10) print(row) print(" " + "-" * 76) row = f" {'mean':<6s}" for h in h_show: row += fmt(mean(barD[h]), signed=True, w=10) + fmt(mean(lst[h]), w=10) print(row) # --------------------------------------------------------------------------- # [6] Sec :from_pl — HR-from-PL pivot vs direct ML, 160 ms FLEURS/VP # --------------------------------------------------------------------------- def t_from_pl(d): hr("[6] Sec sec:from_pl — HR PL-pivot vs direct ML (160 ms)") rows = ["100h", "250h", "500h", "1000h"] print(f" {'hours':<6s}{'direct ml FL':>14s}{'pivot ml FL':>14s}{'Δ FL':>8s}" f"{'direct ml VP':>14s}{'pivot ml VP':>14s}{'Δ VP':>8s}") for h in rows: dml_fl = wer(d, "hr", h, "ml", "160ms", "fleurs") piv_fl = wer(d, "hr", h, "from_pl_ml", "160ms", "fleurs") dml_vp = wer(d, "hr", h, "ml", "160ms", "voxpopuli") piv_vp = wer(d, "hr", h, "from_pl_ml", "160ms", "voxpopuli") dfl = (piv_fl - dml_fl) if (dml_fl is not None and piv_fl is not None) else None dvp = (piv_vp - dml_vp) if (dml_vp is not None and piv_vp is not None) else None print(f" {h:<6s}{fmt(dml_fl,w=14)}{fmt(piv_fl,w=14)}{fmt(dfl,signed=True,w=8)}" f"{fmt(dml_vp,w=14)}{fmt(piv_vp,w=14)}{fmt(dvp,signed=True,w=8)}") # PL(EN) pivot only at 100h piv_en_fl = wer(d, "hr", "100h", "from_pl_enc", "160ms", "fleurs") den_fl = wer(d, "hr", "100h", "enc", "160ms", "fleurs") if piv_en_fl is not None and den_fl is not None: print(f" PL(EN) pivot @100h FLEURS: direct enc={den_fl:.2f} " f"pivot={piv_en_fl:.2f} Δ={piv_en_fl - den_fl:+.2f} pp") # --------------------------------------------------------------------------- # [7] Sec :reinitjoint — joiner re-init Δ at 100 h, 560 ms FLEURS/VP # --------------------------------------------------------------------------- def t_reinitjoint(d): hr("[7] Sec sec:reinitjoint — joiner-reinit Δ vs baseline @ 100h, 560 ms") deltas_fl = {"ml": [], "enc": []} deltas_vp = {"ml": [], "enc": []} rows = [] for lang in LANGS: for init in ("ml", "enc"): base_fl = wer(d, lang, "100h", init, "560ms", "fleurs") rj_fl = wer(d, lang, "100h", f"{init}_reinitjoint", "560ms", "fleurs") base_vp = wer(d, lang, "100h", init, "560ms", "voxpopuli") rj_vp = wer(d, lang, "100h", f"{init}_reinitjoint", "560ms", "voxpopuli") dfl = (rj_fl - base_fl) if (base_fl is not None and rj_fl is not None) else None dvp = (rj_vp - base_vp) if (base_vp is not None and rj_vp is not None) else None if dfl is not None: deltas_fl[init].append(dfl) if dvp is not None: deltas_vp[init].append(dvp) rows.append((lang, init, dfl, dvp)) if not (deltas_fl["ml"] or deltas_fl["enc"]): print(" (no reinitjoint cells found in JSON)") return print(f" {'lang':<4s} {'init':<4s} {'Δ FL':>8s} {'Δ VP':>8s}") for lang, init, dfl, dvp in rows: print(f" {lang:<4s} {init:<4s} {fmt(dfl,signed=True,w=8)} {fmt(dvp,signed=True,w=8)}") all_fl = deltas_fl["ml"] + deltas_fl["enc"] all_vp = deltas_vp["ml"] + deltas_vp["enc"] hurt_fl = sum(1 for x in all_fl if x > 0) hurt_vp = sum(1 for x in all_vp if x > 0) print(f"\n mean Δ FL (all 16): {mean(all_fl):+0.2f} pp ({hurt_fl}/{len(all_fl)} hurt)") print(f" mean Δ FL (ml arm): {mean(deltas_fl['ml']):+0.2f} pp") print(f" mean Δ FL (enc arm):{mean(deltas_fl['enc']):+0.2f} pp") print(f" mean Δ VP (all): {mean(all_vp):+0.2f} pp ({hurt_vp}/{len(all_vp)} hurt)") print(f" mean Δ VP (ml arm): {mean(deltas_vp['ml']):+0.2f} pp") print(f" mean Δ VP (enc arm):{mean(deltas_vp['enc']):+0.2f} pp") if deltas_fl["enc"] and deltas_fl["ml"]: worst_enc = max(rows, key=lambda r: r[2] if r[1] == "enc" and r[2] is not None else -1) worst_ml = max(rows, key=lambda r: r[2] if r[1] == "ml" and r[2] is not None else -1) print(f" worst Δ FL enc: {worst_enc[0]}-{worst_enc[1]} {worst_enc[2]:+0.2f}") print(f" worst Δ FL ml: {worst_ml[0]}-{worst_ml[1]} {worst_ml[2]:+0.2f}") # --------------------------------------------------------------------------- # [8] Table :quant — INT4 vs FP32 @ 560 ms FLEURS # --------------------------------------------------------------------------- def t_quant(d): hr("[8] Table tab:quant — INT4 vs FP32 @ 560 ms FLEURS") rows = {h: {"ml": [], "enc": []} for h in HOURS} all_cells = [] # (lang, hours, init, Δ_int4-fp32) paired = [] # (lang, hours, Δ_ml, Δ_enc) for h in HOURS: per_lang_paired = {} for lang in LANGS: for init in ("ml", "enc"): i4 = wer(d, lang, h, init, "560ms", "fleurs_int4") f3 = wer(d, lang, h, init, "560ms", "fleurs_fp32") if i4 is None or f3 is None: continue dq = i4 - f3 rows[h][init].append(dq) all_cells.append((lang, h, init, dq)) per_lang_paired.setdefault(lang, {})[init] = dq for lang, cells in per_lang_paired.items(): if "ml" in cells and "enc" in cells: paired.append((lang, h, cells["ml"], cells["enc"])) print(f" {'hours':<6s}{'Δ_ml':>9s}{'n_ml':>6s}{'Δ_enc':>9s}{'n_enc':>6s}") for h in HOURS: ml = rows[h]["ml"]; en = rows[h]["enc"] print(f" {h:<6s}{fmt(mean(ml),signed=True,w=9)}{len(ml):>6d}" f"{fmt(mean(en),signed=True,w=9)}{len(en):>6d}") # pooled stats over all (lang, hours, init) dq_all = [c[3] for c in all_cells] if dq_all: dq_sorted = sorted(dq_all) med = statistics.median(dq_sorted) n = len(dq_all) within05 = sum(1 for x in dq_all if abs(x) <= 0.5) within10 = sum(1 for x in dq_all if abs(x) <= 1.0) worse = sum(1 for x in dq_all if x > 0) better = sum(1 for x in dq_all if x < 0) print() print(f" pooled (n={n}): mean={mean(dq_all):+0.2f} median={med:+0.2f}" f" range=[{min(dq_all):+0.2f},{max(dq_all):+0.2f}]") print(f" |Δ| ≤ 0.5 pp: {within05}/{n} |Δ| ≤ 1.0 pp: {within10}/{n}") print(f" INT4 worse than FP32: {worse}/{n} INT4 better: {better}/{n}") # paired ML vs EN quant cost if paired: diffs = [p[3] - p[2] for p in paired] # Δ_enc - Δ_ml enc_costlier = sum(1 for x in diffs if x > 0) print(f"\n paired ML vs EN (same lang, same hours, n={len(paired)}):") print(f" mean (Δ_enc - Δ_ml) = {mean(diffs):+0.2f} pp") print(f" EN costlier than ML in {enc_costlier}/{len(paired)} cells") print(f" range = [{min(diffs):+0.2f}, {max(diffs):+0.2f}] pp") # 100h breakdown (paper says 'weakest at 100h, EN costlier in 5 of 8') for h in HOURS: sub = [(p[2], p[3]) for p in paired if p[1] == h] if not sub: continue sub_diffs = [b - a for a, b in sub] print(f" {h}: paired n={len(sub)} mean Δ_enc-Δ_ml={mean(sub_diffs):+0.2f}" f" EN costlier in {sum(1 for x in sub_diffs if x > 0)}/{len(sub)}") # --------------------------------------------------------------------------- # [9] ES 5000h ML deltas vs ES 2500h ML (tab:5000h_es), plus ES 5000h ML # vs the Nemotron-3.5 ML baseline (tab:supp:es5000h); all four test # sets, 560 ms streaming. # --------------------------------------------------------------------------- def t_es_5000h(d): if "5000h" not in d.get("es", {}): return hr("[9] Sec sec:hours — ES 5000h vs 2500h ML, 560 ms streaming") for dataset in ("fleurs", "cv", "mls", "voxpopuli"): a = wer(d, "es", "5000h", "ml", "560ms", dataset) b = wer(d, "es", "2500h", "ml", "560ms", dataset) delta_ = (a - b) if (a is not None and b is not None) else None print(f" {dataset:<10s} 5000h={fmt(a)} 2500h={fmt(b)}" f" Δ={fmt(delta_, signed=True)}") # tab:supp:es5000h — ES 5000h (ML) vs contemporaneous Nemotron-3.5 ML # baseline, 560 ms streaming. Δ = WER_5000h − WER_Nemotron (negative: # our 5000h model better). if "nvidia-nemotron-3.5-asr" in d.get("es", {}).get("5000h", {}): print(" -- tab:supp:es5000h — ES 5000h (ML) vs Nemotron-3.5 ML:") for dataset in ("fleurs", "cv", "mls", "voxpopuli"): a = wer(d, "es", "5000h", "ml", "560ms", dataset) n = wer(d, "es", "5000h", "nvidia-nemotron-3.5-asr", "560ms", dataset) delta_ = (a - n) if (a is not None and n is not None) else None print(f" {dataset:<10s} 5000h={fmt(a)} nemotron={fmt(n)}" f" Δ={fmt(delta_, signed=True)}") # --------------------------------------------------------------------------- # [10] fig:gap_powerlaw — fit Δ(h) = a · h^(-β) on the 160 ms macro means # with a language-bootstrap 95% CI on β. # --------------------------------------------------------------------------- def t_powerlaw(d, B=10000, seed=0): hr("[10] fig:gap_powerlaw — transfer-gap power-law fit (160 ms FLEURS)") import math import random as _rand rng = _rand.Random(seed) hours_int = [int(h[:-1]) for h in HOURS] def fit(deltas_by_h): """Return (β, log_a, R²) from least-squares fit on log(h) vs log(Δ) across hours where Δ > 0 (so log is defined).""" xs, ys = [], [] for h, dl in zip(hours_int, deltas_by_h): if dl is None or dl <= 0: continue xs.append(math.log(h)); ys.append(math.log(dl)) if len(xs) < 2: return None, None, None n = len(xs) mx = sum(xs)/n; my = sum(ys)/n sxy = sum((x-mx)*(y-my) for x, y in zip(xs, ys)) sxx = sum((x-mx)**2 for x in xs) if sxx == 0: return None, None, None slope = sxy / sxx # = -β intercept = my - slope * mx beta = -slope # R² syy = sum((y-my)**2 for y in ys) if syy == 0: r2 = 1.0 else: ss_res = sum((y - (slope*x + intercept))**2 for x, y in zip(xs, ys)) r2 = 1 - ss_res/syy return beta, intercept, r2 # point estimate from the full 8-lang macro means macro = [mean([delta(d, l, h, "160ms", "fleurs") for l in LANGS]) for h in HOURS] beta, log_a, r2 = fit(macro) if beta is None: print(" (insufficient points for power-law fit)") return print(f" hours mean Δ (160 ms FLEURS)") for h, m in zip(HOURS, macro): print(f" {h:<8s} {fmt(m, signed=True)}") print(f"\n β_TG = {beta:.3f} R² = {r2:.4f} " f"(fit on log Δ vs log h, where Δ>0)") # language-bootstrap CI: resample 8 languages with replacement, recompute # macro means per hours, refit, collect β. betas = [] n_lang = len(LANGS) for _ in range(B): sample = [LANGS[rng.randrange(n_lang)] for _ in range(n_lang)] ms = [mean([delta(d, l, h, "160ms", "fleurs") for l in sample]) for h in HOURS] b, _, _ = fit(ms) if b is not None and math.isfinite(b): betas.append(b) if betas: betas.sort() lo = betas[int(0.025 * len(betas))] hi = betas[int(0.975 * len(betas))] frac_below = sum(1 for b in betas if b < 0.5) / len(betas) print(f" language-bootstrap 95% CI on β (B={B}): [{lo:.2f}, {hi:.2f}]") print(f" P(β < 0.5) = {frac_below:.4f} ({100 * frac_below:.2f}%)") # off-tier residuals (paper Fig. fig:gap_powerlaw caption: 0.23/0.29/0.13 pp) import math as _m print("\n Off-tier residuals against the 160 ms-fitted curve:") for tier in ("560ms", "1120ms", "offline"): mac = [mean([delta(d, l, h, tier, "fleurs") for l in LANGS]) for h in HOURS] res = [] for h, m in zip(hours_int, mac): if m is None or m <= 0: continue pred = _m.exp(log_a + (-beta) * _m.log(h)) res.append((m - pred) ** 2) if res: rms = (sum(res) / len(res)) ** 0.5 print(f" {tier:<8s} RMS={rms:.2f} pp (n={len(res)})") # --------------------------------------------------------------------------- # [11] tab:hybrid — hybrid-encoder, 100h training, 560 ms FLEURS # Splices: hybrid_0to12 / hybrid_last / hybrid_first / hybrid_middle # Reference rows are seed-45 ml / enc (paper: same common seed). # --------------------------------------------------------------------------- def t_hybrid(d): hr("[11] tab:hybrid — hybrid encoder @ 100h, 560 ms FLEURS") rows = [ ("ML (s45)", "ml_s45"), ("0:12", "hybrid_0to12"), ("last", "hybrid_last"), ("first", "hybrid_first"), ("middle", "hybrid_middle"), ("EN (s45)", "enc_s45"), ] # header print(f" {'row':<10s}" + "".join(f"{l.upper():>7s}" for l in LANGS) + f"{'mean':>9s}{'Δ vs ML':>10s}") ml_row = None table = [] for label, init in rows: cells = [wer(d, l, "100h", init, "560ms", "fleurs") for l in LANGS] mn = mean(cells) table.append((label, init, cells, mn)) if init == "ml_s45": ml_row = cells for label, init, cells, mn in table: if ml_row is None or any(c is None for c in cells) or any(m is None for m in ml_row): d_vs_ml = None else: pairwise = [c - m for c, m in zip(cells, ml_row)] d_vs_ml = sum(pairwise) / len(pairwise) row = f" {label:<10s}" + "".join(fmt(c, w=7) for c in cells) + fmt(mn, w=9) row += fmt(d_vs_ml, signed=True, w=10) if d_vs_ml is not None else f"{'--':>10s}" print(row) # seen / unseen group means print("\n group means:") for label, init, cells, _ in table: seen_m = mean([wer(d, l, "100h", init, "560ms", "fleurs") for l in SEEN]) unseen_m = mean([wer(d, l, "100h", init, "560ms", "fleurs") for l in UNSEEN]) print(f" {label:<10s} seen={fmt(seen_m, w=7)} unseen={fmt(unseen_m, w=7)}") # --------------------------------------------------------------------------- # [12] tab:seed + sec:seed — seed comparison # (a) HR/PT main-grid 160 ms FLEURS + VP, default seed vs seed 45 # (b) 16-cell 100h re-run @ 560 ms across all 8 langs × 2 inits; # stats: mean |Δ|, median, max on FLEURS and VP # (c) HR-100h FLEURS swing collapse at 560 ms # (d) Largest seed-induced EN-ML gap excursion (IS at 100h) # --------------------------------------------------------------------------- def t_seed(d): hr("[12] tab:seed + sec:seed — seed-default vs seed-45") # (a) HR / PT main grid at 160 ms FLEURS + VP print(" (a) HR / PT main-grid FLEURS@160ms and VP@160ms seed deltas:") print(f" {'lang':<4s}{'init':<5s}{'hours':<6s}" f"{'FL_s1':>8s}{'FL_s2':>8s}{'ΔFL':>8s}" f"{'VP_s1':>8s}{'VP_s2':>8s}{'ΔVP':>8s}") fl_abs, vp_abs = [], [] rows = [] for lang in ("hr", "pt"): for init in ("ml", "enc"): for h in HOURS: a_fl = wer(d, lang, h, init, "160ms", "fleurs") b_fl = wer(d, lang, h, init+"_s45","160ms", "fleurs") a_vp = wer(d, lang, h, init, "160ms", "voxpopuli") b_vp = wer(d, lang, h, init+"_s45","160ms", "voxpopuli") if a_fl is None or b_fl is None: continue dfl = b_fl - a_fl dvp = (b_vp - a_vp) if (a_vp is not None and b_vp is not None) else None fl_abs.append(abs(dfl)) if dvp is not None: vp_abs.append(abs(dvp)) rows.append((lang, init, h, dfl, dvp)) print(f" {lang:<4s}{init:<5s}{h:<6s}" f"{a_fl:>8.2f}{b_fl:>8.2f}{dfl:>+8.2f}" f"{fmt(a_vp,w=8)}{fmt(b_vp,w=8)}{fmt(dvp,signed=True,w=8)}") if fl_abs: print(f"\n mean |ΔFL| = {sum(fl_abs)/len(fl_abs):.2f} pp" f" (n={len(fl_abs)}, max={max(fl_abs):.2f})") if vp_abs: print(f" mean |ΔVP| = {sum(vp_abs)/len(vp_abs):.2f} pp" f" (n={len(vp_abs)}, max={max(vp_abs):.2f})") # (b) 16-cell 100h re-run @ 560 ms (all 8 langs × 2 inits) print("\n (b) 100h × 8 langs × 2 inits @ 560 ms (FLEURS, VP):") fl, vp = [], [] cells_fl, cells_vp = [], [] for lang in LANGS: for init in ("ml", "enc"): a_fl = wer(d, lang, "100h", init, "560ms", "fleurs") b_fl = wer(d, lang, "100h", init+"_s45", "560ms", "fleurs") a_vp = wer(d, lang, "100h", init, "560ms", "voxpopuli") b_vp = wer(d, lang, "100h", init+"_s45", "560ms", "voxpopuli") if a_fl is not None and b_fl is not None: fl.append(abs(b_fl - a_fl)) cells_fl.append((lang, init, b_fl - a_fl)) if a_vp is not None and b_vp is not None: vp.append(abs(b_vp - a_vp)) cells_vp.append((lang, init, b_vp - a_vp)) if fl: s = sorted(fl) worst = max(cells_fl, key=lambda x: abs(x[2])) print(f" FLEURS: mean |Δ|={sum(fl)/len(fl):.2f} median={s[len(s)//2]:.2f}" f" max={max(fl):.2f} ({worst[0]}-{worst[1]}) n={len(fl)}") if vp: s = sorted(vp) worst = max(cells_vp, key=lambda x: abs(x[2])) print(f" VoxPopuli: mean |Δ|={sum(vp)/len(vp):.2f} median={s[len(s)//2]:.2f}" f" max={max(vp):.2f} ({worst[0]}-{worst[1]}) n={len(vp)}") # (c) HR-100h FLEURS swing collapse at 560 ms vs 160 ms print("\n (c) HR-100h FLEURS seed swing collapse 160 ms → 560 ms:") for init in ("ml", "enc"): for tier in ("160ms", "560ms"): a = wer(d, "hr", "100h", init, tier, "fleurs") b = wer(d, "hr", "100h", init+"_s45", tier, "fleurs") if a is not None and b is not None: print(f" hr-{init:<3s} @ {tier:<6s}: s1={a:.2f} s2={b:.2f} Δ={b-a:+.2f}") # (d) Largest seed-induced EN-ML gap excursion at 100h / 560 ms print("\n (d) Seed-induced EN-ML gap excursion at 100h / 560 ms FLEURS:") print(f" {'lang':<4s}{'Δ(s1)':>10s}{'Δ(s2)':>10s}{'shift':>10s}{'sign?':>8s}") biggest = (None, 0.0) for lang in LANGS: ml1 = wer(d, lang, "100h", "ml", "560ms", "fleurs") en1 = wer(d, lang, "100h", "enc", "560ms", "fleurs") ml2 = wer(d, lang, "100h", "ml_s45", "560ms", "fleurs") en2 = wer(d, lang, "100h", "enc_s45", "560ms", "fleurs") if any(x is None for x in (ml1, en1, ml2, en2)): continue d1 = en1 - ml1; d2 = en2 - ml2 sign_keep = "yes" if (d1 >= 0) == (d2 >= 0) else "NO" shift = d2 - d1 print(f" {lang:<4s}{d1:>+10.2f}{d2:>+10.2f}{shift:>+10.2f}{sign_keep:>8s}") if abs(shift) > abs(biggest[1]): biggest = (lang, shift) if biggest[0]: print(f" largest shift: {biggest[0]} ({biggest[1]:+.2f} pp)") # --------------------------------------------------------------------------- # [13] Streaming penalty per (tier, hours, init) on FLEURS # penalty = WER(tier) - WER(offline) # --------------------------------------------------------------------------- def t_streaming_penalty(d): hr("[13] Streaming penalty (FLEURS): WER(tier) - WER(offline)") print(f" {'init':<5s}{'tier':<10s}" + "".join(f"{h:>10s}" for h in HOURS)) for init in ("ml", "enc"): for tier in ("160ms", "560ms", "1120ms"): row = f" {init:<5s}{tier:<10s}" for h in HOURS: tier_wers = [wer(d, l, h, init, tier, "fleurs") for l in LANGS] off_wers = [wer(d, l, h, init, "offline", "fleurs") for l in LANGS] pairs = [(t - o) for t, o in zip(tier_wers, off_wers) if t is not None and o is not None] m = mean(pairs) row += fmt(m, signed=True, w=10) print(row) # --------------------------------------------------------------------------- # [14] tab:per_dataset — 160 ms WER per (lang, hours, init, dataset) # --------------------------------------------------------------------------- def t_per_dataset(d): hr("[14] tab:per_dataset — 160 ms WER per (lang, hours, init, dataset)") datasets = ("cv", "mls", "voxpopuli", "fleurs") print(f" {'lang':<5s}{'hours':<7s}" + "".join(f"{ds.upper() + ' ml':>10s}{ds.upper() + ' en':>10s}" for ds in datasets)) for lang in LANGS: for h in HOURS: row = f" {lang:<5s}{h:<7s}" for ds in datasets: ml = wer(d, lang, h, "ml", "160ms", ds) en = wer(d, lang, h, "enc", "160ms", ds) row += fmt(ml, w=10) + fmt(en, w=10) print(row) # --------------------------------------------------------------------------- # main # --------------------------------------------------------------------------- def main(argv): src = Path(argv[1]) if len(argv) > 1 else DEFAULT_JSON if not src.is_file(): print(f"error: results file not found: {src}\n" f" pass the path to wer_results.json as the first argument.", file=sys.stderr) return 2 d = json.loads(src.read_text()) print(f"Reading {src}") t_main160(d) t_seen_unseen(d) t_latency_effect(d) t_abs_wer(d) t_lst(d) t_from_pl(d) t_reinitjoint(d) t_quant(d) t_es_5000h(d) t_powerlaw(d) t_hybrid(d) t_seed(d) t_streaming_penalty(d) t_per_dataset(d) return 0 if __name__ == "__main__": sys.exit(main(sys.argv))