Add model-free uzu quant kit

configs/config.json

@@ -0,0 +1,55 @@
+{
+  "name": "qwen35-9b",
+  "model": {
+    "repo": "huihui-ai/Huihui-Qwen3.5-9B-Claude-4.6-Opus-abliterated",
+    "tied_embedding": false,
+    "layers": 32,
+    "hidden": 4096
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "experiments/qwen35-0.8b/data/eval_en_wikitext2_dedup.txt",
+      "ja": "experiments/qwen35-0.8b/data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "calibration": {
+    "samples": 8,
+    "max_tokens": 512,
+    "output_block": "none",
+    "output_block_limit": 2048,
+    "damping": 0.001,
+    "layer_grouped": true,
+    "group_size": 4,
+    "corpora": {
+      "en": "experiments/qwen35-0.8b/data/calibration_en_wikitext2_dedup.txt",
+      "ja": "experiments/qwen35-0.8b/data/calibration_ja_wikipedia_dedup.txt",
+      "mixed50": "experiments/qwen35-0.8b/data/calibration_mixed_en_ja_dedup.txt",
+      "mix65": "experiments/qwen35-0.8b/data/calibration_mixed_ja65_en35_dedup.txt",
+      "mix35": "experiments/qwen35-0.8b/data/calibration_mixed_ja35_en65_dedup.txt"
+    }
+  },
+  "quantization": {
+    "bits": 4,
+    "embedding_bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "symmetric": false,
+    "layout": "output_input"
+  },
+  "qad": {
+    "optimizer": "adamw",
+    "steps": 10,
+    "seq": 256,
+    "lr": 2e-05,
+    "save_every": 5,
+    "val_chunks": 2,
+    "val_every": 5,
+    "parallel": "tensor",
+    "corpus": "experiments/qwen35-0.8b/data/calibration_en_wikitext2_dedup.txt",
+    "scale_lr": 1e-06,
+    "early_stop_patience": 2
+  }
+}

dataset-metadata.json

@@ -0,0 +1,12 @@
+{
+  "title": "uzu quant kit public",
+  "id": "yamahei21python/uzu-quant-kit-public",
+  "licenses": [
+    {
+      "name": "CC-BY-SA-4.0"
+    }
+  ],
+  "subtitle": "Model-free uzu/lalamo quantization scripts and dedup corpora",
+  "description": "Public, model-free kit for reproducing uzu/lalamo INT4 quantization experiments.\n\nscripts/: rht_int4_convert, yaqa_calibration, eval_quantized, compute_bpc, merge_language_hessians, dedup/corpus guards, qad_finetune\nconfigs/: experiments/qwen35-{0.8b,4b,9b}/config.json\ntests/: model-free guard tests, BPC tests, tiny 2-device sharding probe\ndata/: dedup calibration and eval corpora\n\nCorpora:\n- eval_en_wikitext2_dedup.txt / calibration_en_wikitext2_dedup.txt: derived from WikiText-2 (CC BY-SA 4.0)\n- eval_ja_wikipedia_dedup.txt / calibration_ja_wikipedia_dedup.txt: derived from Japanese Wikipedia (CC BY-SA 4.0)\n- mixed*: deterministic EN/JA mixtures of the above\n\nNo model weights are included. No private data.\n\nRules enforced by the scripts:\n- calibration and eval corpora must not overlap (corpus_guard.py)\n- eval must report config_hash, corpus_sha256, and 100 chunks\n- QAD requires student provenance and refuses unverified students\n\nRepository: https://github.com/yamahei21python/uzu",
+  "resources": []
+}

scripts/check_experiment.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""Fail fast when an experiment mixes incompatible eval/calibration settings."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from collections import defaultdict
+from pathlib import Path
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as file:
+        for chunk in iter(lambda: file.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()[:16]
+
+
+def expected_eval(config: dict, corpus: str) -> dict:
+    eval_cfg = config["eval"]
+    corpus_path = Path(corpus)
+    return {
+        "corpus": str(corpus_path),
+        "corpus_sha256": sha256_file(corpus_path),
+        "max_sequences": eval_cfg["max_sequences"],
+        "max_tokens": eval_cfg["max_tokens"],
+        "min_tokens": eval_cfg["min_tokens"],
+    }
+
+
+def config_hash(value: dict) -> str:
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode("utf-8")).hexdigest()[:16]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--root", type=Path, default=None)
+    parser.add_argument("--json-out", type=Path, default=None)
+    args = parser.parse_args()
+
+    config = json.loads(args.config.read_text())
+    root = args.root or args.config.parent
+    eval_cfg = config["eval"]
+    calib_cfg = config["calibration"]
+    corpora = {Path(path).name: path for path in eval_cfg["corpora"].values()}
+    expected_by_name = {name: expected_eval(config, path) for name, path in corpora.items()}
+
+    errors: list[str] = []
+    warnings: list[str] = []
+    ppl_rows = []
+    baseline_by_corpus: dict[str, list[float]] = defaultdict(list)
+
+    for path in sorted(root.rglob("ppl_*.json")):
+        data = json.loads(path.read_text())
+        corpus_name = Path(data.get("corpus", "")).name
+        row = {"path": str(path), "corpus": corpus_name}
+        ppl_rows.append(row)
+
+        if corpus_name not in corpora:
+            errors.append(f"{path}: unknown corpus {corpus_name!r}")
+            continue
+
+        expected = expected_by_name[corpus_name]
+        if data.get("chunks") != expected["max_sequences"]:
+            errors.append(
+                f"{path}: chunks={data.get('chunks')} != config max_sequences={expected['max_sequences']}"
+            )
+        if data.get("tokens") is not None and data.get("chunks"):
+            approx = data["chunks"] * expected["max_tokens"] - data["chunks"]
+            if abs(int(data["tokens"]) - approx) > expected["max_sequences"]:
+                warnings.append(
+                    f"{path}: tokens={data.get('tokens')} differs from approx {approx}"
+                )
+
+        if data.get("config"):
+            if data["config"] != expected:
+                errors.append(f"{path}: embedded eval config differs from model config")
+            if data.get("config_hash") != config_hash(expected):
+                errors.append(f"{path}: config_hash mismatch")
+        else:
+            warnings.append(f"{path}: legacy result without config/config_hash")
+
+        if "bf16_ppl" in data:
+            baseline_by_corpus[corpus_name].append(float(data["bf16_ppl"]))
+
+    for corpus_name, values in baseline_by_corpus.items():
+        if max(values) - min(values) > 0.01:
+            errors.append(
+                f"BF16 baseline drift for {corpus_name}: {sorted(set(round(value, 4) for value in values))}"
+            )
+
+    calibration_rows = []
+    calibration_corpora: set[Path] = set(
+        Path(path) for path in calib_cfg.get("corpora", {}).values()
+    )
+    qad_corpus = config.get("qad", {}).get("corpus")
+    if qad_corpus:
+        calibration_corpora.add(Path(qad_corpus))
+    for path in sorted(root.rglob("calibration.json")):
+        data = json.loads(path.read_text())
+        row = {"path": str(path), "corpus": Path(data.get("corpus", "")).name}
+        calibration_rows.append(row)
+        if data.get("corpus"):
+            calibration_corpora.add(Path(data["corpus"]))
+        checks = {
+            "samples": calib_cfg["samples"],
+            "max_tokens": calib_cfg["max_tokens"],
+            "output_block": calib_cfg["output_block"],
+        }
+        for key, expected in checks.items():
+            if data.get(key) != expected:
+                errors.append(f"{path}: {key}={data.get(key)!r} != config {expected!r}")
+        damping = float(data.get("damping", -1))
+        if abs(damping - float(calib_cfg["damping"])) > 1e-12:
+            errors.append(f"{path}: damping={damping} != config {calib_cfg['damping']}")
+
+    eval_corpora = {Path(path) for path in corpora.values()}
+
+    def long_lines(path: Path) -> set[str]:
+        return {
+            line.strip()
+            for line in path.read_text(encoding="utf-8").splitlines()
+            if len(line.strip()) >= 20
+        }
+
+    for eval_corpus in sorted(eval_corpora):
+        if not eval_corpus.exists():
+            continue
+        lines = [
+            line.strip()
+            for line in eval_corpus.read_text(encoding="utf-8").splitlines()
+            if len(line.strip()) >= 20
+        ]
+        duplicates = len(lines) - len(set(lines))
+        if duplicates:
+            errors.append(f"{eval_corpus}: {duplicates} duplicate long lines; dedup required")
+
+    overlap_checks = 0
+    for calibration_corpus in sorted(calibration_corpora):
+        if not calibration_corpus.exists():
+            errors.append(f"missing calibration corpus: {calibration_corpus}")
+            continue
+        for eval_corpus in sorted(eval_corpora):
+            if not eval_corpus.exists():
+                errors.append(f"missing eval corpus: {eval_corpus}")
+                continue
+            overlap_checks += 1
+            if calibration_corpus.resolve() == eval_corpus.resolve():
+                errors.append(f"calibration and eval use the same file: {eval_corpus}")
+                continue
+            overlap = long_lines(calibration_corpus) & long_lines(eval_corpus)
+            if overlap:
+                sample = next(iter(overlap))[:80]
+                errors.append(
+                    f"corpus overlap: {calibration_corpus} vs {eval_corpus} "
+                    f"({len(overlap)} lines, e.g. {sample!r})"
+                )
+
+    report = {
+        "config": str(args.config),
+        "config_name": config.get("name"),
+        "ppl_rows": len(ppl_rows),
+        "calibration_rows": len(calibration_rows),
+        "corpus_overlap_checks": overlap_checks,
+        "errors": errors,
+        "warnings": warnings,
+        "ok": not errors,
+    }
+    text = json.dumps(report, indent=2, ensure_ascii=False)
+    print(text)
+    if args.json_out:
+        args.json_out.parent.mkdir(parents=True, exist_ok=True)
+        args.json_out.write_text(text + "\n")
+    raise SystemExit(0 if not errors else 1)
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_bpc.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""Normalize evaluation perplexity to bits-per-character (BPC).
+
+PPL is not comparable across languages or tokenizers: a tokenizer with higher
+fertility (tokens per character) spreads the same text over more tokens, which
+inflates PPL. BPC divides the total negative log-likelihood by characters
+instead:
+
+    BPC = log2(PPL) * tokens / chars = log2(PPL) * fertility
+
+Only the public tokenizer is needed. No model weights, no GPU.
+
+``tokens`` here means *scored* positions, matching what ``eval_quantized.py``
+puts in its JSON: each chunk contributes ``len(chunk) - 1`` predictions, since
+the first token of every chunk is only context. The character count is measured
+on the same scored stream: the chunks are rebuilt with the same
+``chunks_from_text`` logic as ``eval_quantized.py``, the full stream is decoded
+once, and the characters of the skipped first token of each chunk are removed.
+This avoids counting every chunk boundary twice.
+
+Usage:
+    python scripts/compute_bpc.py \
+        --ppl-json out/eval/ppl_en.json \
+        --ppl-json out/eval/ppl_ja.json \
+        --tokenizer Qwen/Qwen3.5-0.8B
+
+    python scripts/compute_bpc.py --ppl-json ppl_en.json --tokenizer ./tokenizer-dir --json report.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+
+def load_tokenizer(source: str):
+    from tokenizers import Tokenizer
+
+    path = Path(source)
+    if path.is_dir():
+        return Tokenizer.from_file(str(path / "tokenizer.json"))
+    if path.is_file():
+        return Tokenizer.from_file(str(path))
+    from huggingface_hub import hf_hub_download
+
+    return Tokenizer.from_file(hf_hub_download(source, "tokenizer.json"))
+
+
+def chunks_from_text(tokenizer, text: str, max_tokens: int, min_tokens: int, limit: int) -> list[list[int]]:
+    """Mirror of eval_quantized.chunks_from_text; must stay identical."""
+    ids = tokenizer.encode(text, add_special_tokens=True).ids
+    chunks = [ids[start : start + max_tokens] for start in range(0, len(ids), max_tokens)]
+    chunks = [chunk for chunk in chunks if len(chunk) >= min_tokens]
+    return chunks[:limit]
+
+
+def read_corpus(path: str) -> str:
+    text = Path(path).read_text(encoding="utf-8")
+    return text.replace("\x00", "")
+
+
+def scored_tokens(chunks: list[list[int]]) -> int:
+    """Predictions per chunk: every token except the first (context only)."""
+    return sum(max(len(chunk) - 1, 0) for chunk in chunks)
+
+
+def target_chars(tokenizer, chunks: list[list[int]]) -> int:
+    """Characters of the scored stream.
+
+    Decoding the whole stream at once keeps multi-byte characters intact; the
+    context-only first token of each chunk is then removed. A token that holds a
+    partial UTF-8 sequence at a chunk boundary can shift this by at most one
+    character per chunk.
+    """
+    flat: list[int] = []
+    for chunk in chunks:
+        flat.extend(chunk)
+    full = tokenizer.decode(flat)
+    skipped = sum(len(tokenizer.decode([chunk[0]])) for chunk in chunks if chunk)
+    return len(full) - skipped
+
+
+def bpc(ppl: float, tokens: int, chars: int) -> float:
+    if chars <= 0:
+        raise ValueError("chars must be positive")
+    if tokens <= 0:
+        raise ValueError("tokens must be positive")
+    if ppl <= 0:
+        raise ValueError("ppl must be positive")
+    return math.log2(ppl) * tokens / chars
+
+
+def sha256_text(path: str) -> str | None:
+    try:
+        return hashlib.sha256(Path(path).read_bytes()).hexdigest()[:16]
+    except OSError:
+        return None
+
+
+def analyze(payload: dict[str, Any], tokenizer_source: str, corpus_override: str | None) -> dict[str, Any]:
+    config = payload.get("config") or {}
+    corpus = corpus_override or config.get("corpus") or payload.get("corpus")
+    if not corpus:
+        raise SystemExit("no corpus in PPL JSON; pass --corpus")
+    max_tokens = int(config.get("max_tokens", 128))
+    min_tokens = int(config.get("min_tokens", 16))
+    max_sequences = int(config.get("max_sequences", payload.get("chunks", 0) or 0))
+    if max_sequences <= 0:
+        raise SystemExit("no max_sequences in PPL JSON; pass --max-sequences")
+
+    tokenizer = load_tokenizer(tokenizer_source)
+    text = read_corpus(corpus)
+    chunks = chunks_from_text(tokenizer, text, max_tokens, min_tokens, max_sequences)
+    if not chunks:
+        raise SystemExit(f"no chunks from {corpus}")
+
+    tokens = scored_tokens(chunks)
+    chars = target_chars(tokenizer, chunks)
+    fertility = tokens / chars
+
+    expected_chunks = payload.get("chunks")
+    expected_tokens = payload.get("tokens")
+    report: dict[str, Any] = {
+        "corpus": corpus,
+        "corpus_sha256": sha256_text(corpus),
+        "tokenizer": tokenizer_source,
+        "config": {
+            "max_tokens": max_tokens,
+            "min_tokens": min_tokens,
+            "max_sequences": max_sequences,
+        },
+        "chunks": len(chunks),
+        "tokens": tokens,
+        "chars": chars,
+        "tokens_per_char": fertility,
+        "reproduced": {
+            "chunks_match": expected_chunks is None or expected_chunks == len(chunks),
+            "tokens_match": expected_tokens is None or expected_tokens == tokens,
+        },
+    }
+
+    for key, value in payload.items():
+        if key.endswith("_ppl") and isinstance(value, (int, float)):
+            label = key[: -len("_ppl")] or "model"
+            report[f"bpc_{label}"] = bpc(float(value), tokens, chars)
+            report[f"ppl_{label}"] = float(value)
+
+    if "delta_nll_per_token" in payload:
+        report["bpc_delta"] = float(payload["delta_nll_per_token"]) / math.log(2) * fertility
+
+    return report
+
+
+def format_table(reports: list[dict[str, Any]]) -> str:
+    lines = [
+        "| run | chunks | tokens | chars | tok/char | PPL | BPC |",
+        "|---|---:|---:|---:|---:|---:|---:|",
+    ]
+    for report in reports:
+        name = Path(report.get("source", "?")).parent.name or "?"
+        ppl = report.get("ppl_candidate", report.get("ppl_bf16"))
+        bp = report.get("bpc_candidate", report.get("bpc_bf16"))
+        lines.append(
+            f"| {name} | {report['chunks']} | {report['tokens']} | {report['chars']} "
+            f"| {report['tokens_per_char']:.4f} | {ppl:.2f} | {bp:.4f} |"
+        )
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--ppl-json", action="append", required=True, help="eval_quantized.py output (repeatable)")
+    parser.add_argument("--tokenizer", required=True, help="tokenizer dir, tokenizer.json, or HF repo id")
+    parser.add_argument("--corpus", default=None, help="override corpus path recorded in the PPL JSON")
+    parser.add_argument("--json", default=None, help="write the report here")
+    parser.add_argument("--strict", action="store_true", help="fail when chunk/token counts do not reproduce")
+    args = parser.parse_args()
+
+    reports = []
+    failed = False
+    for path in args.ppl_json:
+        payload = json.loads(Path(path).read_text(encoding="utf-8"))
+        report = analyze(payload, args.tokenizer, args.corpus)
+        report["source"] = str(path)
+        reports.append(report)
+        reproduced = report["reproduced"]
+        if args.strict and not (reproduced["chunks_match"] and reproduced["tokens_match"]):
+            failed = True
+            print(f"MISMATCH {path}: {reproduced}")
+
+    for report in reports:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    print()
+    print(format_table(reports))
+
+    if args.json:
+        Path(args.json).write_text(json.dumps(reports, indent=2, ensure_ascii=False), encoding="utf-8")
+        print(f"\nwrote {args.json}")
+    if failed:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/corpus_guard.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Reject calibration corpora that overlap with evaluation corpora."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def long_lines(path: Path, min_chars: int) -> set[str]:
+    return {
+        line.strip()
+        for line in path.read_text(encoding="utf-8").splitlines()
+        if len(line.strip()) >= min_chars
+    }
+
+
+def overlap_lines(calibration: Path, eval_corpora: list[Path], min_chars: int = 20) -> tuple[int, str | None]:
+    blocked: set[str] = set()
+    for path in eval_corpora:
+        blocked |= long_lines(path, min_chars)
+    if not blocked:
+        return 0, None
+    overlap = long_lines(calibration, min_chars) & blocked
+    if not overlap:
+        return 0, None
+    return len(overlap), next(iter(overlap))[:120]
+
+
+def assert_disjoint(
+    calibration: Path,
+    eval_corpora: list[Path],
+    *,
+    min_chars: int = 20,
+    allow_overlap: bool = False,
+) -> None:
+    if not eval_corpora:
+        if allow_overlap:
+            return
+        raise SystemExit(
+            "at least one --eval-corpus is required; use --allow-overlap only for deliberate analysis"
+        )
+    for path in eval_corpora:
+        if not path.exists():
+            raise SystemExit(f"missing eval corpus: {path}")
+    count, sample = overlap_lines(calibration, eval_corpora, min_chars)
+    if count and not allow_overlap:
+        raise SystemExit(
+            f"calibration corpus overlaps evaluation corpora: {count} lines "
+            f"(e.g. {sample!r}). Deduplicate first or pass --allow-overlap."
+        )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--calibration", type=Path, required=True)
+    parser.add_argument("--eval", nargs="+", type=Path, required=True)
+    parser.add_argument("--min-chars", type=int, default=20)
+    parser.add_argument("--allow-overlap", action="store_true")
+    args = parser.parse_args()
+    assert_disjoint(
+        args.calibration,
+        args.eval,
+        min_chars=args.min_chars,
+        allow_overlap=args.allow_overlap,
+    )
+    print("corpus guard: ok")
+
+
+if __name__ == "__main__":
+    main()

scripts/dedup_lines.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Remove duplicate non-empty lines from a corpus, keeping first occurrence."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+
+    lines = args.input.read_text(encoding="utf-8").splitlines()
+    seen: set[str] = set()
+    kept: list[str] = []
+    removed = 0
+    for line in lines:
+        key = line.strip()
+        if key and key in seen:
+            removed += 1
+            continue
+        if key:
+            seen.add(key)
+        kept.append(line)
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text("\n".join(kept) + "\n", encoding="utf-8")
+    print(f"{args.input} -> {args.output}: removed={removed} kept={len(kept)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/eval_quantized.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Teacher-forced evaluation: BF16 vs quantized model on a fixed corpus.
+
+Computes, over fixed token chunks:
+  * Perplexity (independent chunks; identical chunking for both models)
+  * NLL delta per token
+  * Top-1 / Top-5 agreement
+  * KL(BF16 || candidate)
+  * Cosine similarity of logits
+  * Top-1 logit margin change
+
+No sampling, no generation: the same token sequence is fed to both models.
+
+Usage:
+  JAX_PLATFORM_NAME=cpu python scripts/eval_quantized.py \
+    --bf16-dir /tmp/qwen35_0.8b_bf16_lalamo_lalamo_origcfg \
+    --candidate-dir /tmp/qwen35_0.8b_rht_int4_lalamo_lalamo_origcfg \
+    --corpus experiments/qwen35-0.8b/data/wikitext2_sample.txt \
+    --max-sequences 100 --max-tokens 128 \
+    --json-out experiments/qwen35-0.8b/rtn-int4-g32/eval_wikitext2.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+import time
+from pathlib import Path
+
+os.environ.setdefault("JAX_PLATFORM_NAME", "cpu")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--bf16-dir", type=Path, required=True)
+    parser.add_argument("--candidate-dir", type=Path, required=True)
+    parser.add_argument("--corpus", type=Path, required=True, help="UTF-8 text file")
+    parser.add_argument("--lalamo-path", default=os.environ.get("LALAMO_PATH", "/tmp/lalamo-direct"))
+    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("--json-out", type=Path, default=None)
+    parser.add_argument(
+        "--progress-jsonl",
+        type=Path,
+        default=None,
+        help="default: <json-out>.progress.jsonl or <candidate-dir>/eval_progress.jsonl",
+    )
+    return parser.parse_args()
+
+
+def chunks_from_text(tokenizer, text: str, max_tokens: int, min_tokens: int, limit: int) -> list[list[int]]:
+    ids = tokenizer.encode(text, add_special_tokens=True).ids
+    chunks = [ids[start : start + max_tokens] for start in range(0, len(ids), max_tokens)]
+    chunks = [chunk for chunk in chunks if len(chunk) >= min_tokens]
+    return chunks[:limit]
+
+
+def main() -> None:
+    args = parse_args()
+    if args.progress_jsonl:
+        progress_path = args.progress_jsonl
+    elif args.json_out:
+        progress_path = args.json_out.with_suffix(".progress.jsonl")
+    else:
+        progress_path = args.candidate_dir / "eval_progress.jsonl"
+    progress_path.parent.mkdir(parents=True, exist_ok=True)
+    run_id = time.strftime("%Y%m%d-%H%M%S")
+    progress_path.write_text("", encoding="utf-8")
+    eval_config = {
+        "corpus": str(args.corpus),
+        "corpus_sha256": hashlib.sha256(args.corpus.read_bytes()).hexdigest()[:16],
+        "max_sequences": args.max_sequences,
+        "max_tokens": args.max_tokens,
+        "min_tokens": args.min_tokens,
+    }
+    config_hash = hashlib.sha256(json.dumps(eval_config, sort_keys=True).encode("utf-8")).hexdigest()[:16]
+
+    def progress(record: dict) -> None:
+        record = {"run_id": run_id, "config_hash": config_hash, **record}
+        with open(progress_path, "a", encoding="utf-8") as file:
+            file.write(json.dumps(record) + "\n")
+
+    corpus_lines = [
+        line.strip()
+        for line in args.corpus.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    duplicate_lines = len(corpus_lines) - len(set(corpus_lines))
+    if duplicate_lines:
+        raise SystemExit(
+            f"eval corpus has {duplicate_lines} duplicate non-empty lines; "
+            "use scripts/dedup_lines.py first"
+        )
+    text = "\n".join(corpus_lines)
+
+    sys.path.insert(0, args.lalamo_path)
+
+    import jax
+    import jax.numpy as jnp
+    import numpy as np
+
+    from lalamo.model import Model
+    from lalamo.module import Keychain
+    from lalamo.modules import DecoderForwardPassConfig, ForwardPassMode
+    from lalamo.utils.sharding import ShardingConfig
+    from tokenizers import Tokenizer
+
+    for label, directory in (("bf16", args.bf16_dir), ("candidate", args.candidate_dir)):
+        config_path = directory / "config.json"
+        if not config_path.exists():
+            raise SystemExit(f"{label}: missing {config_path}")
+        lalamo_config = json.loads(config_path.read_text())
+        token_codec = lalamo_config.get("token_codec_config", {})
+        if "response_format" not in token_codec:
+            raise SystemExit(
+                f"{label}: {directory} is uzu-normalized; create a lalamo eval copy "
+                "(scripts/make_lalamo_eval_copy.py)"
+            )
+
+    def tokenizer_hash(directory: Path) -> str:
+        return hashlib.sha256((directory / "tokenizer.json").read_bytes()).hexdigest()
+
+    if tokenizer_hash(args.bf16_dir) != tokenizer_hash(args.candidate_dir):
+        raise SystemExit("bf16/candidate tokenizer.json mismatch")
+
+    sharding = ShardingConfig.replicated()
+    keychain = Keychain.init(seed=0, sharding_config=sharding)
+    forward_pass_config = DecoderForwardPassConfig.for_inference(mode=ForwardPassMode.MULTI_TOKEN)
+
+    print("loading BF16 model...")
+    bf16 = Model.load(args.bf16_dir, sharding, dtype=jnp.bfloat16)
+    print("loading candidate model...")
+    candidate = Model.load(args.candidate_dir, sharding, dtype=jnp.bfloat16)
+    tokenizer = Tokenizer.from_file(str(args.bf16_dir / "tokenizer.json"))
+    print("loaded")
+
+    text = "\n".join(corpus_lines)
+    chunks = chunks_from_text(tokenizer, text, args.max_tokens, args.min_tokens, args.max_sequences)
+    if not chunks:
+        raise SystemExit("no chunks: corpus too small or min-tokens too high")
+    print(f"chunks: {len(chunks)}  mean tokens: {sum(len(c) for c in chunks) / len(chunks):.1f}")
+
+    def logits_for(model, ids: list[int]) -> np.ndarray:
+        token_ids = jnp.asarray([ids], dtype=jnp.int32)
+        positions = jnp.arange(len(ids), dtype=jnp.int32)[None, :]
+        result = model.decoder(
+            token_ids=token_ids,
+            token_positions=positions,
+            state=None,
+            return_updated_state=False,
+            lengths_without_padding=None,
+            forward_pass_config=forward_pass_config,
+            keychain=keychain.split(1)[0],
+        )
+        return np.asarray(result.logits[0], dtype=np.float32)
+
+    total_nll_bf16 = 0.0
+    total_nll_candidate = 0.0
+    total_positions = 0
+    top1_matches = 0
+    top5_overlap_sum = 0.0
+    kl_sum = 0.0
+    cosine_sum = 0.0
+    margin_delta_sum = 0.0
+    started_at = time.time()
+
+    for index, ids in enumerate(chunks):
+        bf_logits = logits_for(bf16, ids)
+        qa_logits = logits_for(candidate, ids)
+        # Predict token i+1 from position i.
+        bf_pred = bf_logits[:-1]
+        qa_pred = qa_logits[:-1]
+        targets = np.asarray(ids[1:], dtype=np.int64)
+
+        bf_log_prob = bf_pred - bf_pred.max(axis=-1, keepdims=True)
+        bf_log_prob = bf_log_prob - np.log(np.exp(bf_log_prob).sum(axis=-1, keepdims=True))
+        qa_log_prob = qa_pred - qa_pred.max(axis=-1, keepdims=True)
+        qa_log_prob = qa_log_prob - np.log(np.exp(qa_log_prob).sum(axis=-1, keepdims=True))
+
+        bf_target_log_prob = bf_log_prob[np.arange(len(targets)), targets]
+        qa_target_log_prob = qa_log_prob[np.arange(len(targets)), targets]
+        total_nll_bf16 -= float(bf_target_log_prob.sum())
+        total_nll_candidate -= float(qa_target_log_prob.sum())
+        total_positions += len(targets)
+
+        bf_top1 = bf_pred.argmax(axis=-1)
+        qa_top1 = qa_pred.argmax(axis=-1)
+        top1_matches += int((bf_top1 == qa_top1).sum())
+
+        bf_sorted = np.argsort(-bf_pred, axis=-1)[:, :5]
+        qa_sorted = np.argsort(-qa_pred, axis=-1)[:, :5]
+        for bf_row, qa_row in zip(bf_sorted, qa_sorted):
+            top5_overlap_sum += len(set(bf_row.tolist()) & set(qa_row.tolist())) / 5.0
+
+        bf_prob = np.exp(bf_log_prob)
+        qa_prob = np.exp(qa_log_prob)
+        kl_sum += float(
+            np.sum(bf_prob * (np.log(bf_prob + 1e-45) - np.log(qa_prob + 1e-45)), axis=-1).sum()
+        )
+        cosine_sum += float(
+            (
+                np.sum(bf_pred * qa_pred, axis=-1)
+                / (np.linalg.norm(bf_pred, axis=-1) * np.linalg.norm(qa_pred, axis=-1) + 1e-45)
+            ).sum()
+        )
+
+        bf_margin = np.sort(bf_pred, axis=-1)[:, -1] - np.sort(bf_pred, axis=-1)[:, -2]
+        qa_margin = np.sort(qa_pred, axis=-1)[:, -1] - np.sort(qa_pred, axis=-1)[:, -2]
+        margin_delta_sum += float(np.abs(bf_margin - qa_margin).sum())
+
+        if total_positions:
+            progress(
+                {
+                    "chunk": index + 1,
+                    "chunks": len(chunks),
+                    "tokens": total_positions,
+                    "bf16_ppl": math.exp(total_nll_bf16 / total_positions),
+                    "candidate_ppl": math.exp(total_nll_candidate / total_positions),
+                    "delta_nll_per_token": (total_nll_candidate - total_nll_bf16) / total_positions,
+                    "top1_agreement": top1_matches / total_positions,
+                    "kl_bf16_candidate": kl_sum / total_positions,
+                    "elapsed_s": time.time() - started_at,
+                }
+            )
+        if (index + 1) % 10 == 0 or index + 1 == len(chunks):
+            print(f"  {index + 1}/{len(chunks)} chunks")
+
+    mean_nll_bf16 = total_nll_bf16 / total_positions
+    mean_nll_candidate = total_nll_candidate / total_positions
+    results = {
+        "bf16_dir": str(args.bf16_dir),
+        "candidate_dir": str(args.candidate_dir),
+        "corpus": str(args.corpus),
+        "config": eval_config,
+        "config_hash": config_hash,
+        "chunks": len(chunks),
+        "tokens": total_positions,
+        "bf16_ppl": math.exp(mean_nll_bf16),
+        "candidate_ppl": math.exp(mean_nll_candidate),
+        "delta_nll_per_token": mean_nll_candidate - mean_nll_bf16,
+        "top1_agreement": top1_matches / total_positions,
+        "top5_overlap": top5_overlap_sum / total_positions,
+        "kl_bf16_candidate": kl_sum / total_positions,
+        "cosine_logits": cosine_sum / total_positions,
+        "mean_abs_top1_margin_delta": margin_delta_sum / total_positions,
+    }
+    print(json.dumps(results, indent=2))
+    if args.json_out:
+        args.json_out.parent.mkdir(parents=True, exist_ok=True)
+        args.json_out.write_text(json.dumps(results, indent=2) + "\n")
+        print(f"saved {args.json_out}")
+
+
+if __name__ == "__main__":
+    main()

scripts/make_lalamo_eval_copy.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""Create a lalamo-loadable evaluation copy from a uzu-normalized model directory.
+
+Conversion rewrites two things for uzu:
+  * config.json (strict fields, no response_format)
+  * HybridSpec metadata (flat form, original kept as model.safetensors.lalamo.bak)
+
+lalamo evaluation (PPL / logits) needs the opposite form. This script links the
+original weights and writes a lalamo config without duplicating tensor bytes.
+
+Usage:
+  python scripts/make_lalamo_eval_copy.py \
+    --source /tmp/qwen35_0.8b_rht_int4_lalamo \
+    --dest /tmp/qwen35_0.8b_rht_int4_lalamo_lalamo
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+from pathlib import Path
+
+RESPONSE_FORMAT = {
+    "reasoning_pattern": r"(?: response|(?:(?: think|(?=.* response))(?P<chain_of_thought>.*?)(?: response\s*|\Z)))?(?P<response>.*)",
+    "prefixes": [" think", " response"],
+    "turn_pattern": None,
+    "tool_calls": {
+        "tags": ["<tool_call>", "</tool_call>"],
+        "function_pattern": r"<function=([^>\n]+)>(.*?)</function>",
+        "parameter_pattern": r"<parameter=([^>\n]+)>\n?(.*?)\n?</parameter>",
+    },
+}
+
+
+def link_or_copy(source: Path, destination: Path) -> None:
+    if destination.exists():
+        destination.unlink()
+    try:
+        os.link(source, destination)
+    except OSError:
+        shutil.copy2(source, destination)
+
+
+def lalamo_config(source: Path) -> dict:
+    saved = source / "config.lalamo.json"
+    if saved.exists():
+        return json.loads(saved.read_text())
+
+    config = json.loads((source / "config.json").read_text())
+    token_codec = config.get("token_codec_config")
+    if token_codec is not None:
+        token_codec.pop("end_of_thinking_tag", None)
+        token_codec.pop("output_parser_regex", None)
+        token_codec["response_format"] = RESPONSE_FORMAT
+    return config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", type=Path, required=True)
+    parser.add_argument("--dest", type=Path, required=True)
+    args = parser.parse_args()
+
+    args.dest.mkdir(parents=True, exist_ok=True)
+    (args.dest / "config.json").write_text(json.dumps(lalamo_config(args.source), indent=2) + "\n")
+
+    weights = args.source / "model.safetensors"
+    original_weights = args.source / "model.safetensors.lalamo.bak"
+    link_or_copy(original_weights if original_weights.exists() else weights, args.dest / "model.safetensors")
+
+    for name in ("tokenizer.json", "encoding.json"):
+        source = args.source / name
+        if source.exists():
+            link_or_copy(source, args.dest / name)
+
+    print(f"created {args.dest}")
+    for file in sorted(args.dest.iterdir()):
+        print(f"  {file.name}: {file.stat().st_size / 1e6:.1f} MB")
+
+
+if __name__ == "__main__":
+    main()

scripts/merge_calibration_groups.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Validate and merge layer-grouped YAQA calibration NPZ files."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+from pathlib import Path
+
+import numpy as np
+
+GROUP_RE = re.compile(r"group-(\d+)-(\d+)\.npz$")
+LAYER_RE = re.compile(r"/\[(\d+)\]/")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--layers", type=int, required=True)
+    parser.add_argument("--group-size", type=int, default=4)
+    parser.add_argument("inputs", nargs="+", type=Path)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    expected = []
+    for start in range(0, args.layers, args.group_size):
+        end = min(start + args.group_size, args.layers)
+        expected.append((start, end))
+
+    seen_ranges: dict[tuple[int, int], Path] = {}
+    merged: dict[str, np.ndarray] = {}
+    covered_layers: set[int] = set()
+
+    for path in args.inputs:
+        match = GROUP_RE.search(path.name)
+        if not match:
+            raise SystemExit(f"unexpected group filename: {path}")
+        start, end = int(match.group(1)), int(match.group(2))
+        if (start, end) in seen_ranges:
+            raise SystemExit(f"duplicate group {start}-{end}: {seen_ranges[(start, end)]} and {path}")
+        seen_ranges[(start, end)] = path
+
+        with np.load(path) as data:
+            keys = [key for key in data.files if key != "__meta__"]
+            if not keys:
+                raise SystemExit(f"empty group: {path}")
+            for key in keys:
+                layer_match = LAYER_RE.search(key)
+                if not layer_match:
+                    raise SystemExit(f"key has no layer index: {key} in {path}")
+                layer = int(layer_match.group(1))
+                if not (start <= layer < end):
+                    raise SystemExit(f"key {key} outside group {start}-{end} in {path}")
+                if key in merged:
+                    raise SystemExit(f"duplicate calibration key: {key}")
+                merged[key] = data[key]
+                covered_layers.add(layer)
+
+    missing_groups = [f"{start}-{end}" for start, end in expected if (start, end) not in seen_ranges]
+    if missing_groups:
+        raise SystemExit(f"missing groups: {missing_groups}")
+    missing_layers = sorted(set(range(args.layers)) - covered_layers)
+    if missing_layers:
+        raise SystemExit(f"missing layers: {missing_layers}")
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    tmp = args.output.with_name(args.output.name + ".tmp.npz")
+    np.savez(tmp, **merged)
+    os.replace(tmp, args.output)
+    print(
+        f"merged {len(seen_ranges)} groups / {len(merged)} arrays / "
+        f"{len(covered_layers)} layers -> {args.output}"
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/merge_language_hessians.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Merge EN/JA raw Hessian calibrations with per-language normalization."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--en", type=Path, required=True)
+    parser.add_argument("--ja", type=Path, required=True)
+    parser.add_argument("--ja-ratio", type=float, default=0.5)
+    parser.add_argument("--damping", type=float, default=1e-3)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--json-out", type=Path, default=None)
+    return parser.parse_args()
+
+
+def normalize(matrix: np.ndarray) -> np.ndarray:
+    scale = float(np.mean(np.diagonal(matrix, axis1=-2, axis2=-1)))
+    return matrix / max(scale, 1e-30)
+
+
+def regularize(matrix: np.ndarray, damping: float) -> tuple[np.ndarray, float | None]:
+    sigma = damping
+    for _ in range(8):
+        candidate = matrix + np.eye(matrix.shape[-1], dtype=matrix.dtype) * sigma
+        try:
+            np.linalg.cholesky(candidate)
+            return candidate.astype(np.float32), sigma
+        except np.linalg.LinAlgError:
+            sigma *= 10.0
+    eigenvalues, eigenvectors = np.linalg.eigh(matrix)
+    eigenvalues = np.clip(eigenvalues, 1e-6, None)
+    rebuilt = (eigenvectors * eigenvalues[..., None, :]) @ np.swapaxes(eigenvectors, -1, -2)
+    return rebuilt.astype(np.float32), None
+
+
+def main() -> None:
+    args = parse_args()
+    if not 0.0 <= args.ja_ratio <= 1.0:
+        raise SystemExit("--ja-ratio must be within [0, 1]")
+
+    with np.load(args.en) as en_data, np.load(args.ja) as ja_data:
+        en_keys = set(en_data.files)
+        ja_keys = set(ja_data.files)
+        keys = sorted(en_keys & ja_keys)
+        if not keys:
+            raise SystemExit("EN/JA calibration have no common keys")
+        if en_keys != ja_keys:
+            print(f"warning: key mismatch en_only={sorted(en_keys - ja_keys)} ja_only={sorted(ja_keys - en_keys)}")
+
+        arrays: dict[str, np.ndarray] = {}
+        records = []
+        for key in keys:
+            en = np.asarray(en_data[key], dtype=np.float64)
+            ja = np.asarray(ja_data[key], dtype=np.float64)
+            if en.shape != ja.shape:
+                raise SystemExit(f"shape mismatch for {key}: {en.shape} vs {ja.shape}")
+            mixed = (1.0 - args.ja_ratio) * normalize(en) + args.ja_ratio * normalize(ja)
+            mixed, used_damping = regularize(mixed, args.damping)
+            arrays[key] = mixed
+            records.append(
+                {
+                    "key": key,
+                    "shape": list(mixed.shape),
+                    "damping": used_damping,
+                    "en_trace": float(np.trace(normalize(en), axis1=-2, axis2=-1).sum()),
+                    "ja_trace": float(np.trace(normalize(ja), axis1=-2, axis2=-1).sum()),
+                }
+            )
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    tmp = args.output.with_name(args.output.name + ".tmp")
+    np.savez(tmp, **arrays)
+    os.replace(tmp, args.output)
+
+    summary = {
+        "en": str(args.en),
+        "ja": str(args.ja),
+        "ja_ratio": args.ja_ratio,
+        "damping": args.damping,
+        "arrays": len(arrays),
+        "overlap_checked": True,
+        "calibration_corpora": [str(args.en), str(args.ja)],
+        "records": records,
+    }
+    if args.json_out:
+        args.json_out.parent.mkdir(parents=True, exist_ok=True)
+        args.json_out.write_text(json.dumps(summary, indent=2) + "\n")
+    print(f"merged {len(arrays)} arrays -> {args.output}")
+
+
+if __name__ == "__main__":
+    main()

scripts/qad_finetune.py

@@ -0,0 +1,498 @@
+#!/usr/bin/env python3
+"""Minimal Quantization-Aware Distillation (QAD) for lalamo HybridMatrix models.
+
+Pipeline:
+  1. Load a BF16 teacher and an RHT+INT4 PTQ student (lalamo format).
+  2. Switch student HybridMatrix nodes to CompressionImplementation.TRAINING.
+  3. Teacher-forced forward on a corpus; KL(teacher || student) loss.
+  4. Optimize:
+       - master_weights: Muon (optax.contrib.muon)
+       - scales / zero points: AdamW
+     with deterministic STE from lalamo's rounding.
+  5. Switch back to INFERENCE, save, rewrite metadata for uzu.
+
+This is a first-stage QAD: the loss uses teacher-forced corpus text. For the
+full Mirai recipe, replace the corpus with teacher-generated rollouts.
+
+Usage:
+  JAX_PLATFORM_NAME=cpu python scripts/qad_finetune.py \
+    --teacher-dir /tmp/qwen35_0.8b_bf16_lalamo_lalamo_origcfg \
+    --student-dir /tmp/qwen35_0.8b_yaqa_hin_hout_lalamo_eval \
+    --corpus experiments/qwen35-0.8b/data/calibration_en_wikitext2_dedup.txt \
+    --eval-corpus experiments/qwen35-0.8b/data/eval_en_wikitext2.txt \
+    --eval-corpus experiments/qwen35-0.8b/data/eval_ja_wikipedia.txt \
+    --output-dir /tmp/qwen35_0.8b_qad_lalamo \
+    --steps 50 --seq 128 --lr 1e-4
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import pickle
+import shutil
+import sys
+import time
+from pathlib import Path
+
+os.environ.setdefault("JAX_PLATFORM_NAME", "cpu")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--teacher-dir", type=Path, required=True)
+    parser.add_argument("--student-dir", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--corpus", type=Path, required=True)
+    parser.add_argument("--eval-corpus", type=Path, action="append", default=[], help="evaluation corpus to keep disjoint")
+    parser.add_argument("--allow-overlap", action="store_true", help="allow training/eval overlap for analysis only")
+    parser.add_argument("--lalamo-path", default=os.environ.get("LALAMO_PATH", "/tmp/lalamo-direct"))
+    parser.add_argument("--steps", type=int, default=50)
+    parser.add_argument("--seq", type=int, default=128)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--muon-lr", type=float, default=1e-3)
+    parser.add_argument(
+        "--optimizer",
+        choices=("muon", "adamw"),
+        default="muon",
+        help="muon: master=Muon + scales=AdamW; adamw: all trainables=AdamW",
+    )
+    parser.add_argument("--adam-b1", type=float, default=0.9)
+    parser.add_argument("--adam-b2", type=float, default=0.95, help="short QAD (<100 steps) uses 0.95, not 0.999")
+    parser.add_argument("--scale-min", type=float, default=1e-6, help="lower clamp for scale params; 0 disables")
+    parser.add_argument("--grad-clip", type=float, default=1.0, help="global norm clip; 0 disables")
+    parser.add_argument("--scale-lr", type=float, default=1e-6, help="AdamW lr for scales/zero-points")
+    parser.add_argument("--early-stop-patience", type=int, default=2, help="stop after N non-improving val evals")
+    parser.add_argument("--student-provenance", type=Path, default=None, help="default: <student-dir>/provenance.json")
+    parser.add_argument("--allow-unverified-student", action="store_true")
+    parser.add_argument("--temperature", type=float, default=1.0)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--val-chunks", type=int, default=2, help="fixed chunks used for comparable validation loss")
+    parser.add_argument("--val-every", type=int, default=5, help="evaluate fixed validation chunks every N steps")
+    parser.add_argument("--save-every", type=int, default=10, help="checkpoint interval; 0 = only final")
+    parser.add_argument("--checkpoint-dir", type=Path, default=None, help="default: <output-dir>/checkpoints")
+    parser.add_argument("--resume", default=None, help="'auto' or a checkpoint directory")
+    parser.add_argument("--keep-checkpoints", type=int, default=2, help="retain the newest N checkpoints")
+    parser.add_argument("--parallel", choices=("replicated", "tensor", "fsdp", "data"), default="replicated")
+    parser.add_argument("--dry-run", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    sys.path.insert(0, args.lalamo_path)
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+    from corpus_guard import assert_disjoint
+
+    assert_disjoint(args.corpus, args.eval_corpus, allow_overlap=args.allow_overlap)
+
+    import equinox as eqx
+    import jax
+    import jax.numpy as jnp
+    import numpy as np
+    import optax
+
+    from lalamo.compressed.hybrid import HybridMatrix
+    from lalamo.model import Model
+    from lalamo.module import Keychain
+    from lalamo.modules import DecoderForwardPassConfig, ForwardPassMode
+    from lalamo.utils.sharding import ShardingConfig
+    from lalamo.utils.surgery import map_nodes_of_type_with_path
+    from lalamo.weight_matrix import CompressionImplementation, GradientEstimator
+
+    from normalize_lalamo_config import normalize
+    from rewrite_lalamo_hybrid_spec import rewrite
+
+    if args.parallel == "tensor":
+        sharding = ShardingConfig.tensor_parallel()
+    elif args.parallel == "fsdp":
+        sharding = ShardingConfig.fully_sharded_data_parallel()
+    elif args.parallel == "data":
+        sharding = ShardingConfig.data_parallel()
+    else:
+        sharding = ShardingConfig.replicated()
+    keychain = Keychain.init(seed=args.seed, sharding_config=sharding)
+    inference_config = DecoderForwardPassConfig.for_inference(mode=ForwardPassMode.MULTI_TOKEN)
+    training_config = DecoderForwardPassConfig.for_training(
+        gradient_estimator=GradientEstimator.DETERMINISTIC_ROUNDING
+    )
+
+    def tokenizer_hash(directory: Path) -> str:
+        return hashlib.sha256((directory / "tokenizer.json").read_bytes()).hexdigest()
+
+    for label, directory in (("teacher", args.teacher_dir), ("student", args.student_dir)):
+        config = json.loads((directory / "config.json").read_text())
+        if "response_format" not in config.get("token_codec_config", {}):
+            raise SystemExit(
+                f"{label}: {directory} is uzu-normalized; QAD requires raw lalamo config"
+            )
+    if tokenizer_hash(args.teacher_dir) != tokenizer_hash(args.student_dir):
+        raise SystemExit("teacher/student tokenizer.json mismatch")
+
+    provenance_path = args.student_provenance or (args.student_dir / "provenance.json")
+    if not provenance_path.exists():
+        if not args.allow_unverified_student:
+            raise SystemExit(
+                f"student provenance missing: {provenance_path}. "
+                "Rebuild the student with a clean calibration or pass --allow-unverified-student for analysis."
+            )
+        provenance = {"overlap_checked": False, "kind": "unknown"}
+    else:
+        provenance = json.loads(provenance_path.read_text(encoding="utf-8"))
+        if not provenance.get("overlap_checked") and not args.allow_unverified_student:
+            raise SystemExit(
+                f"student provenance says overlap_checked=false: {provenance_path}"
+            )
+    print(f"student provenance: kind={provenance.get('kind')} overlap_checked={provenance.get('overlap_checked')}")
+
+    print("loading teacher...")
+    teacher = Model.load(args.teacher_dir, sharding, dtype=jnp.bfloat16)
+    print("loading student...")
+    student = Model.load(args.student_dir, sharding, dtype=jnp.bfloat16)
+
+    def to_training(path, matrix: HybridMatrix) -> HybridMatrix:
+        return matrix.switch_implementation(CompressionImplementation.TRAINING)
+
+    student = map_nodes_of_type_with_path(HybridMatrix, to_training, student)
+    print("student switched to TRAINING implementation")
+
+    def logits_for(model, ids, config):
+        token_ids = jnp.asarray([ids], dtype=jnp.int32)
+        positions = jnp.arange(len(ids), dtype=jnp.int32)[None, :]
+        result = model.decoder(
+            token_ids=token_ids,
+            token_positions=positions,
+            state=None,
+            return_updated_state=False,
+            lengths_without_padding=None,
+            forward_pass_config=config,
+            keychain=keychain.split(1)[0],
+        )
+        return result.logits[0]
+
+    texts = [line.strip() for line in args.corpus.read_text(encoding="utf-8").splitlines() if line.strip()]
+    token_ids = teacher.token_codec.tokenizer.encode("\n\n".join(texts), add_special_tokens=True).ids
+    chunks = [token_ids[start : start + args.seq] for start in range(0, len(token_ids), args.seq)]
+    chunks = [chunk for chunk in chunks if len(chunk) >= 16]
+    if not chunks:
+        raise SystemExit("no usable calibration chunks")
+    print(f"chunks: {len(chunks)} x {args.seq} tokens")
+    val_ids = chunks[-args.val_chunks :] if args.val_chunks > 0 else []
+
+    def collect_params(model):
+        params = {}
+        for path, leaf in jax.tree_util.tree_flatten_with_path(model)[0]:
+            key = jax.tree_util.keystr(path)
+            if any(name in key for name in ("master_weights", "scales", "master_zero_points")) and isinstance(leaf, jax.Array):
+                params[key] = leaf
+        return params
+
+    def inject_params(model, params):
+        return jax.tree_util.tree_map_with_path(
+            lambda path, leaf: params.get(jax.tree_util.keystr(path), leaf),
+            model,
+        )
+
+    params = collect_params(student)
+    print(f"trainable arrays: {len(params)}")
+    total_elements = sum(int(np.prod(value.shape)) for value in params.values())
+    print(f"trainable elements: {total_elements / 1e6:.1f}M")
+
+    def is_scale_key(key: str) -> bool:
+        return key.endswith("scales") or key.endswith("master_zero_points")
+
+    if args.optimizer == "adamw":
+        labels = {
+            key: ("scale" if is_scale_key(key) else "weight")
+            for key in params
+        }
+        optimizer = optax.multi_transform(
+            {
+                "weight": optax.adamw(args.lr, b1=args.adam_b1, b2=args.adam_b2, weight_decay=0.0),
+                "scale": optax.adamw(args.scale_lr, b1=args.adam_b1, b2=args.adam_b2, weight_decay=0.0),
+            },
+            labels,
+        )
+        print(f"optimizer: AdamW weight_lr={args.lr} scale_lr={args.scale_lr}", flush=True)
+    else:
+        labels = {
+            key: (
+                "muon"
+                if key.endswith("master_weights") and value.ndim >= 2
+                else "scale"
+                if is_scale_key(key)
+                else "adam"
+            )
+            for key, value in params.items()
+        }
+        optimizer = optax.multi_transform(
+            {
+                "muon": optax.contrib.muon(args.muon_lr),
+                # weight_decay=0.0 is required: optax.adamw defaults to 1e-4 and would
+                # shrink scales/zero-points towards zero every step (scale collapse).
+                "adam": optax.adamw(args.lr, b1=args.adam_b1, b2=args.adam_b2, weight_decay=0.0),
+                "scale": optax.adamw(args.scale_lr, b1=args.adam_b1, b2=args.adam_b2, weight_decay=0.0),
+            },
+            labels,
+        )
+        print(f"optimizer: Muon(master) + AdamW(scale_lr={args.scale_lr})", flush=True)
+
+    if args.grad_clip > 0:
+        optimizer = optax.chain(optax.clip_by_global_norm(args.grad_clip), optimizer)
+        print(f"grad clip: global norm {args.grad_clip}", flush=True)
+
+    scale_min = float(args.scale_min)
+
+    def clamp_scales(model_params):
+        if scale_min <= 0.0:
+            return model_params
+        return {
+            key: (jnp.maximum(value, scale_min) if key.endswith("scales") else value)
+            for key, value in model_params.items()
+        }
+
+    params = clamp_scales(params)
+    opt_state = optimizer.init(params)
+
+    def loss_fn(current_params, ids):
+        model = inject_params(student, current_params)
+        teacher_logits = jax.lax.stop_gradient(logits_for(teacher, ids, inference_config))
+        student_logits = logits_for(model, ids, training_config)
+        temperature = args.temperature
+        teacher_log_probs = jax.nn.log_softmax(teacher_logits / temperature, axis=-1)
+        student_log_probs = jax.nn.log_softmax(student_logits / temperature, axis=-1)
+        teacher_probs = jnp.exp(teacher_log_probs)
+        kl = jnp.sum(teacher_probs * (teacher_log_probs - student_log_probs), axis=-1).mean()
+        return kl * (temperature**2)
+
+    @jax.jit
+    def train_step(current_params, opt_state, ids):
+        loss, grads = jax.value_and_grad(loss_fn)(current_params, ids)
+        grad_norm = optax.global_norm(grads)
+        updates, new_state = optimizer.update(grads, opt_state, current_params)
+        new_params = optax.apply_updates(current_params, updates)
+        new_params = clamp_scales(new_params)
+        return new_params, new_state, loss, grad_norm
+
+    def validation_loss(current_params):
+        if not val_ids:
+            return None
+        values = [float(loss_fn(current_params, ids)) for ids in val_ids]
+        return sum(values) / len(values)
+
+    if args.dry_run:
+        print("dry-run: no training")
+        return
+
+    import orbax.checkpoint as ocp
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint_dir = args.checkpoint_dir or (args.output_dir / "checkpoints")
+    checkpoint_dir.mkdir(parents=True, exist_ok=True)
+    checkpointer = ocp.PyTreeCheckpointer()
+    checkpoint_meta = {
+        "teacher_dir": str(args.teacher_dir),
+        "student_dir": str(args.student_dir),
+        "eval_corpora": [str(path) for path in args.eval_corpus],
+        "overlap_checked": bool(args.eval_corpus),
+        "seq": args.seq,
+        "optimizer": args.optimizer,
+        "lr": args.lr,
+        "scale_lr": args.scale_lr,
+        "muon_lr": args.muon_lr,
+        "student_provenance_sha256": (
+            hashlib.sha256(provenance_path.read_bytes()).hexdigest()
+            if provenance_path.exists()
+            else None
+        ),
+        "adam_b1": args.adam_b1,
+        "adam_b2": args.adam_b2,
+        "scale_min": args.scale_min,
+    }
+
+    def save_checkpoint(step: int, current_params, current_state, current_rng) -> None:
+        path = checkpoint_dir / f"step_{step:05d}"
+        tmp_path = checkpoint_dir / f".{path.name}.tmp"
+        if tmp_path.exists():
+            shutil.rmtree(tmp_path)
+        checkpointer.save(
+            tmp_path,
+            {"params": current_params, "opt_state": current_state, "step": step},
+            force=True,
+        )
+        with open(tmp_path / "rng.pkl", "wb") as file:
+            pickle.dump(current_rng.bit_generator.state, file)
+        with open(tmp_path / "meta.json", "w", encoding="utf-8") as file:
+            json.dump(checkpoint_meta, file, indent=2, sort_keys=True)
+        (tmp_path / "COMPLETE").write_text("ok\n", encoding="utf-8")
+        if path.exists():
+            shutil.rmtree(path)
+        os.replace(tmp_path, path)
+        keep = max(args.keep_checkpoints, 1)
+        for old in sorted(checkpoint_dir.glob("step_*"))[:-keep]:
+            shutil.rmtree(old, ignore_errors=True)
+        print(f"checkpoint -> {path}", flush=True)
+
+    rng = np.random.default_rng(args.seed)
+    start_step = 0
+    if args.resume:
+        if args.resume == "auto":
+            candidates = sorted(
+                path for path in checkpoint_dir.glob("step_*") if (path / "COMPLETE").exists()
+            )
+            resume_path = candidates[-1] if candidates else None
+        else:
+            resume_path = Path(args.resume)
+        if resume_path is None:
+            print("resume: no complete checkpoint found; starting from 0", flush=True)
+        elif not resume_path.exists():
+            raise SystemExit(f"checkpoint not found: {resume_path}")
+        else:
+            meta_file = resume_path / "meta.json"
+            if not meta_file.exists():
+                raise RuntimeError(f"checkpoint missing meta.json: {resume_path}")
+            saved_meta = json.loads(meta_file.read_text(encoding="utf-8"))
+            for key, expected in checkpoint_meta.items():
+                if saved_meta.get(key) != expected:
+                    raise RuntimeError(
+                        f"checkpoint meta mismatch for {key}: saved={saved_meta.get(key)!r} current={expected!r}"
+                    )
+            restored = checkpointer.restore(resume_path)
+            params = restored["params"]
+            opt_state = restored["opt_state"]
+            start_step = int(restored["step"])
+            rng_file = resume_path / "rng.pkl"
+            if not rng_file.exists():
+                raise RuntimeError(f"checkpoint missing rng.pkl: {resume_path}")
+            with open(rng_file, "rb") as file:
+                rng.bit_generator.state = pickle.load(file)
+            print(f"resumed from {resume_path} at step {start_step}", flush=True)
+
+    run_id = time.strftime("%Y%m%d-%H%M%S")
+    progress_path = args.output_dir / "progress.jsonl"
+    if not args.resume:
+        progress_path.write_text("", encoding="utf-8")
+
+    def progress(record: dict) -> None:
+        record = {"run_id": run_id, **record}
+        with open(progress_path, "a", encoding="utf-8") as file:
+            file.write(json.dumps(record) + "\n")
+
+    def scale_stats(current_params):
+        values = [
+            np.asarray(value, dtype=np.float32).ravel()
+            for key, value in current_params.items()
+            if key.endswith("scales")
+        ]
+        if not values:
+            return 0.0, 0.0
+        merged = np.concatenate(values)
+        return float(merged.min()), float(merged.max())
+
+    initial_scale_min, initial_scale_max = scale_stats(params)
+    started_at = time.time()
+    initial_val = validation_loss(params)
+    best_val = initial_val
+    bad_val_evals = 0
+    if initial_val is not None:
+        progress({"step": 0, "val_loss": initial_val, "elapsed_s": 0.0})
+        print(f"step 0/{args.steps}  val_kl={initial_val:.6f}", flush=True)
+
+    for step in range(start_step, args.steps):
+        ids = chunks[int(rng.integers(0, len(chunks)))]
+        step_started = time.time()
+        params, opt_state, loss, grad_norm = train_step(params, opt_state, ids)
+        jax.block_until_ready(params)
+        now = time.time()
+        loss_value = float(loss)
+        grad_value = float(grad_norm)
+        scale_lo, scale_hi = scale_stats(params)
+        bad = not (
+            np.isfinite(loss_value)
+            and np.isfinite(grad_value)
+            and np.isfinite(scale_lo)
+            and np.isfinite(scale_hi)
+        )
+        collapsed = initial_scale_max > scale_min * 10 and scale_hi <= scale_min * 10
+        if bad or collapsed:
+            reason = "non-finite loss/grad/scale" if bad else "scale collapse"
+            progress(
+                {
+                    "step": step + 1,
+                    "status": "failed",
+                    "reason": reason,
+                    "loss": loss_value,
+                    "grad_norm": grad_value,
+                    "scale_min": scale_lo,
+                    "scale_max": scale_hi,
+                    "elapsed_s": now - started_at,
+                }
+            )
+            raise RuntimeError(f"QAD stopped at step {step + 1}: {reason}")
+        val_loss = None
+        if val_ids and ((step + 1) % args.val_every == 0 or step + 1 == args.steps):
+            val_loss = validation_loss(params)
+            if val_loss is not None:
+                if best_val is None or val_loss < best_val:
+                    best_val = val_loss
+                    bad_val_evals = 0
+                else:
+                    bad_val_evals += 1
+                    if args.early_stop_patience > 0 and bad_val_evals >= args.early_stop_patience:
+                        progress(
+                            {
+                                "step": step + 1,
+                                "status": "early_stop",
+                                "val_loss": val_loss,
+                                "best_val_loss": best_val,
+                                "elapsed_s": now - started_at,
+                            }
+                        )
+                        raise RuntimeError(
+                            f"QAD early stop at step {step + 1}: val loss did not improve "
+                            f"(best={best_val:.6f}, current={val_loss:.6f})"
+                        )
+        record = {
+            "run_id": run_id,
+            "step": step + 1,
+            "loss": loss_value,
+            "val_loss": val_loss,
+            "grad_norm": grad_value,
+            "scale_min": scale_lo,
+            "scale_max": scale_hi,
+            "step_s": now - step_started,
+            "elapsed_s": now - started_at,
+        }
+        with open(progress_path, "a", encoding="utf-8") as file:
+            file.write(json.dumps(record) + "\n")
+        val_text = "" if val_loss is None else f"  val_kl={val_loss:.6f}"
+        print(
+            f"step {step + 1}/{args.steps}  kl={loss_value:.6f}{val_text}  "
+            f"grad={grad_value:.3g}  scale=[{scale_lo:.3g},{scale_hi:.3g}]  "
+            f"step_s={now - step_started:.2f}  elapsed_s={now - started_at:.1f}",
+            flush=True,
+        )
+        if args.save_every and (step + 1) % args.save_every == 0:
+            save_checkpoint(step + 1, params, opt_state, rng)
+
+    if args.steps > 0 and (not args.save_every or args.steps % args.save_every != 0):
+        save_checkpoint(args.steps, params, opt_state, rng)
+
+    trained = inject_params(student, params)
+    trained = map_nodes_of_type_with_path(
+        HybridMatrix,
+        lambda path, matrix: matrix.switch_implementation(CompressionImplementation.INFERENCE),
+        trained,
+    )
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    trained.save(args.output_dir)
+    rewrite(args.output_dir / "model.safetensors")
+    normalize(args.output_dir)
+    print(f"saved QAD model -> {args.output_dir}")
+
+
+if __name__ == "__main__":
+    main()

scripts/rht_int4_convert.py

@@ -0,0 +1,457 @@
+#!/usr/bin/env python3
+"""Convert a supported Hugging Face model to uzu with RHT + INT4 Group32.
+
+This bypasses MLX quantization and applies lalamo's HybridSpec directly:
+  BF16 Linear -> RHT (Hadamard block 32) -> asymmetric INT4 group 32 -> HybridMatrix
+
+The resulting lalamo model is saved, its HybridSpec metadata is rewritten to
+uzu's flat form, and encoding.json is added.
+
+Example (0.8B, local CPU):
+  JAX_PLATFORM_NAME=cpu python scripts/rht_int4_convert.py \
+    --spec-name Qwen3.5-0.8B \
+    --lalamo-path /tmp/lalamo-direct \
+    --output-dir /tmp/qwen35_0.8b_rht_int4_lalamo \
+    --bf16-dir /tmp/qwen35_0.8b_bf16_lalamo
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from dataclasses import replace
+from pathlib import Path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--spec-name", default="Qwen3.5-0.8B", help="Built-in lalamo model spec name")
+    parser.add_argument("--hf-repo", default=None, help="Override origin with this Hugging Face repo")
+    parser.add_argument("--hf-dir", default=None, help="Use a local HF snapshot directory instead of downloading")
+    parser.add_argument("--vendor", default=None)
+    parser.add_argument("--name", default=None)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--bf16-dir", default=None, help="Also save the unquantized model here")
+    parser.add_argument(
+        "--load-from",
+        default=None,
+        help="Load an existing lalamo model directory instead of importing from Hugging Face",
+    )
+    parser.add_argument("--lalamo-path", default=os.environ.get("LALAMO_PATH", "/tmp/lalamo-direct"))
+    parser.add_argument(
+        "--parallel",
+        choices=("replicated", "tensor", "fsdp", "data"),
+        default="replicated",
+        help="JAX device sharding: tensor/fsdp use all visible GPUs as one memory pool",
+    )
+    parser.add_argument("--bits", type=int, default=4, choices=(4, 8))
+    parser.add_argument(
+        "--embedding-bits",
+        type=int,
+        default=None,
+        choices=(4, 8),
+        help="Override --bits for the tied/untied embedding and readout only",
+    )
+    parser.add_argument("--group-size", type=int, default=32)
+    parser.add_argument("--block-size", type=int, default=32, choices=(32, 64, 128))
+    parser.add_argument(
+        "--no-rht",
+        action="store_true",
+        help="Disable RHT and quantize with plain INT4 Group (isolation baseline)",
+    )
+    parser.add_argument(
+        "--quantize-embedding",
+        action="store_true",
+        help="Also quantize the tied token embedding with RHT output-only (matches Mirai-M)",
+    )
+    parser.add_argument("--dtype", default="bfloat16")
+    parser.add_argument("--skip-incompatible", action="store_true", help="Leave non-divisible Linears full precision")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--hf-token", default=None)
+    parser.add_argument(
+        "--preconditioners",
+        default=None,
+        help="NPZ from scripts/yaqa_calibration.py; keys are '<path>/input_block' and optional '/output_block'",
+    )
+    parser.add_argument(
+        "--calibration-json",
+        type=Path,
+        default=None,
+        help="calibration.json paired with --preconditioners; embedded into provenance.json",
+    )
+    parser.add_argument(
+        "--progress-jsonl",
+        type=Path,
+        default=None,
+        help="default: <output-dir>/convert_progress.jsonl",
+    )
+    return parser.parse_args()
+
+
+# uzu config strictness:
+#   * every struct uses `#[serde(deny_unknown_fields)]`
+#   * every field is required, even `Option<T>` (missing != null)
+# lalamo emits a newer token_codec schema that violates both rules.
+_UZU_TOKEN_CODEC_REQUIRED = ("output_parser_regex", "end_of_thinking_tag")
+_UZU_TOKEN_CODEC_UNSUPPORTED = ("response_format", "reasoning_effort")
+
+
+def normalize_config_for_uzu(output_dir: Path) -> None:
+    path = output_dir / "config.json"
+    config = json.loads(path.read_text())
+
+    # Keep the untouched lalamo form for lalamo-side evaluation (PPL / logits).
+    lalamo_path = output_dir / "config.lalamo.json"
+    if not lalamo_path.exists():
+        lalamo_path.write_text(json.dumps(config, indent=2) + "\n")
+
+    token_codec = config.get("token_codec_config")
+    if token_codec is None:
+        return
+
+    removed = [key for key in _UZU_TOKEN_CODEC_UNSUPPORTED if token_codec.pop(key, None) is not None]
+    added = [key for key in _UZU_TOKEN_CODEC_REQUIRED if key not in token_codec]
+    for key in added:
+        token_codec[key] = None
+
+    if removed or added:
+        path.write_text(json.dumps(config, indent=2) + "\n")
+    print(f"normalize config.json: removed={removed or '[]'} added={added or '[]'}")
+
+
+def find_spec(qwen_models, name: str):
+    for spec in qwen_models:
+        if spec.name == name:
+            return spec
+    raise ValueError(f"model spec {name!r} not found")
+
+
+def main() -> None:
+    args = parse_args()
+    os.environ.setdefault("JAX_PLATFORM_NAME", "cpu")
+    if args.hf_token:
+        os.environ["HF_TOKEN"] = args.hf_token
+
+    progress_path = args.progress_jsonl or (Path(args.output_dir) / "convert_progress.jsonl")
+    progress_path.parent.mkdir(parents=True, exist_ok=True)
+    run_id = time.strftime("%Y%m%d-%H%M%S")
+    progress_path.write_text("", encoding="utf-8")
+
+    def progress(record: dict) -> None:
+        record = {"run_id": run_id, **record}
+        with open(progress_path, "a", encoding="utf-8") as file:
+            file.write(json.dumps(record) + "\n")
+
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    sys.path.insert(0, args.lalamo_path)
+
+    import jax
+    import jax.numpy as jnp
+    import equinox as eqx
+    import numpy as np
+
+    from lalamo.compressed.hybrid import HybridSpec
+    from lalamo.compressed.int import IntSpec
+    from lalamo.compressed.incoherence import HadamardSpec, IncoherenceProcessingMode
+    from lalamo.model_import.common import import_model
+    from lalamo.model_import.model_specs.qwen import QWEN_MODELS
+    from lalamo.modules.linear import Linear
+    from lalamo.preconditioner import Preconditioner
+    from lalamo.utils.sharding import ShardingConfig
+    from lalamo.utils.surgery import map_nodes_of_type_with_path, select_nodes_of_type
+    from lalamo.weight_matrix import Layout
+    from rewrite_lalamo_hybrid_spec import rewrite
+
+    if args.parallel == "tensor":
+        sharding = ShardingConfig.tensor_parallel()
+    elif args.parallel == "fsdp":
+        sharding = ShardingConfig.fully_sharded_data_parallel()
+    elif args.parallel == "data":
+        sharding = ShardingConfig.data_parallel()
+    else:
+        sharding = ShardingConfig.replicated()
+
+    if args.load_from:
+        from lalamo.model import Model
+
+        print(f"load lalamo model <- {args.load_from}")
+        model = Model.load(args.load_from, sharding, dtype=jnp.dtype(args.dtype))
+        print("load done")
+    else:
+        spec = find_spec(QWEN_MODELS, args.spec_name)
+        if args.hf_dir:
+            from pathlib import Path as _Path
+
+            from lalamo.model_import.origins import LocalOrigin
+
+            weight_files = tuple(sorted(path.name for path in _Path(args.hf_dir).glob("*.safetensors")))
+            if not weight_files:
+                raise SystemExit(f"no safetensors files in {args.hf_dir}")
+            spec = replace(
+                spec,
+                vendor=args.vendor or spec.vendor,
+                name=args.name or spec.name,
+                origin=LocalOrigin(root=args.hf_dir, weight_files=weight_files),
+            )
+        elif args.hf_repo:
+            from lalamo.model_import.origins import HuggingFaceOrigin
+
+            spec = replace(
+                spec,
+                vendor=args.vendor or spec.vendor,
+                name=args.name or spec.name,
+                origin=HuggingFaceOrigin(repo=args.hf_repo),
+            )
+
+        print(f"import {spec.vendor}/{spec.name} <- {spec.origin.description}")
+        results = import_model(
+            spec,
+            sharding_config=sharding,
+            dtype=jnp.dtype(args.dtype),
+        )
+        model = results.model
+        print("import done")
+
+    if args.bf16_dir:
+        bf16_dir = Path(args.bf16_dir)
+        bf16_dir.mkdir(parents=True, exist_ok=True)
+        print(f"save BF16 baseline -> {bf16_dir}")
+        model.save(bf16_dir)
+        normalize_config_for_uzu(bf16_dir)
+        (bf16_dir / "COMPLETE").write_text("ok\n", encoding="utf-8")
+        print("BF16 baseline saved")
+
+    linear_list = select_nodes_of_type(Linear, model)
+    required_divisor = args.group_size if args.no_rht else max(args.block_size, args.group_size)
+    bad = []
+    for path, linear in linear_list:
+        shape = tuple(int(x) for x in linear.weights.shape)
+        if len(shape) != 2 or any(dimension % required_divisor for dimension in shape):
+            bad.append(("/".join(path), shape))
+
+    print(f"Linear layers: {len(linear_list)}, incompatible: {len(bad)}")
+    for path, shape in bad:
+        print(f"  {path}: {shape}")
+    if bad and not args.skip_incompatible:
+        raise SystemExit("incompatible Linear shapes; use --skip-incompatible to leave them full precision")
+
+    hybrid_spec = HybridSpec(
+        quantization_spec=IntSpec(
+            bits=args.bits,
+            group_size=args.group_size,
+            is_symmetric=False,
+            layout=Layout.OUTPUT_INPUT,
+        ),
+        adapter_spec=None,
+        incoherence_spec=None
+        if args.no_rht
+        else HadamardSpec(
+            block_size=args.block_size,
+            processing_mode=IncoherenceProcessingMode.INPUT_OUTPUT,
+        ),
+    )
+    quantize_key = jax.random.key(0)
+    counts = {"quantized": 0, "skipped": 0, "yaqa": 0}
+
+    calibration = None
+    if args.preconditioners:
+        calibration = np.load(args.preconditioners)
+        print(f"preconditioners: {args.preconditioners} ({len(calibration.files)} arrays)")
+
+    def preconditioner_for(path) -> Preconditioner | None:
+        if calibration is None:
+            return None
+        key = "/".join(path)
+        input_key = f"{key}/input_block"
+        if input_key not in calibration:
+            return None
+        output_key = f"{key}/output_block"
+        return Preconditioner.init(
+            input_block=jnp.asarray(calibration[input_key], dtype=jnp.float32),
+            output_block=jnp.asarray(calibration[output_key], dtype=jnp.float32)
+            if output_key in calibration
+            else None,
+        )
+
+    def quantize_linear(path, linear: Linear) -> Linear:
+        started = time.time()
+        key = "/".join(path)
+        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
+            progress({"path": key, "shape": shape, "status": "skipped", "elapsed_s": time.time() - started})
+            if not args.skip_incompatible:
+                raise ValueError(f"incompatible Linear {path}: {shape}")
+            return linear
+        counts["quantized"] += 1
+        preconditioner = preconditioner_for(path)
+        if preconditioner is not None:
+            counts["yaqa"] += 1
+        progress({"path": key, "shape": shape, "status": "started"})
+        try:
+            new_weights = hybrid_spec.compress(
+                linear.weights.decompress(),
+                key=quantize_key,
+                preconditioner=preconditioner,
+                sharding_config=linear.weights.sharding_config,
+                is_sharded=linear.weights.is_sharded,
+            )
+        except Exception as error:
+            progress(
+                {
+                    "path": key,
+                    "shape": shape,
+                    "status": "failed",
+                    "error": repr(error),
+                    "elapsed_s": time.time() - started,
+                }
+            )
+            raise
+        progress(
+            {
+                "path": key,
+                "shape": shape,
+                "status": "quantized",
+                "yaqa": preconditioner is not None,
+                "elapsed_s": time.time() - started,
+            }
+        )
+        return eqx.tree_at(lambda x: x.weights, linear, new_weights)
+
+    if args.dry_run:
+        print("dry-run: no quantization performed")
+        return
+
+    if args.no_rht:
+        print(f"quantize -> plain INT{args.bits} group {args.group_size} (symmetric=False, layout=output_input)")
+        if args.embedding_bits is not None:
+            print(f"embedding quantize -> plain INT{args.embedding_bits} group {args.group_size} (symmetric=False)")
+    else:
+        print(
+            f"quantize -> RHT block {args.block_size} + INT{args.bits} group {args.group_size} "
+            f"(symmetric=False, layout=output_input)"
+        )
+        if args.embedding_bits is not None:
+            print(
+                f"embedding quantize -> RHT block {args.block_size} + INT{args.embedding_bits} group {args.group_size} "
+                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']}")
+
+    def embedding_spec(layout: Layout, mode: IncoherenceProcessingMode | None) -> HybridSpec:
+        embedding_bits = args.embedding_bits if args.embedding_bits is not None else args.bits
+        return HybridSpec(
+            quantization_spec=IntSpec(
+                bits=embedding_bits,
+                group_size=args.group_size,
+                is_symmetric=False,
+                layout=layout,
+            ),
+            adapter_spec=None,
+            incoherence_spec=None
+            if args.no_rht or mode is None
+            else HadamardSpec(block_size=args.block_size, processing_mode=mode),
+        )
+
+    def quantize_matrix(matrix, layout: Layout, mode: IncoherenceProcessingMode | None, label: str):
+        started = time.time()
+        embedding_dim = int(matrix.shape[-1])
+        if not args.no_rht and embedding_dim % args.block_size:
+            raise SystemExit(f"{label} dim {embedding_dim} is not divisible by block size {args.block_size}")
+        new_matrix = embedding_spec(layout, mode).compress(
+            matrix.decompress(),
+            key=quantize_key,
+            sharding_config=matrix.sharding_config,
+            is_sharded=matrix.is_sharded,
+        )
+        shape = tuple(int(x) for x in matrix.shape)
+        print(f"{label} quantized: shape={shape}")
+        progress({"path": label, "shape": shape, "status": "quantized", "yaqa": False, "elapsed_s": time.time() - started})
+        return new_matrix
+
+    if args.quantize_embedding:
+        embedding = getattr(quantized_model.decoder, "embedding", None)
+        tied = getattr(embedding, "embedding", None)
+        if tied is not None:
+            matrix = quantize_matrix(
+                tied,
+                Layout.INPUT_OUTPUT,
+                IncoherenceProcessingMode.OUTPUT,
+                "tied embedding",
+            )
+            new_embedding = eqx.tree_at(lambda node: node.embedding, embedding, matrix)
+            quantized_model = eqx.tree_at(
+                lambda root: root.decoder.embedding,
+                quantized_model,
+                new_embedding,
+            )
+        elif hasattr(embedding, "input_embedding") and hasattr(embedding, "output_embedding"):
+            input_embedding = quantize_matrix(
+                embedding.input_embedding,
+                Layout.INPUT_OUTPUT,
+                IncoherenceProcessingMode.OUTPUT,
+                "input_embedding",
+            )
+            output_embedding = quantize_matrix(
+                embedding.output_embedding,
+                Layout.OUTPUT_INPUT,
+                IncoherenceProcessingMode.INPUT,
+                "output_embedding (lm_head)",
+            )
+            embedding = eqx.tree_at(lambda node: node.input_embedding, embedding, input_embedding)
+            embedding = eqx.tree_at(lambda node: node.output_embedding, embedding, output_embedding)
+            quantized_model = eqx.tree_at(
+                lambda root: root.decoder.embedding,
+                quantized_model,
+                embedding,
+            )
+        else:
+            print("embedding: neither tied nor untied embedding found, skipped")
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    print(f"save quantized model -> {output_dir}")
+    quantized_model.save(output_dir)
+
+    print("rewrite HybridSpec metadata for uzu")
+    rewrite(output_dir / "model.safetensors")
+
+    normalize_config_for_uzu(output_dir)
+
+    encoding = {"type": "hanashi", "name": "qwen3.5"}
+    (output_dir / "encoding.json").write_text(json.dumps(encoding, indent=2) + "\n")
+
+    calibration_summary = None
+    if args.calibration_json and args.calibration_json.exists():
+        calibration_summary = json.loads(args.calibration_json.read_text())
+    source = args.hf_repo or (str(args.hf_dir) if args.hf_dir else None) or args.load_from or args.spec_name
+    provenance = {
+        "kind": "yaqa" if args.preconditioners else "rtn",
+        "source": source,
+        "preconditioners": args.preconditioners,
+        "calibration_json": str(args.calibration_json) if args.calibration_json else None,
+        "calibration": calibration_summary,
+        "overlap_checked": (
+            bool(calibration_summary.get("overlap_checked"))
+            if calibration_summary is not None
+            else args.preconditioners is None
+        ),
+    }
+    (output_dir / "provenance.json").write_text(
+        json.dumps(provenance, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    (output_dir / "COMPLETE").write_text("ok\n", encoding="utf-8")
+    print("encoding.json / provenance.json written")
+
+    for f in sorted(output_dir.iterdir()):
+        if f.is_file():
+            print(f"  {f.name}: {f.stat().st_size / 1e6:.1f} MB")
+
+
+if __name__ == "__main__":
+    main()

scripts/tiny_sharding_probe.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Tiny 2-device sharding probe for uzu/lalamo TP semantics.
+
+Usage on Kaggle T4x2:
+  python scripts/tiny_sharding_probe.py
+
+Usage on CPU with 2 forced devices:
+  FORCE_2_CPU=1 python scripts/tiny_sharding_probe.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+if os.environ.get("FORCE_2_CPU") == "1":
+    os.environ.setdefault("XLA_FLAGS", "--xla_force_host_platform_device_count=2")
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from jax.sharding import AxisType, Mesh, NamedSharding, PartitionSpec as P
+
+
+def main() -> None:
+    devices = jax.devices()
+    report = {"devices": [str(device) for device in devices], "cases": [], "ok": False}
+    if len(devices) < 2:
+        report["error"] = f"need >=2 devices, got {len(devices)}"
+        print(json.dumps(report, indent=2))
+        raise SystemExit(1)
+
+    mesh = Mesh(np.asarray(devices[:2]), ("tensor",), axis_types=(AxisType.Explicit,))
+    base = jnp.asarray(np.arange(64, dtype=np.float32).reshape(8, 8))
+
+    def record(name: str, expect_error: bool, expected: str, fn) -> None:
+        try:
+            fn()
+        except Exception as error:  # noqa: BLE001 - probe records the exact runtime error
+            message = str(error)
+            passed = expect_error and expected in message
+            report["cases"].append(
+                {"name": name, "expected": expected, "ok": passed, "error": message[:500]}
+            )
+        else:
+            report["cases"].append(
+                {"name": name, "expected": expected, "ok": not expect_error, "error": None}
+            )
+
+    def column_sharded_matmul() -> None:
+        sharding = NamedSharding(mesh, P(None, "tensor"))
+        with jax.set_mesh(mesh):
+            x = jax.device_put(base, sharding)
+            _ = x @ x.T
+
+    def row_sharded_matmul() -> None:
+        sharding = NamedSharding(mesh, P("tensor", None))
+        with jax.set_mesh(mesh):
+            x = jax.device_put(base, sharding)
+            _ = x @ x.T
+
+    def replicated_reshard_matmul() -> None:
+        sharded = NamedSharding(mesh, P(None, "tensor"))
+        replicated = NamedSharding(mesh, P())
+        with jax.set_mesh(mesh):
+            x = jax.device_put(base, sharded)
+            x_rep = jax.device_put(x, replicated)
+            result = x_rep @ x_rep.T
+            expected = base @ base.T
+            diff = float(jnp.max(jnp.abs(result - expected)))
+            report["reshard_max_abs_diff"] = diff
+            if diff > 1e-4:
+                raise RuntimeError(f"reshard mismatch: {diff}")
+
+    record("column_sharded_matmul", True, "Contracting dimensions are sharded", column_sharded_matmul)
+    record("row_sharded_matmul", True, "illegally sharded", row_sharded_matmul)
+    record("replicated_reshard_matmul", False, "", replicated_reshard_matmul)
+
+    report["ok"] = all(case["ok"] for case in report["cases"])
+    print(json.dumps(report, indent=2))
+    raise SystemExit(0 if report["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()

scripts/yaqa_calibration.py

@@ -0,0 +1,467 @@
+#!/usr/bin/env python3
+"""Sketch B YAQA calibration for lalamo language models.
+
+Universal part of the pipeline (Layer 2 in YAQA_CALIBRATION_DESIGN.md):
+
+  forward  -> pseudo target sampling from the model's own logits
+  backward -> per-sample weight gradient G_b for every selected Linear
+  H_I = mean_b G_b^T G_b
+  H_O = mean_b G_b G_b^T
+  damping + PSD checks -> preconditioners.npz
+
+Per-model work is limited to selecting LinearSite entries.
+
+Usage:
+  JAX_PLATFORM_NAME=cpu python scripts/yaqa_calibration.py \
+    --model-dir /tmp/qwen35_0.8b_bf16_lalamo_lalamo_origcfg \
+    --corpus experiments/qwen35-0.8b/data/calibration.txt \
+    --output experiments/qwen35-0.8b/yaqa-hin/calibration.npz \
+    --samples 32 --max-tokens 128 --output-block none
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+os.environ.setdefault("JAX_PLATFORM_NAME", "cpu")
+
+
+@dataclass(frozen=True)
+class LinearSite:
+    path: tuple[str, ...]
+    linear: object
+    out_dim: int
+    in_dim: int
+    components: tuple[int, ...]
+
+    @property
+    def key(self) -> str:
+        return "/".join(self.path)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-dir", type=Path, default=None, help="saved lalamo model directory")
+    parser.add_argument("--spec-name", default="Qwen3.5-0.8B", help="built-in lalamo spec for direct HF import")
+    parser.add_argument("--hf-repo", default=None, help="load directly from this Hugging Face repo (no save)")
+    parser.add_argument("--hf-dir", default=None, help="load directly from a local HF snapshot directory")
+    parser.add_argument("--corpus", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--lalamo-path", default=os.environ.get("LALAMO_PATH", "/tmp/lalamo-direct"))
+    parser.add_argument(
+        "--parallel",
+        choices=("replicated", "tensor", "fsdp", "data"),
+        default="replicated",
+        help="JAX device sharding: tensor/fsdp use all visible GPUs as one memory pool",
+    )
+    parser.add_argument("--samples", type=int, default=32)
+    parser.add_argument("--max-tokens", type=int, default=128)
+    parser.add_argument("--min-tokens", type=int, default=32, help="drop shorter trailing chunks")
+    parser.add_argument("--layer-filter", default="", help="only paths containing this substring")
+    parser.add_argument("--output-block", choices=("none", "small", "all"), default="none")
+    parser.add_argument("--output-block-limit", type=int, default=2048)
+    parser.add_argument("--raw-output", action="store_true", help="save raw H before normalization/damping (for language-balanced merge)")
+    parser.add_argument("--damping", type=float, default=1e-2, help="initial sigma_reg after mean-diagonal normalization")
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument(
+        "--calib-dtype",
+        choices=("float32", "bfloat16"),
+        default="float32",
+        help="model dtype during calibration; bfloat16 halves memory for 4B/9B",
+    )
+    parser.add_argument("--json-out", type=Path, default=None)
+    parser.add_argument("--eval-corpus", type=Path, action="append", default=[], help="evaluation corpus to keep disjoint")
+    parser.add_argument("--allow-overlap", action="store_true", help="allow calibration/eval overlap for analysis only")
+    parser.add_argument("--progress-jsonl", type=Path, default=None, help="default: <output>.progress.jsonl")
+    parser.add_argument("--checkpoint-every", type=int, default=0, help="save partial accumulators every N samples; 0=off")
+    parser.add_argument("--checkpoint-path", type=Path, default=None, help="default: <output>.partial.npz")
+    parser.add_argument("--resume", default=None, help="'auto' or a partial npz path")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    from corpus_guard import assert_disjoint
+
+    assert_disjoint(args.corpus, args.eval_corpus, allow_overlap=args.allow_overlap)
+    progress_path = args.progress_jsonl or args.output.with_suffix(".progress.jsonl")
+    progress_path.parent.mkdir(parents=True, exist_ok=True)
+    checkpoint_path = args.checkpoint_path or args.output.with_suffix(".partial.npz")
+    if checkpoint_path.suffix != ".npz":
+        checkpoint_path = checkpoint_path.with_suffix(".npz")
+    if checkpoint_path.resolve() == args.output.resolve():
+        raise SystemExit("--checkpoint-path must differ from --output")
+    run_id = time.strftime("%Y%m%d-%H%M%S")
+    if not args.resume:
+        progress_path.write_text("", encoding="utf-8")
+
+    def progress(record: dict) -> None:
+        record = {"run_id": run_id, **record}
+        with open(progress_path, "a", encoding="utf-8") as file:
+            file.write(json.dumps(record) + "\n")
+
+    sys.path.insert(0, args.lalamo_path)
+
+    import equinox as eqx
+    import jax
+    import jax.numpy as jnp
+    import numpy as np
+
+    from lalamo.model import Model
+    from lalamo.module import Keychain
+    from lalamo.modules import DecoderForwardPassConfig, ForwardPassMode
+    from lalamo.modules.linear import Linear
+    from lalamo.utils.sharding import ShardingConfig
+    from lalamo.utils.surgery import select_nodes_of_type
+    from tokenizers import Tokenizer
+
+    if args.parallel == "tensor":
+        sharding = ShardingConfig.tensor_parallel()
+    elif args.parallel == "fsdp":
+        sharding = ShardingConfig.fully_sharded_data_parallel()
+    elif args.parallel == "data":
+        sharding = ShardingConfig.data_parallel()
+    else:
+        sharding = ShardingConfig.replicated()
+    keychain = Keychain.init(seed=args.seed, sharding_config=sharding)
+    forward_pass_config = DecoderForwardPassConfig.for_inference(mode=ForwardPassMode.MULTI_TOKEN)
+
+    dtype = jnp.dtype(args.calib_dtype)
+    if args.hf_repo or args.hf_dir:
+        from dataclasses import replace as dataclass_replace
+        from pathlib import Path as _Path
+
+        from lalamo.model_import.common import import_model
+        from lalamo.model_import.model_specs.qwen import QWEN_MODELS
+
+        spec = next((item for item in QWEN_MODELS if item.name == args.spec_name), None)
+        if spec is None:
+            raise SystemExit(f"lalamo spec {args.spec_name!r} not found")
+        if args.hf_dir:
+            from lalamo.model_import.origins import LocalOrigin
+
+            weight_files = tuple(sorted(path.name for path in _Path(args.hf_dir).glob("*.safetensors")))
+            if not weight_files:
+                raise SystemExit(f"no safetensors in {args.hf_dir}")
+            origin = LocalOrigin(root=args.hf_dir, weight_files=weight_files)
+        else:
+            from lalamo.model_import.origins import HuggingFaceOrigin
+
+            origin = HuggingFaceOrigin(repo=args.hf_repo)
+        print(f"importing {args.spec_name} from {origin.description} ({args.calib_dtype})...")
+        results = import_model(dataclass_replace(spec, origin=origin), sharding_config=sharding, dtype=dtype)
+        model = results.model
+        tokenizer = model.token_codec.tokenizer
+    else:
+        if args.model_dir is None:
+            raise SystemExit("provide --model-dir, --hf-repo, or --hf-dir")
+        print(f"loading model ({args.calib_dtype})...")
+        model = Model.load(args.model_dir, sharding, dtype=dtype)
+        tokenizer = Tokenizer.from_file(str(args.model_dir / "tokenizer.json"))
+    print("loaded")
+
+    def module_at(root, attribute_path):
+        node = root
+        for part in attribute_path:
+            if part.startswith("["):
+                node = node[int(part[1:-1])]
+            else:
+                node = getattr(node, part.lstrip("."))
+        return node
+
+    layer_filters = [item for item in args.layer_filter.split(",") if item]
+    sites: list[LinearSite] = []
+    for path, linear in select_nodes_of_type(Linear, model):
+        joined = "/".join(path)
+        if layer_filters and not any(item in joined for item in layer_filters):
+            continue
+        shape = tuple(int(x) for x in linear.weights.shape)
+        if len(shape) < 2:
+            continue
+        components = shape[:-2]
+        out_dim, in_dim = shape[-2], shape[-1]
+        sites.append(LinearSite(path=path, linear=linear, out_dim=out_dim, in_dim=in_dim, components=components))
+    if not sites:
+        raise SystemExit("no LinearSite selected")
+    print(f"sites: {len(sites)}")
+
+    def logits_for(m, ids):
+        token_ids = jnp.asarray([ids], dtype=jnp.int32)
+        positions = jnp.arange(len(ids), dtype=jnp.int32)[None, :]
+        result = m.decoder(
+            token_ids=token_ids,
+            token_positions=positions,
+            state=None,
+            return_updated_state=False,
+            lengths_without_padding=None,
+            forward_pass_config=forward_pass_config,
+            keychain=keychain.split(1)[0],
+        )
+        return result.logits[0]
+
+    def cross_entropy(logits, targets):
+        log_probs = jax.nn.log_softmax(logits.astype(jnp.float32), axis=-1)
+        # Official get_hess_llama.py uses F.cross_entropy(..., reduction="mean")
+        # over all tokens of the batch. Per-sample mean keeps the same scale
+        # independently of sequence length.
+        return -jnp.mean(jnp.take_along_axis(log_probs, targets[:, None], axis=-1))
+
+    base_arrays = tuple(site.linear.weights.weights for site in sites)
+
+    def model_with_weights(arrays):
+        updated = model
+        for site, array in zip(sites, arrays):
+            current = module_at(updated, site.path)
+            new_weights = eqx.tree_at(lambda wm: wm.weights, current.weights, array)
+            new_linear = eqx.tree_at(lambda linear: linear.weights, current, new_weights)
+            updated = eqx.tree_at(lambda root, path=site.path: module_at(root, path), updated, new_linear)
+        return updated
+
+    current_ids: list[int] = []
+    current_targets = None
+
+    def per_sample_loss(arrays):
+        m = model_with_weights(arrays)
+        logits = logits_for(m, current_ids)
+        return cross_entropy(logits, current_targets)
+
+    texts = [line.strip() for line in args.corpus.read_text(encoding="utf-8").splitlines() if line.strip()]
+    if not texts:
+        raise SystemExit("empty calibration corpus")
+
+    def build_chunks() -> list[list[int]]:
+        # Concatenate documents and cut into full-context windows, matching the
+        # official calibration flow (continuous sequences instead of single lines).
+        joined = "\n\n".join(texts)
+        ids = tokenizer.encode(joined, add_special_tokens=True).ids
+        chunks = [ids[start : start + args.max_tokens] for start in range(0, len(ids), args.max_tokens)]
+        chunks = [chunk for chunk in chunks if len(chunk) >= args.min_tokens]
+        if not chunks:
+            raise SystemExit("no usable calibration chunks")
+        rng = np.random.default_rng(args.seed)
+        rng.shuffle(chunks)
+        return chunks
+
+    chunks = build_chunks()
+    if len(chunks) < args.samples:
+        print(f"warning: only {len(chunks)} calibration chunks available, using all")
+        args.samples = len(chunks)
+
+    accumulators = []
+    for site in sites:
+        components = site.components or ()
+        input_shape = (*components, site.in_dim, site.in_dim)
+        accumulators.append(
+            {
+                "input": np.zeros(input_shape, dtype=np.float32),
+                "output": np.zeros((*components, site.out_dim, site.out_dim), dtype=np.float32)
+                if args.output_block == "all"
+                or (args.output_block == "small" and site.out_dim <= args.output_block_limit)
+                else None,
+                "samples": 0,
+            }
+        )
+
+    meta = {
+        "site_keys": [site.key for site in sites],
+        "site_shapes": [[site.in_dim, site.out_dim] for site in sites],
+        "output_block": args.output_block,
+        "output_block_limit": args.output_block_limit,
+        "corpus": str(args.corpus),
+        "seed": args.seed,
+        "samples": args.samples,
+        "model_dir": str(args.model_dir) if args.model_dir else None,
+        "calib_dtype": args.calib_dtype,
+        "parallel": args.parallel,
+    }
+
+    def save_partial() -> None:
+        arrays: dict[str, np.ndarray] = {}
+        for site, accumulator in zip(sites, accumulators):
+            arrays[f"{site.key}/input"] = accumulator["input"]
+            if accumulator["output"] is not None:
+                arrays[f"{site.key}/output"] = accumulator["output"]
+            arrays[f"{site.key}/samples"] = np.asarray([accumulator["samples"]], dtype=np.int64)
+        arrays["processed"] = np.asarray([processed], dtype=np.int64)
+        arrays["sample_index"] = np.asarray([sample_index], dtype=np.int64)
+        arrays["__meta__"] = np.asarray(json.dumps(meta, sort_keys=True))
+        checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = checkpoint_path.with_name(checkpoint_path.name + ".tmp.npz")
+        np.savez(tmp_path, **arrays)
+        os.replace(tmp_path, checkpoint_path)
+        print(f"  checkpoint -> {checkpoint_path}", flush=True)
+
+    processed = 0
+    sample_index = 0
+    if args.resume:
+        if args.resume == "auto":
+            resume_path = checkpoint_path if checkpoint_path.exists() else None
+        else:
+            resume_path = Path(args.resume)
+        if resume_path is None:
+            print("resume: no partial checkpoint found; starting from 0", flush=True)
+        elif not resume_path.exists():
+            raise SystemExit(f"checkpoint not found: {resume_path}")
+        else:
+            with np.load(resume_path) as saved:
+                if "__meta__" not in saved:
+                    raise SystemExit("partial checkpoint missing __meta__; refusing to resume")
+                saved_meta = json.loads(str(saved["__meta__"]))
+                if saved_meta != meta:
+                    raise SystemExit(
+                        "partial checkpoint metadata mismatch; refusing to mix runs\n"
+                        f"saved={saved_meta}\ncurrent={meta}"
+                    )
+                for site, accumulator in zip(sites, accumulators):
+                    accumulator["input"] = saved[f"{site.key}/input"]
+                    if accumulator["output"] is not None and f"{site.key}/output" in saved:
+                        accumulator["output"] = saved[f"{site.key}/output"]
+                    accumulator["samples"] = int(saved[f"{site.key}/samples"][0])
+                processed = int(saved["processed"][0])
+                sample_index = int(saved["sample_index"][0])
+            print(f"resumed from {resume_path}: processed={processed} sample_index={sample_index}", flush=True)
+
+    grad_fn = jax.grad(per_sample_loss)
+    rng = np.random.default_rng(args.seed)
+    started_at = time.time()
+    while processed < args.samples:
+        ids = chunks[sample_index]
+        sample_index += 1
+        current_ids = ids
+        logits = logits_for(model, ids)
+        current_targets = jax.random.categorical(
+            jax.random.key(args.seed + processed), logits, axis=-1
+        )
+        grads = grad_fn(base_arrays)
+        for site, accumulator, gradient in zip(sites, accumulators, grads):
+            G = np.asarray(gradient, dtype=np.float64)
+            if G.ndim == 2:
+                accumulator["input"] += G.T @ G
+                if accumulator["output"] is not None:
+                    accumulator["output"] += G @ G.T
+            else:
+                # MoE-style leading component axes: one Hessian per component.
+                for component in np.ndindex(*site.components):
+                    g = G[component]
+                    accumulator["input"][component] += g.T @ g
+                    if accumulator["output"] is not None:
+                        accumulator["output"][component] += g @ g.T
+            accumulator["samples"] += 1
+        processed += 1
+        progress(
+            {
+                "sample": processed,
+                "samples": args.samples,
+                "sample_index": sample_index,
+                "elapsed_s": time.time() - started_at,
+            }
+        )
+        if args.checkpoint_every and processed % args.checkpoint_every == 0:
+            save_partial()
+        if processed % 4 == 0:
+            print(f"  sample {processed}/{args.samples}")
+
+    records = []
+    arrays: dict[str, np.ndarray] = {}
+
+    def regularize(matrix: np.ndarray, name: str):
+        # Official pipeline: H /= mean(diag), then add sigma_reg (1e-2) until
+        # Cholesky succeeds. Fall back to eigenvalue clipping if needed.
+        scale = float(np.mean(np.diagonal(matrix, axis1=-2, axis2=-1)))
+        normalized = matrix / max(scale, 1e-30)
+        sigma = args.damping
+        for _ in range(8):
+            candidate = normalized + np.eye(normalized.shape[-1]) * sigma
+            try:
+                np.linalg.cholesky(candidate)
+                return candidate.astype(np.float32), sigma
+            except np.linalg.LinAlgError:
+                sigma *= 10.0
+        eigenvalues, eigenvectors = np.linalg.eigh(normalized)
+        eigenvalues = np.clip(eigenvalues, 1e-6, None)
+        rebuilt = (eigenvectors * eigenvalues[..., None, :]) @ np.swapaxes(eigenvectors, -1, -2)
+        print(f"warning: {name} needed eigenvalue clipping")
+        return rebuilt.astype(np.float32), None
+
+    for site, accumulator in zip(sites, accumulators):
+        count = max(accumulator["samples"], 1)
+        H_I = accumulator["input"] / count
+        H_O = None if accumulator["output"] is None else accumulator["output"] / count
+        if args.raw_output:
+            damping_input = None
+        else:
+            H_I, damping_input = regularize(H_I, f"{site.key}/input_block")
+        record = {
+            "path": site.key,
+            "in_dim": site.in_dim,
+            "out_dim": site.out_dim,
+            "components": list(site.components),
+            "samples": accumulator["samples"],
+            "input_trace": float(np.trace(H_I, axis1=-2, axis2=-1).sum()),
+            "input_min_eig": None,
+            "input_max_eig": None,
+            "input_condition": None,
+            "input_damping": damping_input,
+            "output_block": H_O is not None,
+        }
+        try:
+            eigenvalues = np.linalg.eigvalsh(H_I)
+            record["input_min_eig"] = float(eigenvalues.min())
+            record["input_max_eig"] = float(eigenvalues.max())
+            record["input_condition"] = float(eigenvalues.max() / max(eigenvalues.min(), 1e-30))
+        except np.linalg.LinAlgError:
+            record["input_condition"] = float("inf")
+        arrays[f"{site.key}/input_block"] = H_I
+        if H_O is not None:
+            if args.raw_output:
+                damping_output = None
+            else:
+                H_O, damping_output = regularize(H_O, f"{site.key}/output_block")
+            arrays[f"{site.key}/output_block"] = H_O
+            record["output_damping"] = damping_output
+            try:
+                eigenvalues = np.linalg.eigvalsh(H_O)
+                record["output_min_eig"] = float(eigenvalues.min())
+                record["output_max_eig"] = float(eigenvalues.max())
+                record["output_condition"] = float(eigenvalues.max() / max(eigenvalues.min(), 1e-30))
+            except np.linalg.LinAlgError:
+                record["output_condition"] = float("inf")
+        records.append(record)
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    np.savez(args.output, **arrays)
+    if checkpoint_path.exists():
+        checkpoint_path.unlink()
+    print(f"saved {args.output} ({len(arrays)} arrays)")
+
+    summary = {
+        "model_dir": str(args.model_dir),
+        "corpus": str(args.corpus),
+        "eval_corpora": [str(path) for path in args.eval_corpus],
+        "overlap_checked": bool(args.eval_corpus),
+        "raw_output": bool(args.raw_output),
+        "samples": args.samples,
+        "max_tokens": args.max_tokens,
+        "output_block": args.output_block,
+        "damping": args.damping,
+        "layers": records,
+    }
+    if args.json_out:
+        args.json_out.parent.mkdir(parents=True, exist_ok=True)
+        args.json_out.write_text(json.dumps(summary, indent=2) + "\n")
+        print(f"saved {args.json_out}")
+    for record in records:
+        print(
+            f"  {record['path']} in={record['in_dim']} out={record['out_dim']} "
+            f"cond={record['input_condition']:.3e} out_block={record['output_block']}"
+        )
+
+
+if __name__ == "__main__":
+    main()

tests/test_compute_bpc.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+import math
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("tokenizers")
+
+from tokenizers import Tokenizer, models, pre_tokenizers  # noqa: E402
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def build_tokenizer(path: Path) -> None:
+    vocab = {
+        "<unk>": 0,
+        "the": 1,
+        "quick": 2,
+        "brown": 3,
+        "fox": 4,
+        "jumps": 5,
+        "over": 6,
+        "lazy": 7,
+        "dog": 8,
+        "second": 9,
+        "line": 10,
+        "here": 11,
+        "third": 12,
+        "another": 13,
+    }
+    tokenizer = Tokenizer(models.WordLevel(vocab=vocab, unk_token="<unk>"))
+    tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()
+    tokenizer.save(str(path / "tokenizer.json"))
+
+
+def write_fixture(tmp_path: Path, *, tokens: int, chunks: int, ppl: float) -> tuple[Path, Path]:
+    corpus = tmp_path / "corpus.txt"
+    corpus.write_text(
+        "the quick brown fox jumps over the lazy dog\n"
+        "second line here\n"
+        "third another line here\n" * 4,
+        encoding="utf-8",
+    )
+    tokenizer_dir = tmp_path / "tok"
+    tokenizer_dir.mkdir()
+    build_tokenizer(tokenizer_dir)
+    payload = {
+        "corpus": str(corpus),
+        "config": {
+            "corpus": str(corpus),
+            "max_sequences": chunks,
+            "max_tokens": 4,
+            "min_tokens": 1,
+        },
+        "chunks": chunks,
+        "tokens": tokens,
+        "bf16_ppl": ppl,
+        "candidate_ppl": ppl * 1.1,
+    }
+    ppl_json = tmp_path / "ppl_en.json"
+    ppl_json.write_text(json.dumps(payload), encoding="utf-8")
+    return ppl_json, tokenizer_dir
+
+
+def run(*args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(ROOT / "scripts" / "compute_bpc.py"), *args],
+        cwd=ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+
+def test_bpc_is_log2_ppl_times_fertility(tmp_path: Path) -> None:
+    ppl_json, tokenizer_dir = write_fixture(tmp_path, tokens=9, chunks=3, ppl=8.0)
+    out = tmp_path / "report.json"
+    result = run("--ppl-json", str(ppl_json), "--tokenizer", str(tokenizer_dir), "--json", str(out))
+    assert result.returncode == 0, result.stdout + result.stderr
+    report = json.loads(out.read_text(encoding="utf-8"))[0]
+    assert report["chunks"] == 3
+    # every chunk contributes len(chunk) - 1 scored predictions
+    assert report["tokens"] == report["chunks"] * 3
+    assert report["chars"] > 0
+    expected = math.log2(8.0) * report["tokens"] / report["chars"]
+    assert report["bpc_bf16"] == pytest.approx(expected)
+    assert report["bpc_candidate"] == pytest.approx(math.log2(8.8) * report["tokens"] / report["chars"])
+    assert report["reproduced"]["chunks_match"] is True
+    assert report["reproduced"]["tokens_match"] is True
+
+
+def test_strict_mode_flags_token_drift(tmp_path: Path) -> None:
+    ppl_json, tokenizer_dir = write_fixture(tmp_path, tokens=99, chunks=3, ppl=8.0)
+    result = run("--ppl-json", str(ppl_json), "--tokenizer", str(tokenizer_dir), "--strict")
+    assert result.returncode == 1
+    assert "tokens_match" in result.stdout
+
+
+def test_accepts_corpus_override(tmp_path: Path) -> None:
+    ppl_json, tokenizer_dir = write_fixture(tmp_path, tokens=9, chunks=3, ppl=8.0)
+    payload = json.loads(ppl_json.read_text(encoding="utf-8"))
+    payload["corpus"] = str(tmp_path / "missing.txt")
+    payload["config"]["corpus"] = str(tmp_path / "missing.txt")
+    ppl_json.write_text(json.dumps(payload), encoding="utf-8")
+    override = tmp_path / "corpus.txt"
+    result = run("--ppl-json", str(ppl_json), "--tokenizer", str(tokenizer_dir), "--corpus", str(override))
+    assert result.returncode == 0, result.stdout + result.stderr

tests/test_experiment_guards.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPTS = ROOT / "scripts"
+
+
+def run(script: str, *args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(SCRIPTS / script), *args],
+        cwd=ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+
+def test_corpus_guard_rejects_overlap(tmp_path: Path) -> None:
+    eval_corpus = tmp_path / "eval.txt"
+    calib = tmp_path / "calib.txt"
+    eval_corpus.write_text("this is a long evaluation line\n", encoding="utf-8")
+    calib.write_text("this is a long evaluation line\n", encoding="utf-8")
+    result = run(
+        "corpus_guard.py",
+        "--calibration",
+        str(calib),
+        "--eval",
+        str(eval_corpus),
+    )
+    assert result.returncode == 1
+    assert "overlaps" in result.stderr
+
+
+def test_corpus_guard_accepts_disjoint(tmp_path: Path) -> None:
+    eval_corpus = tmp_path / "eval.txt"
+    calib = tmp_path / "calib.txt"
+    eval_corpus.write_text("evaluation only line with enough length\n", encoding="utf-8")
+    calib.write_text("calibration only line with enough length\n", encoding="utf-8")
+    result = run(
+        "corpus_guard.py",
+        "--calibration",
+        str(calib),
+        "--eval",
+        str(eval_corpus),
+    )
+    assert result.returncode == 0
+
+
+def test_dedup_lines_removes_duplicates(tmp_path: Path) -> None:
+    source = tmp_path / "source.txt"
+    output = tmp_path / "output.txt"
+    source.write_text("a\nb\na\nc\nb\n", encoding="utf-8")
+    result = run("dedup_lines.py", "--input", str(source), "--output", str(output))
+    assert result.returncode == 0
+    assert output.read_text(encoding="utf-8").splitlines() == ["a", "b", "c"]
+
+
+def _write_config(tmp_path: Path, *, overlap: bool = False) -> tuple[Path, Path]:
+    eval_en = tmp_path / "eval_en.txt"
+    eval_ja = tmp_path / "eval_ja.txt"
+    calib = tmp_path / "calib.txt"
+    eval_en.write_text(
+        "the quick brown fox jumps over the lazy dog\n"
+        "a second distinct evaluation sentence for the fixture\n"
+        "a third distinct evaluation sentence for the fixture\n",
+        encoding="utf-8",
+    )
+    eval_ja.write_text(
+        "日本語の評価用の長い文章です。これは十分な長さがあります。\n"
+        "二つ目の評価用文章です。これも十分な長さがあります。\n"
+        "三つ目の評価用文章です。これも十分な長さがあります。\n",
+        encoding="utf-8",
+    )
+    if overlap:
+        calib.write_text("the quick brown fox jumps over the lazy dog\n", encoding="utf-8")
+    else:
+        calib.write_text("a completely separate calibration sentence for testing\n", encoding="utf-8")
+    config = {
+        "name": "fixture",
+        "model": {},
+        "eval": {
+            "max_sequences": 2,
+            "max_tokens": 4,
+            "min_tokens": 1,
+            "corpora": {"en": str(eval_en), "ja": str(eval_ja)},
+        },
+        "calibration": {
+            "samples": 2,
+            "max_tokens": 4,
+            "output_block": "small",
+            "damping": 0.001,
+            "corpora": {"calib": str(calib)},
+        },
+    }
+    path = tmp_path / "config.json"
+    path.write_text(json.dumps(config), encoding="utf-8")
+    return path, calib
+
+
+def _write_ppl(root: Path, corpus: Path, chunks: int = 2) -> None:
+    directory = root / "condition"
+    directory.mkdir()
+    payload = {
+        "corpus": str(corpus),
+        "chunks": chunks,
+        "tokens": chunks * 4 - chunks,
+        "bf16_ppl": 1.0,
+        "candidate_ppl": 1.1,
+    }
+    (directory / "ppl_en.json").write_text(json.dumps(payload), encoding="utf-8")
+
+
+def test_check_experiment_accepts_consistent_fixture(tmp_path: Path) -> None:
+    config, calib = _write_config(tmp_path)
+    eval_en = tmp_path / "eval_en.txt"
+    _write_ppl(tmp_path, eval_en)
+    (tmp_path / "condition" / "calibration.json").write_text(
+        json.dumps(
+            {
+                "corpus": str(calib),
+                "samples": 2,
+                "max_tokens": 4,
+                "output_block": "small",
+                "damping": 0.001,
+            }
+        ),
+        encoding="utf-8",
+    )
+    result = run("check_experiment.py", "--config", str(config), "--root", str(tmp_path))
+    assert result.returncode == 0, result.stdout + result.stderr
+
+
+def test_check_experiment_rejects_chunk_drift(tmp_path: Path) -> None:
+    config, calib = _write_config(tmp_path)
+    eval_en = tmp_path / "eval_en.txt"
+    _write_ppl(tmp_path, eval_en, chunks=3)
+    result = run("check_experiment.py", "--config", str(config), "--root", str(tmp_path))
+    assert result.returncode == 1
+    assert "chunks=3" in result.stdout
+
+
+def test_check_experiment_rejects_corpus_overlap(tmp_path: Path) -> None:
+    config, _ = _write_config(tmp_path, overlap=True)
+    eval_en = tmp_path / "eval_en.txt"
+    _write_ppl(tmp_path, eval_en)
+    result = run("check_experiment.py", "--config", str(config), "--root", str(tmp_path))
+    assert result.returncode == 1
+    assert "corpus overlap" in result.stdout
+
+
+def test_merge_calibration_groups_validates_coverage(tmp_path: Path) -> None:
+    def write_group(name: str, layer: int) -> Path:
+        path = tmp_path / name
+        np.savez(
+            path,
+            **{f"decoder/transformer/layers/[{layer}]/mixer/in_proj/input_block": np.eye(2, dtype=np.float32)},
+        )
+        return path
+
+    first = write_group("group-0-1.npz", 0)
+    second = write_group("group-1-2.npz", 1)
+    output = tmp_path / "merged.npz"
+    result = run(
+        "merge_calibration_groups.py",
+        "--output",
+        str(output),
+        "--layers",
+        "2",
+        "--group-size",
+        "1",
+        str(first),
+        str(second),
+    )
+    assert result.returncode == 0, result.stderr
+    with np.load(output) as data:
+        assert len(data.files) == 2
+
+
+def test_merge_calibration_groups_rejects_missing_group(tmp_path: Path) -> None:
+    first = tmp_path / "group-0-1.npz"
+    np.savez(
+        first,
+        **{"decoder/transformer/layers/[0]/mixer/in_proj/input_block": np.eye(2, dtype=np.float32)},
+    )
+    output = tmp_path / "merged.npz"
+    result = run(
+        "merge_calibration_groups.py",
+        "--output",
+        str(output),
+        "--layers",
+        "2",
+        "--group-size",
+        "1",
+        str(first),
+    )
+    assert result.returncode == 1
+    assert "missing groups" in result.stderr

tests/test_tiny_sharding.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("jax")
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_tiny_sharding_probe_on_two_cpu_devices() -> None:
+    env = os.environ.copy()
+    env["FORCE_2_CPU"] = "1"
+    result = subprocess.run(
+        [sys.executable, str(ROOT / "scripts" / "tiny_sharding_probe.py")],
+        cwd=ROOT,
+        env=env,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    report = json.loads(result.stdout)
+    assert report["ok"] is True
+    assert len(report["devices"]) == 2
+    names = {case["name"] for case in report["cases"]}
+    assert names == {"column_sharded_matmul", "row_sharded_matmul", "replicated_reshard_matmul"}