File size: 4,503 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 | """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()
|