code/quant_model.py

"""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)