File size: 4,463 Bytes
6ec9472 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | """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()
|