Download code/trace_routing.py from mkvn/quantization-cache-amplification: direct link, hf CLI and curl.
- Browser
- Download file 5.87 kB
-
https://huggingface.co/datasets/mkvn/quantization-cache-amplification/resolve/main/code/trace_routing.py
- Command line
-
hf download hf://datasets/mkvn/quantization-cache-amplification/code/trace_routing.py
-
curl -L -o trace_routing.py https://huggingface.co/datasets/mkvn/quantization-cache-amplification/resolve/main/code/trace_routing.py
5.87 kB
| """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") | |
| 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)) | |