Skip to content

armgit / laya

Public Imported from GitHub
0

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.

research(step4): single-T4 self-contained Kaggle Gate R package

Bruce-Yii710f806fc2f1
diff --git a/research/scripts/step4_benchmark/kaggle/build_kernel.py b/research/scripts/step4_benchmark/kaggle/build_kernel.py
new file mode 100644
index 00000000..58d74491
--- /dev/null
+++ b/research/scripts/step4_benchmark/kaggle/build_kernel.py
@@ -0,0 +1,187 @@
+"""Generate the self-contained Kaggle Gate R runner for #887 Step 4.
+
+The harness under this directory is not in the upstream repo yet (public mutation authority is
+NONE), so the kernel cannot clone it. This generator embeds the four harness files verbatim (as
+base64) into one script, plus a `kernel-metadata.json` pinned to a single T4.
+
+Single T4 on Kaggle means `machine_shape: "NvidiaTeslaT4"`; the kernel then pins
+`CUDA_VISIBLE_DEVICES=0` and asserts exactly one visible GPU, so the run is single-device with no
+torchrun and no 2-GPU assert — the shipped `laya-train` path.
+
+Run the API with `KAGGLE_API_TOKEN` exported from `kaggle auth print-access-token`; the stored
+credential is not picked up automatically by this CLI build.
+
+ python research/scripts/step4_benchmark/kaggle/build_kernel.py
+ KAGGLE_API_TOKEN=$(kaggle auth print-access-token) kaggle kernels push -p <dir>
+"""
+from __future__ import annotations
+
+import base64
+import json
+import os
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+HARNESS = HERE.parent
+EMBED = ("prepare_data.py", "run_benchmark.py", "evaluate.py", "metrics.py")
+PINNED_SHA = "a4a8921afebfd852bba0000475cfb6ab737a124c"
+KERNEL_ID = "yuyi722333/laya-step4-gate-r"
+
+TEMPLATE = '''"""#887 Step 4 Gate R, generated by build_kernel.py -- do not edit here.
+
+Single-device T4 reproduction of the typed-decisions fine-tune through the shipped `laya-train`,
+then the Step-4 evaluator. No torchrun, no 2-GPU assert, no early stopping, no option shuffling.
+"""
+import base64
+import json
+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 _name, _b64 in _EMBEDDED.items():
+ (HARNESS / _name).write_bytes(base64.b64decode(_b64))
+sys.path.insert(0, str(HARNESS))
+
+
+def run(cmd):
+ print("\\n$ " + " ".join(cmd), flush=True)
+ return subprocess.run(cmd, check=True)
+
+
+# --- one visible T4 -------------------------------------------------------------------------
+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)
+for _i in range(n_gpu):
+ _p = torch.cuda.get_device_properties(_i)
+ print(" GPU", _i, _p.name, round(_p.total_memory / 1e9, 1), "GB", flush=True)
+assert n_gpu == 1, "expected exactly one visible T4, got %d" % n_gpu
+
+# --- laya at the pinned SHA, without disturbing Kaggle's torch ------------------------------
+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])
+
+# --- base checkpoint config readback --------------------------------------------------------
+from huggingface_hub import snapshot_download # noqa: E402
+
+base_dir = snapshot_download("convaiinnovations/laya")
+with open(os.path.join(base_dir, "rl_agent_config.json"), encoding="utf-8") as _f:
+ base_cfg = json.load(_f)
+base_keys = ("max_len", "head_max_len", "max_tokens_per_batch", "temperature",
+ "temperature_by_options", "option_layout")
+print("BASE_CONFIG " + json.dumps({k: base_cfg.get(k) for k in base_keys}), flush=True)
+
+# --- data -----------------------------------------------------------------------------------
+run([sys.executable, str(HARNESS / "prepare_data.py"), "--out-dir", str(WORK / "data")])
+with open(WORK / "data" / "train.jsonl", encoding="utf-8") as _f:
+ n_train_cases = sum(1 for _l in _f if _l.strip())
+with open(WORK / "data" / "test_meta.json", encoding="utf-8") as _f:
+ test_meta = json.load(_f)
+print("SPLITS train_cases=%d test_cases=%d" % (n_train_cases, len(test_meta)), flush=True)
+
+# --- Gate R: rlcd, seed 0, notebook hyperparameters ----------------------------------------
+cmd = [sys.executable, "-m", "laya.train_cli",
+ "--data", str(WORK / "data" / "train.jsonl"),
+ "--out", str(WORK / "run_rlcd_seed0"),
+ "--base", "convaiinnovations/laya",
+ "--loss", "rlcd", "--seed", "0",
+ "--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()
+_proc = subprocess.run(cmd, check=True, capture_output=True, text=True)
+train_seconds = round(time.time() - _t0, 1)
+print(_proc.stdout)
+if _proc.stderr:
+ print(_proc.stderr, file=sys.stderr)
+(WORK / "step4_train.log").write_text(_proc.stdout + "\\n" + _proc.stderr, encoding="utf-8")
+
+train_split_line = next((ln for ln in _proc.stdout.splitlines() if ln.startswith("train items")), "")
+peak_gpu_gb = round(torch.cuda.max_memory_allocated() / 1e9, 2)
+print("TRAIN_SECONDS", train_seconds, "PEAK_GPU_GB", peak_gpu_gb, flush=True)
+print("TRAIN_SPLIT", train_split_line, flush=True)
+
+# --- evaluate with the Step-4 evaluator -----------------------------------------------------
+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,
+ "train_seconds": train_seconds,
+ "peak_gpu_gb": peak_gpu_gb,
+ "train_split_line": train_split_line,
+ "base_config": {k: base_cfg.get(k) for k in ("max_len", "head_max_len")},
+ "n_train_cases": n_train_cases,
+ "n_test_cases": len(test_meta),
+ }
+}
+for _label, _ckpt in (("rlcd_seed0", str(WORK / "run_rlcd_seed0")),
+ ("base", "convaiinnovations/laya"),
+ ("published", "convaiinnovations/laya-typed-decisions")):
+ try:
+ results[_label] = evaluate_checkpoint(_ckpt, test_meta, device="cuda", temperatures="shipped")
+ except Exception as _e: # noqa: BLE001 - a missing optional row must not kill the run
+ results[_label] = {"error": "%s: %s" % (type(_e).__name__, _e)}
+ print(_label, json.dumps(results[_label]), flush=True)
+
+with open(WORK / "step4_gate_r_results.json", "w", encoding="utf-8") as _f:
+ json.dump(results, _f, indent=2)
+print("\\nRESULTS " + json.dumps(results, indent=2), flush=True)
+'''
+
+
+def main() -> int:
+ embedded = {}
+ for name in EMBED:
+ embedded[name] = base64.b64encode((HARNESS / name).read_bytes()).decode("ascii")
+
+ script = (TEMPLATE
+ .replace("__PINNED_SHA__", PINNED_SHA)
+ .replace("__EMBEDDED__", json.dumps(embedded, indent=1)))
+ (HERE / "step4_gate_r.py").write_text(script, encoding="utf-8", newline="\n")
+
+ metadata = {
+ "id": KERNEL_ID,
+ "title": "Laya Step 4 Gate R",
+ "code_file": "step4_gate_r.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": [],
+ }
+ (HERE / "kernel-metadata.json").write_text(json.dumps(metadata, indent=2) + "\n",
+ encoding="utf-8", newline="\n")
+ print("wrote", HERE / "step4_gate_r.py", "and", HERE / "kernel-metadata.json")
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/research/scripts/step4_benchmark/kaggle/kernel-metadata.json b/research/scripts/step4_benchmark/kaggle/kernel-metadata.json
new file mode 100644
index 00000000..7e3e95e2
--- /dev/null
+++ b/research/scripts/step4_benchmark/kaggle/kernel-metadata.json
@@ -0,0 +1,16 @@
+{
+ "id": "yuyi722333/laya-step4-gate-r",
+ "title": "Laya Step 4 Gate R",
+ "code_file": "step4_gate_r.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/step4_gate_r.py b/research/scripts/step4_benchmark/kaggle/step4_gate_r.py
new file mode 100644
index 00000000..4e29c5ca
--- /dev/null
+++ b/research/scripts/step4_benchmark/kaggle/step4_gate_r.py
@@ -0,0 +1,126 @@
+"""#887 Step 4 Gate R, generated by build_kernel.py -- do not edit here.
+
+Single-device T4 reproduction of the typed-decisions fine-tune through the shipped `laya-train`,
+then the Step-4 evaluator. No torchrun, no 2-GPU assert, no early stopping, no option shuffling.
+"""
+import base64
+import json
+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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",
+ "run_benchmark.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 _name, _b64 in _EMBEDDED.items():
+ (HARNESS / _name).write_bytes(base64.b64decode(_b64))
+sys.path.insert(0, str(HARNESS))
+
+
+def run(cmd):
+ print("\n$ " + " ".join(cmd), flush=True)
+ return subprocess.run(cmd, check=True)
+
+
+# --- one visible T4 -------------------------------------------------------------------------
+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)
+for _i in range(n_gpu):
+ _p = torch.cuda.get_device_properties(_i)
+ print(" GPU", _i, _p.name, round(_p.total_memory / 1e9, 1), "GB", flush=True)
+assert n_gpu == 1, "expected exactly one visible T4, got %d" % n_gpu
+
+# --- laya at the pinned SHA, without disturbing Kaggle's torch ------------------------------
+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])
+
+# --- base checkpoint config readback --------------------------------------------------------
+from huggingface_hub import snapshot_download # noqa: E402
+
+base_dir = snapshot_download("convaiinnovations/laya")
+with open(os.path.join(base_dir, "rl_agent_config.json"), encoding="utf-8") as _f:
+ base_cfg = json.load(_f)
+base_keys = ("max_len", "head_max_len", "max_tokens_per_batch", "temperature",
+ "temperature_by_options", "option_layout")
+print("BASE_CONFIG " + json.dumps({k: base_cfg.get(k) for k in base_keys}), flush=True)
+
+# --- data -----------------------------------------------------------------------------------
+run([sys.executable, str(HARNESS / "prepare_data.py"), "--out-dir", str(WORK / "data")])
+with open(WORK / "data" / "train.jsonl", encoding="utf-8") as _f:
+ n_train_cases = sum(1 for _l in _f if _l.strip())
+with open(WORK / "data" / "test_meta.json", encoding="utf-8") as _f:
+ test_meta = json.load(_f)
+print("SPLITS train_cases=%d test_cases=%d" % (n_train_cases, len(test_meta)), flush=True)
+
+# --- Gate R: rlcd, seed 0, notebook hyperparameters ----------------------------------------
+cmd = [sys.executable, "-m", "laya.train_cli",
+ "--data", str(WORK / "data" / "train.jsonl"),
+ "--out", str(WORK / "run_rlcd_seed0"),
+ "--base", "convaiinnovations/laya",
+ "--loss", "rlcd", "--seed", "0",
+ "--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()
+_proc = subprocess.run(cmd, check=True, capture_output=True, text=True)
+train_seconds = round(time.time() - _t0, 1)
+print(_proc.stdout)
+if _proc.stderr:
+ print(_proc.stderr, file=sys.stderr)
+(WORK / "step4_train.log").write_text(_proc.stdout + "\n" + _proc.stderr, encoding="utf-8")
+
+train_split_line = next((ln for ln in _proc.stdout.splitlines() if ln.startswith("train items")), "")
+peak_gpu_gb = round(torch.cuda.max_memory_allocated() / 1e9, 2)
+print("TRAIN_SECONDS", train_seconds, "PEAK_GPU_GB", peak_gpu_gb, flush=True)
+print("TRAIN_SPLIT", train_split_line, flush=True)
+
+# --- evaluate with the Step-4 evaluator -----------------------------------------------------
+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,
+ "train_seconds": train_seconds,
+ "peak_gpu_gb": peak_gpu_gb,
+ "train_split_line": train_split_line,
+ "base_config": {k: base_cfg.get(k) for k in ("max_len", "head_max_len")},
+ "n_train_cases": n_train_cases,
+ "n_test_cases": len(test_meta),
+ }
+}
+for _label, _ckpt in (("rlcd_seed0", str(WORK / "run_rlcd_seed0")),
+ ("base", "convaiinnovations/laya"),
+ ("published", "convaiinnovations/laya-typed-decisions")):
+ try:
+ results[_label] = evaluate_checkpoint(_ckpt, test_meta, device="cuda", temperatures="shipped")
+ except Exception as _e: # noqa: BLE001 - a missing optional row must not kill the run
+ results[_label] = {"error": "%s: %s" % (type(_e).__name__, _e)}
+ print(_label, json.dumps(results[_label]), flush=True)
+
+with open(WORK / "step4_gate_r_results.json", "w", encoding="utf-8") as _f:
+ json.dump(results, _f, indent=2)
+print("\nRESULTS " + json.dumps(results, indent=2), flush=True)