"""Sequential layer-wise quantisation of OLMoE-1B-7B with Hessian-aware sub-2-bit residual VQ, plus frequency-conditioned bit allocation over experts. Runs on a 4 GB GPU by moving one decoder layer at a time onto the device. """ import argparse, gc, json, os, sys, time import torch import torch.nn as nn from transformers import AutoModelForCausalLM, AutoTokenizer sys.path.insert(0, os.path.dirname(__file__)) import codec, data MODEL = "allenai/OLMoE-1B-7B-0924" DEV = "cuda" def hkey_of(name): """Linears sharing an input share one Hessian.""" if name.endswith(("q_proj", "k_proj", "v_proj")): return "attn.in" if name.endswith("o_proj"): return "attn.o" if ".experts." in name: e = name.split(".experts.")[1].split(".")[0] if name.endswith("down_proj"): return f"e{e}.mid" return f"e{e}.in" return None def find_linears(layer): out = {} for n, m in layer.named_modules(): if isinstance(m, nn.Linear) and hkey_of(n) is not None: out[n] = m return out class Catcher(nn.Module): def __init__(self, mod, store): super().__init__() self.mod, self.store = mod, store def forward(self, hs, **kw): self.store["inps"].append(hs.detach().to("cpu")) if "kw" not in self.store: self.store["kw"] = {k: v for k, v in kw.items() if k not in ("past_key_value", "past_key_values")} raise RuntimeError("caught") @torch.no_grad() def capture_inputs(model, batches): store = {"inps": []} model.model.embed_tokens.to(DEV) model.model.rotary_emb.to(DEV) layers = model.model.layers layers[0] = Catcher(layers[0], store) for b in batches: try: model(b.to(DEV)) except RuntimeError as e: if "caught" not in str(e): raise layers[0] = layers[0].mod model.model.embed_tokens.to("cpu") torch.cuda.empty_cache() return store["inps"], store["kw"] @torch.no_grad() def run_layer(layer, inps, kw, out=None): res = out if out is not None else [None] * len(inps) for j, x in enumerate(inps): y = layer(x.to(DEV), **kw) y = y[0] if isinstance(y, tuple) else y res[j] = y.detach().to("cpu") return res def alloc_stages(freq, base_stages, spread, n_experts): """Frequency-conditioned bit allocation. Experts are ranked by measured activation frequency; the top third get +`spread` stages, the bottom third -`spread`, keeping the mean rate equal to `base_stages` so the comparison against uniform allocation is rate-matched. """ order = sorted(range(n_experts), key=lambda i: -freq[i]) st = [base_stages] * n_experts k = n_experts // 3 for i in order[:k]: st[i] = base_stages + spread for i in order[-k:]: st[i] = max(1, base_stages - spread) return st @torch.no_grad() def quantize_model(stages, nsamples=32, seqlen=2048, rht_on=True, ldlq_on=True, alloc="uniform", spread=1, refine=0, tag="", rtn_bits=None): tok = AutoTokenizer.from_pretrained(MODEL) model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16, low_cpu_mem_usage=True) model.eval() model.config.use_cache = False cbs = codec.build_codebooks(8, device=DEV) batches = data.calib_batches(tok, nsamples, seqlen) inps, kw = capture_inputs(model, batches) outs = [None] * len(inps) layers = model.model.layers n_exp = model.config.num_experts freq = load_freq(n_exp, len(layers)) log = {"layers": [], "bits": [], "params": []} t_start = time.time() for li, layer in enumerate(layers): t0 = time.time() layer.to(DEV) lin = find_linears(layer) H, cnt = {}, {} reps = {} for n, m in lin.items(): k = hkey_of(n) reps.setdefault(k, (n, m)) hooks = [] need_hess = ldlq_on and rtn_bits is None def mk(k, insize): H[k] = torch.zeros(insize, insize, device=DEV, dtype=torch.float32) cnt[k] = 0 def fn(mod, inp, out): x = inp[0].detach().reshape(-1, insize).float() if x.shape[0]: H[k] += x.t() @ x cnt[k] += x.shape[0] return fn if need_hess: for k, (n, m) in reps.items(): hooks.append(m.register_forward_hook(mk(k, m.in_features))) run_layer(layer, inps, kw) for h in hooks: h.remove() if alloc == "freq": st_e = alloc_stages(freq[li], stages, spread, n_exp) else: st_e = [stages] * n_exp fact = {} lbits, lparams = 0.0, 0 for n, m in lin.items(): k = hkey_of(n) s = stages if ".experts." in n: s = st_e[int(n.split(".experts.")[1].split(".")[0])] W = m.weight.data.to(DEV).float() if rtn_bits is not None: Wq, info = codec.rtn(W, rtn_bits) elif ldlq_on: if k not in fact: fact[k] = codec.prepare_hessian(H[k], 1234, rht_on=rht_on) L, dead = fact[k] Wq, info = codec.ldlq_quantize(W, L, dead, cbs, s, rht_on=rht_on, refine=refine) else: Wq, info = codec.quantize(W, cbs, s, rht_on=rht_on, refine=refine) m.weight.data = Wq.to(torch.bfloat16) lbits += info["bits"] * W.numel() lparams += W.numel() del W, Wq H.clear(); fact.clear() torch.cuda.empty_cache() run_layer(layer, inps, kw, outs) layer.to("cpu") inps, outs = outs, inps gc.collect(); torch.cuda.empty_cache() log["layers"].append(li) log["bits"].append(lbits / lparams) log["params"].append(lparams) print(f"[{tag}] layer {li:2d} {lbits/lparams:.3f} bits/w " f"({time.time()-t0:.0f}s, total {time.time()-t_start:.0f}s)", flush=True) avg_bits = sum(log["bits"][i] * log["params"][i] for i in range(len(log["bits"]))) \ / sum(log["params"]) log["avg_bits"] = avg_bits log["quantized_params"] = sum(log["params"]) model.config.use_cache = False return model, tok, log def load_freq(n_exp, n_layers): p = os.path.join(os.path.dirname(__file__), "..", "results", "routing_freq.json") if os.path.exists(p): f = json.load(open(p)) return [f[str(l)] for l in range(n_layers)] return [[1.0] * n_exp for _ in range(n_layers)] @torch.no_grad() def perplexity(model, tok, seqlen=2048, limit=None): """Layer-sequential evaluation: each layer is moved to the GPU once and all sequences are streamed through it, rather than paging layers per sequence.""" tests = data.test_tokens(tok, seqlen) if limit: tests = tests[:limit] pos = torch.arange(seqlen, device=DEV).unsqueeze(0) model.model.embed_tokens.to(DEV); model.model.rotary_emb.to(DEV) hs = [model.model.embed_tokens(b.to(DEV)).cpu() for b in tests] pe = model.model.rotary_emb(hs[0].to(DEV), pos) model.model.embed_tokens.to("cpu"); torch.cuda.empty_cache() for layer in model.model.layers: layer.to(DEV) for j in range(len(hs)): y = layer(hs[j].to(DEV), attention_mask=None, position_ids=pos, position_embeddings=pe) hs[j] = (y[0] if isinstance(y, tuple) else y).cpu() layer.to("cpu"); torch.cuda.empty_cache() model.model.norm.to(DEV); model.lm_head.to(DEV) nll, ntok = 0.0, 0 for j, b in enumerate(tests): logits = model.lm_head(model.model.norm(hs[j].to(DEV))).float() loss = torch.nn.functional.cross_entropy( logits[:, :-1].reshape(-1, logits.shape[-1]), b.to(DEV)[:, 1:].reshape(-1)) nll += loss.item() * (seqlen - 1) ntok += seqlen - 1 del logits torch.cuda.empty_cache() return float(torch.exp(torch.tensor(nll / ntok))) if __name__ == "__main__": ap = argparse.ArgumentParser() ap.add_argument("--stages", type=int, default=3) ap.add_argument("--nsamples", type=int, default=32) ap.add_argument("--seqlen", type=int, default=2048) ap.add_argument("--no-rht", action="store_true") ap.add_argument("--no-ldlq", action="store_true") ap.add_argument("--alloc", default="uniform") ap.add_argument("--spread", type=int, default=1) ap.add_argument("--ppl-limit", type=int, default=24) ap.add_argument("--rtn", type=int, default=None) ap.add_argument("--fp16", action="store_true") ap.add_argument("--tag", default="run") a = ap.parse_args() if a.fp16: tok = AutoTokenizer.from_pretrained(MODEL) m = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16, low_cpu_mem_usage=True) m.eval(); m.config.use_cache = False ppl = perplexity(m, tok, a.seqlen, a.ppl_limit) print(f"[fp16] wikitext2 ppl={ppl:.4f}", flush=True) json.dump({"ppl": ppl, "seqlen": a.seqlen, "limit": a.ppl_limit}, open(os.path.join(os.path.dirname(__file__), "..", "results", "fp16_ppl.json"), "w"), indent=2) sys.exit(0) m, tok, log = quantize_model(a.stages, a.nsamples, a.seqlen, rht_on=not a.no_rht, ldlq_on=not a.no_ldlq, alloc=a.alloc, spread=a.spread, tag=a.tag, rtn_bits=a.rtn) t0 = time.time() ppl = perplexity(m, tok, a.seqlen, a.ppl_limit) log.update(ppl=ppl, config=vars(a), ppl_secs=time.time() - t0) print(f"[{a.tag}] avg_bits={log['avg_bits']:.3f} wikitext2 ppl={ppl:.3f}", flush=True) out = os.path.join(os.path.dirname(__file__), "..", "results", f"quant_{a.tag}.json") json.dump(log, open(out, "w"), indent=2) print("saved", out)