import json, os, sys import numpy as np import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt sys.path.insert(0, os.path.dirname(__file__)) RES = os.path.join(os.path.dirname(__file__), "..", "results") FIG = os.path.join(os.path.dirname(__file__), "..", "paper", "figs") plt.rcParams.update({ "font.size": 8, "axes.labelsize": 8, "axes.titlesize": 8.5, "legend.fontsize": 7, "xtick.labelsize": 7, "ytick.labelsize": 7, "figure.dpi": 200, "savefig.dpi": 200, "axes.grid": True, "grid.alpha": 0.25, "grid.linewidth": 0.5, "lines.linewidth": 1.3, "axes.spines.top": False, "axes.spines.right": False, "font.family": "serif", "mathtext.fontset": "cm", }) C = ["#1b3a6b", "#c1440e", "#2e7d32", "#6a1b9a", "#c98a00", "#00695c"] def load(n): p = os.path.join(RES, n) return json.load(open(p)) if os.path.exists(p) else None def fig_amplification(): pr = load("projection.json") if not pr: return a = pr["amplification"] bits = [x["bits"] for x in a] frac = [x["frac"] * 100 for x in a] size = [x["model_gb"] for x in a] fig, ax = plt.subplots(1, 2, figsize=(6.9, 2.35)) ax[0].plot(bits, size, "o-", color=C[0]) ax[0].axhline(294, ls="--", c=C[1], lw=1) ax[0].text(9, 320, "free NVMe (294 GB)", color=C[1], fontsize=6.5) ax[0].axhline(24, ls=":", c=C[2], lw=1) ax[0].text(9, 27, "usable DRAM (24 GB)", color=C[2], fontsize=6.5) ax[0].set_yscale("log"); ax[0].set_xlabel("weight rate (bits/parameter)") ax[0].set_ylabel("model footprint (GB)") ax[0].set_title("(a) 1.05T-parameter footprint") ax[1].plot(bits, frac, "o-", color=C[0]) ax[1].set_xlabel("weight rate (bits/parameter)") ax[1].set_ylabel("expert slots resident in 24 GB (%)") ax[1].set_title("(b) DRAM cache capacity") for b, f in zip(bits, frac): if b in (16, 1.5): ax[1].annotate(f"{f:.1f}%", (b, f), textcoords="offset points", xytext=(4, 4), fontsize=6.5) fig.tight_layout(); fig.savefig(os.path.join(FIG, "amplification.pdf")) plt.close(fig) def fig_io(): io = load("io_bench.json") if not io: return fig, ax = plt.subplots(figsize=(3.4, 2.35)) for i, t in enumerate([1, 2, 4, 8]): pts = sorted([(r["block_kb"], r["mb_s"] / 1000) for r in io["random"] if r["threads"] == t]) ax.plot([p[0] for p in pts], [p[1] for p in pts], "o-", color=C[i], label=f"{t} thread" + ("s" if t > 1 else ""), ms=3) ax.set_xscale("log", base=2) ax.set_xlabel("read block size (KiB)") ax.set_ylabel("random-read bandwidth (GB/s)") ax.axhline(io["host"]["seq_read_mb_s"] / 1000, ls="--", c="k", lw=0.9) ax.text(80, io["host"]["seq_read_mb_s"] / 1000 + 0.15, "sequential", fontsize=6.5) ax.legend(loc="lower right") fig.tight_layout(); fig.savefig(os.path.join(FIG, "io.pdf")); plt.close(fig) def fig_cache(): cp = load("cache_policy.json") cv = load("cache_validation.json") if not cp or not cv: return fr = load("routing_freq.json") fig, ax = plt.subplots(1, 3, figsize=(6.9, 2.25)) F = np.array([fr[str(l)] for l in range(cp["layers"])]) for l in range(0, cp["layers"], 3): ax[0].plot(np.arange(1, F.shape[1] + 1), np.sort(F[l])[::-1], color=C[0], alpha=0.35, lw=0.8) s = cp["zipf_s"] r = np.arange(1, F.shape[1] + 1) z = r ** (-s); z = z / z.sum() ax[0].plot(r, z, "--", color=C[1], lw=1.4, label=f"Zipf $s$={s:.2f}") ax[0].set_xscale("log"); ax[0].set_yscale("log") ax[0].set_xlabel("expert rank"); ax[0].set_ylabel("activation probability") ax[0].set_title("(a) expert popularity"); ax[0].legend() h = cp["policies"] x = [r["frac"] * 100 for r in h] ax[1].plot(x, [r["lru"] * 100 for r in h], "o-", color=C[0], label="LRU", ms=3) ax[1].plot(x, [r["static"] * 100 for r in h], "^-", color=C[2], label="popularity-pinned", ms=3) ax[1].plot(x, [r["hybrid"] * 100 for r in h], "d-", color=C[4], label="hybrid (75% pinned)", ms=3) ax[1].plot(x, [r["analytic_static"] * 100 for r in h], "s:", color=C[1], label="analytic model", ms=3) ws = cp["ws_frac"] * 100 ax[1].axvline(ws, ls="--", c=C[3], lw=1) ax[1].text(ws + 2, 72, "per-token\nworking set", color=C[3], fontsize=6) ax[1].set_xlabel("cache capacity (% of expert slots)") ax[1].set_ylabel("hit rate (%)") ax[1].set_title("(b) replacement policy"); ax[1].legend(loc="lower right") d = cv["distinct_per_batch"] ax[2].plot([r["batch"] for r in d], [r["measured"] for r in d], "o-", color=C[0], label="measured", ms=3) ax[2].plot([r["batch"] for r in d], [r["irm_measured_pop"] for r in d], "s--", color=C[1], label="IRM model", ms=3) ax[2].set_xscale("log", base=2) ax[2].set_xlabel("tokens per batch") ax[2].set_ylabel("distinct experts / layer") ax[2].set_title("(c) batch amortisation"); ax[2].legend(loc="lower right") fig.tight_layout(); fig.savefig(os.path.join(FIG, "cache.pdf")); plt.close(fig) def fig_quality(): import glob runs = [] for p in glob.glob(os.path.join(RES, "quant_*.json")): runs.append(json.load(open(p))) if not runs: return fig, ax = plt.subplots(figsize=(5.0, 3.05)) base = [r for r in runs if r["config"].get("tag", "").startswith("rtn")] ours = sorted([r for r in runs if r["config"]["tag"].startswith("main")], key=lambda r: r["avg_bits"]) abl = sorted([r for r in runs if r["config"]["tag"].startswith("northt")], key=lambda r: r["avg_bits"]) noldl = sorted([r for r in runs if r["config"]["tag"].startswith("noldlq")], key=lambda r: r["avg_bits"]) freq = sorted([r for r in runs if r["config"]["tag"].startswith("freq")], key=lambda r: r["avg_bits"]) fp = load("fp16_ppl.json") for grp, lab, st, c in [(ours, "RVQ + RHT + LDLQ (ours)", "o-", C[0]), (freq, "+ frequency-conditioned alloc.", "D-", C[4]), (noldl, "no LDLQ (data-free)", "s--", C[1]), (abl, "no incoherence processing", "^--", C[2]), (base, "RTN uniform", "v:", C[3])]: if grp: ax.plot([r["avg_bits"] for r in grp], [r["ppl"] for r in grp], st, label=lab, color=c, ms=3) if fp: ax.axhline(fp["ppl"], ls="--", c="k", lw=0.9) ax.text(3.32, fp["ppl"] * 1.12, f"bf16 = {fp['ppl']:.2f}", fontsize=6.5, ha="right", va="bottom") ax.set_yscale("log") ax.set_xlim(0.85, 3.45) ax.set_xlabel("average weight rate (bits/parameter)") ax.set_ylabel("WikiText-2 perplexity") ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.24), ncol=2, frameon=False, fontsize=7) fig.tight_layout() fig.savefig(os.path.join(FIG, "quality.pdf"), bbox_inches="tight") plt.close(fig) def fig_throughput(): pr = load("projection.json") if not pr: return fig, ax = plt.subplots(1, 2, figsize=(6.9, 2.35)) s = pr["sensitivity_1p5bit"] ax[0].plot([x["hit_rate"] * 100 for x in s], [x["tok_s"] for x in s], "-", color=C[0]) hr = pr["projection"][0]["hit_rate"] * 100 ax[0].set_xlabel("expert-cache hit rate (%)") ax[0].set_ylabel("decode throughput (tokens/s)") ax[0].set_yscale("log") ax[0].set_title("(a) sensitivity at 1.5 bit, batch 1") rows = pr["projection"] bits = sorted(set(r["rate_bits"] for r in rows)) for i, B in enumerate([1, 8, 32]): y = [next(r["tok_s"] for r in rows if r["rate_bits"] == b and r["batch"] == B) for b in bits] ax[1].plot(bits, y, "o-", color=C[i], label=f"batch {B}", ms=3) ax[1].set_xlabel("weight rate (bits/parameter)") ax[1].set_ylabel("decode throughput (tokens/s)") ax[1].set_yscale("log"); ax[1].legend() ax[1].set_title("(b) projected 1.05T throughput") fig.tight_layout(); fig.savefig(os.path.join(FIG, "throughput.pdf")) plt.close(fig) if __name__ == "__main__": os.makedirs(FIG, exist_ok=True) for f in [fig_amplification, fig_io, fig_cache, fig_quality, fig_throughput]: try: f() print("ok", f.__name__) except Exception as e: print("skip", f.__name__, type(e).__name__, e)