| """quantized-optimizer-state verifier — correctness gate + achieved-GB/s SPEED LEADERBOARD (uncapped). |
| |
| reward = 0 if the submission is incorrect |
| reward = geomean over graded shapes of GB/s otherwise |
| |
| GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate. |
| |
| There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable |
| by construction and nothing has to be vendored, sealed, or re-benchmarked. |
| |
| CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded |
| shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel |
| scores 0. |
| |
| ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last |
| timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a |
| result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate |
| throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised. |
| |
| WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all |
| submissions are credited identically and the ranking is a pure speed ranking. |
| """ |
| import importlib.util |
| import json |
| import math |
| import os |
| import sys |
| import traceback |
|
|
| import torch |
|
|
| REWARD_DIR = "/logs/verifier" |
| MODULE_PATH = "/app/qadam.py" |
| TOL = 4e-05 |
| NAMES = ('params_out', 'm_out', 'v_out', 'm_absmax_out', 'v_absmax_out') |
|
|
| GRADER_SHAPES = [(146484,), (97656,), (122070,), (136718,), (107421,)] |
| CORRECT_SHAPES = [(7,), (13,), (129,), (61,)] |
|
|
| sys.path.insert(0, "/app") |
|
|
| def canonical_work(NB): |
| """BYTES attributed to one 8-bit AdamW step, from the SHAPE ALONE. |
| |
| N = NB*2048 parameters. Per parameter: read params (2), grads (2), both moment codes (1 + 1) = 6, and |
| write params (2) plus both dequantised moments (4 + 4) = 10. The (N/2048,) absmax vectors are 1/2048 of |
| the traffic and are not counted. 16 bytes per parameter; this is a memory-bound kernel, so the score is |
| achieved bandwidth against that fixed byte count. |
| """ |
| return 16 * NB * 2048 |
|
|
| BLOCK = 2048 |
|
|
|
|
| def _requantise(x, qmap): |
| """x -> (dequantised round trip, per-block absmax). Nearest entry of the ascending 256-point map.""" |
| nb = x.numel() // BLOCK |
| xb = x.view(nb, BLOCK) |
| absmax = xb.abs().amax(-1) |
| c = xb / absmax.clamp(min=1e-30).unsqueeze(-1) |
| mid = (qmap[:-1] + qmap[1:]) * 0.5 |
| code = torch.bucketize(c, mid) |
| return (qmap[code] * absmax.unsqueeze(-1)).reshape(-1), absmax |
|
|
|
|
| def _ref(params, grads, m_code, m_absmax, v_code, v_absmax, qmap1, qmap2, step, |
| lr=1e-3, beta1=0.9, beta2=0.999, eps=1e-8, wd=0.01): |
| """8-bit blockwise AdamW, in fp32. |
| |
| Correct and simple — it is the numerical SPECIFICATION, not a performance target. Every line |
| materialises another full-size fp32 temporary in HBM. |
| """ |
| m = qmap1[m_code.long()] * m_absmax.repeat_interleave(BLOCK) |
| v = qmap2[v_code.long()] * v_absmax.repeat_interleave(BLOCK) |
| g = grads.float() |
|
|
| m_new = beta1 * m + (1.0 - beta1) * g |
| v_new = beta2 * v + (1.0 - beta2) * g * g |
|
|
| bc1 = 1.0 - beta1 ** step |
| bc2 = 1.0 - beta2 ** step |
| denom = (v_new / bc2).sqrt() + eps |
| upd = (lr / bc1) * m_new / denom |
| p_out = params.float() * (1.0 - lr * wd) - upd |
|
|
| m_out, m_absmax_out = _requantise(m_new, qmap1) |
| v_out, v_absmax_out = _requantise(v_new, qmap2) |
| return p_out.to(torch.bfloat16), m_out, v_out, m_absmax_out, v_absmax_out |
|
|
| def _mk(NB, seed): |
| """A parameter buffer of NB blocks of 2048, with its 8-bit moment state already in the quantised form |
| the reference must dequantise. The maps are the fixed nonlinear (cubic) maps the optimiser ships with: |
| fine resolution near zero, coarse near the block maximum.""" |
| gen = torch.Generator(device="cuda").manual_seed(seed) |
| N = NB * 2048 |
|
|
| t = (torch.arange(256, device="cuda", dtype=torch.float32) - 127.5) / 127.5 |
| qmap1 = t.sign() * t.abs() ** 3 |
| qmap2 = (torch.arange(256, device="cuda", dtype=torch.float32) / 255.0) ** 3 |
|
|
| params = (torch.randn(N, device="cuda", generator=gen) * 0.02).to(torch.bfloat16) |
| grads = (torch.randn(N, device="cuda", generator=gen) * 1e-3).to(torch.bfloat16) |
| m_code = torch.randint(0, 256, (N,), device="cuda", dtype=torch.uint8, generator=gen) |
| |
| |
| |
| |
| |
| v_code = torch.randint(1, 256, (N,), device="cuda", dtype=torch.uint8, generator=gen) |
| m_absmax = (1e-3 * (0.5 + torch.rand(NB, device="cuda", generator=gen))).float() |
| v_absmax = (1e-6 * (0.5 + torch.rand(NB, device="cuda", generator=gen))).float() |
| step = 137 |
| return (params, grads, m_code, m_absmax, v_code, v_absmax, qmap1, qmap2, step) |
|
|
|
|
| def _check(out, ref): |
| """-> (ok, value, msg). value = MAX relative error across the returned tuple.""" |
| if out is None or len(out) != len(NAMES): |
| return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}" |
| per = [] |
| for n, a, b in zip(NAMES, out, ref): |
| if a is None or tuple(a.shape) != tuple(b.shape): |
| return False, 1.0, f"{n} bad shape" |
| if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool): |
| |
| bad = int((a != b).sum()) |
| if bad: |
| return False, 1.0, f"{n}: {bad} elements differ" |
| continue |
| per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12)))) |
| if not per: |
| return True, 0.0, "all integer outputs exact" |
| wn, wv = max(per, key=lambda x: x[1]) |
| return wv <= TOL, wv, f"worst {wn} {wv:.2e}" |
|
|
|
|
| def _bench_fresh(fn, mkargs, reps=5, warm=3): |
| """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring.""" |
| wargs = mkargs(0) |
| for _ in range(warm): |
| fn(*wargs) |
| torch.cuda.synchronize() |
| del wargs |
| torch.cuda.empty_cache() |
|
|
| best, timed_ok = float("inf"), True |
| for i in range(reps): |
| args = mkargs(10_000 + i) |
| s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True) |
| s.record() |
| out = fn(*args) |
| e.record() |
| torch.cuda.synchronize() |
| best = min(best, s.elapsed_time(e)) |
| if i == reps - 1: |
| timed_ok = _check(out, _ref(*args))[0] |
| del args, out |
| torch.cuda.empty_cache() |
| return best / 1e3, timed_ok |
|
|
|
|
| def _geomean(xs): |
| return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0 |
|
|
|
|
| def main(): |
| details, correct_gate, geo = {}, False, 0.0 |
| try: |
| spec = importlib.util.spec_from_file_location("submission", MODULE_PATH) |
| m = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(m) |
| fn = m.quantized_adamw_step |
|
|
| corr_ok, msg = True, "" |
| for i, shp in enumerate(CORRECT_SHAPES): |
| args = _mk(*shp, seed=10 + i) |
| ok, val, m_ = _check(fn(*args), _ref(*args)) |
| if not ok: |
| corr_ok, msg = False, f"cfg{i} {shp} {m_}" |
| break |
| del args |
| torch.cuda.empty_cache() |
| details["correct_msg"] = msg or "all correctness shapes pass" |
|
|
| vals, per_shape, perf_ok = [], [], corr_ok |
| for i, shp in enumerate(GRADER_SHAPES): |
| args = _mk(*shp, seed=100 + i) |
| ok, val, m_ = _check(fn(*args), _ref(*args)) |
| if not ok: |
| perf_ok = False |
| del args |
| torch.cuda.empty_cache() |
| t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s)) |
| if not timed_ok: |
| perf_ok = False |
| v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0 |
| vals.append(v) |
| per_shape.append({"shape": list(shp), "gbps": round(v, 3), "ms": round(t * 1e3, 3), |
| "check": m_, "timed_ok": timed_ok}) |
| geo = _geomean(vals) |
| details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok) |
| correct_gate = corr_ok and perf_ok |
| except Exception as e: |
| details["error"] = f"{e.__class__.__name__}: {e}"[:220] |
| details["trace"] = traceback.format_exc()[-800:] |
|
|
| reward = round(geo, 4) if correct_gate else 0.0 |
| os.makedirs(REWARD_DIR, exist_ok=True) |
| json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0, |
| "geomean": round(geo, 4), "metric": "GB/s (geomean over graded shapes)"}, |
| open(f"{REWARD_DIR}/reward.json", "w"), indent=2) |
| open(f"{REWARD_DIR}/reward.txt", "w").write(str(reward)) |
| json.dump(details, open(f"{REWARD_DIR}/details.json", "w"), indent=2, default=str) |
| print("reward:", reward, "GB/s | correct:", 1.0 if correct_gate else 0.0) |
|
|
|
|
| main() |
|
|
