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