Add external eval + speculator quantizer

kit_manifest.json

@@ -1,5 +1,5 @@
 {
-  "built_from_commit": "785e81b0367f96f2bd846e5887d7fa21640ad5f6",
+  "built_from_commit": "59783ecd4ae674d2124d85b224dc33854c57fb3d",
   "capabilities": [
     "rht_int4_convert.layer_filter",
     "eval_quantized.dtype",
@@ -25,9 +25,11 @@
     "scripts/merge_language_hessians.py": "a6385caaa0d7190024b4e47ded59d1ab662e771ce81e18de94b30c8846829b4e",
     "scripts/merge_calibration_groups.py": "58a347ff40c47f629c073c23aea54e215c1e75c052737e5b4a48ff81946d8060",
     "scripts/eval_quantized.py": "5b4e5454630724c116d14fbc64061ffdd6066f4a458e228d372354d3eb32c5b0",
+    "scripts/eval_external_model.py": "55e432b6e581ad78e7ea6e292eff25fbaf7a17706f8eebc492a58fc03a51f948",
+    "scripts/quantize_speculator.py": "6d9299c63774476d93463ea7b5714f090c31d4cba3fdfc07b561982c78d47afa",
     "scripts/qad_finetune.py": "d20b15123731c8b5939ddfc00b3cb5c456a783e569c4babeef3a677a4b537244",
     "scripts/compute_bpc.py": "2b55fd1df406d54b40daeeca2ecaf2efb35981655f5bf5e0cc10c057ce796256",
-    "scripts/run_lane.py": "dc437d0bc41e2eeca3fc51218551b2e7175c6cc8bfc6cb43a61edaa55fbf72cc",
+    "scripts/run_lane.py": "f60869399ab84ae84f654e9773794b813ae1ab52bd031927e46c0ba0650d9b04",
     "scripts/make_sweep_spec.py": "dc31ec026c89e7db316a185575a4423bca988c2ac6cf08ef6df8f955328cda69",
     "scripts/make_smoke_specs.py": "a76091d7a6a38427cdde5264a49d7bb4d8bfcc75284705817dd4c83b012bba2e",
     "scripts/combine_lane_manifests.py": "164ba691d60b3e2987b805426c606d135dcf3cf0c855b38cf7f5d6d57628a481",
@@ -48,7 +50,7 @@
     "scripts/publish_results.py": "bc371280cc9f2fc45b2fee7d63422fb7e51b1f5bb0e14015f58de0f3ecec48ee",
     "scripts/tiny_sharding_probe.py": "29eb58f2689242b919616f6aab6ff753e0de031b16371137975b4d645e836fae",
     "scripts/audit_public_corpus.py": "84f1ec805a74004e71f63a70a8ed19967cb3fad9966f254798e655ab95e53ab0",
-    "scripts/build_kit.py": "1cd317b281a5279980d3db3ef7d786007e103328f5e3128a632efebda940f4ce",
+    "scripts/build_kit.py": "9a61a9d5aff46d62f9bb3fc491ce37607ba589012f12cf9244ed7f2fc2927255",
     "scripts/bootstrap_kaggle.py": "1633e3edbb80976c337444e3e4544e2b5210b2d8d1821e3a2717c1099c00843e",
     "data/calibration_en_wikitext2_dedup.txt": "18a79f4f938cc25747a90a12b120c7131e7f4ac55b58dfc691795ea61d4b5e9a",
     "data/calibration_ja_wikipedia_dedup.txt": "b45e3f3f00f2137be280a75c1fa9c9883a7e69d289257c4388fc701f33fee0d1",
@@ -93,6 +95,9 @@
     "lanes/smoke-group-size-ablation-08b.json": "60a2f363b94cff31abddf80738420bd02988ac2d8de171e84768221ab0982b00",
     "lanes/smoke-robustness-08b-shard1of5.json": "2afb4543eae46384e43f439998d295fe8550b2ec6f69c07ab5d8c9fb1dd46833",
     "lanes/smoke-seed-variance-08b.json": "f6acb2f2d3d3e0213a44013fecab6fac2050a477d28a563a3d307defe49f0fa2",
+    "lanes/sym8-emb-bits-08b.json": "165d30284ffaa4209cc26c2be88222f9053c5a74c892a16ad7fa84a5ca5cc75e",
+    "lanes/sym8-wide8-d1e-1-08b.json": "24d273ce3cd1a7e0ed1a12c91aaf4bb3d9209056dd4ff5db3c9a6bbb580e6e9d",
+    "lanes/sym8-wide8-d1e0-08b.json": "f9c8785bb47427c2be23a63568d81c8c00a5d5b882cf05cff3bc9124052e7abf",
     "tests/test_experiment_guards.py": "d71ddf9586c1d7ece52e217288b9d4b09079be54d32ceaf391be113c1832b6ef",
     "tests/test_compute_bpc.py": "bba5b6d0afc9b0699ebb6f7f0ed9fc5ebfcb98472867e9ccff4262fe9999949f",
     "tests/test_run_lane.py": "0043b2fff1c972612055f89990d15bec10cdf947d74652034d65c267ebaabda8",

lanes/sym8-emb-bits-08b.json

@@ -0,0 +1,57 @@
+{
+  "lane": "sym8-emb-bits-08b",
+  "model": {
+    "hf_repo": "Qwen/Qwen3.5-0.8B",
+    "spec_name": "Qwen3.5-0.8B",
+    "bf16_dir": "bf16-lalamo",
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
+  },
+  "paths": {
+    "kit": "kit",
+    "work": "/kaggle/working",
+    "jax_platform": "gpu"
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "data/eval_en_wikitext2_dedup.txt",
+      "ja": "data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "condition_defaults": {
+    "samples": 32,
+    "max_tokens": 128,
+    "output_block": "small",
+    "output_block_limit": 2048,
+    "damping": 0.1,
+    "raw_output": false
+  },
+  "convert": {
+    "bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "parallel": "tensor",
+    "symmetric_bits": "8",
+    "quantize_embedding": true,
+    "layer_bits_json": "lanes/bits-down-out-8.json"
+  },
+  "conditions": [
+    {
+      "name": "emb8",
+      "convert": {
+        "embedding_bits": 8
+      },
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt"
+    },
+    {
+      "name": "emb4",
+      "convert": {
+        "embedding_bits": 4
+      },
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt"
+    }
+  ]
+}

lanes/sym8-wide8-d1e-1-08b.json

@@ -0,0 +1,48 @@
+{
+  "lane": "sym8-wide8-d1e-1-08b",
+  "model": {
+    "hf_repo": "Qwen/Qwen3.5-0.8B",
+    "spec_name": "Qwen3.5-0.8B",
+    "bf16_dir": "bf16-lalamo",
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
+  },
+  "paths": {
+    "kit": "kit",
+    "work": "/kaggle/working",
+    "jax_platform": "gpu"
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "data/eval_en_wikitext2_dedup.txt",
+      "ja": "data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "condition_defaults": {
+    "samples": 32,
+    "max_tokens": 128,
+    "output_block": "small",
+    "output_block_limit": 2048,
+    "damping": 0.1,
+    "raw_output": false
+  },
+  "convert": {
+    "bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "parallel": "tensor",
+    "symmetric_bits": "8",
+    "quantize_embedding": true,
+    "embedding_bits": 4,
+    "layer_bits_json": "lanes/bits-wide-8.json"
+  },
+  "conditions": [
+    {
+      "name": "wide8-d1e-1",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt"
+    }
+  ]
+}

lanes/sym8-wide8-d1e0-08b.json

@@ -0,0 +1,48 @@
+{
+  "lane": "sym8-wide8-d1e0-08b",
+  "model": {
+    "hf_repo": "Qwen/Qwen3.5-0.8B",
+    "spec_name": "Qwen3.5-0.8B",
+    "bf16_dir": "bf16-lalamo",
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
+  },
+  "paths": {
+    "kit": "kit",
+    "work": "/kaggle/working",
+    "jax_platform": "gpu"
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "data/eval_en_wikitext2_dedup.txt",
+      "ja": "data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "condition_defaults": {
+    "samples": 32,
+    "max_tokens": 128,
+    "output_block": "small",
+    "output_block_limit": 2048,
+    "damping": 1.0,
+    "raw_output": false
+  },
+  "convert": {
+    "bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "parallel": "tensor",
+    "symmetric_bits": "8",
+    "quantize_embedding": true,
+    "embedding_bits": 4,
+    "layer_bits_json": "lanes/bits-wide-8.json"
+  },
+  "conditions": [
+    {
+      "name": "wide8-d1e0",
+      "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt"
+    }
+  ]
+}

scripts/build_kit.py

@@ -40,6 +40,8 @@ KIT_SCRIPTS = [
     "merge_language_hessians.py",
     "merge_calibration_groups.py",
     "eval_quantized.py",
+    "eval_external_model.py",
+    "quantize_speculator.py",
     "qad_finetune.py",
     "compute_bpc.py",
     "run_lane.py",

scripts/eval_external_model.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Evaluate an already-quantized model directory against a BF16 reference.
+
+`run_lane.py` always converts from BF16 first, so it cannot measure a model
+that arrives ready-made (an official release, a QAD output, a downloaded
+checkpoint). This is the missing half: point it at two directories and it
+produces the same ΔBPC JSON that the lanes report.
+
+Both directories must be lalamo-loadable after `make_lalamo_eval_copy.py`; the
+script builds the eval copies itself.
+
+Usage:
+    python scripts/eval_external_model.py \
+        --bf16-dir /kaggle/working/bf16-lalamo \
+        --candidate-dir /kaggle/working/official \
+        --corpus data/eval_en_wikitext2_dedup.txt --corpus data/eval_ja_wikipedia_dedup.txt \
+        --out /kaggle/working/official-eval
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+LANGS = {"wikitext2": "en", "wikipedia": "ja"}
+
+
+def language_of(corpus: Path) -> str:
+    name = corpus.name.lower()
+    for marker, lang in LANGS.items():
+        if marker in name:
+            return lang
+    return name.split("_")[1] if name.startswith("eval_") and "_" in name else "unknown"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--bf16-dir", type=Path, required=True, help="reference BF16 model directory")
+    parser.add_argument("--candidate-dir", type=Path, required=True, help="model to measure")
+    parser.add_argument("--corpus", type=Path, action="append", required=True)
+    parser.add_argument("--out", type=Path, required=True)
+    parser.add_argument("--max-sequences", type=int, default=100)
+    parser.add_argument("--max-tokens", type=int, default=128)
+    parser.add_argument("--min-tokens", type=int, default=16)
+    parser.add_argument("--dtype", default="float32")
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    args.out.mkdir(parents=True, exist_ok=True)
+    copies = {}
+    for label, source in (("bf16", args.bf16_dir), ("candidate", args.candidate_dir)):
+        destination = args.out / f"{label}-eval"
+        copies[label] = destination
+        command = [
+            sys.executable,
+            str(HERE / "make_lalamo_eval_copy.py"),
+            "--source",
+            str(source),
+            "--dest",
+            str(destination),
+        ]
+        if args.dry_run:
+            print("dry-run:", " ".join(command))
+        else:
+            subprocess.run(command, check=True)
+
+    results = {}
+    for corpus in args.corpus:
+        lang = language_of(corpus)
+        payload_path = args.out / f"{lang}.json"
+        command = [
+            sys.executable,
+            str(HERE / "eval_quantized.py"),
+            "--bf16-dir",
+            str(copies["bf16"]),
+            "--candidate-dir",
+            str(copies["candidate"]),
+            "--corpus",
+            str(corpus),
+            "--max-sequences",
+            str(args.max_sequences),
+            "--max-tokens",
+            str(args.max_tokens),
+            "--min-tokens",
+            str(args.min_tokens),
+            "--dtype",
+            args.dtype,
+            "--json-out",
+            str(payload_path),
+        ]
+        if args.dry_run:
+            print("dry-run:", " ".join(command))
+            continue
+        subprocess.run(command, check=True)
+        payload = json.loads(payload_path.read_text())
+        delta = (payload["bpc_candidate"] / payload["bpc_bf16"] - 1) * 100
+        results[lang] = {
+            "ppl": payload["candidate_ppl"],
+            "bf16_ppl": payload["bf16_ppl"],
+            "bpc_delta_pct": round(delta, 2),
+        }
+        print(f"{lang}: {payload['candidate_ppl']:.3f} bpc_delta={delta:+.2f}%", flush=True)
+
+    if args.dry_run:
+        return
+    (args.out / "summary.json").write_text(
+        json.dumps(results, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    print("=== FINAL ===", flush=True)
+    print(json.dumps(results, indent=1), flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/quantize_speculator.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Quantize a converted DFlash speculator to int4 like the official Mirai draft.
+
+`lalamo speculator convert` only writes float dtypes, so a converted draft stays
+bf16 (about 2.2GB for the 9B draft) while the official one is 755MB. This
+script reloads the draft as a lalamo module, compresses every Linear with a
+4-bit group-32 hybrid spec (the same scheme as the target model) and writes the
+result back in the uzu-loadable layout.
+
+The speculator directory also needs `shapes.json`, which the converter does not
+write; pass --shapes to copy one (or create an Argmax chain by default).
+
+Usage:
+  python scripts/quantize_speculator.py \
+    --source /tmp/spec_guglxni --output /tmp/spec_guglxni_int4 \
+    --bits 4 --group-size 32
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import time
+from pathlib import Path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", type=Path, required=True, help="converted speculator directory")
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--bits", type=int, default=4, choices=(4, 8))
+    parser.add_argument("--group-size", type=int, default=32)
+    parser.add_argument("--block-size", type=int, default=32)
+    parser.add_argument(
+        "--symmetric",
+        action="store_true",
+        help="omit zero points (required for int8; uzu never compiles asymmetric int8)",
+    )
+    parser.add_argument(
+        "--no-rewrite",
+        action="store_true",
+        help="skip the uzu metadata rewrite (the result will not load in uzu)",
+    )
+    parser.add_argument(
+        "--shapes",
+        type=Path,
+        default=None,
+        help="shapes.json to copy; default writes an Argmax chain with budget 16",
+    )
+    args = parser.parse_args()
+
+    import equinox as eqx
+    import jax
+    import jax.numpy as jnp
+
+    from lalamo.compressed.hybrid import HybridSpec
+    from lalamo.compressed.incoherence import HadamardSpec, IncoherenceProcessingMode
+    from lalamo.compressed.int import IntSpec
+    from lalamo.models.speculator import SpeculatorModel
+    from lalamo.modules.linear import Linear
+    from lalamo.utils.sharding import ShardingConfig
+    from lalamo.utils.surgery import map_nodes_of_type_with_path
+    from lalamo.weight_matrix import Layout
+
+    if args.bits == 8 and not args.symmetric:
+        raise SystemExit("int8 must be symmetric: uzu only compiles zero-point dequant for 4 bits")
+
+    sharding = ShardingConfig.replicated()
+    started = time.time()
+    model = SpeculatorModel.load(args.source, sharding, dtype=jnp.bfloat16)
+    print(f"loaded {args.source} in {time.time() - started:.1f}s", flush=True)
+
+    spec = HybridSpec(
+        quantization_spec=IntSpec(
+            bits=args.bits,
+            group_size=args.group_size,
+            is_symmetric=args.symmetric,
+            layout=Layout.OUTPUT_INPUT,
+        ),
+        adapter_spec=None,
+        incoherence_spec=None
+        if args.block_size <= 0
+        else HadamardSpec(
+            block_size=args.block_size,
+            processing_mode=IncoherenceProcessingMode.INPUT_OUTPUT,
+        ),
+    )
+
+    quantized = 0
+    skipped: list[tuple[str, tuple[int, ...]]] = []
+    key = jax.random.key(0)
+
+    def quantize_linear(path: tuple[str, ...], linear: Linear) -> Linear:
+        nonlocal quantized
+        shape = tuple(int(x) for x in linear.weights.shape)
+        if len(shape) != 2 or any(dimension % args.group_size for dimension in shape):
+            skipped.append(("/".join(path), shape))
+            return linear
+        started_at = time.time()
+        new_weights = spec.compress(
+            linear.weights.decompress(),
+            key=key,
+            sharding_config=linear.weights.sharding_config,
+            is_sharded=linear.weights.is_sharded,
+        )
+        quantized += 1
+        print(f"  {'.'.join(path)} {shape} {time.time() - started_at:.1f}s", flush=True)
+        return eqx.tree_at(lambda x: x.weights, linear, new_weights)
+
+    model = map_nodes_of_type_with_path(Linear, quantize_linear, model)
+    print(f"quantized {quantized} Linear layers, skipped {len(skipped)}", flush=True)
+    for path, shape in skipped:
+        print(f"  skipped {path} {shape}")
+
+    args.output.mkdir(parents=True, exist_ok=True)
+    model.save(args.output)
+
+    if args.shapes is not None:
+        shutil.copy2(args.shapes, args.output / "shapes.json")
+    else:
+        (args.output / "shapes.json").write_text(
+            json.dumps(
+                {
+                    "default": {
+                        "tree_budget": 16,
+                        "max_tree_depth": 16,
+                        "dflash_depth_override": None,
+                        "construction_method": {"type": "Argmax"},
+                    }
+                },
+                indent=2,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
+    if not args.no_rewrite:
+        import sys
+
+        sys.path.insert(0, str(Path(__file__).resolve().parent))
+        from rewrite_lalamo_hybrid_spec import rewrite
+
+        # uzu only understands the flat HybridSpec form; lalamo writes the nested one.
+        rewrite(args.output / "model.safetensors", backup=False)
+
+    total = sum(path.stat().st_size for path in args.output.iterdir())
+    print(f"wrote {args.output} ({total / 1e6:.0f}MB) in {time.time() - started:.0f}s")
+
+
+if __name__ == "__main__":
+    main()

scripts/run_lane.py

@@ -484,13 +484,17 @@ class Runner:
             ]
         convert_settings = dict(self.spec.get("convert", {}))
         convert_settings.update(condition.get("convert") or {})
-        for key in ("bits", "group_size", "block_size", "parallel", "embedding_bits"):
+        for key in ("bits", "group_size", "block_size", "parallel", "embedding_bits", "symmetric_bits"):
             if key in convert_settings:
                 convert_command += [f"--{key.replace('_', '-')}", str(convert_settings[key])]
         if convert_settings.get("quantize_embedding"):
             convert_command.append("--quantize-embedding")
         if convert_settings.get("layer_filter"):
             convert_command += ["--layer-filter", str(convert_settings["layer_filter"])]
+        if convert_settings.get("layer_bits_json"):
+            settings_path = self.resolve(convert_settings["layer_bits_json"])
+            assert settings_path is not None
+            convert_command += ["--layer-bits-json", str(settings_path)]
         if condition.get("layer_bits_json"):
             bits_path = self.resolve(condition["layer_bits_json"])
             assert bits_path is not None
@@ -576,7 +580,7 @@ class Runner:
                 "--calibration-json",
                 str(out / "calibration.json"),
             ]
-            for key in ("bits", "group_size", "block_size", "parallel", "embedding_bits"):
+            for key in ("bits", "group_size", "block_size", "parallel", "embedding_bits", "symmetric_bits"):
                 if key in self.spec.get("convert", {}):
                     convert_command += [f"--{key.replace('_', '-')}", str(self.spec["convert"][key])]
             if self.spec.get("convert", {}).get("quantize_embedding"):