| """Sub-2-bit weight codec: randomised Hadamard incoherence processing followed by |
| multi-stage residual vector quantisation on a shared (amortised-free) codebook. |
| |
| Rate is controlled in 0.5 bit/weight steps by the number of residual stages: |
| each stage codes a d=16 subvector with an 8-bit index -> 0.5 bit/weight/stage. |
| """ |
| import math |
| import torch |
|
|
| D_SUB = 16 |
| CB_BITS = 8 |
| CB_SIZE = 1 << CB_BITS |
| BITS_PER_STAGE = CB_BITS / D_SUB |
|
|
|
|
| |
| def _fwht(x): |
| """In-place fast Walsh-Hadamard transform over the last dim (power of 2).""" |
| n = x.shape[-1] |
| assert n & (n - 1) == 0, f"dim {n} not a power of two" |
| h = 1 |
| orig = x.shape |
| x = x.reshape(-1, n).clone() |
| while h < n: |
| x = x.view(-1, n // (2 * h), 2, h) |
| a = x[:, :, 0, :].clone() |
| b = x[:, :, 1, :].clone() |
| x[:, :, 0, :] = a + b |
| x[:, :, 1, :] = a - b |
| x = x.view(-1, n) |
| h *= 2 |
| return (x / math.sqrt(n)).reshape(orig) |
|
|
|
|
| def _signs(n, seed, device, dtype): |
| g = torch.Generator(device="cpu").manual_seed(seed) |
| return (torch.randint(0, 2, (n,), generator=g).to(device=device, |
| dtype=dtype) * 2 - 1) |
|
|
|
|
| def rht_forward(W, seed): |
| sr = _signs(W.shape[1], seed, W.device, W.dtype) |
| sl = _signs(W.shape[0], seed + 1, W.device, W.dtype) |
| X = _fwht(W * sr) |
| X = _fwht((X * sl.unsqueeze(1)).t().contiguous()).t().contiguous() |
| return X |
|
|
|
|
| def rht_inverse(X, seed): |
| sr = _signs(X.shape[1], seed, X.device, X.dtype) |
| sl = _signs(X.shape[0], seed + 1, X.device, X.dtype) |
| W = _fwht(X.t().contiguous()).t().contiguous() * sl.unsqueeze(1) |
| W = _fwht(W) * sr |
| return W |
|
|
|
|
| |
| _CN = {} |
|
|
|
|
| def _cnorm(C): |
| k = id(C) |
| if k not in _CN or _CN[k][0] is not C: |
| _CN[k] = (C, (C * C).sum(1).unsqueeze(0)) |
| return _CN[k][1] |
|
|
|
|
| def _assign(X, C, chunk=1 << 20): |
| if X.shape[0] <= chunk: |
| return (_cnorm(C) - 2.0 * (X @ C.t())).argmin(1) |
| out = torch.empty(X.shape[0], dtype=torch.long, device=X.device) |
| Cn = _cnorm(C) |
| for s in range(0, X.shape[0], chunk): |
| e = min(s + chunk, X.shape[0]) |
| out[s:e] = (Cn - 2.0 * (X[s:e] @ C.t())).argmin(1) |
| return out |
|
|
|
|
| def rht_hessian(H, seed): |
| """Transform an input-side Hessian into the RHT basis: H' = T^T H T with |
| T = diag(s_r) * Hadamard (orthogonal, symmetric Hadamard).""" |
| s = _signs(H.shape[0], seed, H.device, H.dtype) |
| A = H * s.unsqueeze(0) * s.unsqueeze(1) |
| A = _fwht(A) |
| A = _fwht(A.t().contiguous()).t().contiguous() |
| return A |
|
|
|
|
| |
| def vq(V, codebooks, stages, refine=1): |
| """Multi-stage residual VQ of [N, D_SUB] rows, with optional coordinate |
| refinement: each stage index is re-solved against the residual left by all |
| the other stages, which recovers part of the greedy-encoding loss.""" |
| Q = torch.zeros_like(V) |
| parts = [] |
| for s in range(stages): |
| C = codebooks[s] |
| idx = _assign(V - Q, C) |
| p = C[idx] |
| parts.append(p) |
| Q = Q + p |
| for _ in range(refine): |
| for s in range(stages): |
| Q = Q - parts[s] |
| idx = _assign(V - Q, codebooks[s]) |
| parts[s] = codebooks[s][idx] |
| Q = Q + parts[s] |
| return Q |
|
|
|
|
| def _block_ldl(H, blk): |
| """H = L D L^T with L block-unit-lower-triangular (blocks of size blk). |
| |
| The per-block inverses are batched into a single call rather than looped. |
| """ |
| n = H.shape[0] |
| C = torch.linalg.cholesky(H) |
| K = n // blk |
| diag = torch.stack([C[k * blk:(k + 1) * blk, k * blk:(k + 1) * blk] |
| for k in range(K)]) |
| dinv = torch.linalg.inv(diag) |
| Binv = torch.zeros_like(C) |
| idx = torch.arange(blk, device=H.device) |
| for k in range(K): |
| Binv[k * blk + idx[:, None], k * blk + idx[None, :]] = dinv[k] |
| return C @ Binv |
|
|
|
|
| def prepare_hessian(H, seed, rht_on=True, blk=D_SUB, damp=0.01): |
| """Rotate, damp and block-LDL-factorise a Hessian once, so that every linear |
| sharing this input reuses the factorisation.""" |
| dev = H.device |
| Hf = H.float().clone() |
| dead = torch.diag(Hf) <= 0 |
| if dead.any(): |
| Hf[dead, dead] = 1.0 |
| Hf += torch.eye(Hf.shape[0], device=dev) * (damp * torch.diag(Hf).mean()) |
| Hr = rht_hessian(Hf, seed) if rht_on else Hf |
| return _block_ldl(Hr, blk), dead |
|
|
|
|
| def ldlq_quantize(W, L, dead, codebooks, stages, seed=1234, rht_on=True, |
| blk=D_SUB, refine=0): |
| """Hessian-aware quantisation: minimise ||(W-What) X||_F with H = X X^T, |
| by block-LDL error feedback over blk-column groups, each group coded by the |
| residual VQ. `L`/`dead` come from `prepare_hessian` and are shared by all |
| linears reading the same input.""" |
| dt = W.dtype |
| Wf = W.float() |
| if dead is not None and dead.any(): |
| Wf = Wf.clone() |
| Wf[:, dead] = 0.0 |
|
|
| X = rht_forward(Wf, seed) if rht_on else Wf |
| scale = X.pow(2).mean(dim=1, keepdim=True).sqrt().clamp_min(1e-8) |
| Xn = X / scale |
|
|
| o, i = Xn.shape |
| K = i // blk |
| Q = torch.zeros_like(Xn) |
| E = torch.zeros_like(Xn) |
| for k in range(K - 1, -1, -1): |
| s = slice(k * blk, (k + 1) * blk) |
| tgt = Xn[:, s] |
| if k + 1 < K: |
| tgt = tgt + E[:, (k + 1) * blk:] @ L[(k + 1) * blk:, s] |
| Q[:, s] = vq(tgt.reshape(-1, D_SUB), codebooks, stages, |
| refine).reshape(o, blk) |
| E[:, s] = Xn[:, s] - Q[:, s] |
|
|
| Xq = Q * scale |
| What = rht_inverse(Xq, seed) if rht_on else Xq |
| bits = stages * BITS_PER_STAGE + 16.0 / i |
| return What.to(dt), dict(bits=bits, stages=stages) |
|
|
|
|
| def quantize(W, codebooks, stages, seed=1234, rht_on=True, refine=1): |
| """Quantise [out,in] weight matrix at `stages`*0.5 bits/weight, ignoring |
| activation statistics (the data-free ablation of `ldlq_quantize`).""" |
| Wf = W.float() |
| X = rht_forward(Wf, seed) if rht_on else Wf |
| o, i = X.shape |
| scale = X.pow(2).mean(dim=1, keepdim=True).sqrt().clamp_min(1e-8) |
| Xn = X / scale |
| Q = vq(Xn.reshape(-1, D_SUB), codebooks, stages, refine).reshape(o, i) |
| Xq = Q * scale |
| What = rht_inverse(Xq, seed) if rht_on else Xq |
| bits = stages * BITS_PER_STAGE + 16.0 / i |
| return What.to(W.dtype), dict(bits=bits, stages=stages) |
|
|
|
|
| def build_codebooks(max_stages=6, device="cpu", seed=0): |
| """Stage-0 codebook on Gaussian data; each later stage on the residual |
| distribution produced by the preceding stages (so shapes adapt).""" |
| g = torch.Generator(device="cpu").manual_seed(seed) |
| X = torch.randn(400_000, D_SUB, generator=g).to(device) |
| cbs, R = [], X.clone() |
| for s in range(max_stages): |
| C = _kmeans(R, CB_SIZE, iters=35, seed=seed + s, device=device) |
| cbs.append(C) |
| R = R - C[_assign(R, C)] |
| return cbs |
|
|
|
|
| def _kmeans(X, size, iters, seed, device): |
| g = torch.Generator(device="cpu").manual_seed(seed) |
| n = X.shape[0] |
| C = X[torch.randperm(n, generator=g)[:size]].clone() |
| for _ in range(iters): |
| idx = _assign(X, C) |
| C_new = torch.zeros_like(C) |
| cnt = torch.zeros(size, device=device) |
| C_new.index_add_(0, idx, X) |
| cnt.index_add_(0, idx, torch.ones(n, device=device)) |
| dead = cnt == 0 |
| C_new[~dead] /= cnt[~dead].unsqueeze(1) |
| if dead.any(): |
| C_new[dead] = X[torch.randint(0, n, (int(dead.sum()),), |
| generator=g)] |
| C = C_new |
| return C |
|
|
|
|
| |
| def rtn(W, bits, group=128): |
| """Round-to-nearest uniform baseline with per-group asymmetric scales.""" |
| o, i = W.shape |
| Wf = W.float().reshape(o, i // group, group) |
| mn = Wf.amin(-1, keepdim=True) |
| mx = Wf.amax(-1, keepdim=True) |
| n = 2 ** bits - 1 |
| s = ((mx - mn) / n).clamp_min(1e-9) |
| q = ((Wf - mn) / s).round().clamp(0, n) |
| Wq = (q * s + mn).reshape(o, i) |
| eff = bits + 2 * 16.0 / group |
| return Wq.to(W.dtype), dict(bits=eff) |
|
|
