Rebuild: XLA attention on T4, calib dtype, quota ledger

kit_manifest.json

@@ -1,21 +1,23 @@
 {
-  "built_from_commit": "c483b866a0d0528b4a0adebb44027e77de0d2c89",
+  "built_from_commit": "6cd35afd5dc2643aa317d19781ba43441181ddd8",
   "files": {
     "scripts/rht_int4_convert.py": "c27bec9abcca8ab673f6b1e1a1252d5fb5562c1cdc57be4d7023ccc6844a79ce",
     "scripts/rewrite_lalamo_hybrid_spec.py": "154564c88391f81b5c24f64125d99abc15d81bd082a8264e36d43a00d4c47a04",
     "scripts/normalize_lalamo_config.py": "248a5a07d0829c9e383eeba1a5204e88abdc065f78737d1191d376a1f37476c4",
     "scripts/make_lalamo_eval_copy.py": "5563e8542ef51e57cc6ed5cff48fcc81d58fb6487d75350df8273cfad948a500",
-    "scripts/yaqa_calibration.py": "4fdf85cfbd3266d9b080cbc3d7663dd3adc27e951a53e211d51874654b2ddd7d",
+    "scripts/yaqa_calibration.py": "1b3a6d7b2099a87c773093c1f03444be0160d4d98aaeac061560836e982f869d",
     "scripts/merge_language_hessians.py": "a6385caaa0d7190024b4e47ded59d1ab662e771ce81e18de94b30c8846829b4e",
     "scripts/merge_calibration_groups.py": "58a347ff40c47f629c073c23aea54e215c1e75c052737e5b4a48ff81946d8060",
-    "scripts/eval_quantized.py": "60200dfb9ad65857642e18fed10ac092853cf2c2addabe81b398e425d91bfe6e",
-    "scripts/qad_finetune.py": "4f639ac8e266cf09051c713fba9d87703b8f43c660c14e089f3b0e64d97a5ad7",
+    "scripts/eval_quantized.py": "f5a1bcf8972e258f99b563934430779642473a54b5bfa4c31cfe2a28b0a424fb",
+    "scripts/qad_finetune.py": "26830bf55203a6a2e7fd79451c400949a1f6cdd1fc8d4011b62ff59d39c6e486",
     "scripts/compute_bpc.py": "2b55fd1df406d54b40daeeca2ecaf2efb35981655f5bf5e0cc10c057ce796256",
-    "scripts/run_lane.py": "73dff4a4099211edba03a3de5f30416a9b456eb62a79c9faaf89fbc41721a481",
+    "scripts/run_lane.py": "d5137c69ce30024e54d1fe61274963b53a8d38654d1aa4c986fbd48054cc8596",
     "scripts/make_sweep_spec.py": "dc31ec026c89e7db316a185575a4423bca988c2ac6cf08ef6df8f955328cda69",
     "scripts/combine_lane_manifests.py": "164ba691d60b3e2987b805426c606d135dcf3cf0c855b38cf7f5d6d57628a481",
     "scripts/make_qad_dataset.py": "18e91221c5ac1b07362dd6978956168ed1148a3c6e8f73e0a2efc3f1f4047634",
-    "scripts/ag_fetch.py": "ba8c9e5d8a4fceb41695a5483a967b0d3bda75a3759b311cb7441bc22f31dd2e",
+    "scripts/ag_fetch.py": "22c9a1ba1b93f360191d08f5992dceee40b168010de98aeff78ac7e219395342",
+    "scripts/lalamo_forward.py": "e4429221ecb6127faae9a5770bcc16d4e72d7c5ab7a7e2171477266be820745a",
+    "scripts/kaggle_usage.py": "e1c4c1a902d716e09a9b8fce9a0019b152a758f2390dd34c678fc44c7aef48b1",
     "scripts/eval_generation.py": "bc240aef06c6ede583c3334fd0483ca9153ca07a52e22ef53c85c0b4fb90f7d2",
     "scripts/pull_results.py": "e5873cfda71dcebcf86e1ecfaacefc9bf01a142521d06c065654eaea7d07de5c",
     "scripts/corpus_guard.py": "5f226a81988acaebd80b8b81dfb4207ed8b661e52067b0260deec6ee48e9af6a",
@@ -24,7 +26,7 @@
     "scripts/check_experiment.py": "a2e7e40909f68031dfccd7013ed055dfbc0ebb21f2a619622b71e6772c685ca5",
     "scripts/tiny_sharding_probe.py": "29eb58f2689242b919616f6aab6ff753e0de031b16371137975b4d645e836fae",
     "scripts/audit_public_corpus.py": "84f1ec805a74004e71f63a70a8ed19967cb3fad9966f254798e655ab95e53ab0",
-    "scripts/build_kit.py": "b7f2f5ec352e23dc0b2dac604b4f709bff8bcf7e4b94d537eab6e5f15eda8a9e",
+    "scripts/build_kit.py": "b60973e4a7de8167284e128e7f812384ebc01b44a138440132a9ceaed84c8126",
     "scripts/bootstrap_kaggle.py": "1633e3edbb80976c337444e3e4544e2b5210b2d8d1821e3a2717c1099c00843e",
     "data/calibration_en_wikitext2_dedup.txt": "18a79f4f938cc25747a90a12b120c7131e7f4ac55b58dfc691795ea61d4b5e9a",
     "data/calibration_ja_wikipedia_dedup.txt": "b45e3f3f00f2137be280a75c1fa9c9883a7e69d289257c4388fc701f33fee0d1",
@@ -33,16 +35,17 @@
     "data/calibration_mixed_ja65_en35_dedup.txt": "36e17429433759bbad53cf62dbca2d880abe716d60b3bb32fc7b7ca96bb093e1",
     "data/eval_en_wikitext2_dedup.txt": "342e8f6a77fb9db7e1a14aa7cabe13c1f13eeaa4f045f8fb3689c0b26c742c0e",
     "data/eval_ja_wikipedia_dedup.txt": "707c9a6c951dd0b831c746a5d6e6972e4dbc71498e75c4aa8f12140eeed89213",
-    "lanes/README.md": "ad36c1790453ca41e32d393be11b76aba7fc204d836705a3b3a3c910dae33cb2",
+    "lanes/README.md": "44743cd2b9831d0a2249da307c031f70b2822ca71339db7182964e71d8b4a887",
     "lanes/smoke-08b.json": "de6e66bf9c37325c6efb0c5a37f3b4edb7df500a27a481b24337ddad3df916ee",
     "lanes/clean-suite-08b.json": "a1b74a5f2b7a36edc3fe060ec071df27bcbafe7975fd46ba3562b77458d94b99",
     "lanes/balanced-h-08b.json": "21a16d50b0b5096843e0a8fb944a6fdbb7314f3c2c51618eb9651a7575192cb8",
+    "lanes/damping-ablation-08b.json": "bb0a635c8b3e2b80d701af45c3561bbc9570af01614a800ee3acef3dccd22c1a",
     "lanes/robustness-08b-shard1of3.json": "11bd73ddfb110c60420546e1c6f47d777ce6d8c321cf31ce5003d15c96743b9b",
     "lanes/robustness-08b-shard2of3.json": "3196a32cf56eb1e3792a4f15a29effa561ff0472d82282f5e98ad8e283249935",
     "lanes/robustness-08b-shard3of3.json": "3f6928c34d3145d7d17eda991e6dede3695a0e9b723fbf4c068a6c07bc9cfd17",
     "tests/test_experiment_guards.py": "d71ddf9586c1d7ece52e217288b9d4b09079be54d32ceaf391be113c1832b6ef",
     "tests/test_compute_bpc.py": "bba5b6d0afc9b0699ebb6f7f0ed9fc5ebfcb98472867e9ccff4262fe9999949f",
-    "tests/test_run_lane.py": "fe5b613a31f217fbb71e5ff33aaa4975f65ca22f36024e224d0eff6fd05a80c0",
+    "tests/test_run_lane.py": "222939127650e04d98a9e3da52ec2f972bb45a030eb297cd2f59e3f3a9496139",
     "tests/test_tiny_sharding.py": "eaed062b5547ed66923d567753494fe2c26d15c7df4a160601182aacdbf0ceb1",
     "configs/qwen35-0.8b.json": "12640a7b738d8c8dbc046f59e9249b85d5d3775b8ee2afe9becaba285ae90764",
     "configs/qwen35-4b.json": "8f32da42655963134c1f73f4fa825c8ae16b464254d4fd9ddccf6b2f8ecae833",

lanes/README.md

@@ -54,6 +54,15 @@ T4（compute capability 7.5）では XLA の Triton GEMM が使えず、calibrat
 - 明示的に足したい場合は `paths.xla_flags` に書く
 - 検出できなかった場合は何も足さない。その場合は spec に書く
 
+さらに lalamo の推論は既定で **Pallas-Triton flash attention** を使い、これも T4 ではコンパイルできない。
+`run_lane` は cc < 8.0 を検出すると `UZU_ATTENTION_IMPL=xla` も渡す（`scripts/lalamo_forward.py`）。
+手動で切り替える場合:
+
+```bash
+UZU_ATTENTION_IMPL=xla python scripts/eval_quantized.py ...
+UZU_ATTENTION_IMPL=pallas ...   # 既定に戻す
+```
+
 ## シャード実行
 
 1 セッション 12h を跨ぐ条件列は、spec を分けるか `--shard` で切る。

lanes/damping-ablation-08b.json

@@ -0,0 +1,43 @@
+{
+  "lane": "damping-ablation-08b",
+  "model": {
+    "hf_repo": "Qwen/Qwen3.5-0.8B",
+    "spec_name": "Qwen3.5-0.8B",
+    "bf16_dir": "bf16-lalamo",
+    "bf16_source": "/kaggle/input/uzu-bf16-08b-lalamo",
+    "bf16_source_auto": true
+  },
+  "paths": {
+    "kit": "kit",
+    "work": "/kaggle/working",
+    "jax_platform": "gpu"
+  },
+  "eval": {
+    "max_sequences": 100,
+    "max_tokens": 128,
+    "min_tokens": 16,
+    "corpora": {
+      "en": "data/eval_en_wikitext2_dedup.txt",
+      "ja": "data/eval_ja_wikipedia_dedup.txt"
+    }
+  },
+  "condition_defaults": {
+    "samples": 32,
+    "max_tokens": 128,
+    "output_block": "small",
+    "output_block_limit": 2048,
+    "damping": 0.01,
+    "calib_dtype": "float32",
+    "raw_output": false
+  },
+  "convert": {
+    "bits": 4,
+    "group_size": 32,
+    "block_size": 32,
+    "parallel": "tensor"
+  },
+  "conditions": [
+    {"name": "enonly-d1e-2", "calibration_corpus": "data/calibration_en_wikitext2_dedup.txt"},
+    {"name": "mixed50-d1e-2", "calibration_corpus": "data/calibration_mixed_en_ja_dedup.txt"}
+  ]
+}

scripts/ag_fetch.py

@@ -70,6 +70,20 @@ def last_final(log_path: Path) -> str | None:
     return final
 
 
+def log_completed(log_path: Path) -> bool:
+    """True when the run log already holds a completed response.
+
+    The wrapper writes its state file only after the process returns, so a dead
+    pid plus no state is not proof of failure: the log often has the result.
+    """
+    if not log_path.exists():
+        return False
+    for payload in json_objects(log_path.read_text(encoding="utf-8", errors="replace")):
+        if isinstance(payload, dict) and payload.get("status") == "completed":
+            return True
+    return False
+
+
 def recover_from_log(log_path: Path, out_dir: Path) -> Path | None:
     final = last_final(log_path)
     if not final:

scripts/build_kit.py

@@ -47,6 +47,8 @@ KIT_SCRIPTS = [
     "combine_lane_manifests.py",
     "make_qad_dataset.py",
     "ag_fetch.py",
+    "lalamo_forward.py",
+    "kaggle_usage.py",
     "eval_generation.py",
     "pull_results.py",
     # guards / audits
@@ -77,6 +79,7 @@ KIT_LANES = [
     "smoke-08b.json",
     "clean-suite-08b.json",
     "balanced-h-08b.json",
+    "damping-ablation-08b.json",
     "robustness-08b-shard1of3.json",
     "robustness-08b-shard2of3.json",
     "robustness-08b-shard3of3.json",

scripts/eval_quantized.py

@@ -126,6 +126,7 @@ def main() -> None:
     from lalamo.model import Model
     from lalamo.module import Keychain
     from lalamo.modules import DecoderForwardPassConfig, ForwardPassMode
+    from lalamo_forward import apply_attention_env, describe
     from lalamo.utils.sharding import ShardingConfig
     from tokenizers import Tokenizer
 
@@ -150,6 +151,8 @@ def main() -> None:
     sharding = ShardingConfig.replicated()
     keychain = Keychain.init(seed=0, sharding_config=sharding)
     forward_pass_config = DecoderForwardPassConfig.for_inference(mode=ForwardPassMode.MULTI_TOKEN)
+    forward_pass_config = apply_attention_env(forward_pass_config)
+    print(f"attention: {describe()}", flush=True)
 
     print("loading BF16 model...")
     bf16 = Model.load(args.bf16_dir, sharding, dtype=jnp.bfloat16)

scripts/kaggle_usage.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Kaggle GPU usage ledger.
+
+Kaggle gives each account ~30 GPU-hours per week, 2 concurrent sessions. The
+number that matters is not "did it finish" but "how many GPU seconds did it
+cost", and nobody was tracking it.
+
+    # record a finished run by hand
+    python scripts/kaggle_usage.py log --kernel yamahei21python/uzu-eval-4b-rtn-probe \
+        --account owner --seconds 5420 --gpu T4x2 --note "4B RTN eval v3"
+
+    # or track it until it stops
+    python scripts/kaggle_usage.py track --kernel yamahei21python/uzu-emb8-08b-gpu --account owner
+
+    # weekly report against the quota
+    python scripts/kaggle_usage.py report --week 2026-W45 --quota-hours 30
+
+The ledger is JSON Lines so a crashed run cannot corrupt it.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import time
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+LEDGER = ROOT / "logs" / "kaggle_usage.jsonl"
+TERMINAL = ("COMPLETE", "ERROR", "FAILED", "CANCEL", "CANCELLED")
+
+
+def week_key(value: date) -> str:
+    year, week, _ = value.isocalendar()
+    return f"{year}-W{week:02d}"
+
+
+def is_terminal(status: str) -> bool:
+    upper = status.upper()
+    return any(marker in upper for marker in TERMINAL)
+
+
+def append_entry(ledger: Path, entry: dict[str, Any]) -> None:
+    ledger.parent.mkdir(parents=True, exist_ok=True)
+    with ledger.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+
+def read_entries(ledger: Path) -> list[dict[str, Any]]:
+    if not ledger.exists():
+        return []
+    entries = []
+    for line in ledger.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            entries.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+    return entries
+
+
+def summarize(entries: list[dict[str, Any]], week: str, quota_hours: float) -> dict[str, Any]:
+    filtered = [entry for entry in entries if entry.get("week") == week]
+    by_account: dict[str, dict[str, Any]] = {}
+    for entry in filtered:
+        account = entry.get("account", "unknown")
+        bucket = by_account.setdefault(account, {"runs": 0, "seconds": 0.0, "kernels": []})
+        bucket["runs"] += 1
+        bucket["seconds"] += float(entry.get("seconds", 0))
+        bucket["kernels"].append(entry.get("kernel"))
+    quota_seconds = quota_hours * 3600
+    for account, bucket in by_account.items():
+        bucket["hours"] = round(bucket["seconds"] / 3600, 2)
+        bucket["remaining_hours"] = round((quota_seconds - bucket["seconds"]) / 3600, 2)
+        bucket["used_pct"] = round(100 * bucket["seconds"] / quota_seconds, 1) if quota_seconds else None
+    total_seconds = sum(bucket["seconds"] for bucket in by_account.values())
+    return {
+        "week": week,
+        "quota_hours_per_account": quota_hours,
+        "accounts": by_account,
+        "total_hours": round(total_seconds / 3600, 2),
+        "runs": len(filtered),
+    }
+
+
+def format_report(summary: dict[str, Any]) -> str:
+    lines = [
+        f"week {summary['week']}  quota {summary['quota_hours_per_account']}h/account  runs {summary['runs']}",
+        f"{'account':10s} {'hours':>8s} {'left':>8s} {'used':>7s} kernels",
+        "-" * 72,
+    ]
+    for account, bucket in sorted(summary["accounts"].items()):
+        kernels = ", ".join(str(name) for name in bucket["kernels"][-3:])
+        lines.append(
+            f"{account:10s} {bucket['hours']:8.2f} {bucket['remaining_hours']:8.2f} "
+            f"{(bucket['used_pct'] or 0):6.1f}% {kernels}"
+        )
+    return "\n".join(lines)
+
+
+def kernel_status(kernel: str) -> str:
+    result = subprocess.run(
+        ["kaggle", "kernels", "status", kernel], text=True, capture_output=True, check=False
+    )
+    text = (result.stdout or "") + (result.stderr or "")
+    for line in text.splitlines():
+        if "status" in line.lower():
+            return line.strip()
+    return text.strip()
+
+
+def track(kernel: str, account: str, interval: float, ledger: Path) -> dict[str, Any]:
+    started = time.time()
+    status = ""
+    while True:
+        status = kernel_status(kernel)
+        if is_terminal(status):
+            break
+        print(f"{time.strftime('%H:%M:%S')} {status}", flush=True)
+        time.sleep(interval)
+    entry = {
+        "kernel": kernel,
+        "account": account,
+        "seconds": round(time.time() - started, 1),
+        "status": status,
+        "week": week_key(date.today()),
+        "finished": datetime.now().isoformat(timespec="seconds"),
+        "note": "tracked",
+    }
+    append_entry(ledger, entry)
+    return entry
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--ledger", type=Path, default=LEDGER)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    log = sub.add_parser("log")
+    log.add_argument("--kernel", required=True)
+    log.add_argument("--account", default="owner")
+    log.add_argument("--seconds", type=float, required=True)
+    log.add_argument("--gpu", default="T4x2")
+    log.add_argument("--week", default=None)
+    log.add_argument("--note", default="")
+
+    track_cmd = sub.add_parser("track")
+    track_cmd.add_argument("--kernel", required=True)
+    track_cmd.add_argument("--account", default="owner")
+    track_cmd.add_argument("--interval", type=float, default=60.0)
+
+    report = sub.add_parser("report")
+    report.add_argument("--week", default=None)
+    report.add_argument("--quota-hours", type=float, default=30.0)
+    report.add_argument("--json", type=Path, default=None)
+
+    args = parser.parse_args()
+
+    if args.command == "log":
+        entry = {
+            "kernel": args.kernel,
+            "account": args.account,
+            "seconds": args.seconds,
+            "gpu": args.gpu,
+            "week": args.week or week_key(date.today()),
+            "logged": datetime.now().isoformat(timespec="seconds"),
+            "note": args.note,
+        }
+        append_entry(args.ledger, entry)
+        print(json.dumps(entry, ensure_ascii=False))
+    elif args.command == "track":
+        entry = track(args.kernel, args.account, args.interval, args.ledger)
+        print(json.dumps(entry, ensure_ascii=False))
+    else:
+        week = args.week or week_key(date.today())
+        summary = summarize(read_entries(args.ledger), week, args.quota_hours)
+        print(format_report(summary))
+        if args.json:
+            args.json.parent.mkdir(parents=True, exist_ok=True)
+            args.json.write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+            print(f"wrote {args.json}")
+
+
+if __name__ == "__main__":
+    main()

scripts/lalamo_forward.py

@@ -0,0 +1,51 @@
+"""Force the lalamo attention implementation when the GPU cannot run Pallas.
+
+lalamo's inference config defaults to the Pallas-Triton flash attention kernel
+(``MixerForwardPassConfig.for_inference``). Pallas-Triton needs a Triton backend
+that T4 (compute capability 7.5) does not provide, so the first forward fails
+during XLA compilation even with ``--xla_gpu_enable_triton_gemm=false``.
+
+``UZU_ATTENTION_IMPL=xla`` switches the mixer config to the plain XLA path.
+``pallas`` forces the default back. Anything else (including unset) keeps the
+config as-is.
+"""
+
+from __future__ import annotations
+
+import os
+
+ENV_VAR = "UZU_ATTENTION_IMPL"
+
+
+def requested() -> str | None:
+    value = os.environ.get(ENV_VAR, "").strip().lower()
+    return value if value in ("xla", "pallas") else None
+
+
+def apply_attention_env(config):
+    """Return config with the attention implementation overridden, if requested."""
+    mode = requested()
+    if mode is None:
+        return config
+
+    from dataclasses import replace
+
+    from lalamo.modules import AttentionImplementation
+
+    target = AttentionImplementation.XLA if mode == "xla" else AttentionImplementation.PALLAS
+    transformer = config.transformer_forward_pass_config
+    mixer = transformer.mixer_forward_pass_config
+    if getattr(mixer, "attention_implementation", None) == target:
+        return config
+    return replace(
+        config,
+        transformer_forward_pass_config=replace(
+            transformer,
+            mixer_forward_pass_config=replace(mixer, attention_implementation=target),
+        ),
+    )
+
+
+def describe() -> str:
+    mode = requested()
+    return f"attention={mode or 'default'}"

scripts/qad_finetune.py

@@ -108,6 +108,7 @@ def main() -> None:
 
     from lalamo.compressed.hybrid import HybridMatrix
     from lalamo.model import Model
+    from lalamo_forward import apply_attention_env, describe
     from lalamo.module import Keychain
     from lalamo.modules import DecoderForwardPassConfig, ForwardPassMode
     from lalamo.utils.sharding import ShardingConfig
@@ -126,10 +127,15 @@ def main() -> None:
     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
+    inference_config = apply_attention_env(
+        DecoderForwardPassConfig.for_inference(mode=ForwardPassMode.MULTI_TOKEN)
     )
+    training_config = apply_attention_env(
+        DecoderForwardPassConfig.for_training(
+            gradient_estimator=GradientEstimator.DETERMINISTIC_ROUNDING
+        )
+    )
+    print(f"attention: {describe()}", flush=True)
 
     def tokenizer_hash(directory: Path) -> str:
         return hashlib.sha256((directory / "tokenizer.json").read_bytes()).hexdigest()

scripts/run_lane.py

@@ -31,6 +31,7 @@ from typing import Any
 
 DEFAULT_CONDITION = {
     "samples": 32,
+    "calib_dtype": "float32",
     "max_tokens": 128,
     "output_block": "small",
     "output_block_limit": 2048,
@@ -142,6 +143,9 @@ class Runner:
         flags = list(self.spec.get("paths", {}).get("xla_flags", []))
         if self.triton_off:
             flags.append("--xla_gpu_enable_triton_gemm=false")
+            # lalamo inference defaults to the Pallas-Triton flash attention kernel,
+            # which T4 cannot compile. XLA attention is the supported path there.
+            env.setdefault("UZU_ATTENTION_IMPL", "xla")
         existing = env.get("XLA_FLAGS", "")
         for flag in flags:
             if flag not in existing:
@@ -263,6 +267,7 @@ class Runner:
                 "max_tokens": base.get("max_tokens"),
                 "output_block": base.get("output_block"),
                 "damping": base.get("damping"),
+                "calib_dtype": base.get("calib_dtype"),
                 "raw_output": base.get("raw_output"),
                 "ja_ratio": base.get("ja_ratio"),
                 "overlap_checked": base.get("overlap_checked"),
@@ -350,6 +355,8 @@ class Runner:
             ]
             for eval_corpus in self.eval_corpora().values():
                 command += ["--eval-corpus", str(eval_corpus)]
+            if settings.get("calib_dtype"):
+                command += ["--calib-dtype", str(settings["calib_dtype"])]
             if settings.get("raw_output"):
                 command.append("--raw-output")
             if self.spec.get("convert", {}).get("parallel"):

scripts/yaqa_calibration.py

@@ -114,6 +114,7 @@ def main() -> None:
     import numpy as np
 
     from lalamo.model import Model
+    from lalamo_forward import apply_attention_env, describe
     from lalamo.module import Keychain
     from lalamo.modules import DecoderForwardPassConfig, ForwardPassMode
     from lalamo.modules.linear import Linear
@@ -131,6 +132,8 @@ def main() -> None:
         sharding = ShardingConfig.replicated()
     keychain = Keychain.init(seed=args.seed, sharding_config=sharding)
     forward_pass_config = DecoderForwardPassConfig.for_inference(mode=ForwardPassMode.MULTI_TOKEN)
+    forward_pass_config = apply_attention_env(forward_pass_config)
+    print(f"attention: {describe()}", flush=True)
 
     dtype = jnp.dtype(args.calib_dtype)
     if args.hf_repo or args.hf_dir:

tests/test_run_lane.py

@@ -71,6 +71,17 @@ def test_smoke_spec_is_cheap_and_single_condition() -> None:
     assert all("--max-sequences 2" in line for line in evals)
 
 
+def test_calib_dtype_is_passed_to_calibration() -> None:
+    result = run_lane(LANES / "damping-ablation-08b.json")
+    assert result.returncode == 0, result.stdout + result.stderr
+    calibration = [
+        line for line in result.stdout.splitlines() if line.startswith("$ ") and "yaqa_calibration.py" in line
+    ]
+    assert len(calibration) == 2
+    assert all("--calib-dtype float32" in line for line in calibration)
+    assert all("--damping 0.01" in line for line in calibration)
+
+
 def test_missing_spec_fields_fail_loudly(tmp_path: Path) -> None:
     spec = tmp_path / "bad.json"
     spec.write_text(json.dumps({"lane": "bad", "paths": {"kit": "kit", "work": str(tmp_path)}}), encoding="utf-8")