| """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") |
|
|
| |
| 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"]) |
|
|
|
|
| |
| 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()) |
|
|
|
|
| |
| 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") |
|
|
| |
| 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}%") |
|
|
| |
| cp = json.load(open(os.path.join(RES, "cache_policy.json"))) |
| s_hat = cp["zipf_s"] |
| bias = cp["mae_analytic_zipf"] * 100 |
| out["zipf_s"] = s_hat |
| out["zipf_bias_pp"] = bias |
| ws = T1["topk"] * T1["layers"] |
| 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}") |
|
|
| |
| 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() |
|
|
