Rebuild: smoke-all + layer filter fix

kit_manifest.json

@@ -1,7 +1,7 @@
 {
-  "built_from_commit": "5ff2ebafa50e7641aa9874a71c302067288c7088",
+  "built_from_commit": "73d54d05a6711a90648643369a7f365b101c0d91",
   "files": {
-    "scripts/rht_int4_convert.py": "231093f61c11c80da4e07b6ae527ac5424bb97fe5b8c31150e8c46d57c575512",
+    "scripts/rht_int4_convert.py": "add2a584ad9e0d586bfaa16230b19491c580f9e7a11a7aac5fdfb4972e1eca9d",
     "scripts/rewrite_lalamo_hybrid_spec.py": "154564c88391f81b5c24f64125d99abc15d81bd082a8264e36d43a00d4c47a04",
     "scripts/normalize_lalamo_config.py": "248a5a07d0829c9e383eeba1a5204e88abdc065f78737d1191d376a1f37476c4",
     "scripts/make_lalamo_eval_copy.py": "5563e8542ef51e57cc6ed5cff48fcc81d58fb6487d75350df8273cfad948a500",
@@ -11,8 +11,9 @@
     "scripts/eval_quantized.py": "703904d36ff9f096aa2d7cfbad420318908834b34c2890d10e85aa05fb4fdd28",
     "scripts/qad_finetune.py": "26830bf55203a6a2e7fd79451c400949a1f6cdd1fc8d4011b62ff59d39c6e486",
     "scripts/compute_bpc.py": "2b55fd1df406d54b40daeeca2ecaf2efb35981655f5bf5e0cc10c057ce796256",
-    "scripts/run_lane.py": "5fff87e57a01282b59466e739942230f4dc31c3ee7a48a63d27fcb087d95d3e7",
+    "scripts/run_lane.py": "e3b3bfebbf8955a0bdf7447c564d9b3ecc388d5afb2777096e091578d3ca3513",
     "scripts/make_sweep_spec.py": "dc31ec026c89e7db316a185575a4423bca988c2ac6cf08ef6df8f955328cda69",
+    "scripts/make_smoke_specs.py": "824400dc0d85c9ebd360b10ed4f7056938a1915efd5da6f1a5ac3fb33eb7e998",
     "scripts/combine_lane_manifests.py": "164ba691d60b3e2987b805426c606d135dcf3cf0c855b38cf7f5d6d57628a481",
     "scripts/make_qad_dataset.py": "c8ca660ffe781e066fdf3c9bfce2fdf2af40bef13160519fdc6f1410f740a72d",
     "scripts/ag_fetch.py": "2d13b52f5f41a84c61d196a0eaaf35f2d03b39e45b4379d80adb7e84c451ef7f",
@@ -27,7 +28,7 @@
     "scripts/check_docs.py": "e867ccced2e240fadd9a467dcca018e0d668c5e92ddccaeb4f9f936252f7883d",
     "scripts/tiny_sharding_probe.py": "29eb58f2689242b919616f6aab6ff753e0de031b16371137975b4d645e836fae",
     "scripts/audit_public_corpus.py": "84f1ec805a74004e71f63a70a8ed19967cb3fad9966f254798e655ab95e53ab0",
-    "scripts/build_kit.py": "9df408d52f3a4125899ce14523650381b88e7a541baf59f09c69c8779c24d4ea",
+    "scripts/build_kit.py": "eaa35d13bbd3f7525e9d52302d1acd2257a9a5e8cc2dd552da33dc8ed45c19e9",
     "scripts/bootstrap_kaggle.py": "1633e3edbb80976c337444e3e4544e2b5210b2d8d1821e3a2717c1099c00843e",
     "data/calibration_en_wikitext2_dedup.txt": "18a79f4f938cc25747a90a12b120c7131e7f4ac55b58dfc691795ea61d4b5e9a",
     "data/calibration_ja_wikipedia_dedup.txt": "b45e3f3f00f2137be280a75c1fa9c9883a7e69d289257c4388fc701f33fee0d1",

scripts/build_kit.py

@@ -44,6 +44,7 @@ KIT_SCRIPTS = [
     "compute_bpc.py",
     "run_lane.py",
     "make_sweep_spec.py",
+    "make_smoke_specs.py",
     "combine_lane_manifests.py",
     "make_qad_dataset.py",
     "ag_fetch.py",

scripts/make_smoke_specs.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Derive tiny smoke specs from the real lane specs.
+
+A full lane takes hours; a broken flag, missing file, or merge mismatch shows up
+in the first minutes. This shrinks every lane (samples 1, 32 tokens, 2 eval
+chunks) so one CPU session can prove that all of them run end to end.
+
+    python scripts/make_smoke_specs.py --out-dir lanes
+
+The generated files are named ``smoke-<lane>.json``. ``balanced-h`` keeps its
+merge but only at ratio 0.5; robustness shards keep only the first two
+conditions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import glob
+import json
+from pathlib import Path
+
+DEFAULT_SKIP = {"smoke-08b"}
+
+
+def shrink(spec: dict, robustness_limit: int) -> dict:
+    spec = copy.deepcopy(spec)
+    spec["lane"] = f"smoke-{spec['lane']}"
+    spec.setdefault("paths", {})["jax_platform"] = "cpu"
+    spec.setdefault("eval", {})["max_sequences"] = 2
+    spec["eval"]["max_tokens"] = 32
+    spec["eval"]["min_tokens"] = 4
+    spec["eval"]["dtype"] = "float32"
+    spec.setdefault("convert", {})["parallel"] = "replicated"
+    # quantize only layer 0 so a smoke conversion takes seconds, not ten minutes
+    spec["convert"]["layer_filter"] = "/[0]/"
+
+    is_robustness = "robustness" in spec["lane"]
+    conditions = spec.get("conditions", [])
+    if is_robustness:
+        conditions = conditions[:robustness_limit]
+
+    for condition in conditions:
+        condition["samples"] = 1
+        condition["max_tokens"] = 32
+        condition.setdefault("calib_dtype", "float32")
+    spec["conditions"] = conditions
+
+    merge = spec.get("merge")
+    if merge:
+        merge["ratios"] = [0.5]
+    return spec
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--lanes-dir", type=Path, default=Path("lanes"))
+    parser.add_argument("--out-dir", type=Path, default=Path("lanes"))
+    parser.add_argument("--robustness-limit", type=int, default=2)
+    parser.add_argument("--include", nargs="*", default=None)
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    written = []
+    for path in sorted(args.lanes_dir.glob("*.json")):
+        if path.name.startswith("smoke-") or path.stem in DEFAULT_SKIP:
+            continue
+        if args.include and path.stem not in args.include:
+            continue
+        if path.name == "bits-down-out-6.json":
+            continue
+        try:
+            spec = json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            continue
+        if "conditions" not in spec:
+            continue
+        smoke = shrink(spec, args.robustness_limit)
+        out = args.out_dir / f"{smoke['lane']}.json"
+        print(f"{path.name} -> {out.name} ({len(smoke['conditions'])} conditions)")
+        if not args.dry_run:
+            out.write_text(json.dumps(smoke, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        written.append(out.name)
+    print(f"{len(written)} smoke specs")
+
+
+if __name__ == "__main__":
+    main()

scripts/rht_int4_convert.py

@@ -135,6 +135,13 @@ def find_spec(qwen_models, name: str):
     raise ValueError(f"model spec {name!r} not found")
 
 
+def should_quantize(path: str, filters: list[str]) -> bool:
+    """Empty filters means everything; otherwise any substring match."""
+    if not filters:
+        return True
+    return any(item in path for item in filters)
+
+
 def resolve_bits(path: str, rules: list[dict], default: int) -> int:
     """First rule whose ``match`` substring appears in the layer path wins."""
     for rule in rules:
@@ -292,7 +299,10 @@ def main() -> None:
     hybrid_spec = build_hybrid_spec(args.bits)
     layer_bits_used: dict[str, int] = {}
     quantize_key = jax.random.key(0)
-    counts = {"quantized": 0, "skipped": 0, "yaqa": 0}
+    counts = {"quantized": 0, "skipped": 0, "yaqa": 0, "filtered": 0}
+    layer_filters = [item for item in (args.layer_filter or "").split(",") if item]
+    if layer_filters:
+        print(f"layer filter: {layer_filters} (other layers stay full precision)")
 
     calibration = None
     if args.preconditioners:
@@ -317,6 +327,9 @@ def main() -> None:
     def quantize_linear(path, linear: Linear) -> Linear:
         started = time.time()
         key = "/".join(path)
+        if not should_quantize(key, layer_filters):
+            counts["filtered"] += 1
+            return linear
         shape = tuple(int(x) for x in linear.weights.shape)
         if len(shape) != 2 or any(dimension % required_divisor for dimension in shape):
             counts["skipped"] += 1
@@ -381,7 +394,10 @@ def main() -> None:
                 f"(symmetric=False)"
             )
     quantized_model = map_nodes_of_type_with_path(Linear, quantize_linear, model)
-    print(f"quantized: {counts['quantized']}, skipped: {counts['skipped']}, yaqa: {counts['yaqa']}")
+    print(
+        f"quantized: {counts['quantized']}, skipped: {counts['skipped']}, "
+        f"yaqa: {counts['yaqa']}, filtered: {counts['filtered']}"
+    )
     if layer_bits_used:
         distribution = {}
         for bits in layer_bits_used.values():

scripts/run_lane.py

@@ -441,6 +441,8 @@ class Runner:
         for key in ("bits", "group_size", "block_size", "parallel"):
             if key in convert_settings:
                 convert_command += [f"--{key.replace('_', '-')}", str(convert_settings[key])]
+        if convert_settings.get("layer_filter"):
+            convert_command += ["--layer-filter", str(convert_settings["layer_filter"])]
         if condition.get("layer_bits_json"):
             bits_path = self.resolve(condition["layer_bits_json"])
             assert bits_path is not None