| |
| """Kernel-level smoke test for the quantised V4.1 expert blocks on a real ggml backend. |
| |
| Loads expert tensors straight out of the artifact produced by ``v41_quant_experts.py`` |
| (raw IQ2_XXS / Q2_K block bytes), multiplies them by an activation row through ggml's |
| ``ggml_mul_mat`` on the selected backend (CPU or CUDA), and compares the result with a |
| float32 reference computed from the original MXFP4 decode. Also reports achieved weight |
| bandwidth so the one-B200 throughput assumptions can be checked against hardware. |
| |
| This proves the blocks execute on the target GPU. It is not a model run: no tokenizer, no |
| attention, no generation. Plan gates for a kernel qualification are rel-RMS <= 1% and |
| cosine >= 0.999 against the fp32 reference. |
| |
| Usage: |
| python3 v41_quant_kernel_smoke.py --artifact OUT --ggml-lib /opt/llama.cpp/build/bin \\ |
| --tensors 4 --json kernel-smoke.json |
| python3 v41_quant_kernel_smoke.py --artifact OUT --ggml-lib ... --cpu-only |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from v41_quant_experts import ( |
| GGML_TYPE_IDS, |
| decode_mxfp4, |
| read_safetensors_header, |
| ) |
|
|
| from gguf.constants import GGMLQuantizationType |
| from gguf.quants import dequantize |
|
|
|
|
| def load_expert_tensor(artifact: Path, name: str, shard: str, shape: tuple[int, ...]) -> bytes: |
| header, start = read_safetensors_header(artifact / shard) |
| begin, end = header[name]["data_offsets"] |
| with open(artifact / shard, "rb") as fh: |
| fh.seek(start + begin) |
| return fh.read(end - begin) |
|
|
|
|
| def run_kernel( |
| kernel_bin: Path, |
| blocks: bytes, |
| rows: int, |
| cols: int, |
| ggml_type: str, |
| activation: np.ndarray, |
| work: Path, |
| ) -> tuple[np.ndarray, float]: |
| """Execute one quantised tensor through the ggml harness and return (result, GiB/s).""" |
| import subprocess |
| import tempfile |
|
|
| with tempfile.TemporaryDirectory(dir=work) as tmp: |
| tmp_path = Path(tmp) |
| (tmp_path / "blocks.bin").write_bytes(blocks) |
| (tmp_path / "act.f32").write_bytes(activation.astype(np.float32).tobytes()) |
| out = tmp_path / "out.f32" |
| proc = subprocess.run( |
| [ |
| str(kernel_bin), |
| str(tmp_path / "blocks.bin"), |
| str(rows), |
| str(cols), |
| str(GGML_TYPE_IDS[ggml_type]), |
| str(tmp_path / "act.f32"), |
| str(out), |
| str(os.cpu_count() or 4), |
| ], |
| capture_output=True, |
| text=True, |
| ) |
| if proc.returncode != 0: |
| raise SystemExit(f"kernel_smoke failed: {proc.stderr.strip()}") |
| bandwidth = 0.0 |
| for line in proc.stderr.splitlines(): |
| if "GiB_per_s=" in line: |
| bandwidth = float(line.rsplit("GiB_per_s=", 1)[1]) |
| result = np.frombuffer(out.read_bytes(), dtype=np.float32) |
| return result, bandwidth |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--artifact", type=Path, required=True) |
| parser.add_argument("--kernel-bin", type=Path, help="compiled kernel_smoke binary") |
| parser.add_argument("--tensors", type=int, default=4, help="expert tensors to test") |
| parser.add_argument("--seed", type=int, default=20260910) |
| parser.add_argument("--json", type=Path) |
| parser.add_argument("--work", type=Path, default=Path("/tmp")) |
| args = parser.parse_args() |
|
|
| plan = json.loads((args.artifact / "plan.json").read_text()) |
| quantised = [ |
| tensor |
| for shard in plan["shards"] |
| for tensor in shard["tensors"] |
| if tensor["role"] == "quantised" |
| ] |
| if not quantised: |
| raise SystemExit("artifact has no quantised expert tensors") |
|
|
| rng = np.random.default_rng(args.seed) |
| step = max(1, len(quantised) // args.tensors) |
| picked = quantised[::step][: args.tensors] |
|
|
| results = [] |
| for tensor in picked: |
| raw = load_expert_tensor( |
| args.artifact, tensor["name"], tensor["out_shard"], tuple(tensor["out_shape"]) |
| ) |
| expected = int(np.prod(tensor["out_shape"])) |
| if len(raw) != expected: |
| raise SystemExit(f"{tensor['name']}: {len(raw)} bytes != planned {expected}") |
| rows, row_bytes = tensor["out_shape"] |
| block_bytes = 66 if tensor["ggml_type"] == "IQ2_XXS" else 84 |
| cols = row_bytes // block_bytes * 256 |
| entry = { |
| "name": tensor["name"], |
| "ggml_type": tensor["ggml_type"], |
| "rows": rows, |
| "cols": cols, |
| "bytes": len(raw), |
| } |
| if args.kernel_bin: |
| activation = rng.standard_normal(cols).astype(np.float32) |
| result, bandwidth = run_kernel( |
| args.kernel_bin, raw, rows, cols, tensor["ggml_type"], activation, args.work |
| ) |
| blocks = np.frombuffer(raw, dtype=np.uint8) |
| qtype = GGMLQuantizationType[tensor["ggml_type"]] |
| reference = dequantize(blocks, qtype).reshape(rows, cols).astype(np.float64) |
| expected_vec = reference @ activation.astype(np.float64) |
| got = result.astype(np.float64) |
| cosine = float(expected_vec @ got / (np.linalg.norm(expected_vec) * np.linalg.norm(got))) |
| rel_rms = float( |
| np.sqrt(((expected_vec - got) ** 2).mean()) / np.sqrt((expected_vec**2).mean()) |
| ) |
| entry.update( |
| { |
| "cosine_vs_reference": round(cosine, 8), |
| "relative_rms_vs_reference": round(rel_rms, 8), |
| "weight_bandwidth_GiB_per_s": round(bandwidth, 3), |
| "finite": bool(np.isfinite(got).all()), |
| } |
| ) |
| results.append(entry) |
|
|
| record = { |
| "artifact": str(args.artifact), |
| "kernel_bin": str(args.kernel_bin) if args.kernel_bin else None, |
| "tensors": results, |
| "gates": {"cosine_min": 0.999, "relative_rms_max": 0.01}, |
| } |
| if args.kernel_bin: |
| ok = all( |
| r["cosine_vs_reference"] >= 0.999 and r["relative_rms_vs_reference"] <= 0.01 |
| for r in results |
| ) |
| |
| |
| record["kernel_agrees_with_dequantised_reference"] = ok |
| print(json.dumps(record, indent=1)) |
| if args.json: |
| args.json.write_text(json.dumps(record, indent=1) + "\n") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
