Upload 12 files

__init__.py

@@ -14,6 +14,7 @@ from .factored import (
     factor_only_solve,
     factor_q2k_block,
 )
+from .gguf import GGUFReader, expand_importance, lookup_imatrix, read_imatrix
 from .pipeline import Q2KQuantizer, QuantizedTensor, TensorStats
 from .q2k import Q2KBlock, QK_K, dequantize_params, pack_codes, unpack_codes
 
@@ -30,6 +31,10 @@ __all__ = [
     "factor_candidates",
     "factor_only_solve",
     "factor_q2k_block",
+    "GGUFReader",
+    "expand_importance",
+    "lookup_imatrix",
+    "read_imatrix",
     "pack_codes",
     "unpack_codes",
 ]

__main__.py

@@ -1,9 +1,14 @@
-"""Command-line entry point for the V2 factored Q2_K quantizer.
+"""Command-line entry point for HPC-Quantize V2.
 
 Examples::
 
     python -m hpc_quantize_v2 --demo
     python -m hpc_quantize_v2 --input tensor.npy --output tensor_q2k.npz
+    python -m hpc_quantize_v2 --gguf model.gguf --list-tensors
+    python -m hpc_quantize_v2 --gguf model.gguf --tensor blk.0.ffn_down.weight \
+        --imatrix-gguf imatrix.gguf --output ffn_down_q2k.npz
+    python -m hpc_quantize_v2 --gguf model.gguf --all-q2k \
+        --imatrix-gguf imatrix.gguf --output model_q2k_arrays.npz
 """
 
 from __future__ import annotations
@@ -13,14 +18,180 @@ import argparse
 import numpy as np
 
 from .config import HPCConfig
+from .factored import factor_only_solve
+from .gguf import (
+    GGUFReader,
+    expand_importance,
+    is_q2k_eligible,
+    lookup_imatrix,
+    read_imatrix,
+)
 from .pipeline import Q2KQuantizer
+from .reference import reference_solve, synthetic_cases
+
+
+def _config_from_args(args) -> HPCConfig:
+    cfg = HPCConfig(verbose=args.verbose)
+    if args.cand_d is not None:
+        cfg.n_cand_d = args.cand_d
+    if args.cand_m is not None:
+        cfg.n_cand_m = args.cand_m
+    if args.mse:
+        cfg.optimizer = "mse"
+    if args.no_spectral:
+        cfg.use_spectral = False
+    return cfg.validate()
+
+
+def _importance_for(imat, name, n_elements, row_width):
+    if imat is None:
+        return None
+    raw = lookup_imatrix(imat, name)
+    if raw is None:
+        return None
+    return expand_importance(raw, n_elements, row_width)
+
+
+def _save_result(path: str, res, prefix: str = "", extra: dict | None = None) -> None:
+    payload = {
+        f"{prefix}scales": res.scales,
+        f"{prefix}qs": res.qs,
+        f"{prefix}dm": res.dm,
+        f"{prefix}dequantized": res.dequantize(),
+        f"{prefix}rmse": np.float32(res.stats.rmse),
+    }
+    if extra:
+        payload.update(extra)
+    np.savez_compressed(path, **payload)
+
+
+def _run_gguf(args, cfg: HPCConfig) -> None:
+    reader = GGUFReader(args.gguf)
+    imat = None
+    imatrix_path = args.imatrix_gguf or args.imatrix
+    if imatrix_path:
+        imat = read_imatrix(imatrix_path)
+        print(f"iMatrix: {len(imat)} tensors from {imatrix_path}")
+
+    if args.list_tensors or (not args.tensor and not args.all_q2k):
+        print(f"{reader.path}: {len(reader.tensors)} tensors, {len(reader.metadata)} metadata keys")
+        for ti in reader.tensors:
+            tag = "Q2K" if is_q2k_eligible(ti.name, ti.dims) else "   "
+            print(
+                f"  {tag} {ti.name:48s} {ti.type_name:6s} "
+                f"dims={ti.dims} row={ti.row_width}"
+            )
+        return
+
+    quantizer = Q2KQuantizer(cfg)
+    if args.all_q2k:
+        payload: dict[str, np.ndarray] = {}
+        done = 0
+        for ti in reader.tensors:
+            if not is_q2k_eligible(ti.name, ti.dims):
+                continue
+            if args.limit and done >= args.limit:
+                break
+            x, row = reader.read_tensor(ti.name)
+            if args.rows:
+                x = x[: args.rows * row]
+            imp = _importance_for(imat, ti.name, x.size, row)
+            res = quantizer.quantize(x, importance=imp, row_width=row)
+            prefix = ti.name.replace("/", "_") + "__"
+            payload[f"{prefix}scales"] = res.scales
+            payload[f"{prefix}qs"] = res.qs
+            payload[f"{prefix}dm"] = res.dm
+            payload[f"{prefix}rmse"] = np.float32(res.stats.rmse)
+            print(
+                f"  {ti.name:48s} row={row:6d} rmse={res.stats.rmse:.6e} "
+                f"imatrix={'yes' if imp is not None else 'no'}"
+            )
+            done += 1
+        if args.output:
+            np.savez_compressed(args.output, **payload)
+            print(f"wrote {args.output} ({done} tensors)")
+        return
+
+    ti = reader.info(args.tensor)
+    x, row = reader.read_tensor(ti.name)
+    if args.rows:
+        x = x[: args.rows * row]
+    imp = _importance_for(imat, ti.name, x.size, row)
+    res = quantizer.quantize(x, importance=imp, row_width=row)
+    print(
+        f"{ti.name}: type={ti.type_name} row={row} blocks={len(res.blocks)} "
+        f"rmse={res.stats.rmse:.6e} imatrix={'yes' if imp is not None else 'no'}"
+    )
+    if args.output:
+        _save_result(
+            args.output,
+            res,
+            extra={
+                "name": np.array(ti.name),
+                "row_width": np.int64(row),
+                "source_type": np.array(ti.type_name),
+            },
+        )
+        print(f"wrote {args.output}")
+
+
+def _run_numpy(args, cfg: HPCConfig) -> None:
+    weights = np.load(args.input)
+    importance = np.load(args.importance) if args.importance else None
+    if importance is None and (args.imatrix_gguf or args.imatrix):
+        if not args.tensor_name:
+            raise SystemExit("--tensor-name is required to select an iMatrix entry for .npy input")
+        imat = read_imatrix(args.imatrix_gguf or args.imatrix)
+        raw = lookup_imatrix(imat, args.tensor_name)
+        if raw is None:
+            raise SystemExit(f"iMatrix entry not found: {args.tensor_name}")
+        row = int(weights.shape[-1]) if weights.ndim >= 2 else int(weights.size)
+        importance = expand_importance(raw, weights.size, row)
+    res = Q2KQuantizer(cfg).quantize(weights, importance=importance)
+    if args.output:
+        _save_result(args.output, res)
+        print(f"wrote {args.output}")
+    else:
+        _ = res.dequantize()
+
+
+def _bench(per_kind: int) -> None:
+    from collections import defaultdict
+
+    cases = synthetic_cases(123, per_kind)
+    for use_spectral in (False, True):
+        cfg = HPCConfig(use_spectral=use_spectral)
+        gains = defaultdict(list)
+        for kind, x in cases:
+            w = np.ones(x.size, dtype=np.float32)
+            v2 = factor_only_solve(x, w, cfg)
+            ref_obj, _ = reference_solve(x, w, cfg, use_spectral)
+            gains[kind].append((ref_obj - v2.objective) / max(abs(ref_obj), 1.0e-30))
+        print(f"spectral={use_spectral}")
+        for kind, vals in gains.items():
+            arr = np.asarray(vals)
+            print(
+                f"  {kind:14s} mean={arr.mean()*100:6.2f}% "
+                f"median={np.median(arr)*100:6.2f}% min={arr.min()*100:6.2f}% "
+                f"worse={int(np.sum(arr < -1e-9))}/{arr.size}"
+            )
 
 
 def main() -> None:
     parser = argparse.ArgumentParser(description="HPC-Quantize V2 factored Q2_K")
-    parser.add_argument("--input", help=".npy file containing float weights")
-    parser.add_argument("--importance", help="optional .npy importance matrix")
-    parser.add_argument("--output", help="output .npz with scales/qs/dm")
+    source = parser.add_mutually_exclusive_group()
+    source.add_argument("--input", help=".npy file containing float weights")
+    source.add_argument("--gguf", help="source GGUF file")
+    parser.add_argument("--tensor", help="GGUF tensor name to quantize")
+    parser.add_argument("--tensor-name", help="name used to look up an iMatrix entry for .npy input")
+    parser.add_argument("--list-tensors", action="store_true", help="list GGUF tensors and exit")
+    parser.add_argument("--all-q2k", action="store_true", help="quantize all eligible GGUF tensors")
+    parser.add_argument("--limit", type=int, default=0, help="limit tensors in --all-q2k")
+    parser.add_argument("--rows", type=int, default=0, help="limit rows for a single GGUF tensor")
+    parser.add_argument("--importance", help="optional .npy importance array")
+    parser.add_argument("--imatrix-gguf", help="llama.cpp iMatrix .gguf file")
+    parser.add_argument("--imatrix", help="alias for --imatrix-gguf (GGUF or legacy .dat)")
+    parser.add_argument("--output", help="output .npz")
     parser.add_argument("--demo", action="store_true", help="quantize synthetic weights")
     parser.add_argument("--blocks", type=int, default=64, help="demo block count")
     parser.add_argument("--std", type=float, default=0.02, help="demo weight std")
@@ -28,39 +199,41 @@ def main() -> None:
     parser.add_argument("--cand-d", type=int, default=None, help="candidate d count")
     parser.add_argument("--cand-m", type=int, default=None, help="candidate min count")
     parser.add_argument("--mse", action="store_true", help="disable HPC sequence search")
+    parser.add_argument("--no-spectral", action="store_true", help="disable spectral/DC objective")
     parser.add_argument("--verbose", action="store_true")
+    parser.add_argument("--bench", action="store_true", help="measure solver gains vs C port")
+    parser.add_argument("--bench-per-kind", type=int, default=12)
     args = parser.parse_args()
 
+    cfg = _config_from_args(args)
+
+    if args.bench:
+        _bench(args.bench_per_kind)
+        return
+
+    if args.gguf:
+        _run_gguf(args, cfg)
+        return
+
     if args.demo:
         rng = np.random.default_rng(args.seed)
         weights = rng.normal(0.0, args.std, size=(args.blocks, 256)).astype(np.float32)
         importance = None
-    elif args.input:
-        weights = np.load(args.input)
-        importance = np.load(args.importance) if args.importance else None
-    else:
-        parser.error("pass --demo or --input")
+        if args.imatrix_gguf or args.imatrix:
+            imat = read_imatrix(args.imatrix_gguf or args.imatrix)
+            name = args.tensor_name or next(iter(imat))
+            importance = expand_importance(lookup_imatrix(imat, name), weights.size, int(weights.shape[-1]))
+        res = Q2KQuantizer(cfg).quantize(weights, importance=importance)
+        if args.output:
+            _save_result(args.output, res)
+            print(f"wrote {args.output}")
+        return
 
-    cfg = HPCConfig(verbose=True)
-    if args.cand_d is not None:
-        cfg.n_cand_d = args.cand_d
-    if args.cand_m is not None:
-        cfg.n_cand_m = args.cand_m
-    if args.mse:
-        cfg.optimizer = "mse"
+    if args.input:
+        _run_numpy(args, cfg)
+        return
 
-    result = Q2KQuantizer(cfg).quantize(weights, importance=importance)
-    if args.output:
-        np.savez_compressed(
-            args.output,
-            scales=result.scales,
-            qs=result.qs,
-            dm=result.dm,
-            dequantized=result.dequantize(),
-        )
-        print(f"wrote {args.output}")
-    else:
-        _ = result.dequantize()
+    parser.error("pass --demo, --input, --gguf or --bench")
 
 
 if __name__ == "__main__":

gguf.py

@@ -0,0 +1,326 @@
+"""Minimal GGUF reader and llama.cpp iMatrix loader.
+
+The V2 quantizer works on float tensors, so GGUF ingestion is deliberately a
+thin, read-only layer:
+
+* parse the GGUF header, metadata and tensor directory;
+* dequantize the common source types (F32, F16, BF16, Q8_0, Q4_0 and Q2_K);
+* read llama.cpp ``.gguf``/legacy ``.dat`` importance matrices and normalize
+  each vector to mean 1.0, matching ``imatrix_reader.h``.
+
+No GGUF writer is provided here; the quantizer emits Q2_K arrays that can be
+packed by an external GGUF writer.
+"""
+
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+from .q2k import QK_K, dequantize_params_batch, unpack_codes
+
+GGUF_MAGIC = 0x46554747
+DEFAULT_ALIGNMENT = 32
+
+GGML_TYPE_F32 = 0
+GGML_TYPE_F16 = 1
+GGML_TYPE_Q4_0 = 2
+GGML_TYPE_Q4_1 = 3
+GGML_TYPE_Q5_0 = 6
+GGML_TYPE_Q5_1 = 7
+GGML_TYPE_Q8_0 = 8
+GGML_TYPE_Q2_K = 10
+GGML_TYPE_BF16 = 30
+
+TYPE_NAME = {
+    GGML_TYPE_F32: "F32",
+    GGML_TYPE_F16: "F16",
+    GGML_TYPE_Q4_0: "Q4_0",
+    GGML_TYPE_Q4_1: "Q4_1",
+    GGML_TYPE_Q5_0: "Q5_0",
+    GGML_TYPE_Q5_1: "Q5_1",
+    GGML_TYPE_Q8_0: "Q8_0",
+    GGML_TYPE_Q2_K: "Q2_K",
+    GGML_TYPE_BF16: "BF16",
+}
+
+BLOCK_SIZE = {
+    GGML_TYPE_F32: 1,
+    GGML_TYPE_F16: 1,
+    GGML_TYPE_BF16: 1,
+    GGML_TYPE_Q4_0: 32,
+    GGML_TYPE_Q4_1: 32,
+    GGML_TYPE_Q5_0: 32,
+    GGML_TYPE_Q5_1: 32,
+    GGML_TYPE_Q8_0: 32,
+    GGML_TYPE_Q2_K: QK_K,
+}
+BLOCK_BYTES = {
+    GGML_TYPE_F32: 4,
+    GGML_TYPE_F16: 2,
+    GGML_TYPE_BF16: 2,
+    GGML_TYPE_Q4_0: 18,
+    GGML_TYPE_Q4_1: 20,
+    GGML_TYPE_Q5_0: 22,
+    GGML_TYPE_Q5_1: 24,
+    GGML_TYPE_Q8_0: 34,
+    GGML_TYPE_Q2_K: 84,
+}
+
+
+@dataclass(slots=True)
+class TensorInfo:
+    name: str
+    dims: tuple[int, ...]
+    type: int
+    offset: int
+
+    @property
+    def n_elements(self) -> int:
+        n = 1
+        for d in self.dims:
+            n *= int(d)
+        return n
+
+    @property
+    def row_width(self) -> int:
+        return int(self.dims[0]) if self.dims else 1
+
+    @property
+    def type_name(self) -> str:
+        return TYPE_NAME.get(self.type, f"type_{self.type}")
+
+    @property
+    def n_bytes(self) -> int:
+        if self.type not in BLOCK_SIZE:
+            raise ValueError(f"unsupported GGUF type {self.type} ({self.type_name})")
+        block = BLOCK_SIZE[self.type]
+        if self.n_elements % block != 0:
+            raise ValueError(f"{self.name}: element count is not block-aligned")
+        return (self.n_elements // block) * BLOCK_BYTES[self.type]
+
+
+def _align(value: int, alignment: int = DEFAULT_ALIGNMENT) -> int:
+    return (value + alignment - 1) & ~(alignment - 1)
+
+
+def _read_string(f) -> str:
+    n = struct.unpack("<Q", f.read(8))[0]
+    return f.read(n).decode("utf-8", errors="replace")
+
+
+def _read_value(f, vtype: int):
+    if vtype == 0:
+        return struct.unpack("<B", f.read(1))[0]
+    if vtype == 1:
+        return struct.unpack("<b", f.read(1))[0]
+    if vtype == 2:
+        return struct.unpack("<H", f.read(2))[0]
+    if vtype == 3:
+        return struct.unpack("<h", f.read(2))[0]
+    if vtype == 4:
+        return struct.unpack("<I", f.read(4))[0]
+    if vtype == 5:
+        return struct.unpack("<i", f.read(4))[0]
+    if vtype == 6:
+        return struct.unpack("<f", f.read(4))[0]
+    if vtype == 7:
+        return bool(struct.unpack("<B", f.read(1))[0])
+    if vtype == 8:
+        return _read_string(f)
+    if vtype == 9:
+        subtype = struct.unpack("<I", f.read(4))[0]
+        length = struct.unpack("<Q", f.read(8))[0]
+        if subtype == 8:
+            for _ in range(length):
+                _read_string(f)
+        else:
+            sizes = {0: 1, 1: 1, 2: 2, 3: 2, 4: 4, 5: 4, 6: 4, 7: 1, 10: 8, 11: 8, 12: 8}
+            f.read(sizes.get(subtype, 4) * length)
+        return None
+    if vtype == 10:
+        return struct.unpack("<Q", f.read(8))[0]
+    if vtype == 11:
+        return struct.unpack("<q", f.read(8))[0]
+    if vtype == 12:
+        return struct.unpack("<d", f.read(8))[0]
+    raise ValueError(f"unknown GGUF value type {vtype}")
+
+
+class GGUFReader:
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self.metadata: dict[str, object] = {}
+        self.tensors: list[TensorInfo] = []
+        with self.path.open("rb") as f:
+            magic, version = struct.unpack("<II", f.read(8))
+            if magic != GGUF_MAGIC:
+                raise ValueError(f"{self.path} is not a GGUF file")
+            self.version = version
+            n_tensors, n_kv = struct.unpack("<QQ", f.read(16))
+            for _ in range(n_kv):
+                key = _read_string(f)
+                vtype = struct.unpack("<I", f.read(4))[0]
+                self.metadata[key] = _read_value(f, vtype)
+            for _ in range(n_tensors):
+                name = _read_string(f)
+                n_dims = struct.unpack("<I", f.read(4))[0]
+                dims = tuple(struct.unpack("<Q", f.read(8))[0] for _ in range(n_dims))
+                ttype = struct.unpack("<I", f.read(4))[0]
+                offset = struct.unpack("<Q", f.read(8))[0]
+                self.tensors.append(TensorInfo(name, dims, ttype, offset))
+            self.data_start = _align(f.tell(), int(self.metadata.get("general.alignment", DEFAULT_ALIGNMENT)))
+        self._by_name = {ti.name: ti for ti in self.tensors}
+
+    def info(self, name: str) -> TensorInfo:
+        try:
+            return self._by_name[name]
+        except KeyError:
+            raise KeyError(f"tensor '{name}' not found in {self.path}") from None
+
+    def list_tensors(self) -> list[TensorInfo]:
+        return list(self.tensors)
+
+    def read_tensor(self, name: str) -> tuple[np.ndarray, int]:
+        ti = self.info(name)
+        with self.path.open("rb") as f:
+            f.seek(self.data_start + ti.offset)
+            raw = f.read(ti.n_bytes)
+        if len(raw) != ti.n_bytes:
+            raise ValueError(f"{name}: truncated tensor data")
+        return _dequantize(raw, ti), ti.row_width
+
+
+def _dequantize(raw: bytes, ti: TensorInfo) -> np.ndarray:
+    t = ti.type
+    if t == GGML_TYPE_F32:
+        return np.frombuffer(raw, dtype="<f4").astype(np.float32)
+    if t == GGML_TYPE_F16:
+        return np.frombuffer(raw, dtype="<f2").astype(np.float32)
+    if t == GGML_TYPE_BF16:
+        bits = np.frombuffer(raw, dtype="<u2").astype(np.uint32) << 16
+        return bits.view(np.float32)
+    if t == GGML_TYPE_Q8_0:
+        blocks = np.frombuffer(raw, dtype=np.uint8).reshape(-1, 34)
+        d = blocks[:, :2].copy().view("<f2").reshape(-1).astype(np.float32)
+        q = blocks[:, 2:].view(np.int8).astype(np.float32)
+        return (d[:, None] * q).reshape(-1)
+    if t == GGML_TYPE_Q4_0:
+        blocks = np.frombuffer(raw, dtype=np.uint8).reshape(-1, 18)
+        d = blocks[:, :2].copy().view("<f2").reshape(-1).astype(np.float32)
+        qs = blocks[:, 2:]
+        low = (qs & 0x0F).astype(np.float32) - 8.0
+        high = (qs >> 4).astype(np.float32) - 8.0
+        q = np.concatenate([low, high], axis=1)
+        return (d[:, None] * q).reshape(-1)
+    if t == GGML_TYPE_Q2_K:
+        blocks = np.frombuffer(raw, dtype=np.uint8).reshape(-1, 84)
+        scales = blocks[:, :16]
+        qs = blocks[:, 16:80]
+        d = blocks[:, 80:82].copy().view("<f2").reshape(-1).astype(np.float32)
+        dmin = blocks[:, 82:84].copy().view("<f2").reshape(-1).astype(np.float32)
+        codes = np.stack([unpack_codes(q) for q in qs])
+        return dequantize_params_batch(d, dmin, scales & 0x0F, scales >> 4, codes).reshape(-1)
+    raise ValueError(f"unsupported source GGUF type {ti.type_name} for {ti.name}")
+
+
+def read_imatrix(path: str | Path) -> dict[str, np.ndarray]:
+    """Read a llama.cpp imatrix (GGUF) or legacy .dat file.
+
+    Returns ``name -> float32 vector`` normalized to mean 1.0, exactly the
+    per-input-column ``E[a^2]`` weight used by the C engine.
+    """
+    path = Path(path)
+    imat: dict[str, np.ndarray] = {}
+    with path.open("rb") as f:
+        magic = struct.unpack("<I", f.read(4))[0]
+        if magic == GGUF_MAGIC:
+            f.seek(0)
+            reader = GGUFReader(path)
+            sums: dict[str, np.ndarray] = {}
+            counts: dict[str, np.ndarray] = {}
+            with reader.path.open("rb") as fh:
+                for ti in reader.tensors:
+                    if not (ti.name.endswith(".in_sum2") or ti.name.endswith(".counts")):
+                        continue
+                    fh.seek(reader.data_start + ti.offset)
+                    raw = fh.read(ti.n_bytes)
+                    data = np.frombuffer(raw, dtype="<f4").astype(np.float32)
+                    if ti.name.endswith(".in_sum2"):
+                        sums[ti.name[: -len(".in_sum2")]] = data
+                    else:
+                        counts[ti.name[: -len(".counts")]] = data
+            for base, sum2 in sums.items():
+                c = counts.get(base)
+                if c is not None and c.size and float(c.flat[0]) > 0.0:
+                    values = sum2 / float(c.flat[0])
+                else:
+                    values = np.ones_like(sum2)
+                mean = float(values.mean())
+                imat[base] = values / mean if mean > 1.0e-30 else np.ones_like(values)
+        else:
+            f.seek(0)
+            n_entries = struct.unpack("<i", f.read(4))[0]
+            for _ in range(n_entries):
+                name_len = struct.unpack("<i", f.read(4))[0]
+                name = f.read(name_len).decode("utf-8", errors="replace")
+                n_values = struct.unpack("<i", f.read(4))[0]
+                struct.unpack("<i", f.read(4))[0]
+                values = np.frombuffer(f.read(n_values * 4), dtype="<f4").astype(np.float32)
+                mean = float(values.mean())
+                imat[name] = values / mean if mean > 1.0e-30 else np.ones_like(values)
+    return imat
+
+
+def lookup_imatrix(imat: dict[str, np.ndarray], name: str) -> np.ndarray | None:
+    if name in imat:
+        return imat[name]
+    for suffix in (".weight", ".in_sum2", ".counts"):
+        alt = name[: -len(suffix)] if name.endswith(suffix) else name + suffix
+        if alt in imat:
+            return imat[alt]
+    return None
+
+
+def expand_importance(
+    values: np.ndarray | None, n_elements: int, row_width: int
+) -> np.ndarray | None:
+    if values is None:
+        return None
+    v = np.asarray(values, dtype=np.float32).ravel()
+    if v.size == n_elements:
+        return v
+    if row_width > 0 and v.size == row_width and n_elements % row_width == 0:
+        return np.tile(v, n_elements // row_width)
+    raise ValueError(
+        f"importance length {v.size} does not match {n_elements} elements "
+        f"(row width {row_width})"
+    )
+
+
+def is_q2k_eligible(name: str, dims: tuple[int, ...]) -> bool:
+    if len(dims) < 2:
+        return False
+    if dims[0] % QK_K != 0:
+        return False
+    if "token_embd" in name or name == "output.weight":
+        return False
+    if "norm" in name or ".bias" in name:
+        return False
+    if "ffn_gate_inp" in name:
+        return False
+    if name.startswith("mm.") or name.startswith("a.") or name.startswith("v."):
+        return False
+    if "altup" in name or "laurel" in name or "layer_output_scale" in name:
+        return False
+    if "ssm_a" in name or "ssm_dt" in name or "dt_bias" in name:
+        return False
+    if "ssm_conv1d" in name:
+        return False
+    n_elements = 1
+    for d in dims:
+        n_elements *= int(d)
+    return n_elements >= QK_K and n_elements % QK_K == 0