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