| """Phase 3 -> old setup (8x RTX PRO 6000 Server, the Phase 1/2 box) extrapolation. |
| Usage: /venv/p2/bin/python -I extrap.py ROOT P2_METRICS_JSON OUT_PREFIX |
| Method |
| 1. Box ratio per component (30B prefill / judge / kvflush / rejudge, drafter, python overhead) from the 16 HumanEval |
| items both boxes decoded with the identical config (setup check, token-identical outputs). |
| 2. Old-box seconds of each rd item = sum over components of (this box's ms for that component / ratio). |
| 3. Old-box tokens/s = sum tokens / sum predicted seconds (the artifact's definition: whole decode, scoring excluded). |
| Cross-check: the artifact's own cost model (30B expert loads/token x old-box ms per load + drafter fwd x ms/fwd). |
| 4. Old-box wall per cell = 8 shards, items[k::8] in benchmark order, max shard sum + model load; this box: 4 shards. |
| 5. Cells not yet run: per-item seconds = old-box S0 seconds of the same item x the arm's measured rd/S0 time factor. |
| """ |
| import glob, json, os, re, sys, datetime as dt |
| ROOT, P2, OUT = sys.argv[1], sys.argv[2], sys.argv[3] |
| sys.path[:0] = [f"{ROOT}/code/compat", f"{ROOT}/code"]; os.chdir(ROOT) |
| import research_protocol as P |
| SETS = ["humaneval", "mbpp", "gsm8k500", "ifeval541", "math500", "gpqa", "aime"] |
| ARMS = ["rd1", "rd2"] |
| p2 = json.load(open(P2)) |
| def load(pat): |
| out = {} |
| for f in glob.glob(pat): |
| if f.endswith("running.jsonl"): continue |
| for l in open(f): |
| if l.strip(): |
| try: r = json.loads(l) |
| except ValueError: continue |
| out[int(r["idx"])] = r |
| return out |
| def comp(r): |
| c = {f"moe_{k}": v for k, v in r["ms_by_kind"].items()} |
| c.update({f"dr_{k}": v for k, v in r["drafter_ms_by_kind"].items()}) |
| c["other"] = 1000 * r["seconds"] - sum(v for k, v in c.items()) |
| return c |
| |
| old16 = load("logs/phase2/ref/S0_128M_nopool_by_set/humaneval/*.jsonl"); new16 = load("logs/phase3/setup/check_judge/*.jsonl") |
| ids16 = sorted(new16); assert all(old16[i]["gen_ids"] == new16[i]["gen_ids"] for i in ids16) |
| def ratio(keys): |
| n = sum(comp(new16[i]).get(k, 0) for i in ids16 for k in keys); o = sum(comp(old16[i]).get(k, 0) for i in ids16 for k in keys) |
| return n / o |
| RAT = {"moe_prefill": ratio(["moe_prefill"]), "moe_judge": ratio(["moe_judge"]), "moe_kvflush": ratio(["moe_kvflush"]), |
| "dr": ratio(["dr_prefill", "dr_draft", "dr_flush"]), "other": ratio(["other"])} |
| RAT["moe_rejudge"] = RAT["moe_judge"]; RAT["moe_denoise"] = RAT["moe_judge"] |
| tot_ratio = sum(new16[i]["seconds"] for i in ids16) / sum(old16[i]["seconds"] for i in ids16) |
| |
| loo = [] |
| for j in ids16: |
| rest = [i for i in ids16 if i != j] |
| def rr(keys): |
| return sum(comp(new16[i]).get(k, 0) for i in rest for k in keys) / sum(comp(old16[i]).get(k, 0) for i in rest for k in keys) |
| R2 = {"moe_prefill": rr(["moe_prefill"]), "moe_judge": rr(["moe_judge"]), "moe_kvflush": rr(["moe_kvflush"]), |
| "dr": rr(["dr_prefill", "dr_draft", "dr_flush"]), "other": rr(["other"])} |
| c = comp(new16[j]); pred = sum(v / (R2["dr"] if k.startswith("dr_") else R2.get(k, R2["moe_judge"])) for k, v in c.items()) / 1000 |
| loo.append(pred / old16[j]["seconds"] - 1) |
| def old_seconds(r): |
| return sum(v / (RAT["dr"] if k.startswith("dr_") else RAT.get(k, RAT["moe_judge"])) for k, v in comp(r).items()) / 1000 |
| |
| def order(s): return [int(it["idx"]) for it in P.items_for_split(s)] |
| def stats(Rs): |
| g = sum(r["n_gen_to_eos"] for r in Rs); u = sum(r["unique_expert_layer_loads"] for r in Rs) |
| nd = sum(sum(r["drafter_n_by_kind"].values()) for r in Rs) |
| return {"n": len(Rs), "acc": 100 * sum(bool(r["correct"]) for r in Rs) / len(Rs), |
| "passes_blk": sum(r["n_forward"] - r["n_prefill"] - r["n_flush"] for r in Rs) / sum(r["n_blocks"] for r in Rs), |
| "exp_tok": u / g, "drafter_fwd_tok": nd / g, "tokens": g, |
| "box_sec": sum(r["seconds"] for r in Rs), "old_sec": sum(old_seconds(r) for r in Rs)} |
| def run_start(arm, s): |
| for l in open("logs/phase3/run.log"): |
| m = re.match(rf"\[p3 (\d\d:\d\d:\d\d) UTC\] start {arm} {s} ", l) |
| if m: t = m.group(1) |
| return t if 'm' in dir() else None |
| |
| def load_overhead(arm, s): |
| st = None |
| for l in open("logs/phase3/run.log"): |
| m = re.match(rf"\[p3 (\d\d:\d\d:\d\d) UTC\] start {arm} {s} \(attempt 1\)", l) |
| if m: st = m.group(1) |
| if not st: return None |
| ov = [] |
| for f in glob.glob(f"logs/phase3/decode/{arm}/{s}/*.shard*.jsonl"): |
| rs = [json.loads(l) for l in open(f) if l.strip()] |
| if not rs: continue |
| t0 = dt.datetime.strptime(rs[0]["utc"], "%Y-%m-%dT%H:%M:%SZ") |
| st_dt = t0.replace(hour=int(st[:2]), minute=int(st[3:5]), second=int(st[6:])) |
| if st_dt > t0: st_dt -= dt.timedelta(days=1) |
| ov.append((t0 - st_dt).total_seconds() - rs[0]["seconds"]) |
| return max(ov) if ov else None |
| def wall(sec_by_idx, s, nsh, overhead): |
| o = [i for i in order(s) if i in sec_by_idx] |
| return max(sum(sec_by_idx[i] for i in o[k::nsh]) for k in range(nsh)) + overhead |
| S0old = {s: load(f"logs/phase2/ref/S0_128M_nopool_by_set/{s}/*.jsonl") for s in SETS} |
| res = {"box_ratio_components": RAT, "box_ratio_total": tot_ratio, "loo_rel_err": loo, "cells": {}} |
| k_arm = {} |
| for a in ARMS: |
| num = den = 0 |
| for s in SETS: |
| Rr = load(f"logs/phase3/decode/{a}/{s}/*.jsonl") |
| if not Rr: continue |
| st = stats(list(Rr.values())); ref = p2[s]["S0_nopool"]; stock = p2[s]["stock"] |
| msl = (ref["ms_tok"] - ref["drafter_ms_tok"]) / ref["exp_tok"]; msf = ref["drafter_ms_tok"] / ref["drafter_fwd_tok"] |
| st["tps_box"] = st["tokens"] / st["box_sec"]; st["tps_old"] = st["tokens"] / st["old_sec"] |
| st["tps_old_costmodel"] = 1000 / (st["exp_tok"] * msl + st["drafter_fwd_tok"] * msf) |
| st["old_sec_cost"] = st["tokens"] * (st["exp_tok"] * msl + st["drafter_fwd_tok"] * msf) / 1000 |
| st["f_cost"] = st["old_sec_cost"] / st["old_sec"] |
| st["tps_S0_old"] = 1000 / ref["ms_tok"]; st["tps_stock_table1"] = 1000 / (stock["exp_tok"] * msl) |
| st["acc_S0"] = ref["acc"]; st["acc_stock"] = stock["acc"]; st["passes_S0"] = ref["passes_blk"]; st["passes_stock"] = stock["passes_blk"] |
| st["exp_tok_S0"] = ref["exp_tok"] |
| st["complete"] = os.path.exists(f"logs/phase3/decode/{a}/{s}/.complete") |
| |
| import numpy as np |
| cm = sorted(i for i in Rr if i in S0old[s]) |
| if cm: |
| dd = np.array([int(bool(Rr[i]["correct"])) - int(bool(S0old[s][i]["correct"])) for i in cm]) |
| rng = np.random.default_rng(0); bs = [rng.choice(dd, len(dd)).mean() for _ in range(2000)] |
| st["delta_vs_S0"] = [100 * dd.mean(), 100 * np.percentile(bs, 2.5), 100 * np.percentile(bs, 97.5)] |
| |
| |
| |
| |
| |
| Jf = load(f"logs/phase3/decode/judge/{s}/*.jsonl") |
| if Jf and not os.path.exists(f"logs/phase3/decode/judge/{s}/.complete"): Jf = {} |
| Js = {} if Jf else load(f"logs/phase3/decode/judge_sample/{s}/*.jsonl") |
| if Jf: |
| com = [i for i in Rr if i in Jf] |
| tr = sum(Rr[i]["n_gen_to_eos"] for i in com) / sum(Rr[i]["seconds"] for i in com) |
| tj = sum(Jf[i]["n_gen_to_eos"] for i in com) / sum(Jf[i]["seconds"] for i in com) |
| st["samebox_items"] = len(com); st["samebox_speedup_vs_judge"] = tr / tj; st["samebox_method"] = "full baseline" |
| st["samebox_tps_rd"] = tr; st["samebox_tps_judge"] = tj |
| st["tps_old_samebox"] = (1000 / ref["ms_tok"]) * tr / tj |
| elif Js and len(glob.glob(f"logs/phase3/decode/judge_sample/{s}/*.jsonl.done")) >= 4: |
| ids = [i for i in Js if i in S0old[s]] |
| r12 = sum(Js[i]["seconds"] for i in ids) / sum(S0old[s][i]["seconds"] for i in ids) |
| st["box_ratio_judge_12"] = r12; st["samebox_items"] = len(ids); st["samebox_method"] = "12-item box ratio" |
| st["tps_old_samebox"] = st["tps_box"] * r12 |
| st["samebox_speedup_vs_judge"] = st["tps_old_samebox"] / (1000 / ref["ms_tok"]) |
| st["tps_headline"] = st.get("tps_old_samebox") or st["tps_old_costmodel"] |
| st["headline_src"] = "same-box" if st.get("tps_old_samebox") else "cost model (est.)" |
| common = [i for i in Rr if i in S0old[s]] |
| num += st["f_cost"] * sum(old_seconds(Rr[i]) for i in common); den += sum(S0old[s][i]["seconds"] for i in common) |
| ov = load_overhead(a, s); st["load_overhead_box_s"] = ov |
| if st["complete"]: |
| st["wall_box_4x_min"] = wall({i: r["seconds"] for i, r in Rr.items()}, s, 4, ov or 0) / 60 |
| st["wall_old_8x_min"] = wall({i: old_seconds(r) * st["f_cost"] for i, r in Rr.items()}, s, 8, (ov or 0)) / 60 |
| res["cells"][f"{a}/{s}"] = st |
| k_arm[a] = num / den if den else None |
| res["k_arm_vs_S0_oldbox"] = k_arm |
| |
| box_k = {} |
| for a in ARMS: |
| cs = [c for k, c in res["cells"].items() if k.startswith(a + "/") and c.get("complete")] |
| if cs: box_k[a] = sum(c["box_sec"] for c in cs) / sum(c["old_sec_cost"] for c in cs) |
| res["box_sec_per_old_cost_sec"] = box_k |
| |
| ovs = [c["load_overhead_box_s"] for c in res["cells"].values() if c.get("load_overhead_box_s")] |
| ov = max(ovs) if ovs else 90.0 |
| proj = {} |
| for a in ARMS: |
| for s in SETS: |
| c = res["cells"].get(f"{a}/{s}") |
| if c and c.get("complete"): |
| proj[f"{a}/{s}"] = {"box4": c["wall_box_4x_min"], "old8": c["wall_old_8x_min"], "src": "measured"} |
| else: |
| k = k_arm.get(a) or k_arm.get("rd1") or 1.0 |
| so = {i: r["seconds"] * k for i, r in S0old[s].items()} |
| fb = box_k.get(a) or tot_ratio |
| proj[f"{a}/{s}"] = {"box4": wall({i: v * fb for i, v in so.items()}, s, 4, ov) / 60, |
| "old8": wall(so, s, 8, ov) / 60, "src": f"S0 old-box item times x {k:.3f}"} |
| res["projection_min"] = proj |
| json.dump(res, open(OUT + ".json", "w"), indent=1) |
| |
| L = [] |
| L.append(f"Box ratio (this 4x box / old 8x box, same 16 items, identical outputs): total {tot_ratio:.3f}; components " + |
| ", ".join(f"{k} {v:.3f}" for k, v in RAT.items() if k not in ('moe_rejudge', 'moe_denoise'))) |
| import statistics as stt |
| L.append(f"Leave-one-out per-item error of the old-box time model: mean {100*stt.mean(loo):+.1f}%, sd {100*stt.pstdev(loo):.1f}%, max |{100*max(abs(x) for x in loo):.1f}|%") |
| L.append(f"rd time vs S0 on the old box, same items (pooled over finished sets): " + ", ".join(f"{a} x{v:.3f}" for a, v in k_arm.items() if v)) |
| L.append("") |
| L.append("SAME-BOX: rd vs today's judge on identical items, both decoded on this box under 4-GPU load") |
| for key, c in res["cells"].items(): |
| if c.get("samebox_items"): |
| L.append(f" {key:16s} items {c['samebox_items']:4d} rd {c.get('samebox_tps_rd', float('nan')):.2f} tok/s vs judge {c.get('samebox_tps_judge', float('nan')):.2f} [{c.get('samebox_method','')}] -> {c['samebox_speedup_vs_judge']:.3f}x => old box {c['tps_old_samebox']:.2f} tok/s ({c['tps_old_samebox']/c['tps_stock_table1']:.2f}x stock)") |
| L.append("") |
| L.append("| cell | n | acc (S0 / stock) | passes/blk (S0) | exp/tok (S0) | tok/s this box | tok/s OLD 8x box: HEADLINE [source] / cost model / single-ratio (S0, stock) | wall this box 4x | wall OLD 8x |") |
| L.append("|---|---|---|---|---|---|---|---|---|") |
| for key, c in res["cells"].items(): |
| p = proj[key] |
| L.append(f"| {key}{'' if c['complete'] else ' (partial)'} | {c['n']} | {c['acc']:.1f} ({c['acc_S0']:.1f} / {c['acc_stock']:.1f}) | {c['passes_blk']:.2f} ({c['passes_S0']:.2f}) | " |
| f"{c['exp_tok']:.0f} ({c['exp_tok_S0']:.0f}) | {c['tps_box']:.2f} | **{c['tps_headline']:.2f}** [{c['headline_src']}] / cost {c['tps_old_costmodel']:.2f} / ratio {c['tps_old']:.2f} ({c['tps_S0_old']:.1f}, {c['tps_stock_table1']:.1f}) | " |
| f"{p['box4']:.1f} min | {p['old8']:.1f} min |") |
| t4 = sum(p["box4"] for p in proj.values()); t8 = sum(p["old8"] for p in proj.values()) |
| L.append("") |
| L.append(f"Projected decode wall, all 14 cells: this box 4x {t4/60:.2f} h; OLD 8x box {t8/60:.2f} h (excl. setup/backup; measured where complete, projected elsewhere)") |
| for k, p in proj.items(): L.append(f" {k:16s} 4x {p['box4']:6.1f} min old8x {p['old8']:6.1f} min [{p['src']}]") |
| open(OUT + ".md", "w").write("\n".join(L) + "\n"); print("\n".join(L)) |
|
|
