Paper, codec, routing traces and measurements

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+paper/main.pdf filter=lfs diff=lfs merge=lfs -text

LICENSE-NOTE.md

@@ -0,0 +1,13 @@
+# Licensing
+
+**Code** (`code/`) and **measurement artefacts** (`results/`): Apache License 2.0.
+
+**Paper** (`paper/`, including the PDF, LaTeX source and figures): © Kavin Kumar.
+All rights reserved. Redistribution of the paper text is not granted here.
+
+This split is deliberate. The accompanying arXiv submission uses the arXiv
+perpetual, non-exclusive license, which does not grant third-party redistribution
+rights; releasing the paper text under a Creative Commons license here would
+contradict that choice and could complicate later journal submission. The code and
+data carry a permissive license so the results can be reproduced and the routing
+traces reused.

README.md

@@ -0,0 +1,125 @@
+---
+license: other
+license_name: paper-reserved-code-apache-2.0
+license_link: https://huggingface.co/datasets/mkvn/quantization-cache-amplification/blob/main/LICENSE-NOTE.md
+pretty_name: Quantization as Cache Amplification
+tags:
+  - mixture-of-experts
+  - quantization
+  - llm-inference
+  - systems
+  - moe-routing
+  - expert-offloading
+language:
+  - en
+size_categories:
+  - n<1K
+---
+
+# Quantization as Cache Amplification
+
+**Trillion-Parameter Mixture-of-Experts Inference on a Commodity Laptop**
+
+Kavin Kumar, Neural Metrics
+
+📄 **[Read the paper](paper/main.pdf)** — 11 pages
+
+---
+
+## What this is
+
+Weight quantization is usually justified as footprint reduction. This work argues
+that for *offloaded* mixture-of-experts inference that framing misses the leverage.
+The binding resource is not storage capacity but the fraction of expert slots
+resident in DRAM — and storage traffic depends on that fraction through a cache
+hit rate that is both concave and, for recency-based policies, **discontinuous**.
+
+The central measured result: a least-recently-used expert cache hits **exactly
+zero** whenever its capacity falls below the `k·L` expert slots a single token
+touches. A token routes to `k` experts in each of `L` layers and revisits none of
+them until the next token — a cyclic reference string, the classical worst case
+for LRU. On real OLMoE-1B-7B traces (`k=8`, `L=16`, so 128 slots) we measure 0.0%
+hit rate at 2%, 5% and 10% capacity, jumping to 25.3% the moment capacity reaches
+128. Quantization is what carries a system across that threshold.
+
+Everything here was measured on one laptop: NVIDIA RTX A500 (4 GB VRAM), 32 GB
+DRAM, consumer NVMe, Windows 11.
+
+## Headline numbers
+
+| Result | Value |
+|---|---|
+| LRU hit rate below per-token working set | **0.0%** (measured, all capacities tested) |
+| LRU hit rate at working set (128 slots) | 25.3% |
+| Popularity-pinned hit rate at 10% capacity | 22.9% (vs 0.0% for LRU) |
+| Codec @ 2.01 bits, WikiText-2 PPL | **12.17** (bf16 reference: 8.11) |
+| Frequency-conditioned allocation @ 1.51 bits | 22.02 vs 25.54 uniform — **13.8% better at identical rate** |
+| NVMe random read @ expert-block granularity | 6.01 GB/s (≥ sequential) |
+| GPU device bandwidth | 88.2 GB/s |
+
+### Ablations (all at 1.51 bits, WikiText-2 PPL)
+
+| Configuration | PPL |
+|---|---|
+| RVQ + RHT + LDLQ (full codec) | 25.54 |
+| — without block-LDL error feedback | 7,701.98 |
+| — without incoherence processing | 352.10 |
+| RTN uniform @ 2.25 bits (scalar baseline) | 22,793.90 |
+
+Both codec components are load-bearing, and error feedback matters more than
+rotation.
+
+## Contents
+
+| Path | Contents |
+|---|---|
+| `paper/` | Paper PDF + full LaTeX source and figures |
+| `code/codec.py` | Sub-2-bit codec: randomized Hadamard transform, residual VQ, block-LDL error feedback |
+| `code/quant_model.py` | Layer-sequential quantization + perplexity for OLMoE-1B-7B |
+| `code/trace_routing.py` | Captures per-token expert routing traces |
+| `code/cache_policy.py` | LRU / popularity-pinned / hybrid cache simulation |
+| `code/bench_io.py` | Page-cache-bypassing NVMe, PCIe and DRAM benchmarks |
+| `code/project_1t.py` | 1T reference configuration and throughput roofline |
+| `results/routing_trace.npy` | **Raw routing traces**: `int16[16, 49152, 8]` — the top-8 expert indices selected at every layer for 49,152 held-out tokens |
+| `results/*.json` | Every measurement artefact behind the paper's numbers |
+
+### Using the routing traces
+
+```python
+import numpy as np
+T = np.load("results/routing_trace.npy")   # [layers=16, tokens=49152, topk=8]
+# distinct expert slots touched by one token:
+print(T.shape[0] * T.shape[2])             # 128 -> the LRU threshold
+```
+
+Every number in the paper is generated programmatically from `results/` via
+`code/gen_numbers.py` and `code/gen_tables.py`; nothing is transcribed by hand.
+
+## Scope — please read
+
+**No trillion-parameter model was executed.** No 1T checkpoint was downloaded,
+quantized, or run. The 1T figures (196 GB at 1.5 bits, 1.81–3.08 tokens/s) are an
+*analytical projection* composing measured host parameters with a cache model
+validated against real 7B-scale routing traces. They are not benchmark results
+and should not be cited as such. The paper's Limitations section states this, and
+identifies the weakest assumption: that the Zipf exponent of expert popularity
+(measured `s = 0.65` at 64 experts/layer) is scale-invariant up to 320
+experts/layer. A full sensitivity curve across the entire hit-rate range is
+included precisely because that assumption cannot be foreclosed.
+
+The paper also reports a negative result that constrains any system in this class:
+sustaining the storage stream while materializing fp16 weights would require
+~116 GB/s of device bandwidth against 88.2 GB/s measured, so dequantization must
+be fused into the GEMM rather than staged through VRAM. No fused kernel was
+implemented here.
+
+Quality cost is stated plainly rather than buried: sub-2-bit operation on a
+1.3B-active-parameter MoE is expensive (8.11 → 22.02 PPL at 1.51 bits), which is
+why the systems analysis is parameterized by rate rather than asserting a single
+favourable operating point.
+
+## Model used
+
+[`allenai/OLMoE-1B-7B-0924`](https://huggingface.co/allenai/OLMoE-1B-7B-0924) —
+6.9B total / 1.3B active, 16 layers, 64 experts/layer, top-8. Evaluation on
+WikiText-2.

code/bench_decode.py

@@ -0,0 +1,84 @@
+"""Throughput of on-GPU weight reconstruction (codebook gather) and of the
+online activation-side Hadamard transforms, which is what an inference engine
+must sustain to keep the storage stream busy.
+"""
+import json, os, sys, time
+import torch
+
+sys.path.insert(0, os.path.dirname(__file__))
+import codec
+
+DEV = "cuda"
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+
+
+def bench_decode(stages, nweights=1 << 24, reps=20):
+    C = torch.randn(stages, 256, codec.D_SUB, device=DEV, dtype=torch.float16)
+    n = nweights // codec.D_SUB
+    idx = torch.randint(0, 256, (stages, n), device=DEV, dtype=torch.uint8)
+    scale = torch.randn(nweights // 2048, 1, device=DEV, dtype=torch.float16)
+
+    def run():
+        acc = C[0][idx[0].long()]
+        for s in range(1, stages):
+            acc = acc + C[s][idx[s].long()]
+        return (acc.view(-1, 2048) * scale).view(-1)
+
+    for _ in range(3):
+        run()
+    torch.cuda.synchronize()
+    t0 = time.perf_counter()
+    for _ in range(reps):
+        run()
+    torch.cuda.synchronize()
+    dt = (time.perf_counter() - t0) / reps
+    packed = nweights * stages * codec.CB_BITS / codec.D_SUB / 8
+    return dict(stages=stages, bits=stages * codec.BITS_PER_STAGE,
+                weights_per_s=nweights / dt,
+                fp16_equiv_GBs=nweights * 2 / dt / 1e9,
+                packed_GBs=packed / dt / 1e9)
+
+
+def bench_hadamard(dim=8192, batch=1, reps=200):
+    x = torch.randn(batch, dim, device=DEV)
+    for _ in range(3):
+        codec._fwht(x)
+    torch.cuda.synchronize()
+    t0 = time.perf_counter()
+    for _ in range(reps):
+        codec._fwht(x)
+    torch.cuda.synchronize()
+    return (time.perf_counter() - t0) / reps * 1e6      # microseconds
+
+
+def bench_matmul():
+    out = {}
+    for m, k, n in [(1, 8192, 2048), (32, 8192, 2048), (2048, 8192, 2048)]:
+        a = torch.randn(m, k, device=DEV, dtype=torch.float16)
+        b = torch.randn(k, n, device=DEV, dtype=torch.float16)
+        for _ in range(3):
+            a @ b
+        torch.cuda.synchronize()
+        reps = 50
+        t0 = time.perf_counter()
+        for _ in range(reps):
+            a @ b
+        torch.cuda.synchronize()
+        dt = (time.perf_counter() - t0) / reps
+        out[f"{m}x{k}x{n}"] = dict(tflops=2 * m * k * n / dt / 1e12, ms=dt * 1e3)
+    return out
+
+
+if __name__ == "__main__":
+    res = {"decode": [bench_decode(s) for s in [2, 3, 4]],
+           "hadamard_us": {str(d): bench_hadamard(d) for d in [2048, 4096, 8192]},
+           "matmul": bench_matmul(),
+           "gpu": torch.cuda.get_device_name(0)}
+    for d in res["decode"]:
+        print(f"decode {d['bits']:.1f} bit: {d['weights_per_s']/1e9:.2f} Gweight/s "
+              f"= {d['fp16_equiv_GBs']:.1f} GB/s fp16-equivalent, "
+              f"{d['packed_GBs']:.2f} GB/s of packed bytes consumed")
+    print("hadamard (us):", {k: round(v, 1) for k, v in res["hadamard_us"].items()})
+    for k, v in res["matmul"].items():
+        print(f"matmul {k}: {v['tflops']:.2f} TFLOP/s")
+    json.dump(res, open(os.path.join(RES, "decode_bench.json"), "w"), indent=2)

code/bench_io.py

@@ -0,0 +1,187 @@
+"""Unbuffered (page-cache-bypassing) NVMe random-read benchmark + PCIe H2D + RAM copy.
+
+Uses Win32 CreateFileW with FILE_FLAG_NO_BUFFERING so measurements reflect true
+device behaviour at MoE-expert block granularity rather than page-cache hits.
+"""
+import ctypes, ctypes.wintypes as wt
+import json, mmap, os, random, sys, time
+from concurrent.futures import ThreadPoolExecutor
+
+GENERIC_READ = 0x80000000
+GENERIC_WRITE = 0x40000000
+FILE_SHARE_READ = 0x00000001
+OPEN_EXISTING = 3
+CREATE_ALWAYS = 2
+FILE_FLAG_NO_BUFFERING = 0x20000000
+FILE_FLAG_WRITE_THROUGH = 0x80000000
+FILE_FLAG_RANDOM_ACCESS = 0x10000000
+FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000
+INVALID_HANDLE = ctypes.c_void_p(-1).value
+
+k32 = ctypes.WinDLL("kernel32", use_last_error=True)
+k32.CreateFileW.restype = wt.HANDLE
+k32.CreateFileW.argtypes = [wt.LPCWSTR, wt.DWORD, wt.DWORD, ctypes.c_void_p,
+                            wt.DWORD, wt.DWORD, wt.HANDLE]
+k32.ReadFile.argtypes = [wt.HANDLE, ctypes.c_void_p, wt.DWORD,
+                         ctypes.POINTER(wt.DWORD), ctypes.c_void_p]
+k32.WriteFile.argtypes = [wt.HANDLE, ctypes.c_void_p, wt.DWORD,
+                          ctypes.POINTER(wt.DWORD), ctypes.c_void_p]
+k32.SetFilePointerEx.argtypes = [wt.HANDLE, ctypes.c_longlong,
+                                 ctypes.POINTER(ctypes.c_longlong), wt.DWORD]
+k32.CloseHandle.argtypes = [wt.HANDLE]
+
+SECTOR = 4096
+
+
+def aligned_buf(nbytes):
+    n = (nbytes + SECTOR - 1) // SECTOR * SECTOR
+    mm = mmap.mmap(-1, n)
+    ptr = ctypes.addressof(ctypes.c_char.from_buffer(mm))
+    assert ptr % SECTOR == 0, "buffer not sector aligned"
+    return mm, ptr
+
+
+def open_unbuffered(path, write=False):
+    access = (GENERIC_READ | GENERIC_WRITE) if write else GENERIC_READ
+    create = CREATE_ALWAYS if write else OPEN_EXISTING
+    flags = FILE_FLAG_NO_BUFFERING | (FILE_FLAG_WRITE_THROUGH if write
+                                      else FILE_FLAG_RANDOM_ACCESS)
+    h = k32.CreateFileW(path, access, FILE_SHARE_READ, None, create, flags, None)
+    if h == INVALID_HANDLE:
+        raise ctypes.WinError(ctypes.get_last_error())
+    return h
+
+
+def make_file(path, size_gb):
+    if os.path.exists(path) and os.path.getsize(path) >= size_gb * (1 << 30):
+        return
+    h = open_unbuffered(path, write=True)
+    chunk = 32 << 20
+    mm, ptr = aligned_buf(chunk)
+    mm.write(os.urandom(1 << 20) * (chunk >> 20))
+    written = wt.DWORD(0)
+    n = size_gb * (1 << 30) // chunk
+    for i in range(n):
+        if not k32.WriteFile(h, ptr, chunk, ctypes.byref(written), None):
+            raise ctypes.WinError(ctypes.get_last_error())
+    k32.CloseHandle(h)
+    del mm
+
+
+def read_worker(path, offsets, block):
+    h = open_unbuffered(path)
+    mm, ptr = aligned_buf(block)
+    got = wt.DWORD(0)
+    newpos = ctypes.c_longlong(0)
+    total = 0
+    for off in offsets:
+        k32.SetFilePointerEx(h, ctypes.c_longlong(off), ctypes.byref(newpos), 0)
+        if not k32.ReadFile(h, ptr, block, ctypes.byref(got), None):
+            raise ctypes.WinError(ctypes.get_last_error())
+        total += got.value
+    k32.CloseHandle(h)
+    del mm
+    return total
+
+
+def bench_random(path, fsize, block, nthreads, target_bytes=1 << 30):
+    nreads = max(nthreads * 4, int(target_bytes // block))
+    rng = random.Random(1234 + block + nthreads)
+    maxoff = (fsize - block) // SECTOR
+    offs = [rng.randrange(maxoff) * SECTOR for _ in range(nreads)]
+    parts = [offs[i::nthreads] for i in range(nthreads)]
+    t0 = time.perf_counter()
+    with ThreadPoolExecutor(nthreads) as ex:
+        tot = sum(ex.map(lambda o: read_worker(path, o, block), parts))
+    dt = time.perf_counter() - t0
+    return dict(block_kb=block // 1024, threads=nthreads,
+                mb_s=tot / dt / 1e6, iops=nreads / dt,
+                lat_ms=dt / nreads * nthreads * 1000)
+
+
+def bench_sequential(path, fsize):
+    h = open_unbuffered(path)
+    block = 32 << 20
+    mm, ptr = aligned_buf(block)
+    got = wt.DWORD(0)
+    n = min(64, fsize // block)
+    t0 = time.perf_counter()
+    for _ in range(n):
+        k32.ReadFile(h, ptr, block, ctypes.byref(got), None)
+    dt = time.perf_counter() - t0
+    k32.CloseHandle(h)
+    del mm
+    return n * block / dt / 1e6
+
+
+def bench_pcie():
+    import torch
+    if not torch.cuda.is_available():
+        return {}
+    out = {}
+    for mb in [1, 4, 16, 64]:
+        n = mb * (1 << 20)
+        cpu = torch.empty(n, dtype=torch.uint8).pin_memory()
+        gpu = torch.empty(n, dtype=torch.uint8, device="cuda")
+        for _ in range(3):
+            gpu.copy_(cpu, non_blocking=True)
+        torch.cuda.synchronize()
+        reps = max(5, 512 // mb)
+        t0 = time.perf_counter()
+        for _ in range(reps):
+            gpu.copy_(cpu, non_blocking=True)
+        torch.cuda.synchronize()
+        dt = time.perf_counter() - t0
+        out[f"h2d_{mb}MB_GBs"] = n * reps / dt / 1e9
+        del gpu, cpu
+        torch.cuda.empty_cache()
+    return out
+
+
+def bench_ram():
+    import numpy as np
+    a = np.empty(1 << 28, dtype=np.uint8)
+    b = np.empty(1 << 28, dtype=np.uint8)
+    a[:] = 7
+    for _ in range(2):
+        b[:] = a
+    t0 = time.perf_counter()
+    reps = 8
+    for _ in range(reps):
+        b[:] = a
+    dt = time.perf_counter() - t0
+    return a.nbytes * reps / dt / 1e9
+
+
+if __name__ == "__main__":
+    scratch = sys.argv[1]
+    path = os.path.join(scratch, "iobench.bin")
+    FSIZE_GB = 8
+    print("creating test file...", flush=True)
+    make_file(path, FSIZE_GB)
+    fsize = os.path.getsize(path)
+    res = {"file_gb": FSIZE_GB, "random": [], "host": {}}
+
+    res["host"]["seq_read_mb_s"] = bench_sequential(path, fsize)
+    print(f"sequential unbuffered read: {res['host']['seq_read_mb_s']:.0f} MB/s", flush=True)
+
+    for block_kb in [64, 256, 1024, 4096, 16384]:
+        for nt in [1, 2, 4, 8]:
+            r = bench_random(path, fsize, block_kb * 1024, nt,
+                             target_bytes=512 << 20)
+            res["random"].append(r)
+            print(f"  {block_kb:>6} KB x {nt} thr: {r['mb_s']:8.1f} MB/s  "
+                  f"{r['iops']:8.1f} IOPS  {r['lat_ms']:.3f} ms", flush=True)
+
+    res["host"]["ram_copy_GBs"] = bench_ram()
+    print(f"RAM copy: {res['host']['ram_copy_GBs']:.2f} GB/s", flush=True)
+    res["host"].update(bench_pcie())
+    for k, v in res["host"].items():
+        if k.startswith("h2d"):
+            print(f"{k}: {v:.2f} GB/s", flush=True)
+
+    with open(os.path.join(os.path.dirname(__file__), "..", "results",
+                           "io_bench.json"), "w") as f:
+        json.dump(res, f, indent=2)
+    os.remove(path)
+    print("saved results/io_bench.json")

code/cache_policy.py

@@ -0,0 +1,113 @@
+"""Expert-cache policy comparison on the real OLMoE routing trace.
+
+Key structural fact: a single token touches k*L distinct expert slots. Under a
+purely recency-based policy this is a cyclic reference pattern, so any cache
+smaller than the per-token working set evicts every entry before it is reused
+and the hit rate collapses to zero. Popularity-pinned policies do not have this
+failure mode, and their hit rate is exactly the popularity mass of the pinned
+set -- which is analytically extrapolable.
+"""
+import json, os, sys
+from collections import OrderedDict
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(__file__))
+from project_1t import zipf_fit, zipf_pmf
+
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+
+
+def flat_trace(T, E):
+    L = T.shape[0]
+    return (np.arange(L)[:, None, None] * E + T)          # [L, N, K] global ids
+
+
+def lru_like(F, cap, pinned=None):
+    """LRU over the true interleaved access order, optionally with a pinned set
+    that is never evicted. F is [L, N, K] of global slot ids."""
+    L, N, K = F.shape
+    pinned = pinned if pinned is not None else np.zeros(0, dtype=np.int64)
+    pin = set(pinned.tolist())
+    dyn_cap = max(0, cap - len(pin))
+    cache = OrderedDict()
+    hits = tot = 0
+    for t in range(N):
+        for l in range(L):
+            for s in F[l, t]:
+                s = int(s)
+                tot += 1
+                if s in pin:
+                    hits += 1
+                    continue
+                if s in cache:
+                    hits += 1
+                    cache.move_to_end(s)
+                elif dyn_cap > 0:
+                    if len(cache) >= dyn_cap:
+                        cache.popitem(last=False)
+                    cache[s] = True
+    return hits / tot
+
+
+def static_hits(F, cap, p_global):
+    keep = np.zeros(p_global.shape[0], dtype=bool)
+    keep[np.argsort(-p_global)[:cap]] = True
+    return float(keep[F].mean())
+
+
+def analytic_static(p, cap):
+    """Hit rate of a popularity-pinned cache = mass of the top-`cap` slots."""
+    q = np.sort(np.asarray(p, dtype=np.float64))[::-1]
+    q = q / q.sum()
+    return float(q[:cap].sum())
+
+
+def main():
+    T = np.load(os.path.join(RES, "routing_trace.npy")).astype(np.int64)
+    L, N, K = T.shape
+    E = int(T.max()) + 1
+    freq = json.load(open(os.path.join(RES, "routing_freq.json")))
+    Fq = np.array([freq[str(l)] for l in range(L)])
+    p_global = (Fq / L).reshape(-1)
+    F = flat_trace(T, E)
+    n_slots = L * E
+    ws = K * L                                   # per-token working set in slots
+    s_hat = float(np.median([zipf_fit(Fq[l]) for l in range(L)]))
+
+    out = {"layers": L, "experts": E, "topk": K, "tokens": int(N),
+           "n_slots": n_slots, "token_working_set": ws, "zipf_s": s_hat,
+           "ws_frac": ws / n_slots}
+    print(f"L={L} E={E} K={K} slots={n_slots} per-token working set={ws} "
+          f"({ws/n_slots*100:.1f}% of slots); Zipf s={s_hat:.3f}")
+
+    # analytic static model validated against the trace
+    p_zipf = np.tile(zipf_pmf(E, s_hat) / L, L)
+    rows = []
+    for frac in [0.02, 0.05, 0.10, 0.125, 0.15, 0.25, 0.40, 0.60, 0.80]:
+        cap = max(1, int(frac * n_slots))
+        h_lru = lru_like(F, cap)
+        h_st = static_hits(F, cap, p_global)
+        h_an = analytic_static(p_global, cap)
+        h_az = analytic_static(p_zipf, cap)
+        npin = int(0.75 * cap)
+        pin = np.argsort(-p_global)[:npin]
+        h_hy = lru_like(F, cap, pin)
+        rows.append(dict(frac=frac, cap=cap, lru=h_lru, static=h_st,
+                         hybrid=h_hy, analytic_static=h_an, analytic_zipf=h_az))
+        print(f"  cap {frac*100:5.1f}% ({cap:5d}): LRU {h_lru:.4f} | static {h_st:.4f} "
+              f"| hybrid75 {h_hy:.4f} | analytic {h_an:.4f} | analytic-Zipf {h_az:.4f}")
+    out["policies"] = rows
+    out["mae_analytic_static"] = float(np.mean(
+        [abs(r["static"] - r["analytic_static"]) for r in rows]))
+    out["mae_analytic_zipf"] = float(np.mean(
+        [abs(r["static"] - r["analytic_zipf"]) for r in rows]))
+    out["best_gain_hybrid"] = float(max(r["hybrid"] - r["lru"] for r in rows))
+    print(f"analytic static model MAE vs measured: "
+          f"{out['mae_analytic_static']*100:.2f} pp "
+          f"(Zipf-parameterised: {out['mae_analytic_zipf']*100:.2f} pp)")
+    json.dump(out, open(os.path.join(RES, "cache_policy.json"), "w"), indent=2)
+    print("saved results/cache_policy.json")
+
+
+if __name__ == "__main__":
+    main()

code/codec.py

@@ -0,0 +1,236 @@
+"""Sub-2-bit weight codec: randomised Hadamard incoherence processing followed by
+multi-stage residual vector quantisation on a shared (amortised-free) codebook.
+
+Rate is controlled in 0.5 bit/weight steps by the number of residual stages:
+each stage codes a d=16 subvector with an 8-bit index -> 0.5 bit/weight/stage.
+"""
+import math
+import torch
+
+D_SUB = 16          # subvector dimension
+CB_BITS = 8         # bits per stage index
+CB_SIZE = 1 << CB_BITS
+BITS_PER_STAGE = CB_BITS / D_SUB   # 0.5 bit/weight
+
+
+# ---------------------------------------------------------------- Hadamard
+def _fwht(x):
+    """In-place fast Walsh-Hadamard transform over the last dim (power of 2)."""
+    n = x.shape[-1]
+    assert n & (n - 1) == 0, f"dim {n} not a power of two"
+    h = 1
+    orig = x.shape
+    x = x.reshape(-1, n).clone()
+    while h < n:
+        x = x.view(-1, n // (2 * h), 2, h)
+        a = x[:, :, 0, :].clone()
+        b = x[:, :, 1, :].clone()
+        x[:, :, 0, :] = a + b
+        x[:, :, 1, :] = a - b
+        x = x.view(-1, n)
+        h *= 2
+    return (x / math.sqrt(n)).reshape(orig)
+
+
+def _signs(n, seed, device, dtype):
+    g = torch.Generator(device="cpu").manual_seed(seed)
+    return (torch.randint(0, 2, (n,), generator=g).to(device=device,
+            dtype=dtype) * 2 - 1)
+
+
+def rht_forward(W, seed):
+    sr = _signs(W.shape[1], seed, W.device, W.dtype)
+    sl = _signs(W.shape[0], seed + 1, W.device, W.dtype)
+    X = _fwht(W * sr)                    # right transform
+    X = _fwht((X * sl.unsqueeze(1)).t().contiguous()).t().contiguous()
+    return X
+
+
+def rht_inverse(X, seed):
+    sr = _signs(X.shape[1], seed, X.device, X.dtype)
+    sl = _signs(X.shape[0], seed + 1, X.device, X.dtype)
+    W = _fwht(X.t().contiguous()).t().contiguous() * sl.unsqueeze(1)
+    W = _fwht(W) * sr
+    return W
+
+
+# ---------------------------------------------------------------- codebook
+_CN = {}
+
+
+def _cnorm(C):
+    k = id(C)
+    if k not in _CN or _CN[k][0] is not C:
+        _CN[k] = (C, (C * C).sum(1).unsqueeze(0))
+    return _CN[k][1]
+
+
+def _assign(X, C, chunk=1 << 20):
+    if X.shape[0] <= chunk:
+        return (_cnorm(C) - 2.0 * (X @ C.t())).argmin(1)
+    out = torch.empty(X.shape[0], dtype=torch.long, device=X.device)
+    Cn = _cnorm(C)
+    for s in range(0, X.shape[0], chunk):
+        e = min(s + chunk, X.shape[0])
+        out[s:e] = (Cn - 2.0 * (X[s:e] @ C.t())).argmin(1)
+    return out
+
+
+def rht_hessian(H, seed):
+    """Transform an input-side Hessian into the RHT basis: H' = T^T H T with
+    T = diag(s_r) * Hadamard (orthogonal, symmetric Hadamard)."""
+    s = _signs(H.shape[0], seed, H.device, H.dtype)
+    A = H * s.unsqueeze(0) * s.unsqueeze(1)
+    A = _fwht(A)
+    A = _fwht(A.t().contiguous()).t().contiguous()
+    return A
+
+
+# ---------------------------------------------------------------- quantiser
+def vq(V, codebooks, stages, refine=1):
+    """Multi-stage residual VQ of [N, D_SUB] rows, with optional coordinate
+    refinement: each stage index is re-solved against the residual left by all
+    the other stages, which recovers part of the greedy-encoding loss."""
+    Q = torch.zeros_like(V)
+    parts = []
+    for s in range(stages):
+        C = codebooks[s]
+        idx = _assign(V - Q, C)
+        p = C[idx]
+        parts.append(p)
+        Q = Q + p
+    for _ in range(refine):
+        for s in range(stages):
+            Q = Q - parts[s]
+            idx = _assign(V - Q, codebooks[s])
+            parts[s] = codebooks[s][idx]
+            Q = Q + parts[s]
+    return Q
+
+
+def _block_ldl(H, blk):
+    """H = L D L^T with L block-unit-lower-triangular (blocks of size blk).
+
+    The per-block inverses are batched into a single call rather than looped.
+    """
+    n = H.shape[0]
+    C = torch.linalg.cholesky(H)
+    K = n // blk
+    diag = torch.stack([C[k * blk:(k + 1) * blk, k * blk:(k + 1) * blk]
+                        for k in range(K)])
+    dinv = torch.linalg.inv(diag)
+    Binv = torch.zeros_like(C)
+    idx = torch.arange(blk, device=H.device)
+    for k in range(K):
+        Binv[k * blk + idx[:, None], k * blk + idx[None, :]] = dinv[k]
+    return C @ Binv
+
+
+def prepare_hessian(H, seed, rht_on=True, blk=D_SUB, damp=0.01):
+    """Rotate, damp and block-LDL-factorise a Hessian once, so that every linear
+    sharing this input reuses the factorisation."""
+    dev = H.device
+    Hf = H.float().clone()
+    dead = torch.diag(Hf) <= 0
+    if dead.any():
+        Hf[dead, dead] = 1.0
+    Hf += torch.eye(Hf.shape[0], device=dev) * (damp * torch.diag(Hf).mean())
+    Hr = rht_hessian(Hf, seed) if rht_on else Hf
+    return _block_ldl(Hr, blk), dead
+
+
+def ldlq_quantize(W, L, dead, codebooks, stages, seed=1234, rht_on=True,
+                  blk=D_SUB, refine=0):
+    """Hessian-aware quantisation: minimise ||(W-What) X||_F with H = X X^T,
+    by block-LDL error feedback over blk-column groups, each group coded by the
+    residual VQ. `L`/`dead` come from `prepare_hessian` and are shared by all
+    linears reading the same input."""
+    dt = W.dtype
+    Wf = W.float()
+    if dead is not None and dead.any():
+        Wf = Wf.clone()
+        Wf[:, dead] = 0.0
+
+    X = rht_forward(Wf, seed) if rht_on else Wf
+    scale = X.pow(2).mean(dim=1, keepdim=True).sqrt().clamp_min(1e-8)
+    Xn = X / scale
+
+    o, i = Xn.shape
+    K = i // blk
+    Q = torch.zeros_like(Xn)
+    E = torch.zeros_like(Xn)
+    for k in range(K - 1, -1, -1):
+        s = slice(k * blk, (k + 1) * blk)
+        tgt = Xn[:, s]
+        if k + 1 < K:
+            tgt = tgt + E[:, (k + 1) * blk:] @ L[(k + 1) * blk:, s]
+        Q[:, s] = vq(tgt.reshape(-1, D_SUB), codebooks, stages,
+                     refine).reshape(o, blk)
+        E[:, s] = Xn[:, s] - Q[:, s]
+
+    Xq = Q * scale
+    What = rht_inverse(Xq, seed) if rht_on else Xq
+    bits = stages * BITS_PER_STAGE + 16.0 / i
+    return What.to(dt), dict(bits=bits, stages=stages)
+
+
+def quantize(W, codebooks, stages, seed=1234, rht_on=True, refine=1):
+    """Quantise [out,in] weight matrix at `stages`*0.5 bits/weight, ignoring
+    activation statistics (the data-free ablation of `ldlq_quantize`)."""
+    Wf = W.float()
+    X = rht_forward(Wf, seed) if rht_on else Wf
+    o, i = X.shape
+    scale = X.pow(2).mean(dim=1, keepdim=True).sqrt().clamp_min(1e-8)
+    Xn = X / scale
+    Q = vq(Xn.reshape(-1, D_SUB), codebooks, stages, refine).reshape(o, i)
+    Xq = Q * scale
+    What = rht_inverse(Xq, seed) if rht_on else Xq
+    bits = stages * BITS_PER_STAGE + 16.0 / i          # + fp16 row scale
+    return What.to(W.dtype), dict(bits=bits, stages=stages)
+
+
+def build_codebooks(max_stages=6, device="cpu", seed=0):
+    """Stage-0 codebook on Gaussian data; each later stage on the residual
+    distribution produced by the preceding stages (so shapes adapt)."""
+    g = torch.Generator(device="cpu").manual_seed(seed)
+    X = torch.randn(400_000, D_SUB, generator=g).to(device)
+    cbs, R = [], X.clone()
+    for s in range(max_stages):
+        C = _kmeans(R, CB_SIZE, iters=35, seed=seed + s, device=device)
+        cbs.append(C)
+        R = R - C[_assign(R, C)]
+    return cbs
+
+
+def _kmeans(X, size, iters, seed, device):
+    g = torch.Generator(device="cpu").manual_seed(seed)
+    n = X.shape[0]
+    C = X[torch.randperm(n, generator=g)[:size]].clone()
+    for _ in range(iters):
+        idx = _assign(X, C)
+        C_new = torch.zeros_like(C)
+        cnt = torch.zeros(size, device=device)
+        C_new.index_add_(0, idx, X)
+        cnt.index_add_(0, idx, torch.ones(n, device=device))
+        dead = cnt == 0
+        C_new[~dead] /= cnt[~dead].unsqueeze(1)
+        if dead.any():
+            C_new[dead] = X[torch.randint(0, n, (int(dead.sum()),),
+                                          generator=g)]
+        C = C_new
+    return C
+
+
+# ---------------------------------------------------------------- baseline
+def rtn(W, bits, group=128):
+    """Round-to-nearest uniform baseline with per-group asymmetric scales."""
+    o, i = W.shape
+    Wf = W.float().reshape(o, i // group, group)
+    mn = Wf.amin(-1, keepdim=True)
+    mx = Wf.amax(-1, keepdim=True)
+    n = 2 ** bits - 1
+    s = ((mx - mn) / n).clamp_min(1e-9)
+    q = ((Wf - mn) / s).round().clamp(0, n)
+    Wq = (q * s + mn).reshape(o, i)
+    eff = bits + 2 * 16.0 / group
+    return Wq.to(W.dtype), dict(bits=eff)

code/data.py

@@ -0,0 +1,32 @@
+import io, os
+import torch
+from huggingface_hub import hf_hub_download
+
+_CACHE = {}
+
+
+def _wikitext(split):
+    if split in _CACHE:
+        return _CACHE[split]
+    import pandas as pd
+    fn = hf_hub_download("Salesforce/wikitext", repo_type="dataset",
+                         filename=f"wikitext-2-raw-v1/{split}-00000-of-00001.parquet")
+    txt = "\n\n".join(pd.read_parquet(fn)["text"].tolist())
+    _CACHE[split] = txt
+    return txt
+
+
+def calib_batches(tok, nsamples, seqlen, seed=0):
+    ids = tok(_wikitext("train"), return_tensors="pt").input_ids
+    g = torch.Generator().manual_seed(seed)
+    out = []
+    for _ in range(nsamples):
+        i = torch.randint(0, ids.shape[1] - seqlen - 1, (1,), generator=g).item()
+        out.append(ids[:, i:i + seqlen])
+    return out
+
+
+def test_tokens(tok, seqlen):
+    ids = tok(_wikitext("test"), return_tensors="pt").input_ids
+    n = ids.shape[1] // seqlen
+    return [ids[:, i * seqlen:(i + 1) * seqlen] for i in range(n)]

code/fast_ops.py

@@ -0,0 +1,51 @@
+"""Optimised GPU primitives for the decode path.
+
+ * `fwht_kron`  - Walsh-Hadamard transform as two dense GEMMs via the Kronecker
+   factorisation H_{ab} = H_a (x) H_b, which replaces O(log n) kernel launches
+   with two cuBLAS calls.
+ * `decode`     - multi-stage codebook reconstruction using int32 index_select
+   and a preallocated accumulator, avoiding the int64 promotion and the
+   per-stage temporaries of the naive gather.
+"""
+import math
+import torch
+
+_HCACHE = {}
+
+
+def hadamard_matrix(n, device, dtype):
+    key = (n, device, dtype)
+    if key not in _HCACHE:
+        H = torch.ones(1, 1, device=device, dtype=dtype)
+        while H.shape[0] < n:
+            H = torch.cat([torch.cat([H, H], 1), torch.cat([H, -H], 1)], 0)
+        _HCACHE[key] = H / math.sqrt(n)
+    return _HCACHE[key]
+
+
+def _factor(n):
+    a = 1 << (int(math.log2(n)) // 2)
+    return a, n // a
+
+
+def fwht_kron(x):
+    """Normalised WHT over the last dimension (power of two)."""
+    n = x.shape[-1]
+    a, b = _factor(n)
+    Ha = hadamard_matrix(a, x.device, x.dtype) * math.sqrt(a)
+    Hb = hadamard_matrix(b, x.device, x.dtype) * math.sqrt(b)
+    y = x.reshape(-1, a, b)
+    y = Ha @ y @ Hb
+    return (y / math.sqrt(n)).reshape(x.shape)
+
+
+def decode(idx32, codebooks, scale=None, out=None, row=2048):
+    """idx32: [stages, N] int32 codebook indices; codebooks: [stages][256, D]."""
+    S, N = idx32.shape
+    D = codebooks[0].shape[1]
+    acc = torch.index_select(codebooks[0], 0, idx32[0])
+    for s in range(1, S):
+        acc.add_(torch.index_select(codebooks[s], 0, idx32[s]))
+    if scale is not None:
+        acc = acc.view(-1, row) * scale
+    return acc.reshape(-1)

code/fetch.py

@@ -0,0 +1,8 @@
+import sys, time
+from huggingface_hub import snapshot_download
+
+repo = sys.argv[1]
+t0 = time.time()
+p = snapshot_download(repo, allow_patterns=["*.json", "*.safetensors", "*.txt", "*.model"],
+                      max_workers=8)
+print(f"DONE {repo} -> {p} in {time.time()-t0:.0f}s", flush=True)

code/gen_numbers.py

@@ -0,0 +1,149 @@
+"""Emit paper/numbers.tex so every quantity quoted in the paper is read
+directly from the measurement artefacts rather than transcribed by hand."""
+import glob, json, os, sys
+
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+OUT = os.path.join(os.path.dirname(__file__), "..", "paper", "numbers.tex")
+
+
+def load(n, default=None):
+    p = os.path.join(RES, n)
+    return json.load(open(p)) if os.path.exists(p) else default
+
+
+def fmt(x, d=2):
+    return f"{x:,.{d}f}"
+
+
+def main():
+    M = {}
+    io = load("io_bench.json")
+    if io:
+        rnd = io["random"]
+        best = max(rnd, key=lambda r: r["mb_s"])
+        M["SeqRead"] = fmt(io["host"]["seq_read_mb_s"] / 1000, 2)
+        M["RandBest"] = fmt(best["mb_s"] / 1000, 2)
+        M["RandBestBlock"] = str(best["block_kb"] // 1024)
+        M["RandBestThreads"] = str(best["threads"])
+        one = [r for r in rnd if r["block_kb"] == 1024 and r["threads"] == 1][0]
+        M["RandOneThread"] = fmt(one["mb_s"] / 1000, 2)
+        M["RamCopy"] = fmt(io["host"]["ram_copy_GBs"], 1)
+        M["PCIe"] = fmt(io["host"]["h2d_16MB_GBs"], 2)
+        r64 = [r for r in rnd if r["block_kb"] == 64 and r["threads"] == 1][0]
+        M["RandSmall"] = fmt(r64["mb_s"] / 1000, 2)
+
+    db = load("decode_bench.json")
+    if db:
+        d = [x for x in db["decode"] if abs(x["bits"] - 1.5) < 1e-6][0]
+        M["DecodePacked"] = fmt(d["packed_GBs"], 2)
+        M["DecodeFpEquiv"] = fmt(d["fp16_equiv_GBs"], 1)
+        M["DecodeGw"] = fmt(d["weights_per_s"] / 1e9, 2)
+        M["PeakTflops"] = fmt(max(v["tflops"] for v in db["matmul"].values()), 2)
+        M["GPUName"] = db["gpu"]
+
+    pr = load("projection.json")
+    if pr:
+        P = pr["params"]
+        M["TotalParams"] = fmt(P["total"] / 1e9, 1)
+        M["ActiveParams"] = fmt(P["active"] / 1e9, 1)
+        M["ExpertSlots"] = f"{int(P['n_slots']):,}"
+        amp = {round(a["bits"], 2): a for a in pr["amplification"]}
+        M["FootprintFP"] = fmt(amp[16]["model_gb"], 0)
+        M["FootprintOnePFive"] = fmt(amp[1.5]["model_gb"], 0)
+        M["FootprintTwo"] = fmt(amp[2.0]["model_gb"], 0)
+        M["FootprintOne"] = fmt(amp[1.0]["model_gb"], 0)
+        M["ExpertMBfp"] = fmt(amp[16]["expert_mb"], 1)
+        M["ExpertMB"] = fmt(amp[1.5]["expert_mb"], 2)
+        M["CacheFracFP"] = fmt(amp[16]["frac"] * 100, 2)
+        M["CacheFrac"] = fmt(amp[1.5]["frac"] * 100, 2)
+        M["CacheExpertsFP"] = f"{amp[16]['dram_experts']:,}"
+        M["CacheExperts"] = f"{amp[1.5]['dram_experts']:,}"
+        M["Amplification"] = fmt(amp[1.5]["frac"] / amp[16]["frac"], 1)
+        M["ZipfS"] = fmt(pr["zipf_s"], 2)
+        rows = {(r["rate_bits"], r["batch"]): r for r in pr["projection"]}
+        b1 = rows[(1.5, 1)]
+        M["HitRate"] = fmt(b1["hit_rate"] * 100, 1)
+        M["TokSecOne"] = fmt(b1["tok_s"], 2)
+        M["MBperTok"] = fmt(b1["bytes_per_token_mb"], 0)
+        M["IOatExpert"] = fmt(b1["io_bw_gbs"], 2)
+        M["ResidentGB"] = fmt(b1["resident_gb"], 2)
+        M["TokSecEight"] = fmt(rows[(1.5, 8)]["tok_s"], 2)
+        M["TokSecBatch"] = fmt(rows[(1.5, 32)]["tok_s"], 2)
+        M["TokSecTwoBit"] = fmt(rows[(2.0, 1)]["tok_s"], 2)
+        M["TokSecOneBit"] = fmt(rows[(1.0, 1)]["tok_s"], 2)
+        M["TokSecOneBitBatch"] = fmt(rows[(1.0, 32)]["tok_s"], 2)
+        fp16 = rows[(16.0, 1)]
+        M["TokSecFP"] = fmt(fp16["tok_s"], 2)
+        M["HitRateFP"] = fmt(fp16["hit_rate"] * 100, 1)
+        M["SlotsFP"] = f"{fp16['cap_slots']:,}"
+        M["SpeedupOverFP"] = fmt(b1["tok_s"] / fp16["tok_s"], 1)
+        M["AmpFactor"] = fmt(b1["tok_s"] / fp16["tok_s"] / (16.0 / 1.5), 2)
+        M["ReqDecode"] = fmt(b1["io_bw_gbs"], 2)
+        if "DecodePacked" in M:
+            M["DecodeGap"] = fmt(b1["io_bw_gbs"] / float(M["DecodePacked"]), 0)
+        M["FusedBw"] = fmt(b1["io_bw_gbs"] / 1.5 * 16 * 2, 0)
+        M["FusedRatio"] = fmt(b1["io_bw_gbs"] / 1.5 * 16 * 2 / 88.2, 2)
+        M["ZipfBias"] = fmt(pr.get("zipf_bias_pp", 0), 2)
+
+    cv = load("cache_validation.json")
+    if cv:
+        M["TraceTokens"] = f"{cv['tokens']:,}"
+        M["MassTopQ"] = fmt(cv["mass_top25pct"] * 100, 1)
+        M["ReuseMean"] = fmt(sum(cv["reuse_prev_token"]) / len(cv["reuse_prev_token"]) * 100, 1)
+        d = {r["batch"]: r for r in cv["distinct_per_batch"]}
+        for b, w_ in [(1, "One"), (8, "Eight"), (32, "ThirtyTwo")]:
+            if b in d:
+                M["Distinct" + w_] = fmt(d[b]["measured"], 1)
+        ws = cv["working_set"]
+        for k in ("1", "16", "64", "1024"):
+            if k in ws:
+                M["WorkSet" + {"1": "One", "16": "Sixteen", "64": "SixtyFour",
+                               "1024": "Kilo"}[k]] = fmt(ws[k], 1)
+
+    cp = load("cache_policy.json")
+    if cp:
+        M["ZipfSmeas"] = fmt(cp["zipf_s"], 2)
+        M["TokenWS"] = f"{cp['token_working_set']:,}"
+        M["TokenWSFrac"] = fmt(cp["ws_frac"] * 100, 1)
+        M["Slots"] = f"{cp['n_slots']:,}"
+        M["StaticMAE"] = fmt(cp["mae_analytic_static"] * 100, 2)
+        M["ZipfMAE"] = fmt(cp["mae_analytic_zipf"] * 100, 2)
+        h = {round(r["frac"], 3): r for r in cp["policies"]}
+        for k, name in [(0.02, "Two"), (0.05, "Five"), (0.10, "Ten"),
+                        (0.125, "Twelve"), (0.15, "Fifteen"), (0.25, "TwentyFive"),
+                        (0.40, "Forty")]:
+            if k in h:
+                M["Lru" + name] = fmt(h[k]["lru"] * 100, 1)
+                M["Static" + name] = fmt(h[k]["static"] * 100, 1)
+                M["Hybrid" + name] = fmt(h[k]["hybrid"] * 100, 1)
+
+    fp = load("fp16_ppl.json")
+    if fp:
+        M["PPLfp"] = fmt(fp["ppl"], 2)
+
+    runs = {}
+    for p in glob.glob(os.path.join(RES, "quant_*.json")):
+        r = json.load(open(p))
+        runs[r["config"]["tag"]] = r
+    for tag, name in [("main15", "Ours"), ("main20", "OursTwo"),
+                      ("main10", "OursOne"), ("main25", "OursTwoFive"),
+                      ("noldlq15", "NoLdlq"), ("northt15", "NoRht"),
+                      ("rtn2", "RtnTwo"), ("rtn3", "RtnThree"),
+                      ("freq15", "Freq")]:
+        if tag in runs:
+            M["PPL" + name] = fmt(runs[tag]["ppl"], 2)
+            M["Bits" + name] = fmt(runs[tag]["avg_bits"], 2)
+    M["NumRuns"] = str(len(runs))
+
+    os.makedirs(os.path.dirname(OUT), exist_ok=True)
+    with open(OUT, "w") as f:
+        f.write("% auto-generated by code/gen_numbers.py -- do not edit\n")
+        for k, v in sorted(M.items()):
+            f.write("\\newcommand{\\n%s}{%s}\n" % (k, v))
+    print(f"wrote {OUT} with {len(M)} macros")
+    for k, v in sorted(M.items()):
+        print(f"  {k} = {v}")
+
+
+if __name__ == "__main__":
+    main()

code/gen_tables.py

@@ -0,0 +1,113 @@
+"""Generate the paper's LaTeX tables directly from the measurement artefacts."""
+import glob, json, os
+
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+PAP = os.path.join(os.path.dirname(__file__), "..", "paper")
+
+
+def load(n, d=None):
+    p = os.path.join(RES, n)
+    return json.load(open(p)) if os.path.exists(p) else d
+
+
+def w(name, s):
+    open(os.path.join(PAP, name), "w").write(s)
+    print("wrote", name)
+
+
+def tab_quality():
+    runs = {}
+    for p in glob.glob(os.path.join(RES, "quant_*.json")):
+        r = json.load(open(p))
+        runs[r["config"]["tag"]] = r
+    fp = load("fp16_ppl.json")
+    order = [
+        ("bf16 (reference)", None, None),
+        ("RTN uniform, group 128", "rtn3", "scalar baseline"),
+        ("RTN uniform, group 128", "rtn2", "scalar baseline"),
+        ("RVQ, data-free", "noldlq15", "no LDLQ"),
+        ("RVQ + LDLQ, no rotation", "northt15", "no incoherence proc."),
+        ("RVQ + RHT + LDLQ (ours)", "main10", ""),
+        ("RVQ + RHT + LDLQ (ours)", "main15", ""),
+        ("RVQ + RHT + LDLQ (ours)", "main20", ""),
+        ("\\quad + frequency-cond. alloc.", "freq15", "rate-matched"),
+    ]
+    L = ["\\begin{tabular}{llrr}", "\\toprule",
+         "Method & Note & Bits/weight & PPL $\\downarrow$ \\\\", "\\midrule"]
+    for name, tag, note in order:
+        if tag is None:
+            if fp:
+                L.append(f"{name} & --- & 16.00 & {fp['ppl']:.2f} \\\\")
+                L.append("\\midrule")
+            continue
+        if tag in runs:
+            r = runs[tag]
+            L.append(f"{name} & {note} & {r['avg_bits']:.2f} & {r['ppl']:.2f} \\\\")
+    L += ["\\bottomrule", "\\end{tabular}"]
+    w("tab_quality.tex", "\n".join(L))
+
+
+def tab_amp():
+    pr = load("projection.json")
+    if not pr:
+        return
+    L = ["\\begin{tabular}{rrrrrl}", "\\toprule",
+         "Rate & Footprint & Expert & Resident & Cache & Fits \\\\",
+         "(bits) & (GB) & (MB) & slots & fraction & 294\\,GB? \\\\", "\\midrule"]
+    for a in pr["amplification"]:
+        fits = "yes" if a["model_gb"] < 294 else "\\textbf{no}"
+        L.append(f"{a['bits']:.1f} & {a['model_gb']:,.0f} & {a['expert_mb']:.2f} & "
+                 f"{a['dram_experts']:,} & {a['frac']*100:.2f}\\% & {fits} \\\\")
+    L += ["\\bottomrule", "\\end{tabular}"]
+    w("tab_amp.tex", "\n".join(L))
+
+
+def tab_proj():
+    pr = load("projection.json")
+    if not pr:
+        return
+    ws = pr.get("token_working_set", 512)
+    rows = [r for r in pr["projection"] if r["batch"] in (1, 32)]
+    L = ["\\begin{tabular}{rrrrrrr}", "\\toprule",
+         "Rate & Cache & Recency & Hit & Fetch & \\multicolumn{2}{c}{Tokens/s} \\\\",
+         "\\cmidrule(lr){6-7}",
+         "(bits) & slots & viable? & rate & MB/token & batch 1 & batch 32 \\\\",
+         "\\midrule"]
+    seen = set()
+    for r in sorted(rows, key=lambda x: -x["rate_bits"]):
+        if r["rate_bits"] in seen:
+            continue
+        seen.add(r["rate_bits"])
+        b32 = next(x for x in pr["projection"]
+                   if x["rate_bits"] == r["rate_bits"] and x["batch"] == 32)
+        ok = "yes" if r["cap_slots"] >= ws else "\\textbf{no}"
+        L.append(f"{r['rate_bits']:.1f} & {r['cap_slots']:,} & {ok} & "
+                 f"{r['hit_rate']*100:.1f}\\% & {r['bytes_per_token_mb']:,.0f} & "
+                 f"{r['tok_s']:.2f} & {b32['tok_s']:.2f} \\\\")
+    L += ["\\bottomrule", "\\end{tabular}"]
+    w("tab_proj.tex", "\n".join(L))
+
+
+def tab_policy():
+    cp = load("cache_policy.json")
+    if not cp:
+        return
+    ws = cp["token_working_set"]
+    L = ["\\begin{tabular}{rrrrrr}", "\\toprule",
+         "Capacity & Slots & LRU & Static-freq. & Hybrid & Analytic \\\\",
+         "\\midrule"]
+    for r in cp["policies"]:
+        mark = "$^\\dagger$" if r["cap"] < ws else ""
+        L.append(f"{r['frac']*100:.1f}\\%{mark} & {r['cap']:,} & "
+                 f"{r['lru']*100:.1f}\\% & {r['static']*100:.1f}\\% & "
+                 f"{r['hybrid']*100:.1f}\\% & {r['analytic_static']*100:.1f}\\% \\\\")
+    L += ["\\bottomrule", "\\end{tabular}"]
+    w("tab_policy.tex", "\n".join(L))
+
+
+if __name__ == "__main__":
+    for f in [tab_quality, tab_amp, tab_proj, tab_policy]:
+        try:
+            f()
+        except Exception as e:
+            print("skip", f.__name__, type(e).__name__, e)

code/make_arxiv.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+# Build the arXiv submission tarball: LaTeX source + PDF figures only.
+set -eu
+cd "$(dirname "$0")/.."
+OUT=arxiv
+rm -rf $OUT && mkdir -p $OUT/figs
+
+cp paper/main.tex paper/numbers.tex $OUT/
+cp paper/tab_*.tex $OUT/
+cp paper/figs/*.pdf $OUT/figs/
+
+cd $OUT
+export PATH="$PATH:/c/Users/kavin.kum016/AppData/Local/Programs/MiKTeX/miktex/bin/x64"
+pdflatex -interaction=nonstopmode main.tex > /dev/null 2>&1 || true
+pdflatex -interaction=nonstopmode main.tex > /dev/null 2>&1 || true
+PAGES=$(pdfinfo main.pdf 2>/dev/null | awk '/^Pages/{print $2}')
+if grep -qE "^! " main.log; then
+  echo "LaTeX ERRORS:"; grep -A3 -E "^! " main.log | head -30; exit 1
+fi
+UNDEF=$(grep -c "Undefined control sequence" main.log || true)
+echo "compiled OK: ${PAGES:-?} pages, undefined-control-sequence errors: $UNDEF"
+
+rm -f main.aux main.log main.out main.toc
+cd ..
+tar -czf arxiv-submission.tar.gz -C $OUT main.tex numbers.tex $(cd $OUT && ls tab_*.tex) figs
+echo "wrote arxiv-submission.tar.gz ($(du -h arxiv-submission.tar.gz | cut -f1))"
+tar -tzf arxiv-submission.tar.gz

code/make_figs.py

@@ -0,0 +1,200 @@
+import json, os, sys
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+sys.path.insert(0, os.path.dirname(__file__))
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+FIG = os.path.join(os.path.dirname(__file__), "..", "paper", "figs")
+
+plt.rcParams.update({
+    "font.size": 8, "axes.labelsize": 8, "axes.titlesize": 8.5,
+    "legend.fontsize": 7, "xtick.labelsize": 7, "ytick.labelsize": 7,
+    "figure.dpi": 200, "savefig.dpi": 200, "axes.grid": True,
+    "grid.alpha": 0.25, "grid.linewidth": 0.5, "lines.linewidth": 1.3,
+    "axes.spines.top": False, "axes.spines.right": False,
+    "font.family": "serif", "mathtext.fontset": "cm",
+})
+C = ["#1b3a6b", "#c1440e", "#2e7d32", "#6a1b9a", "#c98a00", "#00695c"]
+
+
+def load(n):
+    p = os.path.join(RES, n)
+    return json.load(open(p)) if os.path.exists(p) else None
+
+
+def fig_amplification():
+    pr = load("projection.json")
+    if not pr:
+        return
+    a = pr["amplification"]
+    bits = [x["bits"] for x in a]
+    frac = [x["frac"] * 100 for x in a]
+    size = [x["model_gb"] for x in a]
+    fig, ax = plt.subplots(1, 2, figsize=(6.9, 2.35))
+    ax[0].plot(bits, size, "o-", color=C[0])
+    ax[0].axhline(294, ls="--", c=C[1], lw=1)
+    ax[0].text(9, 320, "free NVMe (294 GB)", color=C[1], fontsize=6.5)
+    ax[0].axhline(24, ls=":", c=C[2], lw=1)
+    ax[0].text(9, 27, "usable DRAM (24 GB)", color=C[2], fontsize=6.5)
+    ax[0].set_yscale("log"); ax[0].set_xlabel("weight rate (bits/parameter)")
+    ax[0].set_ylabel("model footprint (GB)")
+    ax[0].set_title("(a) 1.05T-parameter footprint")
+    ax[1].plot(bits, frac, "o-", color=C[0])
+    ax[1].set_xlabel("weight rate (bits/parameter)")
+    ax[1].set_ylabel("expert slots resident in 24 GB (%)")
+    ax[1].set_title("(b) DRAM cache capacity")
+    for b, f in zip(bits, frac):
+        if b in (16, 1.5):
+            ax[1].annotate(f"{f:.1f}%", (b, f), textcoords="offset points",
+                           xytext=(4, 4), fontsize=6.5)
+    fig.tight_layout(); fig.savefig(os.path.join(FIG, "amplification.pdf"))
+    plt.close(fig)
+
+
+def fig_io():
+    io = load("io_bench.json")
+    if not io:
+        return
+    fig, ax = plt.subplots(figsize=(3.4, 2.35))
+    for i, t in enumerate([1, 2, 4, 8]):
+        pts = sorted([(r["block_kb"], r["mb_s"] / 1000) for r in io["random"]
+                      if r["threads"] == t])
+        ax.plot([p[0] for p in pts], [p[1] for p in pts], "o-", color=C[i],
+                label=f"{t} thread" + ("s" if t > 1 else ""), ms=3)
+    ax.set_xscale("log", base=2)
+    ax.set_xlabel("read block size (KiB)")
+    ax.set_ylabel("random-read bandwidth (GB/s)")
+    ax.axhline(io["host"]["seq_read_mb_s"] / 1000, ls="--", c="k", lw=0.9)
+    ax.text(80, io["host"]["seq_read_mb_s"] / 1000 + 0.15, "sequential",
+            fontsize=6.5)
+    ax.legend(loc="lower right")
+    fig.tight_layout(); fig.savefig(os.path.join(FIG, "io.pdf")); plt.close(fig)
+
+
+def fig_cache():
+    cp = load("cache_policy.json")
+    cv = load("cache_validation.json")
+    if not cp or not cv:
+        return
+    fr = load("routing_freq.json")
+    fig, ax = plt.subplots(1, 3, figsize=(6.9, 2.25))
+
+    F = np.array([fr[str(l)] for l in range(cp["layers"])])
+    for l in range(0, cp["layers"], 3):
+        ax[0].plot(np.arange(1, F.shape[1] + 1), np.sort(F[l])[::-1],
+                   color=C[0], alpha=0.35, lw=0.8)
+    s = cp["zipf_s"]
+    r = np.arange(1, F.shape[1] + 1)
+    z = r ** (-s); z = z / z.sum()
+    ax[0].plot(r, z, "--", color=C[1], lw=1.4, label=f"Zipf $s$={s:.2f}")
+    ax[0].set_xscale("log"); ax[0].set_yscale("log")
+    ax[0].set_xlabel("expert rank"); ax[0].set_ylabel("activation probability")
+    ax[0].set_title("(a) expert popularity"); ax[0].legend()
+
+    h = cp["policies"]
+    x = [r["frac"] * 100 for r in h]
+    ax[1].plot(x, [r["lru"] * 100 for r in h], "o-", color=C[0],
+               label="LRU", ms=3)
+    ax[1].plot(x, [r["static"] * 100 for r in h], "^-", color=C[2],
+               label="popularity-pinned", ms=3)
+    ax[1].plot(x, [r["hybrid"] * 100 for r in h], "d-", color=C[4],
+               label="hybrid (75% pinned)", ms=3)
+    ax[1].plot(x, [r["analytic_static"] * 100 for r in h], "s:", color=C[1],
+               label="analytic model", ms=3)
+    ws = cp["ws_frac"] * 100
+    ax[1].axvline(ws, ls="--", c=C[3], lw=1)
+    ax[1].text(ws + 2, 72, "per-token\nworking set", color=C[3], fontsize=6)
+    ax[1].set_xlabel("cache capacity (% of expert slots)")
+    ax[1].set_ylabel("hit rate (%)")
+    ax[1].set_title("(b) replacement policy"); ax[1].legend(loc="lower right")
+
+    d = cv["distinct_per_batch"]
+    ax[2].plot([r["batch"] for r in d], [r["measured"] for r in d], "o-",
+               color=C[0], label="measured", ms=3)
+    ax[2].plot([r["batch"] for r in d], [r["irm_measured_pop"] for r in d],
+               "s--", color=C[1], label="IRM model", ms=3)
+    ax[2].set_xscale("log", base=2)
+    ax[2].set_xlabel("tokens per batch")
+    ax[2].set_ylabel("distinct experts / layer")
+    ax[2].set_title("(c) batch amortisation"); ax[2].legend(loc="lower right")
+    fig.tight_layout(); fig.savefig(os.path.join(FIG, "cache.pdf")); plt.close(fig)
+
+
+def fig_quality():
+    import glob
+    runs = []
+    for p in glob.glob(os.path.join(RES, "quant_*.json")):
+        runs.append(json.load(open(p)))
+    if not runs:
+        return
+    fig, ax = plt.subplots(figsize=(5.0, 3.05))
+    base = [r for r in runs if r["config"].get("tag", "").startswith("rtn")]
+    ours = sorted([r for r in runs if r["config"]["tag"].startswith("main")],
+                  key=lambda r: r["avg_bits"])
+    abl = sorted([r for r in runs if r["config"]["tag"].startswith("northt")],
+                 key=lambda r: r["avg_bits"])
+    noldl = sorted([r for r in runs if r["config"]["tag"].startswith("noldlq")],
+                   key=lambda r: r["avg_bits"])
+    freq = sorted([r for r in runs if r["config"]["tag"].startswith("freq")],
+                  key=lambda r: r["avg_bits"])
+    fp = load("fp16_ppl.json")
+    for grp, lab, st, c in [(ours, "RVQ + RHT + LDLQ (ours)", "o-", C[0]),
+                            (freq, "+ frequency-conditioned alloc.", "D-", C[4]),
+                            (noldl, "no LDLQ (data-free)", "s--", C[1]),
+                            (abl, "no incoherence processing", "^--", C[2]),
+                            (base, "RTN uniform", "v:", C[3])]:
+        if grp:
+            ax.plot([r["avg_bits"] for r in grp], [r["ppl"] for r in grp], st,
+                    label=lab, color=c, ms=3)
+    if fp:
+        ax.axhline(fp["ppl"], ls="--", c="k", lw=0.9)
+        ax.text(3.32, fp["ppl"] * 1.12, f"bf16 = {fp['ppl']:.2f}", fontsize=6.5,
+                ha="right", va="bottom")
+    ax.set_yscale("log")
+    ax.set_xlim(0.85, 3.45)
+    ax.set_xlabel("average weight rate (bits/parameter)")
+    ax.set_ylabel("WikiText-2 perplexity")
+    ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.24), ncol=2,
+              frameon=False, fontsize=7)
+    fig.tight_layout()
+    fig.savefig(os.path.join(FIG, "quality.pdf"), bbox_inches="tight")
+    plt.close(fig)
+
+
+def fig_throughput():
+    pr = load("projection.json")
+    if not pr:
+        return
+    fig, ax = plt.subplots(1, 2, figsize=(6.9, 2.35))
+    s = pr["sensitivity_1p5bit"]
+    ax[0].plot([x["hit_rate"] * 100 for x in s], [x["tok_s"] for x in s], "-",
+               color=C[0])
+    hr = pr["projection"][0]["hit_rate"] * 100
+    ax[0].set_xlabel("expert-cache hit rate (%)")
+    ax[0].set_ylabel("decode throughput (tokens/s)")
+    ax[0].set_yscale("log")
+    ax[0].set_title("(a) sensitivity at 1.5 bit, batch 1")
+    rows = pr["projection"]
+    bits = sorted(set(r["rate_bits"] for r in rows))
+    for i, B in enumerate([1, 8, 32]):
+        y = [next(r["tok_s"] for r in rows if r["rate_bits"] == b and r["batch"] == B)
+             for b in bits]
+        ax[1].plot(bits, y, "o-", color=C[i], label=f"batch {B}", ms=3)
+    ax[1].set_xlabel("weight rate (bits/parameter)")
+    ax[1].set_ylabel("decode throughput (tokens/s)")
+    ax[1].set_yscale("log"); ax[1].legend()
+    ax[1].set_title("(b) projected 1.05T throughput")
+    fig.tight_layout(); fig.savefig(os.path.join(FIG, "throughput.pdf"))
+    plt.close(fig)
+
+
+if __name__ == "__main__":
+    os.makedirs(FIG, exist_ok=True)
+    for f in [fig_amplification, fig_io, fig_cache, fig_quality, fig_throughput]:
+        try:
+            f()
+            print("ok", f.__name__)
+        except Exception as e:
+            print("skip", f.__name__, type(e).__name__, e)

code/project_1t.py

@@ -0,0 +1,189 @@
+"""Projection of a 1T-parameter sparse MoE onto the measured machine.
+
+Methodology: every hardware quantity is measured on the host; the expert-cache
+behaviour is modelled with the Che approximation for LRU under an
+independent-reference model, *validated against the real OLMoE trace at E=64*
+before being extrapolated to the 1T configuration's E=320.
+"""
+import json, os, sys
+import numpy as np
+
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+
+# ---------------------------------------------------------------- 1T config
+T1 = dict(name="T1-1046B", layers=64, d_model=8192, n_experts=320, topk=8,
+          d_ff_expert=2048, n_shared=1, kv_dim=1024, vocab=129280)
+
+
+def config_params(c):
+    attn = 2 * c["d_model"] ** 2 + 2 * c["d_model"] * c["kv_dim"]
+    expert = 3 * c["d_model"] * c["d_ff_expert"]
+    per_layer = attn + expert * (c["n_experts"] + c["n_shared"])
+    total = per_layer * c["layers"] + 2 * c["vocab"] * c["d_model"]
+    active = (attn + expert * (c["topk"] + c["n_shared"])) * c["layers"] \
+        + c["vocab"] * c["d_model"]
+    return dict(total=total, active=active, expert=expert,
+                attn_total=attn * c["layers"],
+                shared_total=expert * c["n_shared"] * c["layers"],
+                routed_total=expert * c["n_experts"] * c["layers"],
+                n_slots=c["n_experts"] * c["layers"])
+
+
+# ---------------------------------------------------------------- cache model
+def che_hit_rate(p, capacity):
+    """LRU hit rate under IRM via Che's approximation."""
+    p = np.asarray(p, dtype=np.float64)
+    p = p / p.sum()
+    if capacity >= len(p):
+        return 1.0
+    if capacity <= 0:
+        return 0.0
+    lo, hi = 1e-6, 1e12
+    for _ in range(200):
+        t = (lo * hi) ** 0.5
+        occ = (1.0 - np.exp(-p * t)).sum()
+        if occ < capacity:
+            lo = t
+        else:
+            hi = t
+    t = (lo * hi) ** 0.5
+    return float((p * (1.0 - np.exp(-p * t))).sum())
+
+
+def zipf_fit(freq):
+    """Least-squares Zipf exponent of a measured popularity vector."""
+    f = np.sort(np.asarray(freq, dtype=np.float64))[::-1]
+    f = f[f > 0]
+    r = np.arange(1, len(f) + 1)
+    a, _ = np.polyfit(np.log(r), np.log(f), 1)
+    return float(-a)
+
+
+def zipf_pmf(n, s):
+    r = np.arange(1, n + 1, dtype=np.float64)
+    p = r ** (-s)
+    return p / p.sum()
+
+
+def distinct_per_layer(p, n_draws):
+    """Expected distinct experts touched by n_draws independent selections."""
+    p = np.asarray(p, dtype=np.float64)
+    p = p / p.sum()
+    return float((1.0 - (1.0 - p) ** n_draws).sum())
+
+
+# ---------------------------------------------------------------- throughput
+def io_bandwidth(io, block_bytes, threads=4):
+    """Interpolate measured unbuffered random-read bandwidth at a block size."""
+    pts = [(r["block_kb"] * 1024, r["mb_s"]) for r in io["random"]
+           if r["threads"] == threads]
+    pts.sort()
+    xs = np.log2([p[0] for p in pts]); ys = [p[1] for p in pts]
+    return float(np.interp(np.log2(block_bytes), xs, ys)) * 1e6
+
+
+def analytic_static(p, cap):
+    """Hit rate of a popularity-pinned cache: mass of the top-`cap` slots.
+    Exact given the popularity vector (validated to 0.00 pp on the real trace)."""
+    q = np.sort(np.asarray(p, dtype=np.float64))[::-1]
+    q = q / q.sum()
+    return float(q[:min(cap, len(q))].sum())
+
+
+def hit_rate_for(cfg, cap_slots, zipf_s, bias_pp=0.0):
+    """Popularity-pinned hit rate for a configuration with E experts per layer."""
+    p = np.tile(zipf_pmf(cfg["n_experts"], zipf_s) / cfg["layers"], cfg["layers"])
+    return max(0.0, analytic_static(p, cap_slots) - bias_pp / 100.0)
+
+
+def project(rate_bits, hit_rate, io, cfg=T1, dram_gb=24.0, vram_gb=3.4,
+            batch=1, zipf_s=None):
+    P = config_params(cfg)
+    Bpp = rate_bits / 8.0
+    expert_bytes = P["expert"] * Bpp
+    total_bytes = P["total"] * Bpp
+
+    resident = (P["attn_total"] + P["shared_total"]) * Bpp
+    vram_free = max(0.0, vram_gb * 1e9 - resident)
+    dram_slots = int(dram_gb * 1e9 // expert_bytes)
+    vram_slots = int(vram_free // expert_bytes)
+
+    bw = io_bandwidth(io, expert_bytes)
+    if zipf_s is not None:
+        p = zipf_pmf(cfg["n_experts"], zipf_s)
+        u = distinct_per_layer(p, cfg["topk"] * batch)
+    else:
+        u = cfg["topk"] * batch
+    fetch_per_token = cfg["layers"] * u * (1.0 - hit_rate) / batch
+    bytes_per_token = fetch_per_token * expert_bytes
+    t_io = bytes_per_token / bw
+    return dict(rate_bits=rate_bits, hit_rate=hit_rate, batch=batch,
+                total_gb=total_bytes / 1e9, expert_mb=expert_bytes / 1e6,
+                dram_slots=dram_slots, vram_slots=vram_slots,
+                cache_frac=dram_slots / P["n_slots"],
+                resident_gb=resident / 1e9,
+                io_bw_gbs=bw / 1e9,
+                bytes_per_token_mb=bytes_per_token / 1e6,
+                tok_s=1.0 / t_io if t_io > 0 else float("inf"))
+
+
+def main():
+    io = json.load(open(os.path.join(RES, "io_bench.json")))
+    P = config_params(T1)
+    out = {"config": T1, "params": {k: float(v) for k, v in P.items()}}
+    print(f"{T1['name']}: {P['total']/1e9:.1f}B total, {P['active']/1e9:.1f}B active/token, "
+          f"{P['n_slots']} expert slots")
+
+    # ---- cache-capacity amplification from quantisation
+    amp = []
+    for r in [16, 4, 3, 2, 1.5, 1.0]:
+        eb = P["expert"] * r / 8
+        amp.append(dict(bits=r, model_gb=P["total"] * r / 8 / 1e9,
+                        expert_mb=eb / 1e6,
+                        dram_experts=int(24e9 // eb),
+                        frac=int(24e9 // eb) / P["n_slots"]))
+    out["amplification"] = amp
+    print("\nrate  model_GB  expert_MB  experts_in_24GB  cache_frac")
+    for a in amp:
+        print(f"{a['bits']:>4.1f}  {a['model_gb']:8.0f}  {a['expert_mb']:9.2f}  "
+              f"{a['dram_experts']:15d}  {a['frac']*100:9.2f}%")
+
+    # ---- cache policy calibrated on the measured trace, then extrapolated
+    cp = json.load(open(os.path.join(RES, "cache_policy.json")))
+    s_hat = cp["zipf_s"]
+    bias = cp["mae_analytic_zipf"] * 100      # Zipf-fit optimism, in points
+    out["zipf_s"] = s_hat
+    out["zipf_bias_pp"] = bias
+    ws = T1["topk"] * T1["layers"]            # per-token working set, in slots
+    out["token_working_set"] = ws
+    print(f"\nper-token working set: {ws} expert slots; Zipf s={s_hat:.3f}; "
+          f"Zipf-fit optimism {bias:.2f} pp")
+
+    rows = []
+    for r in [1.0, 1.5, 2.0, 3.0, 4.0, 16.0]:
+        eb = P["expert"] * r / 8
+        cap = int(24e9 // eb)
+        h = hit_rate_for(T1, cap, s_hat, bias_pp=bias)
+        for B in [1, 8, 32]:
+            x = project(r, h, io, batch=B, zipf_s=s_hat)
+            x["cap_slots"] = cap
+            x["lru_viable"] = cap >= ws
+            rows.append(x)
+    out["projection"] = rows
+    print("\nbits  batch  slots  LRUok  hit%   model_GB  expert_MB  IO_GB/s  MB/token  tok/s")
+    for x in rows:
+        print(f"{x['rate_bits']:>4.1f}  {x['batch']:>5d}  {x['cap_slots']:>5d}  "
+              f"{str(x['lru_viable']):>5}  {x['hit_rate']*100:4.1f}  "
+              f"{x['total_gb']:8.0f}  {x['expert_mb']:9.2f}  {x['io_bw_gbs']:7.2f}  "
+              f"{x['bytes_per_token_mb']:8.1f}  {x['tok_s']:6.2f}")
+
+    # ---- sensitivity: tok/s across the whole hit-rate range at 1.5 bit
+    sens = [project(1.5, float(h), io, batch=1, zipf_s=s_hat)
+            for h in np.arange(0.0, 0.99, 0.05)]
+    out["sensitivity_1p5bit"] = sens
+    json.dump(out, open(os.path.join(RES, "projection.json"), "w"), indent=2)
+    print("\nsaved results/projection.json")
+
+
+if __name__ == "__main__":
+    main()

code/quant_model.py

@@ -0,0 +1,279 @@
+"""Sequential layer-wise quantisation of OLMoE-1B-7B with Hessian-aware
+sub-2-bit residual VQ, plus frequency-conditioned bit allocation over experts.
+
+Runs on a 4 GB GPU by moving one decoder layer at a time onto the device.
+"""
+import argparse, gc, json, os, sys, time
+import torch
+import torch.nn as nn
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(__file__))
+import codec, data
+
+MODEL = "allenai/OLMoE-1B-7B-0924"
+DEV = "cuda"
+
+
+def hkey_of(name):
+    """Linears sharing an input share one Hessian."""
+    if name.endswith(("q_proj", "k_proj", "v_proj")):
+        return "attn.in"
+    if name.endswith("o_proj"):
+        return "attn.o"
+    if ".experts." in name:
+        e = name.split(".experts.")[1].split(".")[0]
+        if name.endswith("down_proj"):
+            return f"e{e}.mid"
+        return f"e{e}.in"
+    return None
+
+
+def find_linears(layer):
+    out = {}
+    for n, m in layer.named_modules():
+        if isinstance(m, nn.Linear) and hkey_of(n) is not None:
+            out[n] = m
+    return out
+
+
+class Catcher(nn.Module):
+    def __init__(self, mod, store):
+        super().__init__()
+        self.mod, self.store = mod, store
+
+    def forward(self, hs, **kw):
+        self.store["inps"].append(hs.detach().to("cpu"))
+        if "kw" not in self.store:
+            self.store["kw"] = {k: v for k, v in kw.items()
+                                if k not in ("past_key_value", "past_key_values")}
+        raise RuntimeError("caught")
+
+
+@torch.no_grad()
+def capture_inputs(model, batches):
+    store = {"inps": []}
+    model.model.embed_tokens.to(DEV)
+    model.model.rotary_emb.to(DEV)
+    layers = model.model.layers
+    layers[0] = Catcher(layers[0], store)
+    for b in batches:
+        try:
+            model(b.to(DEV))
+        except RuntimeError as e:
+            if "caught" not in str(e):
+                raise
+    layers[0] = layers[0].mod
+    model.model.embed_tokens.to("cpu")
+    torch.cuda.empty_cache()
+    return store["inps"], store["kw"]
+
+
+@torch.no_grad()
+def run_layer(layer, inps, kw, out=None):
+    res = out if out is not None else [None] * len(inps)
+    for j, x in enumerate(inps):
+        y = layer(x.to(DEV), **kw)
+        y = y[0] if isinstance(y, tuple) else y
+        res[j] = y.detach().to("cpu")
+    return res
+
+
+def alloc_stages(freq, base_stages, spread, n_experts):
+    """Frequency-conditioned bit allocation.
+
+    Experts are ranked by measured activation frequency; the top third get
+    +`spread` stages, the bottom third -`spread`, keeping the mean rate equal to
+    `base_stages` so the comparison against uniform allocation is rate-matched.
+    """
+    order = sorted(range(n_experts), key=lambda i: -freq[i])
+    st = [base_stages] * n_experts
+    k = n_experts // 3
+    for i in order[:k]:
+        st[i] = base_stages + spread
+    for i in order[-k:]:
+        st[i] = max(1, base_stages - spread)
+    return st
+
+
+@torch.no_grad()
+def quantize_model(stages, nsamples=32, seqlen=2048, rht_on=True, ldlq_on=True,
+                   alloc="uniform", spread=1, refine=0, tag="", rtn_bits=None):
+    tok = AutoTokenizer.from_pretrained(MODEL)
+    model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16,
+                                                 low_cpu_mem_usage=True)
+    model.eval()
+    model.config.use_cache = False
+    cbs = codec.build_codebooks(8, device=DEV)
+
+    batches = data.calib_batches(tok, nsamples, seqlen)
+    inps, kw = capture_inputs(model, batches)
+    outs = [None] * len(inps)
+    layers = model.model.layers
+    n_exp = model.config.num_experts
+
+    freq = load_freq(n_exp, len(layers))
+    log = {"layers": [], "bits": [], "params": []}
+    t_start = time.time()
+
+    for li, layer in enumerate(layers):
+        t0 = time.time()
+        layer.to(DEV)
+        lin = find_linears(layer)
+        H, cnt = {}, {}
+
+        reps = {}
+        for n, m in lin.items():
+            k = hkey_of(n)
+            reps.setdefault(k, (n, m))
+
+        hooks = []
+        need_hess = ldlq_on and rtn_bits is None
+
+        def mk(k, insize):
+            H[k] = torch.zeros(insize, insize, device=DEV, dtype=torch.float32)
+            cnt[k] = 0
+
+            def fn(mod, inp, out):
+                x = inp[0].detach().reshape(-1, insize).float()
+                if x.shape[0]:
+                    H[k] += x.t() @ x
+                    cnt[k] += x.shape[0]
+            return fn
+
+        if need_hess:
+            for k, (n, m) in reps.items():
+                hooks.append(m.register_forward_hook(mk(k, m.in_features)))
+            run_layer(layer, inps, kw)
+            for h in hooks:
+                h.remove()
+
+        if alloc == "freq":
+            st_e = alloc_stages(freq[li], stages, spread, n_exp)
+        else:
+            st_e = [stages] * n_exp
+
+        fact = {}
+        lbits, lparams = 0.0, 0
+        for n, m in lin.items():
+            k = hkey_of(n)
+            s = stages
+            if ".experts." in n:
+                s = st_e[int(n.split(".experts.")[1].split(".")[0])]
+            W = m.weight.data.to(DEV).float()
+            if rtn_bits is not None:
+                Wq, info = codec.rtn(W, rtn_bits)
+            elif ldlq_on:
+                if k not in fact:
+                    fact[k] = codec.prepare_hessian(H[k], 1234, rht_on=rht_on)
+                L, dead = fact[k]
+                Wq, info = codec.ldlq_quantize(W, L, dead, cbs, s,
+                                               rht_on=rht_on, refine=refine)
+            else:
+                Wq, info = codec.quantize(W, cbs, s, rht_on=rht_on, refine=refine)
+            m.weight.data = Wq.to(torch.bfloat16)
+            lbits += info["bits"] * W.numel()
+            lparams += W.numel()
+            del W, Wq
+        H.clear(); fact.clear()
+        torch.cuda.empty_cache()
+
+        run_layer(layer, inps, kw, outs)
+        layer.to("cpu")
+        inps, outs = outs, inps
+        gc.collect(); torch.cuda.empty_cache()
+        log["layers"].append(li)
+        log["bits"].append(lbits / lparams)
+        log["params"].append(lparams)
+        print(f"[{tag}] layer {li:2d}  {lbits/lparams:.3f} bits/w  "
+              f"({time.time()-t0:.0f}s, total {time.time()-t_start:.0f}s)", flush=True)
+
+    avg_bits = sum(log["bits"][i] * log["params"][i] for i in range(len(log["bits"]))) \
+        / sum(log["params"])
+    log["avg_bits"] = avg_bits
+    log["quantized_params"] = sum(log["params"])
+    model.config.use_cache = False
+    return model, tok, log
+
+
+def load_freq(n_exp, n_layers):
+    p = os.path.join(os.path.dirname(__file__), "..", "results", "routing_freq.json")
+    if os.path.exists(p):
+        f = json.load(open(p))
+        return [f[str(l)] for l in range(n_layers)]
+    return [[1.0] * n_exp for _ in range(n_layers)]
+
+
+@torch.no_grad()
+def perplexity(model, tok, seqlen=2048, limit=None):
+    """Layer-sequential evaluation: each layer is moved to the GPU once and all
+    sequences are streamed through it, rather than paging layers per sequence."""
+    tests = data.test_tokens(tok, seqlen)
+    if limit:
+        tests = tests[:limit]
+    pos = torch.arange(seqlen, device=DEV).unsqueeze(0)
+    model.model.embed_tokens.to(DEV); model.model.rotary_emb.to(DEV)
+    hs = [model.model.embed_tokens(b.to(DEV)).cpu() for b in tests]
+    pe = model.model.rotary_emb(hs[0].to(DEV), pos)
+    model.model.embed_tokens.to("cpu"); torch.cuda.empty_cache()
+
+    for layer in model.model.layers:
+        layer.to(DEV)
+        for j in range(len(hs)):
+            y = layer(hs[j].to(DEV), attention_mask=None, position_ids=pos,
+                      position_embeddings=pe)
+            hs[j] = (y[0] if isinstance(y, tuple) else y).cpu()
+        layer.to("cpu"); torch.cuda.empty_cache()
+
+    model.model.norm.to(DEV); model.lm_head.to(DEV)
+    nll, ntok = 0.0, 0
+    for j, b in enumerate(tests):
+        logits = model.lm_head(model.model.norm(hs[j].to(DEV))).float()
+        loss = torch.nn.functional.cross_entropy(
+            logits[:, :-1].reshape(-1, logits.shape[-1]),
+            b.to(DEV)[:, 1:].reshape(-1))
+        nll += loss.item() * (seqlen - 1)
+        ntok += seqlen - 1
+        del logits
+        torch.cuda.empty_cache()
+    return float(torch.exp(torch.tensor(nll / ntok)))
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--stages", type=int, default=3)
+    ap.add_argument("--nsamples", type=int, default=32)
+    ap.add_argument("--seqlen", type=int, default=2048)
+    ap.add_argument("--no-rht", action="store_true")
+    ap.add_argument("--no-ldlq", action="store_true")
+    ap.add_argument("--alloc", default="uniform")
+    ap.add_argument("--spread", type=int, default=1)
+    ap.add_argument("--ppl-limit", type=int, default=24)
+    ap.add_argument("--rtn", type=int, default=None)
+    ap.add_argument("--fp16", action="store_true")
+    ap.add_argument("--tag", default="run")
+    a = ap.parse_args()
+
+    if a.fp16:
+        tok = AutoTokenizer.from_pretrained(MODEL)
+        m = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16,
+                                                 low_cpu_mem_usage=True)
+        m.eval(); m.config.use_cache = False
+        ppl = perplexity(m, tok, a.seqlen, a.ppl_limit)
+        print(f"[fp16] wikitext2 ppl={ppl:.4f}", flush=True)
+        json.dump({"ppl": ppl, "seqlen": a.seqlen, "limit": a.ppl_limit},
+                  open(os.path.join(os.path.dirname(__file__), "..", "results",
+                                    "fp16_ppl.json"), "w"), indent=2)
+        sys.exit(0)
+
+    m, tok, log = quantize_model(a.stages, a.nsamples, a.seqlen,
+                                 rht_on=not a.no_rht, ldlq_on=not a.no_ldlq,
+                                 alloc=a.alloc, spread=a.spread, tag=a.tag,
+                                 rtn_bits=a.rtn)
+    t0 = time.time()
+    ppl = perplexity(m, tok, a.seqlen, a.ppl_limit)
+    log.update(ppl=ppl, config=vars(a), ppl_secs=time.time() - t0)
+    print(f"[{a.tag}] avg_bits={log['avg_bits']:.3f}  wikitext2 ppl={ppl:.3f}", flush=True)
+    out = os.path.join(os.path.dirname(__file__), "..", "results", f"quant_{a.tag}.json")
+    json.dump(log, open(out, "w"), indent=2)
+    print("saved", out)

code/run_all.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Full experiment sweep. Each config reloads the model and quantises it
+# layer-sequentially, then evaluates WikiText-2 perplexity.
+set -u
+cd "$(dirname "$0")/.."
+N=32
+S=2048
+P=20
+
+run () {
+  echo "=========== $* ==========="
+  python -u code/quant_model.py --nsamples $N --seqlen $S --ppl-limit $P "$@" 2>&1 \
+    | grep -Ev "^Loading checkpoint|it/s\]$"
+}
+
+python -u code/quant_model.py --fp16 --seqlen $S --ppl-limit $P 2>&1 | tail -2
+
+run --stages 3 --tag main15
+run --stages 4 --tag main20
+run --stages 2 --tag main10
+run --stages 3 --alloc freq --spread 1 --tag freq15
+run --stages 3 --no-ldlq --tag noldlq15
+run --stages 3 --no-rht  --tag northt15
+run --rtn 3 --tag rtn3
+run --rtn 2 --tag rtn2
+echo "ALL RUNS COMPLETE"

code/trace_routing.py

@@ -0,0 +1,165 @@
+"""Capture real per-token expert routing traces from OLMoE and derive the
+statistics that drive the expert-cache model: activation-frequency skew,
+temporal reuse, and cross-layer predictability.
+"""
+import json, os, sys, time
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(__file__))
+import data
+
+MODEL = "allenai/OLMoE-1B-7B-0924"
+DEV = "cuda"
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+
+
+@torch.no_grad()
+def trace(nseq=24, seqlen=2048):
+    tok = AutoTokenizer.from_pretrained(MODEL)
+    model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16,
+                                                 low_cpu_mem_usage=True)
+    model.eval(); model.config.use_cache = False
+    L = model.config.num_hidden_layers
+    E = model.config.num_experts
+    K = model.config.num_experts_per_tok
+
+    picks = {l: [] for l in range(L)}
+    hooks = []
+
+    def mk(l):
+        def fn(mod, inp, out):
+            logits = out[0] if isinstance(out, tuple) else out
+            top = logits.float().reshape(-1, E).topk(K, dim=-1).indices
+            picks[l].append(top.to(torch.int16).cpu())
+        return fn
+
+    for l, layer in enumerate(model.model.layers):
+        hooks.append(layer.mlp.gate.register_forward_hook(mk(l)))
+
+    tests = data.test_tokens(tok, seqlen)[:nseq]
+    model.model.embed_tokens.to(DEV); model.model.rotary_emb.to(DEV)
+    model.model.norm.to(DEV)
+    for i, b in enumerate(tests):
+        b = b.to(DEV)
+        hs = model.model.embed_tokens(b)
+        pos = torch.arange(seqlen, device=DEV).unsqueeze(0)
+        pe = model.model.rotary_emb(hs, pos)
+        for layer in model.model.layers:
+            layer.to(DEV)
+            hs = layer(hs, attention_mask=None, position_ids=pos,
+                       position_embeddings=pe)
+            hs = hs[0] if isinstance(hs, tuple) else hs
+            layer.to("cpu")
+            torch.cuda.empty_cache()
+        print(f"  seq {i+1}/{len(tests)}", flush=True)
+    for h in hooks:
+        h.remove()
+
+    T = torch.stack([torch.cat(picks[l]) for l in range(L)])   # [L, tokens, K]
+    np.save(os.path.join(RES, "routing_trace.npy"), T.numpy().astype(np.int16))
+    print("trace shape", tuple(T.shape))
+    return T.numpy().astype(np.int64), L, E, K
+
+
+def analyse(T, L, E, K):
+    ntok = T.shape[1]
+    freq = np.zeros((L, E))
+    for l in range(L):
+        c = np.bincount(T[l].reshape(-1), minlength=E)
+        freq[l] = c / c.sum()
+    json.dump({str(l): freq[l].tolist() for l in range(L)},
+              open(os.path.join(RES, "routing_freq.json"), "w"))
+
+    srt = np.sort(freq, axis=1)[:, ::-1]
+    cum = np.cumsum(srt, axis=1)
+    out = {
+        "tokens": int(ntok), "layers": L, "experts": E, "topk": K,
+        "gini": [float(gini(freq[l])) for l in range(L)],
+        "mass_top25pct": float(cum[:, E // 4 - 1].mean()),
+        "mass_top50pct": float(cum[:, E // 2 - 1].mean()),
+        "cum_mean": cum.mean(0).tolist(),
+    }
+
+    # temporal reuse: probability an expert used at token t was also used at t-1
+    reuse = []
+    for l in range(L):
+        a = T[l][:-1]; b = T[l][1:]
+        m = np.zeros((len(a), E), dtype=bool)
+        m[np.arange(len(a))[:, None], a] = True
+        hit = m[np.arange(len(b))[:, None], b].sum(1) / K
+        reuse.append(float(hit.mean()))
+    out["reuse_prev_token"] = reuse
+
+    # working set: distinct experts over a window of W tokens
+    ws = {}
+    for W in [1, 4, 16, 64, 256, 1024]:
+        vals = []
+        for l in range(L):
+            n = min(len(T[l]) // W, 64)
+            for i in range(n):
+                vals.append(len(np.unique(T[l][i * W:(i + 1) * W])))
+        ws[W] = float(np.mean(vals))
+    out["working_set"] = ws
+    json.dump(out, open(os.path.join(RES, "routing_stats.json"), "w"), indent=2)
+    return out
+
+
+def gini(p):
+    x = np.sort(p)
+    n = len(x)
+    return float((2 * np.arange(1, n + 1) - n - 1).dot(x) / (n * x.sum()))
+
+
+def simulate_cache(T, L, E, K, expert_bytes, cache_bytes, freq=None,
+                   policy="lru", pin_frac=0.0):
+    """Byte-accurate expert cache simulation over the real trace.
+
+    Returns fraction of expert activations served from cache (hit rate) and
+    bytes fetched from storage per token.
+    """
+    cap = int(cache_bytes // expert_bytes)
+    if cap <= 0:
+        return 0.0, K * L * expert_bytes
+    npin = int(cap * pin_frac)
+    pinned = set()
+    if npin and freq is not None:
+        flat = [(freq[l][e], (l, e)) for l in range(L) for e in range(E)]
+        flat.sort(reverse=True)
+        pinned = {k for _, k in flat[:npin]}
+    from collections import OrderedDict
+    cache = OrderedDict((k, True) for k in pinned)
+    hits = tot = 0
+    ntok = T.shape[1]
+    for t in range(ntok):
+        for l in range(L):
+            for e in T[l, t]:
+                key = (l, int(e))
+                tot += 1
+                if key in cache:
+                    hits += 1
+                    if key not in pinned:
+                        cache.move_to_end(key)
+                else:
+                    cache[key] = True
+                    while len(cache) > cap:
+                        k0, _ = next(iter(cache.items()))
+                        if k0 in pinned:
+                            cache.move_to_end(k0)
+                            continue
+                        cache.popitem(last=False)
+    hr = hits / tot
+    return hr, (1 - hr) * K * L * expert_bytes
+
+
+if __name__ == "__main__":
+    nseq = int(sys.argv[1]) if len(sys.argv) > 1 else 24
+    p = os.path.join(RES, "routing_trace.npy")
+    if os.path.exists(p):
+        T = np.load(p).astype(np.int64)
+        L, E, K = T.shape[0], 64, T.shape[2]
+    else:
+        T, L, E, K = trace(nseq)
+    st = analyse(T, L, E, K)
+    print(json.dumps({k: v for k, v in st.items() if k != "cum_mean"}, indent=2))

code/validate_cache.py

@@ -0,0 +1,110 @@
+"""Validate the analytic expert-cache model against the measured OLMoE trace.
+
+Measures true LRU hit rates over the real routing sequence, compares them with
+Che's approximation driven by the measured popularity vector, and fits the Zipf
+exponent that is later used to extrapolate to a 1T-parameter expert count.
+"""
+import json, os, sys
+from collections import OrderedDict
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(__file__))
+from project_1t import che_hit_rate, zipf_fit, zipf_pmf, distinct_per_layer
+
+RES = os.path.join(os.path.dirname(__file__), "..", "results")
+
+
+def lru_hits(T, cap):
+    """True LRU hit rate over the real interleaved (layer, expert) access order."""
+    L, N, K = T.shape
+    cache = OrderedDict()
+    hits = tot = 0
+    for t in range(N):
+        for l in range(L):
+            base = l * 1000
+            for e in T[l, t]:
+                key = base + int(e)
+                tot += 1
+                if key in cache:
+                    hits += 1
+                    cache.move_to_end(key)
+                else:
+                    if len(cache) >= cap:
+                        cache.popitem(last=False)
+                    cache[key] = True
+    return hits / tot
+
+
+def static_freq_hits(T, cap, p_global):
+    """Static frequency-pinned cache: keep the globally hottest `cap` slots."""
+    L = T.shape[0]
+    E = p_global.shape[0] // L
+    keep = np.zeros(p_global.shape[0], dtype=bool)
+    keep[np.argsort(-p_global)[:cap]] = True
+    flat = np.arange(L)[:, None, None] * E + T
+    return float(keep[flat].mean())
+
+
+def main():
+    T = np.load(os.path.join(RES, "routing_trace.npy")).astype(np.int64)
+    L, N, K = T.shape
+    E = int(T.max()) + 1
+    stats = json.load(open(os.path.join(RES, "routing_stats.json")))
+    freq = json.load(open(os.path.join(RES, "routing_freq.json")))
+    F = np.array([freq[str(l)] for l in range(L)])           # [L, E]
+
+    # global popularity over all (layer, expert) slots
+    p_global = (F / L).reshape(-1)
+    s_layer = [zipf_fit(F[l]) for l in range(L)]
+    s_hat = float(np.median(s_layer))
+
+    out = {"layers": L, "experts": E, "topk": K, "tokens": int(N),
+           "zipf_s": s_hat, "zipf_s_per_layer": s_layer}
+    print(f"trace: L={L} E={E} K={K} tokens={N}; Zipf s (median) = {s_hat:.3f}")
+
+    rows = []
+    n_slots = L * E
+    for frac in [0.02, 0.05, 0.10, 0.15, 0.25, 0.40, 0.60, 0.80]:
+        cap = max(1, int(frac * n_slots))
+        h_meas = lru_hits(T, cap)
+        h_che = che_hit_rate(p_global, cap)
+        h_zipf = che_hit_rate(np.tile(zipf_pmf(E, s_hat) / L, L), cap)
+        h_stat = static_freq_hits(T, cap, p_global)
+        rows.append(dict(frac=frac, cap=cap, measured=h_meas, static=h_stat,
+                         che_measured_pop=h_che, che_zipf=h_zipf))
+        print(f"  cap={frac*100:5.1f}% ({cap:5d} slots): measured LRU {h_meas:.4f} | "
+              f"static-freq {h_stat:.4f} | Che(measured pop) {h_che:.4f} | "
+              f"Che(Zipf s={s_hat:.2f}) {h_zipf:.4f}")
+    out["hit_rates"] = rows
+    err = np.array([abs(r["measured"] - r["che_measured_pop"]) for r in rows])
+    out["che_mae"] = float(err.mean())
+    out["che_zipf_mae"] = float(np.mean([abs(r["measured"] - r["che_zipf"])
+                                         for r in rows]))
+    print(f"Che approximation MAE vs measured LRU: {out['che_mae']:.4f} "
+          f"(Zipf-parameterised: {out['che_zipf_mae']:.4f})")
+
+    # distinct experts per batch: measured vs independent-reference prediction
+    dpb = []
+    rng = np.random.default_rng(0)
+    for B in [1, 2, 4, 8, 16, 32, 64]:
+        meas = []
+        for _ in range(200):
+            ts = rng.integers(0, N, size=B)
+            l = int(rng.integers(0, L))
+            meas.append(len(np.unique(T[l][ts])))
+        pred = distinct_per_layer(F.mean(0), K * B)
+        pred_z = distinct_per_layer(zipf_pmf(E, s_hat), K * B)
+        dpb.append(dict(batch=B, measured=float(np.mean(meas)),
+                        irm_measured_pop=pred, irm_zipf=pred_z))
+        print(f"  batch {B:3d}: distinct experts/layer measured {np.mean(meas):6.2f} | "
+              f"IRM {pred:6.2f} | IRM-Zipf {pred_z:6.2f}")
+    out["distinct_per_batch"] = dpb
+    out["reuse_prev_token"] = stats["reuse_prev_token"]
+    out["working_set"] = stats["working_set"]
+    out["mass_top25pct"] = stats["mass_top25pct"]
+    json.dump(out, open(os.path.join(RES, "cache_validation.json"), "w"), indent=2)
+    print("saved results/cache_validation.json")
+
+
+if __name__ == "__main__":
+    main()

paper/main.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e487d47e8bbd87e9bda9af16834f06d957059a43ec9b98181a3b99cc6c741853
+size 462650

paper/main.tex

@@ -0,0 +1,727 @@
+\documentclass[10pt]{article}
+\usepackage[margin=1in]{geometry}
+\usepackage{amsmath,amssymb}
+\usepackage{graphicx}
+\usepackage{booktabs}
+\usepackage{xcolor}
+\usepackage{caption}
+\usepackage[hidelinks]{hyperref}
+\usepackage{microtype}
+
+\input{numbers}
+
+\captionsetup{font=small,labelfont=bf}
+\setlength{\parskip}{1pt}
+
+\title{\bf Quantization as Cache Amplification:\\[2pt]
+Trillion-Parameter Mixture-of-Experts Inference on a Commodity Laptop}
+
+\author{Kavin Kumar\\ \small Neural Metrics\\ \small\texttt{kavin.kum016@neuralmetrics.ai}}
+\date{\today}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+Weight quantization is usually justified as footprint reduction. We argue that
+for offloaded mixture-of-experts (MoE) inference this framing misses where the
+leverage actually is. In an offloaded MoE engine the binding resource is not
+storage capacity but the fraction of expert slots resident in DRAM, and storage
+traffic depends on that fraction through a cache hit rate that is both concave
+and, for recency-based policies, \emph{discontinuous}. We show on real routing
+traces that a least-recently-used expert cache collapses to a hit rate of
+\emph{exactly zero} whenever its capacity falls below the $kL$ expert slots a
+single token touches --- a cyclic-reference pathology we measure at precisely
+the predicted threshold. Quantization is what moves a system across that
+threshold, so bits buy throughput super-proportionally to their compression
+ratio.
+
+We make this quantitative on one commodity laptop (\nGPUName, 4\,GB VRAM;
+32\,GB DRAM; consumer NVMe). We contribute (i) a sub-2-bit post-training codec
+combining randomized Hadamard incoherence processing, multi-stage residual
+vector quantization, and block-LDL error feedback; (ii) \emph{frequency-conditioned
+bit allocation}, which spends bits on experts in proportion to measured
+activation frequency and so improves distortion and cache residency together;
+and (iii) an end-to-end roofline in which every hardware term is measured on the
+host and the cache term is modelled analytically and validated against
+\nTraceTokens{} tokens of real OLMoE-1B-7B routing traces.
+
+Measured on the host: \nRandBest\,GB/s unbuffered random read at expert-block
+granularity, \nPCIe\,GB/s over PCIe, $88.2$\,GB/s of GPU device bandwidth. On
+OLMoE-1B-7B the codec reaches WikiText-2 perplexity \nPPLOursTwo{} at
+\nBitsOursTwo{} bits and \nPPLFreq{} at \nBitsFreq{} bits against \nPPLfp{} in
+bfloat16; frequency-conditioned allocation improves perplexity by $13.8\%$ over
+uniform allocation at identical rate. We report the quality cost plainly: sub-2-bit
+operation on a $1.3$\,B-active-parameter MoE is expensive, and the systems
+analysis is presented as a function of rate rather than at one favoured point.
+On the traces, expert popularity is Zipfian with exponent $\nZipfSmeas$, and a
+popularity-pinned cache model reproduces measured hit rates to
+\nStaticMAE{} percentage points. Composing these, a $\nTotalParams$\,B-parameter
+MoE occupies \nFootprintOnePFive\,GB at $1.5$ bits --- resident on the laptop's
+free NVMe --- and projects \nTokSecOne{} tokens/s at batch~1 and
+\nTokSecBatch{} tokens/s at batch~32, versus \nTokSecFP{} tokens/s at bfloat16.
+That is a $\nSpeedupOverFP\times$ throughput gain from a $10.7\times$
+compression: $\nAmpFactor\times$ more than compression alone. We also report a
+negative result that constrains any such system: sustaining the storage stream
+while materializing fp16 weights would need ${\sim}\nFusedBw$\,GB/s of device
+bandwidth against $88.2$\,GB/s measured, so dequantization must be fused into
+the GEMM. \textbf{We did not execute a trillion-parameter model}; the 1T figures
+are an analytical projection from measured host parameters and a cache model
+validated at 7B scale, and we report sensitivity across the full hit-rate range.
+\end{abstract}
+
+\section{Introduction}
+
+A trillion-parameter mixture-of-experts model stored at bfloat16 occupies
+roughly \nFootprintFP\,GB. Models of this class are deployed on multi-GPU
+servers whose aggregate high-bandwidth memory exceeds the entire storage budget
+of a consumer machine, and the reasonable assumption is that such models are out
+of reach for a single laptop.
+
+Sparse MoE models complicate that assumption, because the parameters touched by
+any one token are a small fraction of the total. In the reference configuration
+we study (Section~\ref{sec:config}), $\nTotalParams$\,B total parameters yield
+$\nActiveParams$\,B active parameters per token. The other ${\sim}96\%$ of the
+model is idle at any instant; it does not need to be in memory, it needs to be
+\emph{reachable} fast enough. That converts a capacity problem into a
+bandwidth-and-locality problem, which is what caches address.
+
+The usual account of quantization here is that it shrinks the model so more of
+it fits. We think that understates it, for a reason specific to the access
+pattern. Let $f$ be the fraction of expert slots that are DRAM-resident. Storage
+traffic per token is governed by $1-h(f)$, and $h$ is not a gentle function. A
+single token routes to $k$ experts in each of $L$ layers, touching $kL$ distinct
+expert slots before any of them is reused. Under a recency-based policy this is
+a cyclic reference pattern: if the cache holds fewer than $kL$ slots, every
+entry is evicted before its next use and the hit rate is not merely low but
+identically zero. We measure exactly this on real OLMoE traces
+(Section~\ref{sec:policy}): LRU hit rate is $\nLruTen\%$ at $10\%$ capacity and
+jumps to $\nLruTwelve\%$ the moment capacity reaches the $\nTokenWS$-slot
+working set.
+
+Quantization is the lever that moves a system across that threshold. On our
+host, $24$\,GB of DRAM holds \nSlotsFP{} of \nExpertSlots{} expert slots at
+bfloat16 --- below the $512$-slot per-token working set of our 1T reference
+configuration, so recency-based caching is inoperative --- but
+\nCacheExperts{} slots at $1.5$ bits, comfortably above it. The resulting
+throughput gain, $\nSpeedupOverFP\times$, exceeds the $10.7\times$ compression
+ratio by $\nAmpFactor\times$. We call this \emph{cache amplification}.
+
+Our contributions:
+\begin{itemize}\itemsep1pt
+\item \textbf{The cache-amplification framing} (Section~\ref{sec:amp}), with a
+closed form for when compressing weights buys more than its compression ratio,
+and a measured phase transition that is its sharpest instance.
+\item \textbf{A sub-2-bit post-training codec} (Section~\ref{sec:codec}):
+randomized Hadamard incoherence processing, multi-stage residual vector
+quantization on a shared Gaussian codebook, and block-LDL error feedback
+minimizing activation-weighted rather than weight-space error.
+\item \textbf{Frequency-conditioned bit allocation} (Section~\ref{sec:alloc}),
+derived from reverse water-filling over measured expert popularities, which cuts
+perplexity $13.8\%$ at exactly matched average rate.
+\item \textbf{A measured roofline and validated cache model}
+(Sections~\ref{sec:host}--\ref{sec:policy}), including the finding that
+popularity-pinned caching strictly dominates LRU in the capacity regime these
+systems operate in.
+\item \textbf{A projection with explicit sensitivity}
+(Section~\ref{sec:projection}) and a \textbf{negative result} on the
+dequantization path (Section~\ref{sec:decode}).
+\end{itemize}
+
+We state the scope plainly. We did not run a trillion-parameter model. We
+measured every component of the system on real hardware with real models,
+validated the component that must be extrapolated, and composed them.
+Section~\ref{sec:limits} is explicit about what this does and does not
+establish.
+
+\section{Background and Related Work}
+
+\paragraph{Extreme post-training quantization.}
+GPTQ established second-order rounding with error feedback as the standard for
+post-training quantization; AWQ showed activation-scale-aware channel treatment
+matters at low rates. Below $3$ bits scalar quantization becomes
+rate-inefficient and the field moved to vector and lattice codes. QuIP
+introduced incoherence processing --- rotating weights into a basis where
+outliers are suppressed --- and QuIP\# paired randomized Hadamard transforms
+with an $E_8$ lattice codebook. AQLM used additive multi-codebook quantization,
+VPTQ pushed vector PTQ below $2$ bits at $70$--$405$\,B scale, and QTIP replaced
+explicit codebooks with a bitshift trellis to reach high effective dimension.
+BitNet~b1.58 showed ternary weights are viable when trained from scratch. Our
+codec is deliberately conventional in its components: the contribution is the
+allocation policy layered on top and the systems argument it serves, not a new
+rate--distortion frontier.
+
+\paragraph{Offloaded and streaming inference.}
+FlexGen scheduled dense-model weights across GPU, CPU and disk; \emph{LLM in a
+Flash} exploited FFN activation sparsity to stream from flash; PowerInfer
+partitioned neurons by activation frequency between CPU and GPU. For MoE,
+Mixtral-offload introduced LRU expert caching with speculative prefetch, and
+MoE-Infinity, EdgeMoE, Pre-gated MoE, Fiddler, MoBiLE and FlashMoE refined
+placement and replacement. Reported hit rates are modest --- existing policies
+achieve $33$--$44\%$ caching $20$ of $60$ experts per layer, and FlashMoE
+reports up to $51\%$ relative improvement over LRU/LFU via learned replacement.
+This literature holds the weight rate fixed and optimizes the policy. We hold
+the policy simple and observe that the rate is the more powerful lever, because
+it changes $f$ rather than $h(\cdot)$ --- and because it can move the system
+across the discontinuity in $h$ entirely.
+
+\paragraph{Cache analysis.}
+Che's approximation gives an accurate closed form for LRU hit rates under an
+independent-reference model. We found it \emph{inapplicable} in our regime
+precisely because the MoE access pattern is cyclic rather than independent
+(Section~\ref{sec:policy}), which is itself informative: it is the structure
+that IRM discards that produces the phase transition.
+
+\section{Cache Amplification}\label{sec:amp}
+
+Consider an MoE with $L$ layers, $E$ routed experts per layer, top-$k$ routing
+and $P_e$ parameters per expert. At weight rate $r$ (bits/parameter) an expert
+occupies $B(r)=P_e r/8$ bytes, so a DRAM budget $M$ holds $M/B(r)$ slots and the
+resident fraction is
+\begin{equation}
+f(r)\;=\;\frac{M}{B(r)\,L\,E}\;=\;\frac{8M}{P_e\,L\,E\,r}\;\propto\;\frac{1}{r}.
+\label{eq:frac}
+\end{equation}
+Storage traffic per generated token is
+\begin{equation}
+T(r)\;=\;L\,k\,\bigl(1-h(f(r))\bigr)\,B(r).
+\label{eq:traffic}
+\end{equation}
+Writing $\rho=r/r_0$ for the compression ratio against a baseline rate $r_0$,
+the naive expectation is $T\propto\rho$. The actual scaling is
+\begin{equation}
+\frac{T(r)}{T(r_0)}\;=\;\rho\cdot\underbrace{\frac{1-h(f_0/\rho)}{1-h(f_0)}}_{\text{amplification}},
+\label{eq:amp}
+\end{equation}
+whose second factor is at most $1$ whenever $h$ is increasing, and strictly
+below $1$ when $f_0$ lies below the knee of $h$. Equivalently, traffic scales as
+$\rho^{\,1+|\eta|}$ with elasticity $\eta=\mathrm{d}\log(1-h)/\mathrm{d}\log f$.
+
+\paragraph{The discontinuity.}
+For recency-based replacement the amplification factor is not merely favourable
+but discontinuous. A token touches $kL$ distinct expert slots, one per layer per
+selected expert, and revisits none of them until the next token. This is a
+cyclic reference string of period $kL$, the classical worst case for LRU: with
+capacity $C<kL$, every entry is evicted before reuse and
+\begin{equation}
+h_{\mathrm{LRU}}(C)\;=\;0 \qquad\text{for } C<kL,
+\label{eq:threshold}
+\end{equation}
+independently of how skewed expert popularity is. Since $C\propto 1/r$ by
+Eq.~\ref{eq:frac}, there is a critical rate $r^\star = 8M/(P_e k L)$ below which
+recency-based caching begins to function at all. Section~\ref{sec:policy}
+confirms Eq.~\ref{eq:threshold} on real traces, and Section~\ref{sec:projection}
+shows the 1T reference configuration sits on the inoperative side of $r^\star$
+at bfloat16 and the operative side at $1.5$ bits.
+
+Two consequences follow. First, the value of a saved bit is largest exactly
+where systems are most constrained, so the case for extreme rates is stronger in
+offloaded settings than the perplexity--rate curve alone suggests. Second,
+because $h$ depends on \emph{which} experts are resident and not only how many,
+the bit budget should not be spread uniformly.
+
+\section{Method}
+
+\subsection{Codec}\label{sec:codec}
+
+Each linear weight matrix $W\in\mathbb{R}^{o\times i}$ is quantized in three
+stages.
+
+\paragraph{Incoherence processing.}
+We apply a two-sided randomized Hadamard transform
+$W'=(D_\ell H_o)\,W\,(D_r H_i)$ with $D_\ell,D_r$ random sign diagonals and
+$H_n$ the normalized Walsh--Hadamard matrix. This suppresses outliers and drives
+subvector statistics toward i.i.d.\ Gaussian, so a single global codebook serves
+every layer of every model and its storage cost amortizes to zero. As $H$ is
+orthogonal and symmetric the rotation is undone at inference time on
+\emph{activations}, not weights:
+$y=Wx=D_\ell H_o\bigl(W'(H_i D_r x)\bigr)$, costing two vector transforms per
+matmul. We implement the transform as two dense GEMMs via the Kronecker
+factorization $H_{ab}=H_a\otimes H_b$, replacing $O(\log n)$ kernel launches
+with two cuBLAS calls; measured $86.7\,\mu$s versus $1930\,\mu$s for a butterfly
+implementation at $n=8192$, a $22\times$ speedup at $10^{-6}$ agreement.
+
+\paragraph{Residual vector quantization.}
+Rows of $W'$ are normalized by an fp16 per-row RMS scale and partitioned into
+subvectors of dimension $d=16$. Each subvector is coded by $S$ residual stages,
+each an $8$-bit index into a $256$-entry codebook, giving $0.5$ bits/weight per
+stage and a rate ladder in $0.5$-bit steps. Stage $s$'s codebook is trained by
+$k$-means on the residual distribution left by stages $<s$, so later stages
+adapt to the shrinking residual scale.
+
+\paragraph{Block-LDL error feedback.}
+Weight-space error is the wrong objective; what matters is
+$\|(W-\widehat{W})X\|_F$ for calibration activations $X$. With $H=XX^\top$ and
+the block-LDL factorization $H=LDL^\top$ ($L$ block-unit-lower-triangular with
+$d\times d$ blocks), the objective decomposes over column blocks and processing
+them in reverse order with
+\begin{equation}
+\widehat{W}_k \;=\; Q\Bigl(W_k + \textstyle\sum_{j>k} (W_j-\widehat{W}_j)\,L_{jk}\Bigr)
+\label{eq:ldlq}
+\end{equation}
+greedily minimizes it. On synthetic data with a non-trivial Hessian this trades
+higher weight-space error ($0.537$ vs $0.441$ relative Frobenius at $1.5$ bits)
+for a $17$--$18\%$ lower activation-weighted error --- the quantity that governs
+perplexity. Linears sharing an input share one factorization. We quantize layer
+by layer, propagating each layer's \emph{quantized} output forward so later
+layers calibrate against accumulated error.
+
+\subsection{Frequency-Conditioned Bit Allocation}\label{sec:alloc}
+
+Experts are not equally important: their activation frequencies are heavy-tailed
+(Section~\ref{sec:routing}), and an expert's contribution to expected output
+error is weighted by how often it is selected. With $\pi_e$ the activation
+probability and $D(r)$ the distortion at rate $r$, the rate-constrained problem
+\begin{equation}
+\min_{\{r_e\}}\ \sum_e \pi_e D(r_e)
+\quad\text{s.t.}\quad \tfrac{1}{E}\textstyle\sum_e r_e = \bar r
+\label{eq:alloc}
+\end{equation}
+has the reverse-water-filling solution $r_e = \bar r + \tfrac12\log_2(\pi_e/\tilde\pi)$
+for a Gaussian source with $D(r)\propto 2^{-2r}$, $\tilde\pi$ the geometric mean
+of the $\pi_e$: bits should grow logarithmically in popularity.
+
+The systems benefit is separate from and additive to the distortion benefit.
+Cold experts coded at lower rate occupy fewer bytes, so at fixed $M$ more
+\emph{hot} experts become resident: the allocation improves $h$ as well as $D$.
+We implement a rank-based approximation: at average rate $\bar S$ stages, the
+most-activated third of experts in each layer receive $\bar S+1$ stages and the
+least-activated third $\bar S-1$, leaving the mean rate --- and hence the
+comparison against uniform allocation --- exactly rate-matched.
+
+\subsection{Execution Model}\label{sec:exec}
+
+The engine we analyze keeps rate-invariant always-active parameters resident in
+VRAM --- attention projections and the shared expert, \nResidentGB\,GB at
+$1.5$ bits, within the \nGPUName's $4$\,GB --- and treats routed experts as a
+demand-paged working set backed by NVMe with DRAM as a second-level cache.
+Expert blocks at $1.5$ bits are \nExpertMB\,MB, a granularity at which random
+reads are as fast as sequential (Section~\ref{sec:host}), which is why demand
+paging is viable at all.
+
+\section{Experimental Setup}\label{sec:config}
+
+\paragraph{Host.}
+All measurements are from one laptop: Intel 12-core CPU, $32$\,GB DDR5
+(\nRamCopy\,GB/s measured copy bandwidth), \nGPUName{} with $4.29$\,GB VRAM
+($16$ SMs, $88.2$\,GB/s measured device bandwidth, \nPeakTflops\,TFLOP/s peak
+fp16 GEMM), consumer NVMe with $294$\,GB free. Storage is measured through the
+Win32 API with \texttt{FILE\_FLAG\_NO\_BUFFERING}, so results reflect device
+behaviour rather than page-cache hits.
+
+\paragraph{Model.}
+Compression and routing experiments use OLMoE-1B-7B-0924 ($6.9$\,B total,
+$1.3$\,B active, $16$ layers, $64$ experts/layer, top-$8$,
+$d_{\text{model}}{=}2048$) --- the largest fully open MoE whose bfloat16 weights
+fit this machine's DRAM, with power-of-two dimensions suited to the Hadamard
+transform. Calibration uses $32$ sequences of $2048$ tokens from WikiText-2
+train; perplexity is on WikiText-2 test at sequence length $2048$. Routing
+traces cover \nTraceTokens{} tokens of held-out text.
+
+\paragraph{Reference 1T configuration.}
+\textbf{T1} is a DeepSeek-V3-style configuration scaled to
+$\nTotalParams$\,B parameters: $64$ layers, $d_{\text{model}}{=}8192$, $320$
+routed experts plus $1$ shared expert per layer, top-$8$ routing, expert
+intermediate width $2048$, grouped-query attention with $1024$ KV width, vocab
+$129280$. This gives $\nActiveParams$\,B active parameters per token,
+\nExpertSlots{} routed expert slots and a per-token working set of $512$ slots.
+T1 is a paper configuration, not a released checkpoint; it exists to make the
+accounting concrete.
+
+\section{Results}
+
+\subsection{Host Roofline}\label{sec:host}
+
+Table~\ref{tab:host} and Figure~\ref{fig:io} give measured host limits. The
+important feature is the shape of the random-read curve: at $64$\,KiB blocks a
+single thread sustains \nRandSmall\,GB/s, but by $1$\,MiB the same thread
+reaches \nRandOneThread\,GB/s and with modest concurrency the device saturates
+at \nRandBest\,GB/s --- above its \nSeqRead\,GB/s sequential rate. Expert blocks
+at $1.5$ bits are \nExpertMB\,MB, well inside the flat region.
+\emph{Demand-paging experts costs no measurable random-access penalty}, which is
+the enabling hardware fact for this class of system. PCIe transfer measures
+\nPCIe\,GB/s, closely matching storage, so the two stages pipeline without
+either dominating.
+
+\begin{table}[t]
+\centering\small
+\caption{Measured host limits. Storage uses unbuffered, page-cache-bypassing I/O.}
+\label{tab:host}
+\begin{tabular}{lr}
+\toprule
+Quantity & Measured \\
+\midrule
+NVMe sequential read & \nSeqRead\,GB/s \\
+NVMe random read, $64$\,KiB blocks, 1 thread & \nRandSmall\,GB/s \\
+NVMe random read, $1$\,MiB blocks, 1 thread & \nRandOneThread\,GB/s \\
+NVMe random read, peak (\nRandBestBlock\,MiB, \nRandBestThreads\ threads) & \nRandBest\,GB/s \\
+PCIe host$\rightarrow$device ($16$\,MB) & \nPCIe\,GB/s \\
+DRAM copy & \nRamCopy\,GB/s \\
+GPU device copy & $88.2$\,GB/s \\
+GPU peak fp16 GEMM & \nPeakTflops\,TFLOP/s \\
+\bottomrule
+\end{tabular}
+\end{table}
+
+\begin{figure}[t]
+\centering
+\includegraphics[width=0.49\textwidth]{figs/io.pdf}
+\caption{Unbuffered random-read bandwidth versus block size. Bandwidth saturates
+by ${\sim}1$\,MiB; the $1.5$-bit expert block (\nExpertMB\,MB) sits in the flat
+region, so demand-paged experts pay no random-access penalty.}
+\label{fig:io}
+\end{figure}
+
+\subsection{Compression Quality}\label{sec:quality}
+
+Table~\ref{tab:quality} and Figure~\ref{fig:quality} report WikiText-2
+perplexity for OLMoE-1B-7B against a bfloat16 reference of \nPPLfp.
+
+\paragraph{Both codec components are load-bearing.}
+At a fixed \nBitsOurs{} bits, removing block-LDL error feedback --- quantizing
+data-free against weight-space error --- moves perplexity from \nPPLOurs{} to
+\nPPLNoLdlq, a factor of ${\sim}300$. Removing incoherence processing while
+keeping error feedback gives \nPPLNoRht, a factor of ${\sim}14$. Neither
+component is optional at this rate, and error feedback matters more than
+rotation. This is consistent with the synthetic result of
+Section~\ref{sec:codec}: weight-space error is a poor proxy, and the methods
+that optimize the activation-weighted objective dominate.
+
+\paragraph{Frequency-conditioned allocation.}
+At an identical average rate of \nBitsFreq{} bits, allocating stages by measured
+expert popularity improves perplexity from \nPPLOurs{} to \nPPLFreq{} --- a
+$13.8\%$ reduction for no additional storage. Because the allocation is exactly
+rate-matched by construction, this is attributable to the distribution of bits
+across experts rather than to any change in budget. The systems benefit of
+Section~\ref{sec:alloc} --- smaller cold experts admitting more hot experts into
+cache --- is additional to this and not counted here.
+
+\paragraph{Vector quantization dominates scalar rounding.}
+Round-to-nearest with group-128 scales collapses below $3$ bits: \nPPLRtnTwo{}
+at \nBitsRtnTwo{} bits, versus \nPPLOursTwo{} for our codec at a \emph{lower}
+\nBitsOursTwo{} bits. RTN needs \nBitsRtnThree{} bits to reach \nPPLRtnThree,
+i.e.\ ${\sim}1.6\times$ the storage for comparable quality.
+
+\paragraph{The cost of going below two bits.}
+We state this plainly rather than burying it. At \nBitsOursTwo{} bits perplexity
+is \nPPLOursTwo{} ($1.5\times$ the bfloat16 reference), which we regard as a
+usable operating point. At \nBitsFreq{} bits it is \nPPLFreq{} ($2.7\times$),
+which is a substantial degradation, and at \nBitsOursOne{} bit the model
+effectively breaks down (\nPPLOursOne). OLMoE-1B-7B has only $1.3$\,B active
+parameters and is a hard case --- published sub-2-bit results are obtained on
+$70$\,B+ dense models with more elaborate codebooks, and quantization tolerance
+generally improves with scale --- but we have not verified that at 1T, and we
+therefore parameterize every systems result in Section~\ref{sec:projection} by
+rate rather than asserting a single operating point.
+
+\begin{table}[t]
+\centering\small
+\caption{WikiText-2 perplexity for OLMoE-1B-7B at matched average rates.}
+\label{tab:quality}
+\input{tab_quality}
+\end{table}
+
+\begin{figure}[t]
+\centering
+\includegraphics[width=0.55\textwidth]{figs/quality.pdf}
+\caption{Rate--perplexity for OLMoE-1B-7B. Each ablation removes one codec
+component at matched average rate.}
+\label{fig:quality}
+\end{figure}
+
+\subsection{Routing Statistics}\label{sec:routing}
+
+Figure~\ref{fig:cache}(a) shows measured expert popularity over
+\nTraceTokens{} tokens. The distribution is heavy-tailed and well described by a
+Zipf law with exponent $\nZipfSmeas$; the most-activated quartile of experts
+absorbs \nMassTopQ\% of activations. Consecutive tokens reuse \nReuseMean\% of
+their experts, so there is short-range temporal locality on top of the
+popularity skew. Distinct experts touched per layer grows sublinearly in batch
+size --- \nWorkSetOne{} at one token, \nWorkSetSixteen{} at $16$,
+\nWorkSetSixtyFour{} at $64$ of $64$ --- so batching amortizes fetches
+(Figure~\ref{fig:cache}c).
+
+\subsection{Cache Policy and the LRU Threshold}\label{sec:policy}
+
+Table~\ref{tab:policy} and Figure~\ref{fig:cache}(b) compare replacement
+policies over the true interleaved access order. The result is stark. Below the
+$\nTokenWS$-slot per-token working set ($\nTokenWSFrac\%$ of slots for this
+model), LRU achieves a hit rate of \emph{exactly zero} at every capacity tested
+--- $\nLruTwo\%$, $\nLruFive\%$, $\nLruTen\%$ at $2$, $5$ and $10\%$ capacity ---
+and jumps to $\nLruTwelve\%$ the moment capacity reaches $\nTokenWS$ slots. This
+is Eq.~\ref{eq:threshold} observed at precisely the predicted threshold, and it
+is a property of the access pattern, not of our implementation.
+
+Popularity-pinned caching has no such failure mode: it delivers
+$\nStaticTwo\%$, $\nStaticFive\%$ and $\nStaticTen\%$ at the same capacities
+where LRU delivers nothing, and its hit rate is by construction the popularity
+mass of the pinned set --- an analytic quantity we confirm against the trace to
+\nStaticMAE{} percentage points. Above the working set the ordering reverses and
+recency helps: LRU reaches $\nLruTwentyFive\%$ at $25\%$ capacity against
+$\nStaticTwentyFive\%$ static, and a hybrid that pins the hottest $75\%$ of
+capacity and runs LRU over the remainder is best of all at large capacity
+($\nHybridForty\%$ at $40\%$).
+
+Two conclusions follow. Operationally, popularity-pinned or hybrid placement
+should be preferred to pure LRU in offloaded MoE engines, which supports the
+allocation policy of Section~\ref{sec:alloc}: what matters is \emph{which}
+experts are resident, and popularity predicts that well. Methodologically, we
+project with the popularity-pinned model because it is exact given the
+popularity vector and therefore extrapolates without relying on recency
+structure we cannot verify at $E{=}320$. When the popularity vector is replaced
+by its Zipf fit the model becomes optimistic by \nZipfMAE{} points; we subtract
+that bias in all projections.
+
+\begin{table}[t]
+\centering\small
+\caption{Measured expert-cache hit rates on the OLMoE trace ($\nSlots$ slots,
+per-token working set $\nTokenWS$ slots). $^\dagger$ marks capacities below the
+working set, where recency-based replacement cannot hit at all. ``Analytic'' is
+the popularity-mass model used for extrapolation.}
+\label{tab:policy}
+\input{tab_policy}
+\end{table}
+
+\begin{figure}[t]
+\centering
+\includegraphics[width=\textwidth]{figs/cache.pdf}
+\caption{(a) Measured expert popularity per layer with Zipf fit. (b) Hit rate
+versus cache capacity for LRU, popularity pinning and the analytic model; the
+vertical line marks the per-token working set. (c) Distinct experts per layer
+versus batch size.}
+\label{fig:cache}
+\end{figure}
+
+\subsection{Projection to T1}\label{sec:projection}
+
+Table~\ref{tab:amp} instantiates Eq.~\ref{eq:frac} on the host. At bfloat16, T1
+occupies \nFootprintFP\,GB --- it does not fit the machine's storage at all ---
+and $24$\,GB of DRAM would hold \nSlotsFP{} expert slots, \emph{below} the
+$512$-slot per-token working set, so recency-based caching would be inoperative.
+At $1.5$ bits the model occupies \nFootprintOnePFive\,GB, fitting the $294$\,GB
+of free NVMe, and DRAM holds \nCacheExperts{} slots ($\nCacheFrac\%$),
+comfortably above the working set.
+
+\begin{table}[t]
+\centering\small
+\caption{Footprint and DRAM residency for T1 ($\nTotalParams$\,B) with a
+$24$\,GB expert cache on the measured host.}
+\label{tab:amp}
+\input{tab_amp}
+\end{table}
+
+Composing measured bandwidths with the calibrated cache model gives
+Table~\ref{tab:proj}. At $1.5$ bits and batch~1 the projection is
+\nTokSecOne{} tokens/s, fetching \nMBperTok\,MB per token at
+\nIOatExpert\,GB/s; batch~32 reaches \nTokSecBatch{} tokens/s. At $1.0$ bit the
+figures are \nTokSecOneBit{} and \nTokSecOneBitBatch{} tokens/s. The bfloat16
+row projects \nTokSecFP{} tokens/s, so the $10.7\times$ compression to $1.5$
+bits yields a $\nSpeedupOverFP\times$ throughput gain --- $\nAmpFactor\times$
+more than compression alone, which is the amplification of
+Eq.~\ref{eq:amp} made concrete.
+
+Because the hit rate is the least certain input, Figure~\ref{fig:throughput}(a)
+reports throughput across its entire range rather than at a single assumed
+value. The qualitative conclusion is robust: even at $h=0$ the projection stays
+near one token per second, because $Lk B(r)$ at $1.5$ bits is $4.8$\,GB and the
+device delivers ${\sim}\nIOatExpert$\,GB/s.
+
+\begin{table}[t]
+\centering\small
+\caption{Projected T1 decode throughput. Hardware terms measured; hit rate from
+the calibrated popularity-pinned model with the Zipf bias subtracted.}
+\label{tab:proj}
+\input{tab_proj}
+\end{table}
+
+\begin{figure}[t]
+\centering
+\includegraphics[width=\textwidth]{figs/throughput.pdf}
+\caption{(a) Sensitivity of projected batch-1 throughput to expert-cache hit
+rate at $1.5$ bits. (b) Projected throughput versus weight rate and batch size.}
+\label{fig:throughput}
+\end{figure}
+
+\begin{figure}[t]
+\centering
+\includegraphics[width=\textwidth]{figs/amplification.pdf}
+\caption{(a) T1 footprint versus weight rate against the host's storage and DRAM
+limits. (b) Fraction of expert slots resident in $24$\,GB of DRAM.}
+\label{fig:amp}
+\end{figure}
+
+\subsection{A Constraint on the Decode Path}\label{sec:decode}
+
+The projections assume dequantization keeps up with storage. In a
+straightforward implementation it does not, and the gap is instructive.
+
+Our PyTorch-level decode path --- \texttt{index\_select} gathers per residual
+stage into a preallocated accumulator, int32 indices to avoid int64 promotion
+--- sustains \nDecodeGw{} Gweight/s at $1.5$ bits, or \nDecodePacked\,GB/s of
+packed input, against a storage stream of \nIOatExpert\,GB/s: short by roughly
+$\nDecodeGap\times$.
+
+The reason is bandwidth, not arithmetic. Reconstructing $1.5$-bit weights into
+fp16 expands them $10.7\times$, so sustaining \nIOatExpert\,GB/s of packed
+weights means writing ${\sim}\nFusedBw$\,GB/s of fp16 into VRAM and reading it
+back for the GEMM, against $88.2$\,GB/s measured. \emph{Materializing
+dequantized weights is infeasible on this class of GPU by roughly
+$\nFusedRatio\times$ in bandwidth alone}, however well the gather is written.
+Dequantization must be fused into the GEMM prologue so codebook indices expand
+in registers or shared memory and fp16 weights never reach VRAM --- the design
+QuIP\# and QTIP adopt for their inference kernels. Our measurement quantifies
+why it is not optional at this scale. We did not implement a fused kernel; the
+projections in Section~\ref{sec:projection} are I/O rooflines and should be read
+as upper bounds contingent on such a kernel existing.
+
+\section{Discussion and Limitations}\label{sec:limits}
+
+\paragraph{What we did not do.}
+We did not execute a trillion-parameter model. No $1$\,T checkpoint was
+downloaded, quantized or run. T1 is a specified configuration and the throughput
+figures are analytical compositions of measured host parameters with a modelled
+cache term. They are not benchmark results and should not be cited as such.
+
+\paragraph{Extrapolation risk.}
+The cache model is validated at $E{=}64$, $L{=}16$ and applied at $E{=}320$,
+$L{=}64$, assuming the Zipf exponent of expert popularity is scale-invariant.
+This is the weakest link. It is plausible --- load-balancing auxiliary losses
+push MoE routers toward similar popularity profiles --- but we have not tested
+it on a model with $E>64$. If the distribution flattens with $E$, hit rates fall
+and throughput moves down Figure~\ref{fig:throughput}(a). We report the full
+sensitivity curve precisely because we cannot foreclose this. We also assume the
+per-token working set scales as $kL$, which follows from the architecture rather
+than from measurement.
+
+\paragraph{Quality at 1T scale.}
+Our perplexity results are for a $6.9$\,B model with $1.3$\,B active parameters,
+and the degradation at \nBitsFreq{} bits ($\nPPLfp\rightarrow\nPPLFreq$) is
+real. Larger models are generally more quantization-tolerant at fixed rate, so
+sub-2-bit operation should be more forgiving at $1$\,T, but we have not verified
+this and it should not be assumed. A reader who regards \nBitsFreq{} bits as too
+lossy should read the \nBitsOursTwo-bit row of Table~\ref{tab:proj}
+(\nTokSecTwoBit{} tokens/s at batch~1), which still fits the machine's storage
+and still crosses the working-set threshold; the qualitative argument does not
+depend on the most aggressive rate.
+
+\paragraph{Unmodelled costs.}
+The roofline omits KV-cache growth with context length, router computation,
+prefill, filesystem and allocator overhead, and thermal throttling under
+sustained load. Each pushes achieved throughput below the projection. Sustained
+SSD streaming also carries a substantial per-token energy cost --- reported at
+up to ${\sim}12\times$ an HBM baseline --- which matters for a battery-powered
+device and which we did not measure.
+
+\section{Conclusion}
+
+Quantization's role in offloaded mixture-of-experts inference is better
+understood as cache amplification than as footprint reduction. Because a token
+touches $kL$ distinct expert slots before reusing any, recency-based expert
+caches have a hard threshold below which they cannot hit at all --- which we
+measure exactly --- and because resident capacity is inversely proportional to
+the weight rate, quantization is what carries a system across it. On our host
+the $10.7\times$ compression from bfloat16 to $1.5$ bits yields a
+$\nSpeedupOverFP\times$ projected throughput gain, $\nAmpFactor\times$ more than
+compression alone. The reframing has a design consequence: bits should be
+allocated across experts by activation frequency, improving distortion and cache
+residency together, and placement should be popularity-pinned rather than purely
+recency-based.
+
+Instantiated on one commodity laptop with measured storage, PCIe and GPU limits
+and a cache model calibrated against real routing traces, a
+$\nTotalParams$\,B-parameter MoE fits in \nFootprintOnePFive\,GB at $1.5$ bits
+and projects \nTokSecOne--\nTokSecBatch{} tokens/s depending on batch size. The
+binding engineering constraint is not storage but the dequantization path: fp16
+materialization exceeds the device's memory bandwidth, so fusion into the GEMM
+is mandatory. Whether a trillion-parameter model actually runs on a laptop is
+not settled here --- but the storage and bandwidth budgets close, and the kernel
+that has to be written to find out is named.
+
+\paragraph{Reproducibility.}
+All measurement and quantization code, the raw routing traces, and the JSON
+artefacts from which every number in this paper is generated are released with
+the paper. Numbers in the text are injected programmatically from those
+artefacts.
+
+\begin{thebibliography}{99}\small
+
+\bibitem{gptq} E.~Frantar, S.~Ashkboos, T.~Hoefler, D.~Alistarh.
+GPTQ: Accurate Post-Training Quantization for Generative Pre-trained
+Transformers. \emph{ICLR}, 2023.
+
+\bibitem{awq} J.~Lin, J.~Tang, H.~Tang, S.~Yang, X.~Dang, S.~Han.
+AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration.
+\emph{MLSys}, 2024.
+
+\bibitem{quip} J.~Chee, Y.~Cai, V.~Kuleshov, C.~De~Sa.
+QuIP: 2-Bit Quantization of Large Language Models With Guarantees.
+\emph{NeurIPS}, 2023.
+
+\bibitem{quipsharp} A.~Tseng, J.~Chee, Q.~Sun, V.~Kuleshov, C.~De~Sa.
+QuIP\#: Even Better LLM Quantization with Hadamard Incoherence and Lattice
+Codebooks. \emph{ICML}, 2024.
+
+\bibitem{aqlm} V.~Egiazarian, A.~Panferov, D.~Kuznedelev, E.~Frantar,
+A.~Babenko, D.~Alistarh. Extreme Compression of Large Language Models via
+Additive Quantization. \emph{ICML}, 2024.
+
+\bibitem{qtip} A.~Tseng, Q.~Sun, D.~Hou, C.~De~Sa.
+QTIP: Quantization with Trellises and Incoherence Processing.
+\emph{NeurIPS}, 2024.
+
+\bibitem{vptq} Y.~Liu et al. VPTQ: Extreme Low-bit Vector Post-Training
+Quantization for Large Language Models. \emph{EMNLP}, 2024.
+
+\bibitem{bitnet} S.~Ma, H.~Wang, L.~Ma, L.~Wang, W.~Wang, S.~Huang, L.~Dong,
+R.~Wang, J.~Xue, F.~Wei. The Era of 1-bit LLMs: All Large Language Models are in
+1.58 Bits. \emph{arXiv:2402.17764}, 2024.
+
+\bibitem{flexgen} Y.~Sheng, L.~Zheng, B.~Yuan, Z.~Li, M.~Ryabinin, D.~Fu,
+Z.~Xie, B.~Chen, C.~Barrett, J.~Gonzalez, P.~Liang, C.~R\'e, I.~Stoica, C.~Zhang.
+FlexGen: High-Throughput Generative Inference of Large Language Models with a
+Single GPU. \emph{ICML}, 2023.
+
+\bibitem{flash} K.~Alizadeh, I.~Mirzadeh, D.~Belenko, K.~Khatamifard, M.~Cho,
+C.~C.~Del~Mundo, M.~Rastegari, M.~Farajtabar. LLM in a Flash: Efficient Large
+Language Model Inference with Limited Memory. \emph{ACL}, 2024.
+
+\bibitem{powerinfer} Y.~Song, Z.~Mi, H.~Xie, H.~Chen.
+PowerInfer: Fast Large Language Model Serving with a Consumer-grade GPU.
+\emph{SOSP}, 2024.
+
+\bibitem{mixtraloffload} A.~Eliseev, D.~Mazur.
+Fast Inference of Mixture-of-Experts Language Models with Offloading.
+\emph{arXiv:2312.17238}, 2023.
+
+\bibitem{moeinfinity} L.~Xue, Y.~Fu, Z.~Lu, L.~Mai, M.~Marina.
+MoE-Infinity: Offloading-Efficient MoE Model Serving.
+\emph{arXiv:2401.14361}, 2024.
+
+\bibitem{flashmoe} FlashMoE: Reducing SSD I/O Bottlenecks via ML-Based Cache
+Replacement for Mixture-of-Experts Inference on Edge Devices.
+\emph{arXiv:2601.17063}, 2026.
+
+\bibitem{mobile} MoBiLE: Efficient Mixture-of-Experts Inference on Consumer GPU
+with Mixture of Big Little Experts. \emph{arXiv:2510.12357}, 2025.
+
+\bibitem{olmoe} N.~Muennighoff, L.~Soldaini, D.~Groeneveld, K.~Lo, J.~Morrison,
+S.~Min, W.~Shi, P.~Walsh, O.~Tafjord, N.~Lambert, Y.~Gu, S.~Arora, A.~Bhagia,
+D.~Schwenk, D.~Wadden, A.~Wettig, B.~Hui, T.~Dettmers, D.~Kiela, A.~Farhadi,
+N.~A.~Smith, P.~W.~Koh, A.~Singh, H.~Hajishirzi.
+OLMoE: Open Mixture-of-Experts Language Models. \emph{ICLR}, 2025.
+
+\bibitem{deepseek} DeepSeek-AI. DeepSeek-V3 Technical Report.
+\emph{arXiv:2412.19437}, 2024.
+
+\bibitem{switch} W.~Fedus, B.~Zoph, N.~Shazeer. Switch Transformers: Scaling to
+Trillion Parameter Models with Simple and Efficient Sparsity. \emph{JMLR}, 2022.
+
+\bibitem{che} H.~Che, Y.~Tung, Z.~Wang. Hierarchical Web Caching Systems:
+Modeling, Design and Experimental Results. \emph{IEEE JSAC}, 20(7), 2002.
+
+\bibitem{wikitext} S.~Merity, C.~Xiong, J.~Bradbury, R.~Socher.
+Pointer Sentinel Mixture Models. \emph{ICLR}, 2017.
+
+\end{thebibliography}
+
+\end{document}

paper/numbers.tex

@@ -0,0 +1,104 @@
+% auto-generated by code/gen_numbers.py -- do not edit
+\newcommand{\nActiveParams}{39.7}
+\newcommand{\nAmpFactor}{1.54}
+\newcommand{\nAmplification}{10.7}
+\newcommand{\nBitsFreq}{1.51}
+\newcommand{\nBitsNoLdlq}{1.51}
+\newcommand{\nBitsNoRht}{1.51}
+\newcommand{\nBitsOurs}{1.51}
+\newcommand{\nBitsOursOne}{1.01}
+\newcommand{\nBitsOursTwo}{2.01}
+\newcommand{\nBitsRtnThree}{3.25}
+\newcommand{\nBitsRtnTwo}{2.25}
+\newcommand{\nCacheExperts}{2,543}
+\newcommand{\nCacheExpertsFP}{238}
+\newcommand{\nCacheFrac}{12.42}
+\newcommand{\nCacheFracFP}{1.16}
+\newcommand{\nDecodeFpEquiv}{2.4}
+\newcommand{\nDecodeGap}{25}
+\newcommand{\nDecodeGw}{1.20}
+\newcommand{\nDecodePacked}{0.22}
+\newcommand{\nDistinctEight}{38.2}
+\newcommand{\nDistinctOne}{8.0}
+\newcommand{\nDistinctThirtyTwo}{58.3}
+\newcommand{\nExpertMB}{9.44}
+\newcommand{\nExpertMBfp}{100.7}
+\newcommand{\nExpertSlots}{20,480}
+\newcommand{\nFootprintFP}{2,092}
+\newcommand{\nFootprintOne}{131}
+\newcommand{\nFootprintOnePFive}{196}
+\newcommand{\nFootprintTwo}{261}
+\newcommand{\nFusedBw}{116}
+\newcommand{\nFusedRatio}{1.32}
+\newcommand{\nGPUName}{NVIDIA RTX A500 Laptop GPU}
+\newcommand{\nHitRate}{35.5}
+\newcommand{\nHitRateFP}{5.8}
+\newcommand{\nHybridFifteen}{24.9}
+\newcommand{\nHybridFive}{10.6}
+\newcommand{\nHybridForty}{67.3}
+\newcommand{\nHybridTen}{18.4}
+\newcommand{\nHybridTwelve}{21.9}
+\newcommand{\nHybridTwentyFive}{38.2}
+\newcommand{\nHybridTwo}{4.9}
+\newcommand{\nIOatExpert}{5.46}
+\newcommand{\nLruFifteen}{37.0}
+\newcommand{\nLruFive}{0.0}
+\newcommand{\nLruForty}{66.0}
+\newcommand{\nLruTen}{0.0}
+\newcommand{\nLruTwelve}{25.3}
+\newcommand{\nLruTwentyFive}{48.4}
+\newcommand{\nLruTwo}{0.0}
+\newcommand{\nMBperTok}{3,021}
+\newcommand{\nMassTopQ}{44.9}
+\newcommand{\nNumRuns}{8}
+\newcommand{\nPCIe}{6.11}
+\newcommand{\nPPLFreq}{22.02}
+\newcommand{\nPPLNoLdlq}{7,701.98}
+\newcommand{\nPPLNoRht}{352.10}
+\newcommand{\nPPLOurs}{25.54}
+\newcommand{\nPPLOursOne}{156.07}
+\newcommand{\nPPLOursTwo}{12.17}
+\newcommand{\nPPLRtnThree}{10.49}
+\newcommand{\nPPLRtnTwo}{22,793.90}
+\newcommand{\nPPLfp}{8.11}
+\newcommand{\nPeakTflops}{6.94}
+\newcommand{\nRamCopy}{12.9}
+\newcommand{\nRandBest}{6.01}
+\newcommand{\nRandBestBlock}{1}
+\newcommand{\nRandBestThreads}{4}
+\newcommand{\nRandOneThread}{2.81}
+\newcommand{\nRandSmall}{0.49}
+\newcommand{\nReqDecode}{5.46}
+\newcommand{\nResidentGB}{2.42}
+\newcommand{\nReuseMean}{37.0}
+\newcommand{\nSeqRead}{4.79}
+\newcommand{\nSlots}{1,024}
+\newcommand{\nSlotsFP}{238}
+\newcommand{\nSpeedupOverFP}{16.4}
+\newcommand{\nStaticFifteen}{31.0}
+\newcommand{\nStaticFive}{13.5}
+\newcommand{\nStaticForty}{62.4}
+\newcommand{\nStaticMAE}{0.00}
+\newcommand{\nStaticTen}{22.9}
+\newcommand{\nStaticTwelve}{27.1}
+\newcommand{\nStaticTwentyFive}{45.1}
+\newcommand{\nStaticTwo}{6.2}
+\newcommand{\nTokSecBatch}{3.08}
+\newcommand{\nTokSecEight}{2.17}
+\newcommand{\nTokSecFP}{0.11}
+\newcommand{\nTokSecOne}{1.81}
+\newcommand{\nTokSecOneBit}{3.21}
+\newcommand{\nTokSecOneBitBatch}{5.48}
+\newcommand{\nTokSecTwoBit}{1.22}
+\newcommand{\nTokenWS}{128}
+\newcommand{\nTokenWSFrac}{12.5}
+\newcommand{\nTotalParams}{1,045.8}
+\newcommand{\nTraceTokens}{49,152}
+\newcommand{\nWorkSetKilo}{63.2}
+\newcommand{\nWorkSetOne}{8.0}
+\newcommand{\nWorkSetSixteen}{42.1}
+\newcommand{\nWorkSetSixtyFour}{56.6}
+\newcommand{\nZipfBias}{6.84}
+\newcommand{\nZipfMAE}{6.84}
+\newcommand{\nZipfS}{0.65}
+\newcommand{\nZipfSmeas}{0.65}

paper/tab_amp.tex

@@ -0,0 +1,13 @@
+\begin{tabular}{rrrrrl}
+\toprule
+Rate & Footprint & Expert & Resident & Cache & Fits \\
+(bits) & (GB) & (MB) & slots & fraction & 294\,GB? \\
+\midrule
+16.0 & 2,092 & 100.66 & 238 & 1.16\% & \textbf{no} \\
+4.0 & 523 & 25.17 & 953 & 4.65\% & \textbf{no} \\
+3.0 & 392 & 18.87 & 1,271 & 6.21\% & \textbf{no} \\
+2.0 & 261 & 12.58 & 1,907 & 9.31\% & yes \\
+1.5 & 196 & 9.44 & 2,543 & 12.42\% & yes \\
+1.0 & 131 & 6.29 & 3,814 & 18.62\% & yes \\
+\bottomrule
+\end{tabular}

paper/tab_policy.tex

@@ -0,0 +1,15 @@
+\begin{tabular}{rrrrrr}
+\toprule
+Capacity & Slots & LRU & Static-freq. & Hybrid & Analytic \\
+\midrule
+2.0\%$^\dagger$ & 20 & 0.0\% & 6.2\% & 4.9\% & 6.2\% \\
+5.0\%$^\dagger$ & 51 & 0.0\% & 13.5\% & 10.6\% & 13.5\% \\
+10.0\%$^\dagger$ & 102 & 0.0\% & 22.9\% & 18.4\% & 22.9\% \\
+12.5\% & 128 & 25.3\% & 27.1\% & 21.9\% & 27.1\% \\
+15.0\% & 153 & 37.0\% & 31.0\% & 24.9\% & 31.0\% \\
+25.0\% & 256 & 48.4\% & 45.1\% & 38.2\% & 45.1\% \\
+40.0\% & 409 & 66.0\% & 62.4\% & 67.3\% & 62.4\% \\
+60.0\% & 614 & 83.6\% & 80.6\% & 84.7\% & 80.6\% \\
+80.0\% & 819 & 96.0\% & 93.9\% & 95.9\% & 93.9\% \\
+\bottomrule
+\end{tabular}

paper/tab_proj.tex

@@ -0,0 +1,14 @@
+\begin{tabular}{rrrrrrr}
+\toprule
+Rate & Cache & Recency & Hit & Fetch & \multicolumn{2}{c}{Tokens/s} \\
+\cmidrule(lr){6-7}
+(bits) & slots & viable? & rate & MB/token & batch 1 & batch 32 \\
+\midrule
+16.0 & 238 & \textbf{no} & 5.8\% & 47,050 & 0.11 & 0.19 \\
+4.0 & 953 & yes & 20.0\% & 9,991 & 0.52 & 0.89 \\
+3.0 & 1,271 & yes & 24.0\% & 7,120 & 0.73 & 1.24 \\
+2.0 & 1,907 & yes & 30.4\% & 4,348 & 1.22 & 2.09 \\
+1.5 & 2,543 & yes & 35.5\% & 3,021 & 1.81 & 3.08 \\
+1.0 & 3,814 & yes & 43.7\% & 1,759 & 3.21 & 5.48 \\
+\bottomrule
+\end{tabular}

paper/tab_quality.tex

@@ -0,0 +1,16 @@
+\begin{tabular}{llrr}
+\toprule
+Method & Note & Bits/weight & PPL $\downarrow$ \\
+\midrule
+bf16 (reference) & --- & 16.00 & 8.11 \\
+\midrule
+RTN uniform, group 128 & scalar baseline & 3.25 & 10.49 \\
+RTN uniform, group 128 & scalar baseline & 2.25 & 22793.90 \\
+RVQ, data-free & no LDLQ & 1.51 & 7701.98 \\
+RVQ + LDLQ, no rotation & no incoherence proc. & 1.51 & 352.10 \\
+RVQ + RHT + LDLQ (ours) &  & 1.01 & 156.07 \\
+RVQ + RHT + LDLQ (ours) &  & 1.51 & 25.54 \\
+RVQ + RHT + LDLQ (ours) &  & 2.01 & 12.17 \\
+\quad + frequency-cond. alloc. & rate-matched & 1.51 & 22.02 \\
+\bottomrule
+\end{tabular}

results/cache_policy.json

@@ -0,0 +1,96 @@
+{
+  "layers": 16,
+  "experts": 64,
+  "topk": 8,
+  "tokens": 49152,
+  "n_slots": 1024,
+  "token_working_set": 128,
+  "zipf_s": 0.6527289058070496,
+  "ws_frac": 0.125,
+  "policies": [
+    {
+      "frac": 0.02,
+      "cap": 20,
+      "lru": 0.0,
+      "static": 0.06245549519856771,
+      "hybrid": 0.0494688351949056,
+      "analytic_static": 0.062455495198567704,
+      "analytic_zipf": 0.11694738567082635
+    },
+    {
+      "frac": 0.05,
+      "cap": 51,
+      "lru": 0.0,
+      "static": 0.13478676478068033,
+      "hybrid": 0.10638793309529622,
+      "analytic_static": 0.13478676478068036,
+      "analytic_zipf": 0.2219950885845816
+    },
+    {
+      "frac": 0.1,
+      "cap": 102,
+      "lru": 0.0,
+      "static": 0.228851318359375,
+      "hybrid": 0.183563232421875,
+      "analytic_static": 0.228851318359375,
+      "analytic_zipf": 0.3324114679054415
+    },
+    {
+      "frac": 0.125,
+      "cap": 128,
+      "lru": 0.25345611572265625,
+      "static": 0.2711273829142253,
+      "hybrid": 0.2186457316080729,
+      "analytic_static": 0.2711273829142252,
+      "analytic_zipf": 0.3760863959531343
+    },
+    {
+      "frac": 0.15,
+      "cap": 153,
+      "lru": 0.3698643048604329,
+      "static": 0.3095962206522624,
+      "hybrid": 0.24870061874389648,
+      "analytic_static": 0.30959622065226233,
+      "analytic_zipf": 0.4127589521127012
+    },
+    {
+      "frac": 0.25,
+      "cap": 256,
+      "lru": 0.4839518864949544,
+      "static": 0.45073652267456055,
+      "hybrid": 0.3817426363627116,
+      "analytic_static": 0.45073652267456055,
+      "analytic_zipf": 0.5342836357250341
+    },
+    {
+      "frac": 0.4,
+      "cap": 409,
+      "lru": 0.6604461669921875,
+      "static": 0.6235604286193848,
+      "hybrid": 0.6733926137288412,
+      "analytic_static": 0.6235604286193848,
+      "analytic_zipf": 0.6665664373136196
+    },
+    {
+      "frac": 0.6,
+      "cap": 614,
+      "lru": 0.8356102307637533,
+      "static": 0.806199868520101,
+      "hybrid": 0.8468090693155924,
+      "analytic_static": 0.8061998685201008,
+      "analytic_zipf": 0.8008694898685313
+    },
+    {
+      "frac": 0.8,
+      "cap": 819,
+      "lru": 0.9596964518229166,
+      "static": 0.9390878677368164,
+      "hybrid": 0.9588371912638346,
+      "analytic_static": 0.9390878677368164,
+      "analytic_zipf": 0.9085847385781042
+    }
+  ],
+  "mae_analytic_static": 2.852656382717416e-17,
+  "mae_analytic_zipf": 0.06841874865295161,
+  "best_gain_hybrid": 0.183563232421875
+}

results/cache_validation.json

@@ -0,0 +1,164 @@
+{
+  "layers": 16,
+  "experts": 64,
+  "topk": 8,
+  "tokens": 49152,
+  "zipf_s": 0.6527289058070496,
+  "zipf_s_per_layer": [
+    0.5168399731353996,
+    0.45216287722374227,
+    0.611280793656683,
+    0.5906835171510877,
+    0.7793981775030502,
+    0.6480099103325739,
+    0.8399621101649059,
+    0.7226159598776765,
+    0.6574479012815251,
+    0.6178199900164697,
+    0.5407503482861278,
+    0.7115751165458343,
+    0.6219601450559994,
+    0.7641232197074124,
+    0.7869316757535504,
+    0.8445318723149822
+  ],
+  "hit_rates": [
+    {
+      "frac": 0.02,
+      "cap": 20,
+      "measured": 0.0,
+      "static": 0.06245549519856771,
+      "che_measured_pop": 0.026580850797751226,
+      "che_zipf": 0.03699199460718677
+    },
+    {
+      "frac": 0.05,
+      "cap": 51,
+      "measured": 0.0,
+      "static": 0.13478676478068033,
+      "che_measured_pop": 0.0673864982202855,
+      "che_zipf": 0.09189351727660205
+    },
+    {
+      "frac": 0.1,
+      "cap": 102,
+      "measured": 0.0,
+      "static": 0.228851318359375,
+      "che_measured_pop": 0.13345774419413597,
+      "che_zipf": 0.1760246570537025
+    },
+    {
+      "frac": 0.15,
+      "cap": 153,
+      "measured": 0.3698643048604329,
+      "static": 0.3095962206522624,
+      "che_measured_pop": 0.1981815435699793,
+      "che_zipf": 0.25295360799759015
+    },
+    {
+      "frac": 0.25,
+      "cap": 256,
+      "measured": 0.4839518864949544,
+      "static": 0.45073652267456055,
+      "che_measured_pop": 0.3246471540752854,
+      "che_zipf": 0.38915048181000694
+    },
+    {
+      "frac": 0.4,
+      "cap": 409,
+      "measured": 0.6604461669921875,
+      "static": 0.6235604286193848,
+      "che_measured_pop": 0.5013942145993738,
+      "che_zipf": 0.5550206500765682
+    },
+    {
+      "frac": 0.6,
+      "cap": 614,
+      "measured": 0.8356102307637533,
+      "static": 0.806199868520101,
+      "che_measured_pop": 0.7149889036966475,
+      "che_zipf": 0.7333943331893689
+    },
+    {
+      "frac": 0.8,
+      "cap": 819,
+      "measured": 0.9596964518229166,
+      "static": 0.9390878677368164,
+      "che_measured_pop": 0.8950458315684564,
+      "che_zipf": 0.8798901406977873
+    }
+  ],
+  "che_mae": 0.11284206082958438,
+  "che_zipf_mae": 0.10050874951255183,
+  "distinct_per_batch": [
+    {
+      "batch": 1,
+      "measured": 8.0,
+      "irm_measured_pop": 7.565598081578889,
+      "irm_zipf": 7.244434802265509
+    },
+    {
+      "batch": 2,
+      "measured": 14.635,
+      "irm_measured_pop": 14.21605904627252,
+      "irm_zipf": 13.146814196509677
+    },
+    {
+      "batch": 4,
+      "measured": 24.785,
+      "irm_measured_pop": 25.20959290631525,
+      "irm_zipf": 22.39747563960906
+    },
+    {
+      "batch": 8,
+      "measured": 38.245,
+      "irm_measured_pop": 40.331336428136424,
+      "irm_zipf": 35.00525487643894
+    },
+    {
+      "batch": 16,
+      "measured": 50.145,
+      "irm_measured_pop": 55.00905829801991,
+      "irm_zipf": 48.80265749792019
+    },
+    {
+      "batch": 32,
+      "measured": 58.33,
+      "irm_measured_pop": 62.59406412137466,
+      "irm_zipf": 59.23503640459326
+    },
+    {
+      "batch": 64,
+      "measured": 61.625,
+      "irm_measured_pop": 63.953407955543796,
+      "irm_zipf": 63.42120139668306
+    }
+  ],
+  "reuse_prev_token": [
+    0.2499567658847226,
+    0.2796840349128197,
+    0.3672738092816016,
+    0.3708393522003621,
+    0.44042084596447684,
+    0.4547211653882932,
+    0.46631045146589084,
+    0.4375648511729161,
+    0.3781764358812639,
+    0.3395353095562654,
+    0.31294632866065797,
+    0.36515025126650524,
+    0.3588685886350227,
+    0.38883491688877136,
+    0.34283127505035504,
+    0.36325557974405404
+  ],
+  "working_set": {
+    "1": 8.0,
+    "4": 21.099609375,
+    "16": 42.0537109375,
+    "64": 56.6220703125,
+    "256": 61.19140625,
+    "1024": 63.161458333333336
+  },
+  "mass_top25pct": 0.4494392077128093
+}

results/decode_bench.json

@@ -0,0 +1,45 @@
+{
+  "decode": [
+    {
+      "stages": 2,
+      "bits": 1.0,
+      "weights_per_s": 1817943193.799809,
+      "fp16_equiv_GBs": 3.635886387599618,
+      "packed_GBs": 0.22724289922497612
+    },
+    {
+      "stages": 3,
+      "bits": 1.5,
+      "weights_per_s": 1198775873.844113,
+      "fp16_equiv_GBs": 2.3975517476882264,
+      "packed_GBs": 0.22477047634577121
+    },
+    {
+      "stages": 4,
+      "bits": 2.0,
+      "weights_per_s": 863031951.5133244,
+      "fp16_equiv_GBs": 1.7260639030266487,
+      "packed_GBs": 0.2157579878783311
+    }
+  ],
+  "hadamard_us": {
+    "2048": 1603.822000324726,
+    "4096": 1567.6909999456257,
+    "8192": 1929.9134996253997
+  },
+  "matmul": {
+    "1x8192x2048": {
+      "tflops": 0.08747153860226937,
+      "ms": 0.38360399892553687
+    },
+    "32x8192x2048": {
+      "tflops": 2.891719779463005,
+      "ms": 0.37131600081920624
+    },
+    "2048x8192x2048": {
+      "tflops": 6.941912431603671,
+      "ms": 9.899214000906795
+    }
+  },
+  "gpu": "NVIDIA RTX A500 Laptop GPU"
+}

results/fp16_ppl.json

@@ -0,0 +1,5 @@
+{
+  "ppl": 8.107172012329102,
+  "seqlen": 2048,
+  "limit": 20
+}

results/io_bench.json

@@ -0,0 +1,153 @@
+{
+  "file_gb": 8,
+  "random": [
+    {
+      "block_kb": 64,
+      "threads": 1,
+      "mb_s": 494.9510341759896,
+      "iops": 7552.353426757654,
+      "lat_ms": 0.13240905761335853
+    },
+    {
+      "block_kb": 64,
+      "threads": 2,
+      "mb_s": 980.044654849359,
+      "iops": 14954.294660176985,
+      "lat_ms": 0.13374084471706738
+    },
+    {
+      "block_kb": 64,
+      "threads": 4,
+      "mb_s": 1748.0921417310979,
+      "iops": 26673.769252488677,
+      "lat_ms": 0.14996005859302386
+    },
+    {
+      "block_kb": 64,
+      "threads": 8,
+      "mb_s": 2852.569135318681,
+      "iops": 43526.750722025776,
+      "lat_ms": 0.18379501955223532
+    },
+    {
+      "block_kb": 256,
+      "threads": 1,
+      "mb_s": 1547.8506430620785,
+      "iops": 5904.581615684809,
+      "lat_ms": 0.16936000974965282
+    },
+    {
+      "block_kb": 256,
+      "threads": 2,
+      "mb_s": 2876.0505176667384,
+      "iops": 10971.262045542673,
+      "lat_ms": 0.18229443355721742
+    },
+    {
+      "block_kb": 256,
+      "threads": 4,
+      "mb_s": 4576.405233664012,
+      "iops": 17457.600531250046,
+      "lat_ms": 0.22912656254447938
+    },
+    {
+      "block_kb": 256,
+      "threads": 8,
+      "mb_s": 5370.6425547877725,
+      "iops": 20487.37546839818,
+      "lat_ms": 0.3904843747477571
+    },
+    {
+      "block_kb": 1024,
+      "threads": 1,
+      "mb_s": 2805.1044913303567,
+      "iops": 2675.1561082175795,
+      "lat_ms": 0.37380996081992635
+    },
+    {
+      "block_kb": 1024,
+      "threads": 2,
+      "mb_s": 5384.820501499133,
+      "iops": 5135.365010737546,
+      "lat_ms": 0.3894562501045584
+    },
+    {
+      "block_kb": 1024,
+      "threads": 4,
+      "mb_s": 6007.7807939759905,
+      "iops": 5729.46624181365,
+      "lat_ms": 0.6981453125263215
+    },
+    {
+      "block_kb": 1024,
+      "threads": 8,
+      "mb_s": 5833.036315730558,
+      "iops": 5562.816920977171,
+      "lat_ms": 1.4381203109223861
+    },
+    {
+      "block_kb": 4096,
+      "threads": 1,
+      "mb_s": 4233.817423838591,
+      "iops": 1009.4207343670346,
+      "lat_ms": 0.9906671875796746
+    },
+    {
+      "block_kb": 4096,
+      "threads": 2,
+      "mb_s": 5842.093998027338,
+      "iops": 1392.8637499874444,
+      "lat_ms": 1.4358906246343395
+    },
+    {
+      "block_kb": 4096,
+      "threads": 4,
+      "mb_s": 5842.545391522159,
+      "iops": 1392.9713705830952,
+      "lat_ms": 2.871559376217192
+    },
+    {
+      "block_kb": 4096,
+      "threads": 8,
+      "mb_s": 5580.8599282872,
+      "iops": 1330.5806942670822,
+      "lat_ms": 6.012412501149811
+    },
+    {
+      "block_kb": 16384,
+      "threads": 1,
+      "mb_s": 4158.337625827989,
+      "iops": 247.85623704361848,
+      "lat_ms": 4.0345968773181085
+    },
+    {
+      "block_kb": 16384,
+      "threads": 2,
+      "mb_s": 5578.186766517397,
+      "iops": 332.4858407090543,
+      "lat_ms": 6.015293751261197
+    },
+    {
+      "block_kb": 16384,
+      "threads": 4,
+      "mb_s": 5183.172285271779,
+      "iops": 308.94114287327403,
+      "lat_ms": 12.947449999046512
+    },
+    {
+      "block_kb": 16384,
+      "threads": 8,
+      "mb_s": 4622.515008682658,
+      "iops": 275.52336506144155,
+      "lat_ms": 29.03565001906827
+    }
+  ],
+  "host": {
+    "seq_read_mb_s": 4790.751643316461,
+    "ram_copy_GBs": 12.893710872298776,
+    "h2d_1MB_GBs": 6.036089340643436,
+    "h2d_4MB_GBs": 6.090728427703106,
+    "h2d_16MB_GBs": 6.111264413438207,
+    "h2d_64MB_GBs": 6.112899630205483
+  }
+}

results/projection.json

@@ -0,0 +1,641 @@
+{
+  "config": {
+    "name": "T1-1046B",
+    "layers": 64,
+    "d_model": 8192,
+    "n_experts": 320,
+    "topk": 8,
+    "d_ff_expert": 2048,
+    "n_shared": 1,
+    "kv_dim": 1024,
+    "vocab": 129280
+  },
+  "params": {
+    "total": 1045795176448.0,
+    "active": 39713767424.0,
+    "expert": 50331648.0,
+    "attn_total": 9663676416.0,
+    "shared_total": 3221225472.0,
+    "routed_total": 1030792151040.0,
+    "n_slots": 20480.0
+  },
+  "amplification": [
+    {
+      "bits": 16,
+      "model_gb": 2091.590352896,
+      "expert_mb": 100.663296,
+      "dram_experts": 238,
+      "frac": 0.01162109375
+    },
+    {
+      "bits": 4,
+      "model_gb": 522.897588224,
+      "expert_mb": 25.165824,
+      "dram_experts": 953,
+      "frac": 0.046533203125
+    },
+    {
+      "bits": 3,
+      "model_gb": 392.173191168,
+      "expert_mb": 18.874368,
+      "dram_experts": 1271,
+      "frac": 0.062060546875
+    },
+    {
+      "bits": 2,
+      "model_gb": 261.448794112,
+      "expert_mb": 12.582912,
+      "dram_experts": 1907,
+      "frac": 0.093115234375
+    },
+    {
+      "bits": 1.5,
+      "model_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_experts": 2543,
+      "frac": 0.124169921875
+    },
+    {
+      "bits": 1.0,
+      "model_gb": 130.724397056,
+      "expert_mb": 6.291456,
+      "dram_experts": 3814,
+      "frac": 0.18623046875
+    }
+  ],
+  "zipf_s": 0.6527289058070496,
+  "zipf_bias_pp": 6.841874865295161,
+  "token_working_set": 512,
+  "projection": [
+    {
+      "rate_bits": 1.0,
+      "hit_rate": 0.4367962797108301,
+      "batch": 1,
+      "total_gb": 130.724397056,
+      "expert_mb": 6.291456,
+      "dram_slots": 3814,
+      "vram_slots": 284,
+      "cache_frac": 0.18623046875,
+      "resident_gb": 1.610612736,
+      "io_bw_gbs": 5.649691120951909,
+      "bytes_per_token_mb": 1759.091443393542,
+      "tok_s": 3.2117097392349523,
+      "cap_slots": 3814,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 1.0,
+      "hit_rate": 0.4367962797108301,
+      "batch": 8,
+      "total_gb": 130.724397056,
+      "expert_mb": 6.291456,
+      "dram_slots": 3814,
+      "vram_slots": 284,
+      "cache_frac": 0.18623046875,
+      "resident_gb": 1.610612736,
+      "io_bw_gbs": 5.649691120951909,
+      "bytes_per_token_mb": 1467.4761276341483,
+      "tok_s": 3.8499373274714115,
+      "cap_slots": 3814,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 1.0,
+      "hit_rate": 0.4367962797108301,
+      "batch": 32,
+      "total_gb": 130.724397056,
+      "expert_mb": 6.291456,
+      "dram_slots": 3814,
+      "vram_slots": 284,
+      "cache_frac": 0.18623046875,
+      "resident_gb": 1.610612736,
+      "io_bw_gbs": 5.649691120951909,
+      "bytes_per_token_mb": 1030.5399589031413,
+      "tok_s": 5.482263033221125,
+      "cap_slots": 3814,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.35517904351866053,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 3021.0179359737863,
+      "tok_s": 1.8062907821243104,
+      "cap_slots": 2543,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.35517904351866053,
+      "batch": 8,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 2520.2053701334007,
+      "tok_s": 2.1652349903900157,
+      "cap_slots": 2543,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.35517904351866053,
+      "batch": 32,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 1769.8225474726378,
+      "tok_s": 3.0832677875949734,
+      "cap_slots": 2543,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 2.0,
+      "hit_rate": 0.30395889352693944,
+      "batch": 1,
+      "total_gb": 261.448794112,
+      "expert_mb": 12.582912,
+      "dram_slots": 1907,
+      "vram_slots": 14,
+      "cache_frac": 0.093115234375,
+      "resident_gb": 3.221225472,
+      "io_bw_gbs": 5.320004567826719,
+      "bytes_per_token_mb": 4347.982481430631,
+      "tok_s": 1.2235570383614471,
+      "cap_slots": 1907,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 2.0,
+      "hit_rate": 0.30395889352693944,
+      "batch": 8,
+      "total_gb": 261.448794112,
+      "expert_mb": 12.582912,
+      "dram_slots": 1907,
+      "vram_slots": 14,
+      "cache_frac": 0.093115234375,
+      "resident_gb": 3.221225472,
+      "io_bw_gbs": 5.320004567826719,
+      "bytes_per_token_mb": 3627.1909108726686,
+      "tok_s": 1.4667010087282046,
+      "cap_slots": 1907,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 2.0,
+      "hit_rate": 0.30395889352693944,
+      "batch": 32,
+      "total_gb": 261.448794112,
+      "expert_mb": 12.582912,
+      "dram_slots": 1907,
+      "vram_slots": 14,
+      "cache_frac": 0.093115234375,
+      "resident_gb": 3.221225472,
+      "io_bw_gbs": 5.320004567826719,
+      "bytes_per_token_mb": 2547.2068007340467,
+      "tok_s": 2.088564056241376,
+      "cap_slots": 1907,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 3.0,
+      "hit_rate": 0.2401688791612775,
+      "batch": 1,
+      "total_gb": 392.173191168,
+      "expert_mb": 18.874368,
+      "dram_slots": 1271,
+      "vram_slots": 0,
+      "cache_frac": 0.062060546875,
+      "resident_gb": 4.831838208,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 7119.69243955946,
+      "tok_s": 0.7280050829825586,
+      "cap_slots": 1271,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 3.0,
+      "hit_rate": 0.2401688791612775,
+      "batch": 8,
+      "total_gb": 392.173191168,
+      "expert_mb": 18.874368,
+      "dram_slots": 1271,
+      "vram_slots": 0,
+      "cache_frac": 0.062060546875,
+      "resident_gb": 4.831838208,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 5939.417606963728,
+      "tok_s": 0.8726734889283956,
+      "cap_slots": 1271,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 3.0,
+      "hit_rate": 0.2401688791612775,
+      "batch": 32,
+      "total_gb": 392.173191168,
+      "expert_mb": 18.874368,
+      "dram_slots": 1271,
+      "vram_slots": 0,
+      "cache_frac": 0.062060546875,
+      "resident_gb": 4.831838208,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 4170.975637237044,
+      "tok_s": 1.2426762311911366,
+      "cap_slots": 1271,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 4.0,
+      "hit_rate": 0.20026908899632856,
+      "batch": 1,
+      "total_gb": 522.897588224,
+      "expert_mb": 25.165824,
+      "dram_slots": 953,
+      "vram_slots": 0,
+      "cache_frac": 0.046533203125,
+      "resident_gb": 6.442450944,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 9991.409870954525,
+      "tok_s": 0.5187628525118855,
+      "cap_slots": 953,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 4.0,
+      "hit_rate": 0.20026908899632856,
+      "batch": 8,
+      "total_gb": 522.897588224,
+      "expert_mb": 25.165824,
+      "dram_slots": 953,
+      "vram_slots": 0,
+      "cache_frac": 0.046533203125,
+      "resident_gb": 6.442450944,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 8335.072927617983,
+      "tok_s": 0.6218508620479507,
+      "cap_slots": 953,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 4.0,
+      "hit_rate": 0.20026908899632856,
+      "batch": 32,
+      "total_gb": 522.897588224,
+      "expert_mb": 25.165824,
+      "dram_slots": 953,
+      "vram_slots": 0,
+      "cache_frac": 0.046533203125,
+      "resident_gb": 6.442450944,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 5853.332500972426,
+      "tok_s": 0.8855079195331359,
+      "cap_slots": 953,
+      "lru_viable": true
+    },
+    {
+      "rate_bits": 16.0,
+      "hit_rate": 0.05849908967870593,
+      "batch": 1,
+      "total_gb": 2091.590352896,
+      "expert_mb": 100.663296,
+      "dram_slots": 238,
+      "vram_slots": 0,
+      "cache_frac": 0.01162109375,
+      "resident_gb": 25.769803776,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 47050.43338685536,
+      "tok_s": 0.11016205191257217,
+      "cap_slots": 238,
+      "lru_viable": false
+    },
+    {
+      "rate_bits": 16.0,
+      "hit_rate": 0.05849908967870593,
+      "batch": 8,
+      "total_gb": 2091.590352896,
+      "expert_mb": 100.663296,
+      "dram_slots": 238,
+      "vram_slots": 0,
+      "cache_frac": 0.01162109375,
+      "resident_gb": 25.769803776,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 39250.596124128955,
+      "tok_s": 0.13205333923796053,
+      "cap_slots": 238,
+      "lru_viable": false
+    },
+    {
+      "rate_bits": 16.0,
+      "hit_rate": 0.05849908967870593,
+      "batch": 32,
+      "total_gb": 2091.590352896,
+      "expert_mb": 100.663296,
+      "dram_slots": 238,
+      "vram_slots": 0,
+      "cache_frac": 0.01162109375,
+      "resident_gb": 25.769803776,
+      "io_bw_gbs": 5.183172285271779,
+      "bytes_per_token_mb": 27563.86080494246,
+      "tok_s": 0.18804231823512865,
+      "cap_slots": 238,
+      "lru_viable": false
+    }
+  ],
+  "sensitivity_1p5bit": [
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.0,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 4685.049246009132,
+      "tok_s": 1.1647341498128245
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.05,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 4450.796783708675,
+      "tok_s": 1.2260359471713942
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.1,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 4216.544321408219,
+      "tok_s": 1.2941490553475827
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.15000000000000002,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 3982.291859107762,
+      "tok_s": 1.3702754703680289
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.2,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 3748.0393968073054,
+      "tok_s": 1.4559176872660304
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.25,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 3513.786934506849,
+      "tok_s": 1.5529788664170994
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.30000000000000004,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 3279.5344722063924,
+      "tok_s": 1.663905928304035
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.35000000000000003,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 3045.2820099059354,
+      "tok_s": 1.7918986920197302
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.4,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 2811.0295476054794,
+      "tok_s": 1.941223583021374
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.45,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 2576.7770853050224,
+      "tok_s": 2.1176984542051356
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.5,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 2342.524623004566,
+      "tok_s": 2.329468299625649
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.55,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 2108.272160704109,
+      "tok_s": 2.588298110695166
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.6000000000000001,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 1874.0196984036522,
+      "tok_s": 2.911835374532062
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.65,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 1639.7672361031962,
+      "tok_s": 3.32781185660807
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.7000000000000001,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 1405.5147738027392,
+      "tok_s": 3.8824471660427498
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.75,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 1171.262311502283,
+      "tok_s": 4.658936599251298
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.8,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 937.0098492018261,
+      "tok_s": 5.823670749064124
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.8500000000000001,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 702.7573869013694,
+      "tok_s": 7.7648943320855
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.9,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 468.50492460091306,
+      "tok_s": 11.647341498128249
+    },
+    {
+      "rate_bits": 1.5,
+      "hit_rate": 0.9500000000000001,
+      "batch": 1,
+      "total_gb": 196.086595584,
+      "expert_mb": 9.437184,
+      "dram_slots": 2543,
+      "vram_slots": 104,
+      "cache_frac": 0.124169921875,
+      "resident_gb": 2.415919104,
+      "io_bw_gbs": 5.45683685038166,
+      "bytes_per_token_mb": 234.25246230045627,
+      "tok_s": 23.29468299625652
+    }
+  ]
+}

results/quant_freq15.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 1.5103125,
+  "quantized_params": 6710886400,
+  "ppl": 22.018173217773438,
+  "config": {
+    "stages": 3,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": false,
+    "no_ldlq": false,
+    "alloc": "freq",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": null,
+    "fp16": false,
+    "tag": "freq15"
+  },
+  "ppl_secs": 36.206817388534546
+}

results/quant_main10.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125,
+    1.0103125
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 1.0103125,
+  "quantized_params": 6710886400,
+  "ppl": 156.0718231201172,
+  "config": {
+    "stages": 2,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": false,
+    "no_ldlq": false,
+    "alloc": "uniform",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": null,
+    "fp16": false,
+    "tag": "main10"
+  },
+  "ppl_secs": 36.35476326942444
+}

results/quant_main15.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 1.5103125,
+  "quantized_params": 6710886400,
+  "ppl": 25.54167938232422,
+  "config": {
+    "stages": 3,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": false,
+    "no_ldlq": false,
+    "alloc": "uniform",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": null,
+    "fp16": false,
+    "tag": "main15"
+  },
+  "ppl_secs": 37.337796211242676
+}

results/quant_main20.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125,
+    2.0103125
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 2.0103125,
+  "quantized_params": 6710886400,
+  "ppl": 12.165743827819824,
+  "config": {
+    "stages": 4,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": false,
+    "no_ldlq": false,
+    "alloc": "uniform",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": null,
+    "fp16": false,
+    "tag": "main20"
+  },
+  "ppl_secs": 36.14291453361511
+}

results/quant_noldlq15.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 1.5103125,
+  "quantized_params": 6710886400,
+  "ppl": 7701.97509765625,
+  "config": {
+    "stages": 3,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": false,
+    "no_ldlq": true,
+    "alloc": "uniform",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": null,
+    "fp16": false,
+    "tag": "noldlq15"
+  },
+  "ppl_secs": 36.23133039474487
+}

results/quant_northt15.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125,
+    1.5103125
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 1.5103125,
+  "quantized_params": 6710886400,
+  "ppl": 352.1000671386719,
+  "config": {
+    "stages": 3,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": true,
+    "no_ldlq": false,
+    "alloc": "uniform",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": null,
+    "fp16": false,
+    "tag": "northt15"
+  },
+  "ppl_secs": 36.26489615440369
+}

results/quant_rtn2.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25,
+    2.25
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 2.25,
+  "quantized_params": 6710886400,
+  "ppl": 22793.90234375,
+  "config": {
+    "stages": 3,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": false,
+    "no_ldlq": false,
+    "alloc": "uniform",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": 2,
+    "fp16": false,
+    "tag": "rtn2"
+  },
+  "ppl_secs": 35.358806133270264
+}

results/quant_rtn3.json

@@ -0,0 +1,73 @@
+{
+  "layers": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15
+  ],
+  "bits": [
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25,
+    3.25
+  ],
+  "params": [
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400,
+    419430400
+  ],
+  "avg_bits": 3.25,
+  "quantized_params": 6710886400,
+  "ppl": 10.492335319519043,
+  "config": {
+    "stages": 3,
+    "nsamples": 32,
+    "seqlen": 2048,
+    "no_rht": false,
+    "no_ldlq": false,
+    "alloc": "uniform",
+    "spread": 1,
+    "ppl_limit": 20,
+    "rtn": 3,
+    "fp16": false,
+    "tag": "rtn3"
+  },
+  "ppl_secs": 35.27370619773865
+}

results/routing_freq.json

@@ -0,0 +1 @@
+{"0": [0.010378519694010416, 0.008371988932291666, 0.009244283040364584, 0.017913818359375, 0.0103302001953125, 0.017911275227864582, 0.02248382568359375, 0.016405741373697918, 0.011789957682291666, 0.025960286458333332, 0.012369791666666666, 0.0136566162109375, 0.0322113037109375, 0.019254048665364582, 0.013170878092447916, 0.010434468587239584, 0.016161600748697918, 0.023462931315104168, 0.020952860514322918, 0.024920145670572918, 0.01148223876953125, 0.0019709269205729165, 0.02022552490234375, 0.004486083984375, 0.012613932291666666, 0.015462239583333334, 0.02184295654296875, 0.008997599283854166, 0.037732442220052086, 0.019683837890625, 0.014806111653645834, 0.010945638020833334, 0.0104217529296875, 0.013275146484375, 0.0030949910481770835, 0.00989532470703125, 0.00820159912109375, 0.010938008626302084, 0.017865498860677082, 0.01351165771484375, 0.0152587890625, 0.044888814290364586, 0.0119781494140625, 0.013567606608072916, 0.01532745361328125, 0.014673868815104166, 0.027715047200520832, 0.011296590169270834, 0.0115966796875, 0.014523824055989584, 0.010645548502604166, 0.022791544596354168, 0.004193623860677083, 0.02054595947265625, 0.027041117350260418, 0.01636505126953125, 0.009226481119791666, 0.025571187337239582, 0.019287109375, 0.0133819580078125, 0.016466776529947918, 0.015920003255208332, 0.009534200032552084, 0.00336456298828125], "1": [0.01065826416015625, 0.011322021484375, 0.011751810709635416, 0.011037190755208334, 0.01058197021484375, 0.05185699462890625, 0.0096282958984375, 0.012906392415364584, 0.01880645751953125, 0.018964131673177082, 0.007273356119791667, 0.0311126708984375, 0.016156514485677082, 0.0187530517578125, 0.015825907389322918, 0.01287078857421875, 0.0189666748046875, 0.013702392578125, 0.03275299072265625, 0.01349639892578125, 0.013516743977864584, 0.018946329752604168, 0.011202494303385416, 0.017613728841145832, 0.009351094563802084, 0.0015385945638020833, 0.011014302571614584, 0.019343058268229168, 0.0081634521484375, 0.018308003743489582, 0.011263529459635416, 0.01441192626953125, 0.020495096842447918, 0.009577433268229166, 0.009760538736979166, 0.020205179850260418, 0.009607950846354166, 0.02588653564453125, 0.010556538899739584, 0.0151214599609375, 0.019711812337239582, 0.01568603515625, 0.026606241861979168, 0.00888824462890625, 0.01317596435546875, 0.01776123046875, 0.0090789794921875, 0.028948465983072918, 0.0184478759765625, 0.01132965087890625, 0.01511383056640625, 0.015652974446614582, 0.013913472493489584, 0.021191914876302082, 0.01445770263671875, 0.01197052001953125, 0.00891876220703125, 0.011260986328125, 0.01146697998046875, 0.026392618815104168, 0.00675201416015625, 0.018475850423177082, 0.017779032389322918, 0.0127105712890625], "2": [0.009691874186197916, 0.0171661376953125, 0.008822123209635416, 0.0106353759765625, 0.0065460205078125, 0.0003153483072916667, 0.009450276692708334, 0.013033548990885416, 0.0020879109700520835, 0.03218841552734375, 0.049143473307291664, 0.010302225748697916, 0.011263529459635416, 0.010775248209635416, 0.021535237630208332, 0.01019287109375, 0.019915262858072918, 0.010617574055989584, 0.012163798014322916, 0.01507568359375, 0.015764872233072918, 0.015848795572916668, 0.01787567138671875, 0.015703837076822918, 0.010358174641927084, 0.018435160319010418, 0.017346700032552082, 0.01615142822265625, 0.021779378255208332, 0.022572835286458332, 0.008982340494791666, 0.009432474772135416, 0.016604105631510418, 0.013799031575520834, 0.020334879557291668, 0.01567840576171875, 0.05517578125, 0.012054443359375, 0.022806803385416668, 0.015118916829427084, 0.0031000773111979165, 0.00724029541015625, 0.00995635986328125, 0.011601765950520834, 0.021616617838541668, 0.0248260498046875, 0.01331329345703125, 0.010851542154947916, 0.01918792724609375, 0.011233011881510416, 0.011899312337239584, 0.0033416748046875, 0.007870992024739584, 0.0055084228515625, 0.013041178385416666, 0.009808858235677084, 0.01415252685546875, 0.02729034423828125, 0.027631123860677082, 0.027394612630208332, 0.02297210693359375, 0.02170562744140625, 0.009221394856770834, 0.022488911946614582], "3": [0.037816365559895836, 0.006235758463541667, 0.007548014322916667, 0.016721089680989582, 0.0201873779296875, 0.00853729248046875, 0.016682942708333332, 0.008623758951822916, 0.012524922688802084, 0.03018951416015625, 0.018826802571614582, 0.009625752766927084, 0.023648579915364582, 0.008595784505208334, 0.005279541015625, 0.00450897216796875, 0.0114593505859375, 0.01067352294921875, 0.016710917154947918, 0.015958150227864582, 0.02729034423828125, 0.004582722981770833, 0.02420806884765625, 0.032964070638020836, 0.02553558349609375, 0.032292683919270836, 0.00800323486328125, 0.010279337565104166, 0.017534891764322918, 0.01596832275390625, 0.025438944498697918, 0.028826395670572918, 0.011426289876302084, 0.0216217041015625, 0.009043375651041666, 0.0022023518880208335, 0.02126312255859375, 0.017827351888020832, 0.016482035319010418, 0.0037511189778645835, 0.023030598958333332, 0.01773834228515625, 0.014516194661458334, 0.00209808349609375, 0.011906941731770834, 0.007410685221354167, 0.010533650716145834, 0.018076578776041668, 0.027745564778645832, 0.022705078125, 0.01335906982421875, 0.014658610026041666, 0.031140645345052082, 0.008252461751302084, 0.014462788899739584, 0.008466084798177084, 0.015218098958333334, 0.015904744466145832, 0.013829549153645834, 0.021525065104166668, 0.012601216634114584, 0.016370137532552082, 0.0025889078776041665, 0.00896453857421875], "4": [0.005480448404947917, 0.012296040852864584, 0.008183797200520834, 0.008883158365885416, 0.018046061197916668, 0.01018524169921875, 0.014879862467447916, 0.01988983154296875, 0.021052042643229168, 0.004750569661458333, 0.02515411376953125, 0.008603413899739584, 0.0267181396484375, 0.0149078369140625, 0.01622772216796875, 0.0104217529296875, 0.0190277099609375, 0.00090789794921875, 0.0009511311848958334, 0.0009943644205729167, 0.008832295735677084, 0.02024078369140625, 0.01314544677734375, 0.023890177408854168, 0.01515960693359375, 0.01001739501953125, 0.057523091634114586, 0.007937113444010416, 0.019175211588541668, 0.03563690185546875, 0.008173624674479166, 0.00052642822265625, 0.0182647705078125, 0.010607401529947916, 0.0355682373046875, 0.02922821044921875, 0.013338724772135416, 0.026425679524739582, 0.012646993001302084, 0.012204488118489584, 0.011057535807291666, 0.01334381103515625, 0.01471710205078125, 0.022641499837239582, 0.008059183756510416, 0.015157063802083334, 0.011739095052083334, 0.03094482421875, 0.0014750162760416667, 0.0358123779296875, 0.022176106770833332, 0.019439697265625, 0.015841166178385418, 0.014851888020833334, 0.007410685221354167, 0.0008392333984375, 0.013364156087239584, 0.01073455810546875, 0.023348490397135418, 0.0169219970703125, 0.014882405598958334, 0.012644449869791666, 0.032124837239583336, 0.004369099934895833], "5": [0.007481892903645833, 0.01291656494140625, 0.00662994384765625, 0.006444295247395833, 0.0086822509765625, 0.0120849609375, 0.025822957356770832, 0.0091094970703125, 0.020413716634114582, 0.014737447102864584, 0.029558817545572918, 0.013468424479166666, 0.006014506022135417, 0.0111236572265625, 0.015317281087239584, 0.01094818115234375, 0.013455708821614584, 0.019152323404947918, 0.021677652994791668, 0.020701090494791668, 0.02884674072265625, 0.011500040690104166, 0.014645894368489584, 0.025731404622395832, 0.005839029947916667, 0.010899861653645834, 0.00954437255859375, 0.01323699951171875, 0.027394612630208332, 0.0005340576171875, 0.016878763834635418, 0.006991068522135417, 0.014650980631510416, 0.004834493001302083, 0.014750162760416666, 0.021212259928385418, 0.005706787109375, 0.03816986083984375, 0.020182291666666668, 0.006510416666666667, 0.038103739420572914, 0.00379180908203125, 0.00176239013671875, 0.0255279541015625, 0.039418538411458336, 0.015126546223958334, 0.0065155029296875, 0.00841522216796875, 0.005658467610677083, 0.017069498697916668, 0.027966817220052082, 0.0124053955078125, 0.0199737548828125, 0.014790852864583334, 0.021547953287760418, 0.01613616943359375, 0.013590494791666666, 0.024050394694010418, 0.015034993489583334, 0.008084615071614584, 0.008799235026041666, 0.013308207194010416, 0.018725077311197918, 0.040395100911458336], "6": [0.027567545572916668, 0.018796284993489582, 0.025723775227864582, 0.016092936197916668, 0.014836629231770834, 0.0075836181640625, 0.01705169677734375, 0.0098724365234375, 0.012377421061197916, 0.020749409993489582, 0.0029347737630208335, 0.0013707478841145833, 0.022343953450520832, 0.014353434244791666, 0.005160013834635417, 0.022710164388020832, 0.018346150716145832, 0.009775797526041666, 0.05783843994140625, 0.022036234537760418, 0.024495442708333332, 0.040283203125, 0.01683807373046875, 0.008244832356770834, 0.01772308349609375, 0.01432037353515625, 0.020388285319010418, 0.0206451416015625, 0.033437093098958336, 0.015291849772135416, 0.016843159993489582, 0.0037358601888020835, 0.01534271240234375, 0.0021489461263020835, 0.0004984537760416666, 0.025563557942708332, 0.010454813639322916, 0.021489461263020832, 0.0006815592447916666, 0.026397705078125, 0.015085856119791666, 0.00439453125, 0.00020853678385416666, 0.0010935465494791667, 0.01992034912109375, 0.02376556396484375, 0.008257548014322916, 0.021616617838541668, 0.021527608235677082, 0.00885009765625, 0.013773600260416666, 0.00815582275390625, 0.0006281534830729166, 0.0150909423828125, 0.01971435546875, 0.0203399658203125, 0.008534749348958334, 0.015167236328125, 0.010213216145833334, 0.013409932454427084, 0.004778544108072917, 0.027804056803385418, 0.019666035970052082, 0.015658060709635418], "7": [0.006917317708333333, 0.017664591471354168, 0.0019022623697916667, 0.010373433430989584, 0.019251505533854168, 0.027295430501302082, 0.00640869140625, 0.0038121541341145835, 0.0035400390625, 0.00553131103515625, 0.012669881184895834, 0.01195526123046875, 0.011884053548177084, 0.006398518880208333, 0.011998494466145834, 0.009831746419270834, 0.01629638671875, 0.0003763834635416667, 0.013219197591145834, 0.018908182779947918, 0.014628092447916666, 0.027737935384114582, 0.013399759928385416, 0.016955057779947918, 0.017621358235677082, 0.008420308430989584, 0.02088165283203125, 0.01508331298828125, 0.0006688435872395834, 0.020477294921875, 0.022806803385416668, 0.024388631184895832, 0.018419901529947918, 0.0131072998046875, 0.011136372884114584, 0.016398111979166668, 0.013135274251302084, 0.019620259602864582, 0.034032185872395836, 0.010467529296875, 0.02271270751953125, 0.016222635904947918, 0.012941996256510416, 0.043212890625, 0.038653055826822914, 0.007151285807291667, 0.02984619140625, 0.01611328125, 0.018269856770833332, 0.01503753662109375, 0.009976704915364584, 0.0046539306640625, 0.019070943196614582, 0.004290262858072917, 0.001556396484375, 0.0392303466796875, 0.01624298095703125, 0.013852437337239584, 0.017590840657552082, 0.017201741536458332, 0.0035730997721354165, 0.021502176920572918, 0.018096923828125, 0.037378946940104164], "8": [0.017262776692708332, 0.01354217529296875, 0.015050252278645834, 0.00020599365234375, 0.008519490559895834, 0.028912862141927082, 0.016535441080729168, 0.00202178955078125, 0.005366007486979167, 0.013928731282552084, 0.017687479654947918, 0.02367401123046875, 0.030232747395833332, 0.009124755859375, 0.006795247395833333, 0.034434000651041664, 0.013181050618489584, 0.022705078125, 0.039957682291666664, 0.007120768229166667, 0.025316874186197918, 0.014338175455729166, 0.009493509928385416, 0.016558329264322918, 0.0214691162109375, 0.016393025716145832, 0.023106892903645832, 0.017926534016927082, 0.017995198567708332, 0.009076436360677084, 0.014399210611979166, 0.00962066650390625, 0.008900960286458334, 0.019381205240885418, 0.024579366048177082, 0.0159149169921875, 0.012456258138020834, 0.0278472900390625, 0.0037943522135416665, 0.00284576416015625, 0.0133209228515625, 0.00882720947265625, 0.011792500813802084, 0.0035909016927083335, 0.01883697509765625, 0.02906036376953125, 0.005032857259114583, 0.009282430013020834, 0.012288411458333334, 0.008860270182291666, 0.015276590983072916, 0.014279683430989584, 0.020718892415364582, 0.01679229736328125, 0.00800323486328125, 0.026769002278645832, 0.035687764485677086, 0.02027130126953125, 0.016072591145833332, 0.004720052083333333, 0.0036493937174479165, 0.019465128580729168, 0.015050252278645834, 0.024678548177083332], "9": [0.020617167154947918, 0.01406097412109375, 0.014790852864583334, 0.006815592447916667, 0.0008443196614583334, 0.0070953369140625, 0.025011698404947918, 0.025052388509114582, 0.009958902994791666, 0.0179290771484375, 0.0225372314453125, 0.012440999348958334, 0.0069122314453125, 0.017590840657552082, 0.01589202880859375, 0.011751810709635416, 0.0149688720703125, 0.03600311279296875, 0.041910807291666664, 0.0025812784830729165, 0.015607198079427084, 0.015902201334635418, 0.009923299153645834, 0.014712015787760416, 0.010304768880208334, 0.006482442220052083, 0.0215301513671875, 0.01235198974609375, 0.015752156575520832, 0.015472412109375, 0.017384847005208332, 0.015218098958333334, 0.0216064453125, 0.01092529296875, 0.00739288330078125, 0.021687825520833332, 0.023813883463541668, 0.024762471516927082, 0.018468221028645832, 0.0019963582356770835, 0.018633524576822918, 0.021097819010416668, 0.013295491536458334, 0.0201568603515625, 0.013966878255208334, 0.00867462158203125, 0.00021107991536458334, 0.01056671142578125, 0.026685078938802082, 0.009244283040364584, 0.037442525227864586, 0.014312744140625, 0.01464080810546875, 0.016718546549479168, 0.019922892252604168, 0.020192464192708332, 0.0092620849609375, 0.00527191162109375, 0.020810445149739582, 0.015314737955729166, 0.0154571533203125, 0.006121317545572917, 0.011126200358072916, 0.024813334147135418], "10": [0.022707621256510418, 0.022394816080729168, 0.01651763916015625, 0.01314544677734375, 0.00560760498046875, 0.023289998372395832, 0.006228129069010417, 0.016489664713541668, 0.020617167154947918, 0.02289581298828125, 0.01531982421875, 0.014775594075520834, 0.0114288330078125, 0.023646036783854168, 0.016703287760416668, 0.011372884114583334, 0.012486775716145834, 0.027463277180989582, 0.011433919270833334, 0.0038731892903645835, 0.0038655598958333335, 0.008534749348958334, 0.005549112955729167, 0.021601359049479168, 0.0233306884765625, 0.00357818603515625, 0.009539286295572916, 0.012430826822916666, 0.012502034505208334, 0.012364705403645834, 0.012433369954427084, 0.031366984049479164, 0.019994099934895832, 0.011049906412760416, 0.016092936197916668, 0.0037206013997395835, 0.0212860107421875, 0.026204427083333332, 0.012326558430989584, 0.017636617024739582, 0.05213165283203125, 0.02103424072265625, 0.01181793212890625, 0.013234456380208334, 0.0164794921875, 0.012448628743489584, 0.009267171223958334, 0.024564107259114582, 0.01018524169921875, 0.017000834147135418, 0.011243184407552084, 0.012873331705729166, 0.016176859537760418, 0.021161397298177082, 0.032010396321614586, 0.01239013671875, 0.0037790934244791665, 0.0119781494140625, 0.010403951009114584, 0.010759989420572916, 0.013226826985677084, 0.007354736328125, 0.033045450846354164, 0.011627197265625], "11": [0.022371927897135418, 0.033167521158854164, 0.010874430338541666, 0.0142059326171875, 0.008160909016927084, 0.013844807942708334, 0.055498758951822914, 0.018582661946614582, 0.0189971923828125, 0.011388142903645834, 0.007288614908854167, 0.021375020345052082, 0.015635172526041668, 0.00019073486328125, 0.005421956380208333, 0.024378458658854168, 0.007685343424479167, 0.027987162272135418, 0.017038981119791668, 0.012847900390625, 0.015576680501302084, 0.015268961588541666, 0.014251708984375, 0.009862263997395834, 0.015820821126302082, 0.010101318359375, 0.013308207194010416, 0.0026372273763020835, 0.009808858235677084, 0.0115509033203125, 0.018658955891927082, 0.018895467122395832, 0.018229166666666668, 0.009114583333333334, 0.0223541259765625, 0.0075836181640625, 0.01425933837890625, 0.0095367431640625, 0.0045318603515625, 0.009829203287760416, 0.011355082194010416, 0.013621012369791666, 0.015352884928385416, 0.03899383544921875, 0.022051493326822918, 0.02303314208984375, 0.017819722493489582, 0.018717447916666668, 0.0018030802408854167, 0.02024078369140625, 0.0037943522135416665, 0.006159464518229167, 0.009173075358072916, 0.00601959228515625, 0.019343058268229168, 0.03795623779296875, 0.011995951334635416, 0.04059600830078125, 0.0269775390625, 0.01615142822265625, 0.0076904296875, 0.022715250651041668, 0.009124755859375, 0.0011927286783854167], "12": [0.016576131184895832, 0.014246622721354166, 0.040445963541666664, 0.0184783935546875, 0.014233907063802084, 0.01721954345703125, 0.01079559326171875, 0.01963043212890625, 0.0009511311848958334, 0.014284769694010416, 0.011217753092447916, 0.022852579752604168, 0.010653177897135416, 0.007738749186197917, 0.021044413248697918, 0.015271504720052084, 0.013735453287760416, 0.011189778645833334, 0.00328826904296875, 0.055226643880208336, 0.010907491048177084, 0.023165384928385418, 0.018857320149739582, 0.005060831705729167, 0.011411031087239584, 0.02371978759765625, 0.013910929361979166, 0.014134724934895834, 0.010492960611979166, 0.009180704752604166, 0.026092529296875, 0.0021692911783854165, 0.021753946940104168, 0.0076446533203125, 0.016756693522135418, 0.01206207275390625, 0.0103607177734375, 0.0121917724609375, 0.004178365071614583, 0.0068359375, 0.057360331217447914, 0.016909281412760418, 0.01495361328125, 0.00336456298828125, 0.011576334635416666, 0.02325439453125, 0.020861307779947918, 0.0184783935546875, 0.020281473795572918, 0.012664794921875, 0.025553385416666668, 0.016306559244791668, 0.024564107259114582, 0.020444234212239582, 0.008417765299479166, 0.022282918294270832, 0.01444244384765625, 0.013562520345052084, 0.006779988606770833, 0.0100555419921875, 0.007642110188802083, 0.0104522705078125, 0.01406097412109375, 0.005762736002604167], "13": [0.012830098470052084, 0.02161407470703125, 0.008272806803385416, 0.018984476725260418, 0.00554656982421875, 0.009310404459635416, 0.00119781494140625, 0.0269012451171875, 0.024462381998697918, 0.00726318359375, 0.013102213541666666, 0.0003458658854166667, 0.00891876220703125, 0.008148193359375, 0.009600321451822916, 0.008107503255208334, 0.011426289876302084, 0.006573994954427083, 0.01398468017578125, 0.032892862955729164, 0.006853739420572917, 0.009343465169270834, 0.023981730143229168, 0.013323465983072916, 0.01065826416015625, 0.004862467447916667, 0.011782328287760416, 0.025881449381510418, 0.013427734375, 0.02643585205078125, 0.015271504720052084, 0.013158162434895834, 0.027478535970052082, 0.017072041829427082, 0.016863505045572918, 0.02207183837890625, 0.029858907063802082, 0.015645345052083332, 0.009923299153645834, 0.014040629069010416, 0.01019287109375, 0.0256805419921875, 0.008463541666666666, 0.047915140787760414, 0.00957489013671875, 0.004000345865885417, 0.028065999348958332, 0.006947835286458333, 0.02144622802734375, 0.008603413899739584, 0.009440104166666666, 0.00490570068359375, 0.06434885660807292, 0.0027109781901041665, 0.020093282063802082, 0.0252838134765625, 0.02887725830078125, 0.013427734375, 0.014844258626302084, 0.00821685791015625, 0.0020777384440104165, 0.007563273111979167, 0.007649739583333333, 0.0422515869140625], "14": [0.014251708984375, 0.025594075520833332, 0.033894856770833336, 0.039087931315104164, 0.00449371337890625, 0.02930450439453125, 0.0002950032552083333, 0.030248006184895832, 0.0035044352213541665, 0.012982686360677084, 0.013641357421875, 0.012265523274739584, 0.01155853271484375, 0.016789754231770832, 0.02744293212890625, 0.0234832763671875, 0.01568603515625, 0.005587259928385417, 0.016665140787760418, 0.010854085286458334, 0.018646240234375, 0.023618062337239582, 0.004262288411458333, 0.012652079264322916, 0.00606536865234375, 0.008165995279947916, 0.0117645263671875, 0.0135955810546875, 0.00061798095703125, 0.00308990478515625, 0.00136566162109375, 0.01592254638671875, 0.009213765462239584, 0.0025787353515625, 0.00394439697265625, 0.0076446533203125, 0.004038492838541667, 0.041811625162760414, 0.024988810221354168, 0.020624796549479168, 0.01856231689453125, 0.012486775716145834, 0.01020050048828125, 0.030774434407552082, 0.022333780924479168, 0.014600118001302084, 0.02091217041015625, 0.014096577962239584, 0.02204132080078125, 0.033457438151041664, 0.015207926432291666, 0.00351715087890625, 0.023050944010416668, 0.018488566080729168, 0.005877176920572917, 0.008694966634114584, 0.0080413818359375, 0.021227518717447918, 0.011355082194010416, 0.030077616373697918, 0.010080973307291666, 0.009366353352864584, 0.0334014892578125, 0.01990509033203125], "15": [0.015446980794270834, 0.00719451904296875, 0.024706522623697918, 0.040669759114583336, 0.004015604654947917, 0.012148539225260416, 0.008074442545572916, 0.03563690185546875, 0.0033925374348958335, 0.0040740966796875, 0.018300374348958332, 0.004351298014322917, 0.0020853678385416665, 0.01900482177734375, 0.00920867919921875, 0.0181732177734375, 0.012194315592447916, 0.038210550944010414, 0.0007654825846354166, 0.006123860677083333, 0.0131988525390625, 0.030888875325520832, 0.008646647135416666, 0.019663492838541668, 0.010370890299479166, 0.005589803059895833, 0.051531473795572914, 0.0156707763671875, 0.015726725260416668, 0.006121317545572917, 0.0008443196614583334, 0.01576995849609375, 0.00279998779296875, 0.005803426106770833, 0.003631591796875, 0.0121917724609375, 0.023267110188802082, 0.011377970377604166, 0.00786590576171875, 0.0026652018229166665, 0.02513885498046875, 0.01985931396484375, 0.009033203125, 0.0116119384765625, 0.007181803385416667, 0.041142781575520836, 0.016469319661458332, 0.019223531087239582, 0.040425618489583336, 0.047849019368489586, 0.00325775146484375, 0.0021870930989583335, 0.010958353678385416, 0.016754150390625, 0.01837921142578125, 0.02478790283203125, 0.02323150634765625, 0.01389312744140625, 0.0152587890625, 0.023585001627604168, 0.01822662353515625, 0.019014994303385418, 0.014841715494791666, 0.010284423828125]}

results/routing_stats.json

@@ -0,0 +1,118 @@
+{
+  "tokens": 49152,
+  "layers": 16,
+  "experts": 64,
+  "topk": 8,
+  "gini": [
+    0.2641251881917318,
+    0.23673518498738605,
+    0.29776819547017414,
+    0.29947829246520996,
+    0.3454646269480387,
+    0.3215921719868978,
+    0.34398754437764484,
+    0.3286585807800293,
+    0.309318463007609,
+    0.2810204029083252,
+    0.280742883682251,
+    0.3329012393951416,
+    0.3131023248036703,
+    0.3724563121795655,
+    0.3590616385142008,
+    0.4008479118347168
+  ],
+  "mass_top25pct": 0.4494392077128093,
+  "mass_top50pct": 0.7201894124348959,
+  "cum_mean": [
+    0.04957866668701171,
+    0.08984041213989256,
+    0.12564531962076825,
+    0.15774806340535483,
+    0.18765417734781906,
+    0.2160946528116862,
+    0.24337959289550778,
+    0.2692921956380208,
+    0.2938820521036784,
+    0.3178324699401856,
+    0.3411908149719239,
+    0.36395390828450525,
+    0.3860907554626466,
+    0.40786997477213544,
+    0.4289251963297527,
+    0.4494392077128092,
+    0.4695858955383301,
+    0.48933347066243493,
+    0.5085887908935547,
+    0.5272884368896485,
+    0.5454365412394205,
+    0.5631278355916342,
+    0.5805028279622395,
+    0.5973410606384277,
+    0.6137038866678873,
+    0.6296553611755371,
+    0.6453857421875,
+    0.6608610153198242,
+    0.6761328379313151,
+    0.6911047299702963,
+    0.7057998975118002,
+    0.7201894124348959,
+    0.7341702779134114,
+    0.7478232383728028,
+    0.7613116900126139,
+    0.7745154698689779,
+    0.7874118487040203,
+    0.8000138600667318,
+    0.8123443921407064,
+    0.8243754704793295,
+    0.8361045519510906,
+    0.8473731676737467,
+    0.8582647641499838,
+    0.8688268661499025,
+    0.8790240287780763,
+    0.8889846801757814,
+    0.8986585934956869,
+    0.9080793062845866,
+    0.9172714551289876,
+    0.9262355168660482,
+    0.9347052574157716,
+    0.9429275194803874,
+    0.95058012008667,
+    0.957863966623942,
+    0.9648462931315105,
+    0.9712352752685547,
+    0.9771231015523276,
+    0.982486565907796,
+    0.9872740109761556,
+    0.9913490613301595,
+    0.9945575396219889,
+    0.9972108205159506,
+    0.9991180102030437,
+    1.0
+  ],
+  "reuse_prev_token": [
+    0.2499567658847226,
+    0.2796840349128197,
+    0.3672738092816016,
+    0.3708393522003621,
+    0.44042084596447684,
+    0.4547211653882932,
+    0.46631045146589084,
+    0.4375648511729161,
+    0.3781764358812639,
+    0.3395353095562654,
+    0.31294632866065797,
+    0.36515025126650524,
+    0.3588685886350227,
+    0.38883491688877136,
+    0.34283127505035504,
+    0.36325557974405404
+  ],
+  "working_set": {
+    "1": 8.0,
+    "4": 21.099609375,
+    "16": 42.0537109375,
+    "64": 56.6220703125,
+    "256": 61.19140625,
+    "1024": 63.161458333333336
+  }
+}

results/routing_trace.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74d821864ef73b28a53a377f602accf9dd1a4b8d4a7ae1b16bac08e60d40d9d1
+size 12583040