Non-autoregressive System 1 decision engine. Typed choice, score and yes/no decisions over any text in a single forward pass, in 100+ languages, with a router that picks the right checkpoint per request.
Python calibrationclassificationdecision-modelhuggingfacejevmodernbertmultilingualnlppythonpytorchroutingtyped-decisionszero-shot
research(step4): single-T4 Kaggle Gate D kernel for the remaining 5 cells
Bruce-Yii70f17ba3b2a6
diff --git a/research/scripts/step4_benchmark/kaggle/build_gate_d.py b/research/scripts/step4_benchmark/kaggle/build_gate_d.pynew file mode 100644index 00000000..7850b451--- /dev/null+++ b/research/scripts/step4_benchmark/kaggle/build_gate_d.py@@ -0,0 +1,222 @@+"""Generate the Gate D Kaggle kernel: the remaining 5 cells of the 3-seed x 2-loss panel.++One single-T4 session runs the five remaining trainings sequentially under the pinned Gate-R+contract, fail-closed after each: checkpoint exists, `training.laya_train` records the intended+loss/seed/config, counts match (5600/400/skipped {}), metrics finite, and the base sanity row stays+within tolerance of the Gate-R reference. A hard mismatch writes the partial results and aborts.++RLCD seed 0 is reused from the Gate R kernel (different session, same pinned SHA/data/command), as+the Coordinator explicitly allowed; it is embedded as the sixth cell.++ python research/scripts/step4_benchmark/kaggle/build_gate_d.py+ KAGGLE_API_TOKEN=$(kaggle auth print-access-token) kaggle kernels push -p <this dir>/gate_d+"""+from __future__ import annotations++import base64+import json+from pathlib import Path++HERE = Path(__file__).resolve().parent+HARNESS = HERE.parent+OUT = HERE / "gate_d"+EMBED = ("prepare_data.py", "evaluate.py", "metrics.py")+PINNED_SHA = "a4a8921afebfd852bba0000475cfb6ab737a124c"+KERNEL_ID = "yuyi722333/laya-step4-gate-d"++TEMPLATE = '''"""#887 Step 4 Gate D, generated by build_gate_d.py -- do not edit here."""+import base64+import json+import math+import os+import subprocess+import sys+import time+from pathlib import Path++PINNED_SHA = "__PINNED_SHA__"+WORK = Path("/kaggle/working")+HARNESS = WORK / "step4_benchmark"+HARNESS.mkdir(parents=True, exist_ok=True)++_EMBEDDED = __EMBEDDED__+for _n, _b in _EMBEDDED.items():+ (HARNESS / _n).write_bytes(base64.b64decode(_b))+sys.path.insert(0, str(HARNESS))++os.environ["CUDA_VISIBLE_DEVICES"] = "0"+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")+import torch # noqa: E402++n_gpu = torch.cuda.device_count()+print("torch", torch.__version__, "| cuda", torch.cuda.is_available(), "| visible_gpus", n_gpu, flush=True)+assert n_gpu == 1, "expected exactly one visible T4, got %d" % n_gpu+print("GPU", torch.cuda.get_device_name(0), flush=True)++RESULTS_PATH = WORK / "step4_gate_d_results.json"+++def flush_results():+ RESULTS_PATH.write_text(json.dumps(RESULTS, indent=2), encoding="utf-8")+++def run(cmd):+ print("\\n$ " + " ".join(cmd), flush=True)+ p = subprocess.run(cmd, check=True, text=True, capture_output=True)+ sys.stdout.write(p.stdout)+ if p.stderr:+ sys.stderr.write(p.stderr)+ sys.stdout.flush()+ return p.stdout+++run([sys.executable, "-m", "pip", "install", "-q", "--no-deps",+ "git+https://github.com/NandhaKishorM/laya@%s" % PINNED_SHA])+for _mod, _pkg in (("safetensors", "safetensors"), ("datasets", "datasets"),+ ("transformers", "transformers"), ("huggingface_hub", "huggingface_hub")):+ try:+ __import__(_mod)+ except Exception:+ run([sys.executable, "-m", "pip", "install", "-q", _pkg])++from huggingface_hub import snapshot_download # noqa: E402++base_dir = snapshot_download("convaiinnovations/laya")+base_cfg = json.loads((Path(base_dir) / "rl_agent_config.json").read_text(encoding="utf-8"))++run([sys.executable, str(HARNESS / "prepare_data.py"), "--out-dir", str(WORK / "data")])+test_meta = json.loads((WORK / "data" / "test_meta.json").read_text(encoding="utf-8"))++from evaluate import evaluate_checkpoint # noqa: E402++RESULTS = {+ "meta": {+ "pinned_sha": PINNED_SHA,+ "torch": torch.__version__,+ "gpu": torch.cuda.get_device_name(0),+ "visible_gpus": n_gpu,+ "base_config": {k: base_cfg.get(k) for k in ("max_len", "head_max_len")},+ "n_train_cases": 1200,+ "n_test_cases": len(test_meta),+ "reused": {"rlcd_seed0": "Gate R kernel (separate session, same SHA/data/command)"},+ },+ "rlcd_seed0": {+ "checkpoint": "Gate R kernel run_rlcd_seed0 (reused)",+ "temperatures": "shipped", "n_cases": 400, "n_decisions": 2000,+ "accuracy": 0.775, "ece": 0.1504, "brier": 0.0519, "soft_accuracy": 0.5654,+ "per_type_accuracy": {"choice": 0.7417, "noul": 0.8517, "score": 0.7425},+ "loss": "rlcd", "seed": 0, "wall_clock_s": 2691.3,+ },+}++# --- base sanity row, must match the Gate-R reference -----------------------+base_row = evaluate_checkpoint("convaiinnovations/laya", test_meta, device="cuda",+ temperatures="shipped")+RESULTS["base"] = base_row+base_ok = (abs(base_row["accuracy"] - 0.362) <= 0.01 and abs(base_row["ece"] - 0.1741) <= 0.01+ and abs(base_row["brier"] - 0.3287) <= 0.01)+print("BASE_SANITY", "OK" if base_ok else "FAIL", json.dumps(base_row), flush=True)+flush_results()+if not base_ok:+ raise SystemExit("GATE_D_PROTOCOL_PROBLEM: base sanity drift")++# --- the five remaining cells ----------------------------------------------+CELLS = [("rlcd", 1), ("soft-ce", 0), ("soft-ce", 1), ("rlcd", 2), ("soft-ce", 2)]+++def train(loss, seed):+ out = WORK / ("run_" + loss.replace("-", "_") + "_seed%d" % seed)+ cmd = [sys.executable, "-m", "laya.train_cli",+ "--data", str(WORK / "data" / "train.jsonl"),+ "--out", str(out),+ "--base", "convaiinnovations/laya",+ "--loss", loss, "--seed", str(seed),+ "--epochs", "4", "--micro-batch", "8", "--grad-accum", "8",+ "--encoder-lr", "2.5e-5", "--head-lr", "1e-4",+ "--max-len", "1024", "--head-max-len", "256",+ "--device", "cuda"]+ t0 = time.time()+ stdout = run(cmd)+ dt = round(time.time() - t0, 1)+ cfg = json.loads((out / "rl_agent_config.json").read_text(encoding="utf-8"))+ lt = (cfg.get("training") or {}).get("laya_train", {})+ split_line = next((ln for ln in stdout.splitlines() if ln.startswith("train items")), "")+ checks = {+ "loss": lt.get("loss") == loss,+ "seed": lt.get("seed") == seed,+ "epochs": lt.get("epochs") == 4,+ "micro_batch": lt.get("micro_batch") == 8,+ "grad_accum": lt.get("grad_accum") == 8,+ "encoder_lr": abs(float(lt.get("encoder_lr", 0)) - 2.5e-5) < 1e-12,+ "head_lr": abs(float(lt.get("head_lr", 0)) - 1e-4) < 1e-12,+ "max_len": lt.get("max_len") == 1024,+ "head_max_len": lt.get("head_max_len") == 256,+ "calib_seed": lt.get("calib_seed") == 20260922,+ "no_shuffle": list(lt.get("shuffle_options") or []) == [],+ "counts": "train items 5600, calibration items 400, skipped {}" in split_line,+ }+ return out, dt, cfg, checks, split_line+++for loss, seed in CELLS:+ out, dt, cfg, checks, split_line = train(loss, seed)+ print("CELL %s seed%d checks %s" % (loss, seed, json.dumps(checks)), flush=True)+ bad = sorted(k for k, v in checks.items() if not v)+ if bad:+ RESULTS["%s_seed%d" % (loss, seed)] = {"error": "protocol mismatch: " + ",".join(bad),+ "split_line": split_line}+ flush_results()+ raise SystemExit("GATE_D_PROTOCOL_PROBLEM: %s seed%d -> %s" % (loss, seed, bad))++ res = evaluate_checkpoint(str(out), test_meta, device="cuda", temperatures="shipped")+ finite = all(isinstance(res.get(k), (int, float)) and math.isfinite(res[k])+ for k in ("accuracy", "ece", "brier"))+ res.update({+ "loss": loss, "seed": seed, "wall_clock_s": dt,+ "temperature": cfg.get("temperature"),+ "calibration": (cfg.get("training") or {}).get("laya_train_calibration"),+ "split_line": split_line, "finite": finite,+ })+ RESULTS["%s_seed%d" % (loss, seed)] = res+ flush_results()+ print("RESULT %s seed%d %s" % (loss, seed, json.dumps(res)), flush=True)+ if not finite:+ raise SystemExit("GATE_D_PROTOCOL_PROBLEM: non-finite metric %s seed%d" % (loss, seed))++print("ALL_CELLS_DONE", flush=True)+print("RESULTS " + json.dumps(RESULTS, indent=2), flush=True)+'''+++def main() -> int:+ OUT.mkdir(parents=True, exist_ok=True)+ embedded = {name: base64.b64encode((HARNESS / name).read_bytes()).decode("ascii")+ for name in EMBED}+ script = (TEMPLATE.replace("__PINNED_SHA__", PINNED_SHA)+ .replace("__EMBEDDED__", json.dumps(embedded, indent=1)))+ (OUT / "step4_gate_d.py").write_text(script, encoding="utf-8", newline="\n")++ metadata = {+ "id": KERNEL_ID,+ "title": "Laya Step 4 Gate D",+ "code_file": "step4_gate_d.py",+ "language": "python",+ "kernel_type": "script",+ "is_private": True,+ "enable_gpu": True,+ "enable_tpu": False,+ "enable_internet": True,+ "machine_shape": "NvidiaTeslaT4",+ "dataset_sources": [],+ "competition_sources": [],+ "kernel_sources": [],+ "model_sources": [],+ }+ (OUT / "kernel-metadata.json").write_text(json.dumps(metadata, indent=2) + "\n",+ encoding="utf-8", newline="\n")+ print("wrote", OUT / "step4_gate_d.py", "and", OUT / "kernel-metadata.json")+ return 0+++if __name__ == "__main__":+ raise SystemExit(main())diff --git a/research/scripts/step4_benchmark/kaggle/gate_d/kernel-metadata.json b/research/scripts/step4_benchmark/kaggle/gate_d/kernel-metadata.jsonnew file mode 100644index 00000000..56fb0b84--- /dev/null+++ b/research/scripts/step4_benchmark/kaggle/gate_d/kernel-metadata.json@@ -0,0 +1,16 @@+{+ "id": "yuyi722333/laya-step4-gate-d",+ "title": "Laya Step 4 Gate D",+ "code_file": "step4_gate_d.py",+ "language": "python",+ "kernel_type": "script",+ "is_private": true,+ "enable_gpu": true,+ "enable_tpu": false,+ "enable_internet": true,+ "machine_shape": "NvidiaTeslaT4",+ "dataset_sources": [],+ "competition_sources": [],+ "kernel_sources": [],+ "model_sources": []+}diff --git a/research/scripts/step4_benchmark/kaggle/gate_d/step4_gate_d.py b/research/scripts/step4_benchmark/kaggle/gate_d/step4_gate_d.pynew file mode 100644index 00000000..814184b2--- /dev/null+++ b/research/scripts/step4_benchmark/kaggle/gate_d/step4_gate_d.py@@ -0,0 +1,165 @@+"""#887 Step 4 Gate D, generated by build_gate_d.py -- do not edit here."""+import base64+import json+import math+import os+import subprocess+import sys+import time+from pathlib import Path++PINNED_SHA = "a4a8921afebfd852bba0000475cfb6ab737a124c"+WORK = Path("/kaggle/working")+HARNESS = WORK / "step4_benchmark"+HARNESS.mkdir(parents=True, exist_ok=True)++_EMBEDDED = {+ "prepare_data.py": "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",+ "evaluate.py": """"Evaluate a fine-tuned checkpoint on the typed-decisions test split.

Mirrors cell 14 of the published notebook, restricted to the three metrics the Step-4 contract
names: **accuracy**, **ECE** and **Brier**. The 20-option order-flip surface is deliberately not
here: it belongs to `massive_intent.en`, not typed-decisions (see README).

Calibration is not byte-comparable across contracts. `laya.train` fits temperatures with
`fit_temperature_map` (per type, and per option-count bucket above a floor) under the runtime
clamp `[0.5, 5.0]`; the old notebook fitted one LBFGS temperature per type under `[0.1, 10]`.
So ECE and Brier are reported under **both** paths:

- ``--temperatures shipped`` (default) — the checkpoint's own fitted `temperature` and
  `temperature_by_options`, which is what the notebook's number also used;
- ``--temperatures raw`` — temperature 1.0 everywhere, isolating the training from the
  calibration contract.

Accuracy is unaffected by temperature (it only rescales the logits), so it is the clean
reproduction signal.

Usage:
    python evaluate.py --checkpoint runs/step4/rlcd-seed0 \
        --test-meta data/typed_decisions/test_meta.json \
        --out runs/step4/rlcd-seed0/eval_shipped.json
"""
from __future__ import annotations

import argparse
import json
import os
import sys
from typing import Any, Dict, List

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from metrics import (  # noqa: E402
    accuracy,
    brier_score,
    expected_calibration_error,
    soft_accuracy,
)


def _normalise(values: List[float]) -> List[float]:
    total = sum(values)
    if total > 0:
        return [v / total for v in values]
    return values


def evaluate_checkpoint(checkpoint_dir: str, test_meta: List[Dict[str, Any]],
                        device: str = "auto", temperatures: str = "shipped") -> Dict[str, Any]:
    import laya

    agent = laya.load(checkpoint_dir, device=device)
    if temperatures == "raw":
        agent.temperature = [1.0, 1.0, 1.0]
        agent.temperature_by_options = {}
    elif temperatures != "shipped":
        raise ValueError("temperatures must be 'shipped' or 'raw', got %r" % (temperatures,))

    corrects: List[float] = []
    confidences: List[float] = []
    briers: List[float] = []
    softs: List[float] = []
    per_type: Dict[str, List[float]] = {"choice": [], "noul": [], "score": []}
    score_maes: List[float] = []
    within_one: List[float] = []

    for i, case in enumerate(test_meta):
        state = case["state"]
        questions = case["questions"]
        gold = case["gold"]
        answers = agent.predict(state, questions)["answers"]

        for qid, qdef in questions.items():
            if qid not in gold:
                continue
            g = gold[qid]
            qtype = qdef["type"]
            p_ans = answers[qid]

            if qtype == "choice":
                keys = list(qdef["criteria"].keys())
                pred = p_ans["choice"]
                gold_label = str(g["label"])
                is_corr = float(pred == gold_label)

                p_probs = _normalise([p_ans["probabilities"].get(k, 1e-6) for k in keys])
                g_probs = _normalise([g["probabilities"].get(k, 1e-6) for k in keys])

                corrects.append(is_corr)
                confidences.append(max(p_probs))
                briers.append(brier_score(p_probs, g_probs))
                softs.append(soft_accuracy(p_probs, g_probs))
                per_type["choice"].append(is_corr)

            elif qtype == "noul":
                p_val = float(p_ans["noul"])
                g_val = float(g.get("noul", g.get("probabilities", {}).get("true", 0.5)))
                gold_label = str(g["label"]).lower()
                pred_label = "true" if p_val >= 0.5 else "false"
                is_corr = float(pred_label == gold_label)

                p_dist = [1.0 - p_val, p_val]
                g_dist = [1.0 - g_val, g_val]

                corrects.append(is_corr)
                confidences.append(max(p_val, 1.0 - p_val))
                briers.append(brier_score(p_dist, g_dist))
                softs.append(soft_accuracy(p_dist, g_dist))
                per_type["noul"].append(is_corr)

            elif qtype == "score":
                p_score = float(p_ans["score"])
                g_score = float(g.get("score", 0.0))
                score_maes.append(abs(p_score - g_score))
                within_one.append(float(abs(p_score - g_score) <= 1.0))

                n_levels = len(qdef.get("criteria", []))
                p_probs = [p_ans["probabilities"].get(str(i), 0.0) for i in range(n_levels)]
                if sum(p_probs) > 0:
                    p_probs = _normalise(p_probs)
                    p_lvl = int(max(range(len(p_probs)), key=lambda j: p_probs[j]))
                    confidences.append(max(p_probs))
                else:
                    p_lvl = int(round(p_score))
                    confidences.append(0.5)

                g_lvl = int(g.get("label", int(round(g_score))))
                is_corr = float(p_lvl == g_lvl)
                corrects.append(is_corr)
                per_type["score"].append(is_corr)

        if (i + 1) % 100 == 0:
            print(f"  {i + 1}/{len(test_meta)} cases", flush=True)

    result = {
        "checkpoint": checkpoint_dir,
        "temperatures": temperatures,
        "n_cases": len(test_meta),
        "n_decisions": len(corrects),
        "accuracy": round(accuracy(corrects), 4),
        "ece": round(expected_calibration_error(confidences, corrects), 4),
        "brier": round(float(sum(briers) / len(briers)) if briers else float("nan"), 4),
        "soft_accuracy": round(float(sum(softs) / len(softs)) if softs else float("nan"), 4),
        "score_mae": round(float(sum(score_maes) / len(score_maes)) if score_maes else float("nan"), 4),
        "within_one_level": round(float(sum(within_one) / len(within_one)) if within_one else float("nan"), 4),
        "per_type_accuracy": {k: round(accuracy(v), 4) for k, v in per_type.items() if v},
    }
    # `brier`/`soft_accuracy`/`ece` mix question types; record the counts they rest on.
    result["n_brier_decisions"] = len(briers)
    return result


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--checkpoint", required=True)
    parser.add_argument("--test-meta", required=True)
    parser.add_argument("--device", default="auto")
    parser.add_argument("--temperatures", choices=["shipped", "raw"], default="shipped")
    parser.add_argument("--out", default=None,
                        help="Output JSON (default: <checkpoint>/eval_<temperatures>.json)")
    args = parser.parse_args()

    with open(args.test_meta, encoding="utf-8") as f:
        test_meta = json.load(f)
    print(f"loaded {len(test_meta)} test cases", flush=True)

    result = evaluate_checkpoint(args.checkpoint, test_meta, device=args.device,
                                 temperatures=args.temperatures)

    print("\n" + "=" * 60)
    print(f"evaluation: {args.checkpoint} ({args.temperatures} temperatures)")
    print("=" * 60)
    print(f"  accuracy:     {result['accuracy']:.4f}")
    print(f"  ECE:          {result['ece']:.4f}")
    print(f"  Brier:        {result['brier']:.4f}")
    print(f"  soft acc:     {result['soft_accuracy']:.4f}")
    print(f"  per type:     {result['per_type_accuracy']}")
    print("=" * 60)

    out_path = args.out or os.path.join(args.checkpoint, f"eval_{args.temperatures}.json")
    os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
    with open(out_path, "w", encoding="utf-8") as f:
        json.dump(result, f, indent=2)
    print(f"wrote {out_path}")
    return 0


if __name__ == "__main__":
    sys.exit(main())
",+ "metrics.py": "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"+}+for _n, _b in _EMBEDDED.items():+ (HARNESS / _n).write_bytes(base64.b64decode(_b))+sys.path.insert(0, str(HARNESS))++os.environ["CUDA_VISIBLE_DEVICES"] = "0"+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")+import torch # noqa: E402++n_gpu = torch.cuda.device_count()+print("torch", torch.__version__, "| cuda", torch.cuda.is_available(), "| visible_gpus", n_gpu, flush=True)+assert n_gpu == 1, "expected exactly one visible T4, got %d" % n_gpu+print("GPU", torch.cuda.get_device_name(0), flush=True)++RESULTS_PATH = WORK / "step4_gate_d_results.json"+++def flush_results():+ RESULTS_PATH.write_text(json.dumps(RESULTS, indent=2), encoding="utf-8")+++def run(cmd):+ print("\n$ " + " ".join(cmd), flush=True)+ p = subprocess.run(cmd, check=True, text=True, capture_output=True)+ sys.stdout.write(p.stdout)+ if p.stderr:+ sys.stderr.write(p.stderr)+ sys.stdout.flush()+ return p.stdout+++run([sys.executable, "-m", "pip", "install", "-q", "--no-deps",+ "git+https://github.com/NandhaKishorM/laya@%s" % PINNED_SHA])+for _mod, _pkg in (("safetensors", "safetensors"), ("datasets", "datasets"),+ ("transformers", "transformers"), ("huggingface_hub", "huggingface_hub")):+ try:+ __import__(_mod)+ except Exception:+ run([sys.executable, "-m", "pip", "install", "-q", _pkg])++from huggingface_hub import snapshot_download # noqa: E402++base_dir = snapshot_download("convaiinnovations/laya")+base_cfg = json.loads((Path(base_dir) / "rl_agent_config.json").read_text(encoding="utf-8"))++run([sys.executable, str(HARNESS / "prepare_data.py"), "--out-dir", str(WORK / "data")])+test_meta = json.loads((WORK / "data" / "test_meta.json").read_text(encoding="utf-8"))++from evaluate import evaluate_checkpoint # noqa: E402++RESULTS = {+ "meta": {+ "pinned_sha": PINNED_SHA,+ "torch": torch.__version__,+ "gpu": torch.cuda.get_device_name(0),+ "visible_gpus": n_gpu,+ "base_config": {k: base_cfg.get(k) for k in ("max_len", "head_max_len")},+ "n_train_cases": 1200,+ "n_test_cases": len(test_meta),+ "reused": {"rlcd_seed0": "Gate R kernel (separate session, same SHA/data/command)"},+ },+ "rlcd_seed0": {+ "checkpoint": "Gate R kernel run_rlcd_seed0 (reused)",+ "temperatures": "shipped", "n_cases": 400, "n_decisions": 2000,+ "accuracy": 0.775, "ece": 0.1504, "brier": 0.0519, "soft_accuracy": 0.5654,+ "per_type_accuracy": {"choice": 0.7417, "noul": 0.8517, "score": 0.7425},+ "loss": "rlcd", "seed": 0, "wall_clock_s": 2691.3,+ },+}++# --- base sanity row, must match the Gate-R reference -----------------------+base_row = evaluate_checkpoint("convaiinnovations/laya", test_meta, device="cuda",+ temperatures="shipped")+RESULTS["base"] = base_row+base_ok = (abs(base_row["accuracy"] - 0.362) <= 0.01 and abs(base_row["ece"] - 0.1741) <= 0.01+ and abs(base_row["brier"] - 0.3287) <= 0.01)+print("BASE_SANITY", "OK" if base_ok else "FAIL", json.dumps(base_row), flush=True)+flush_results()+if not base_ok:+ raise SystemExit("GATE_D_PROTOCOL_PROBLEM: base sanity drift")++# --- the five remaining cells ----------------------------------------------+CELLS = [("rlcd", 1), ("soft-ce", 0), ("soft-ce", 1), ("rlcd", 2), ("soft-ce", 2)]+++def train(loss, seed):+ out = WORK / ("run_" + loss.replace("-", "_") + "_seed%d" % seed)+ cmd = [sys.executable, "-m", "laya.train_cli",+ "--data", str(WORK / "data" / "train.jsonl"),+ "--out", str(out),+ "--base", "convaiinnovations/laya",+ "--loss", loss, "--seed", str(seed),+ "--epochs", "4", "--micro-batch", "8", "--grad-accum", "8",+ "--encoder-lr", "2.5e-5", "--head-lr", "1e-4",+ "--max-len", "1024", "--head-max-len", "256",+ "--device", "cuda"]+ t0 = time.time()+ stdout = run(cmd)+ dt = round(time.time() - t0, 1)+ cfg = json.loads((out / "rl_agent_config.json").read_text(encoding="utf-8"))+ lt = (cfg.get("training") or {}).get("laya_train", {})+ split_line = next((ln for ln in stdout.splitlines() if ln.startswith("train items")), "")+ checks = {+ "loss": lt.get("loss") == loss,+ "seed": lt.get("seed") == seed,+ "epochs": lt.get("epochs") == 4,+ "micro_batch": lt.get("micro_batch") == 8,+ "grad_accum": lt.get("grad_accum") == 8,+ "encoder_lr": abs(float(lt.get("encoder_lr", 0)) - 2.5e-5) < 1e-12,+ "head_lr": abs(float(lt.get("head_lr", 0)) - 1e-4) < 1e-12,+ "max_len": lt.get("max_len") == 1024,+ "head_max_len": lt.get("head_max_len") == 256,+ "calib_seed": lt.get("calib_seed") == 20260922,+ "no_shuffle": list(lt.get("shuffle_options") or []) == [],+ "counts": "train items 5600, calibration items 400, skipped {}" in split_line,+ }+ return out, dt, cfg, checks, split_line+++for loss, seed in CELLS:+ out, dt, cfg, checks, split_line = train(loss, seed)+ print("CELL %s seed%d checks %s" % (loss, seed, json.dumps(checks)), flush=True)+ bad = sorted(k for k, v in checks.items() if not v)+ if bad:+ RESULTS["%s_seed%d" % (loss, seed)] = {"error": "protocol mismatch: " + ",".join(bad),+ "split_line": split_line}+ flush_results()+ raise SystemExit("GATE_D_PROTOCOL_PROBLEM: %s seed%d -> %s" % (loss, seed, bad))++ res = evaluate_checkpoint(str(out), test_meta, device="cuda", temperatures="shipped")+ finite = all(isinstance(res.get(k), (int, float)) and math.isfinite(res[k])+ for k in ("accuracy", "ece", "brier"))+ res.update({+ "loss": loss, "seed": seed, "wall_clock_s": dt,+ "temperature": cfg.get("temperature"),+ "calibration": (cfg.get("training") or {}).get("laya_train_calibration"),+ "split_line": split_line, "finite": finite,+ })+ RESULTS["%s_seed%d" % (loss, seed)] = res+ flush_results()+ print("RESULT %s seed%d %s" % (loss, seed, json.dumps(res)), flush=True)+ if not finite:+ raise SystemExit("GATE_D_PROTOCOL_PROBLEM: non-finite metric %s seed%d" % (loss, seed))++print("ALL_CELLS_DONE", flush=True)+print("RESULTS " + json.dumps(RESULTS, indent=2), flush=True)