results: jobs/20261011-002644-large-ilqr-steer-learn/** index/episodes.jsonl leaderboard/*

.gitattributes

@@ -74,3 +74,8 @@ results/jobs/20261009-102724-large-base-mppi1024/episodes.jsonl filter=lfs diff=
 results/jobs/20261009-102724-large-base-mppi1024/gautschi/0/episodes.json filter=lfs diff=lfs merge=lfs -text
 results/jobs/20261009-102724-large-base-mppi1024/gautschi/1/episodes.json filter=lfs diff=lfs merge=lfs -text
 results/jobs/20261010-184358-large-ilqr-two-rate/episodes.jsonl filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261011-002644-large-ilqr-steer-learn/episodes.jsonl filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/0/episodes.json filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/1/episodes.json filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/3/episodes.json filter=lfs diff=lfs merge=lfs -text
+results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/2/episodes.json filter=lfs diff=lfs merge=lfs -text

results/jobs/20261011-002644-large-ilqr-steer-learn/episodes.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec32f2fffd28cfd67a7917b0802e33dfa4ced7742b5033c9b50a246a67ad2a72
+size 42382872

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/0/episodes.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4c947b9fe414b3025163150bff5cf9d9f25bacc20cb820ac34ed4e22626fad4
+size 23863560

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/0/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/0/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 177 -J AutoSim-large-large-ilqr-steer-learn-1 --comment 20261011-002644-large-ilqr-steer-learn -o AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/0/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/0/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/0/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261011-002644-large-ilqr-steer-learn --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/b37fb519b32e564d2d8a8ea1259cbf2e695ba1a28d93504f20e4c2970a4f6f00 --stack $HOME/AutoSim/stacks/09f6048d97a12a43c7f0539e9db22b0251c622d6cafda2946841254a27f32824 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/0/timeline.jsonl --done $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/0/done.txt

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/1/episodes.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc42687066dd1bb4435872808f2f9ca935eb7d9467ca1d4acdccb65b7f68aa09
+size 23863595

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/1/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/1/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 177 -J AutoSim-large-large-ilqr-steer-learn-2 --comment 20261011-002644-large-ilqr-steer-learn -o AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/1/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/1/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/1/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261011-002644-large-ilqr-steer-learn --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/b37fb519b32e564d2d8a8ea1259cbf2e695ba1a28d93504f20e4c2970a4f6f00 --stack $HOME/AutoSim/stacks/09f6048d97a12a43c7f0539e9db22b0251c622d6cafda2946841254a27f32824 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/1/timeline.jsonl --done $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/1/done.txt

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/2/episodes.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4173afcc40a795fe3f2a0d6220b34f2ece0bf4761b10d25712002f43a1e8fbc2
+size 23863551

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/2/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/2/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 177 --dependency=afterany:16948095 -J AutoSim-large-large-ilqr-steer-learn-3 --comment 20261011-002644-large-ilqr-steer-learn -o AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/2/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/2/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/2/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261011-002644-large-ilqr-steer-learn --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/b37fb519b32e564d2d8a8ea1259cbf2e695ba1a28d93504f20e4c2970a4f6f00 --stack $HOME/AutoSim/stacks/09f6048d97a12a43c7f0539e9db22b0251c622d6cafda2946841254a27f32824 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/2/timeline.jsonl --done $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/2/done.txt

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/3/episodes.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc6199c1dd325ec16c9f19e273f889af224186438446d4bf963d0866f975a521
+size 23863444

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/3/gautschi_launch.py

@@ -0,0 +1,145 @@
+"""Runs on a Gautschi node (stdlib only): episodes from a queue in parallel workers, one contained Apptainer per episode."""
+import argparse
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+
+RUN = ("source /opt/ros/humble/setup.bash && source /ws/install/setup.bash"
+       " && python3 -m simnode.batch /batch.json /out")
+CUDA_LIB = "/ws/mpc_cuda/libmpc_cuda.so"   # built per stack by runner/gautschi.build_stack for gautschi-gpu
+SAMPLE_S = 15
+STAGGER_S = 0.25   # between worker starts: the dev job's one error was a stack starved in the 96-way start burst
+EPISODE_TIMEOUT_S = 1200   # about 4x the slowest lap; a killed episode has no outcome and is retried by the host
+
+
+def worker_cmd(i, work, out, ep, sif, engine, stack, gpu=None):
+    """Private /tmp, HOME, /dev/shm, IPC, PIDs and loopback per episode, plus a distinct ROS_DOMAIN_ID per worker;
+    gpu (a host CUDA device) adds the driver and the stack's CUDA MPC kernel."""
+    cuda = ["--nv", "--env", f"CUDA_VISIBLE_DEVICES={gpu}", "--env", f"MPC_CUDA_LIB={CUDA_LIB}"] if gpu is not None else []
+    if gpu is None and os.path.exists(os.path.join(stack, "mpc_cuda", "libmpc_cuda.so")):
+        cuda = ["--env", f"MPC_CUDA_LIB={CUDA_LIB}"]   # CPU node: the library's native iLQR solve still loads; its MPPI falls back to numpy
+    return ["apptainer", "exec", *cuda, "--contain", "--cleanenv", "--ipc", "--pid", "--net", "--network", "none", "--workdir", work,
+            "--env", f"ROS_DOMAIN_ID={i + 1}", "--env", "ROS_HOME=/tmp/ros", "--env", "TMPDIR=/tmp",
+            "--bind", f"{engine}:/opt/sim:ro", "--bind", f"{stack}:/ws:ro", "--bind", f"{out}:/out",
+            "--bind", f"{ep}:/batch.json:ro", sif, "bash", "-lc", RUN]
+
+
+def parse_smi(text):
+    """nvidia-smi 'utilization.gpu, memory.used' csv rows to per-GPU lists."""
+    rows = [[int(v) for v in ln.split(",")] for ln in text.strip().splitlines() if ln.strip()]
+    return {"gpu_util": [r[0] for r in rows], "gpu_mem_mib": [r[1] for r in rows]}
+
+
+def _solver(logdir):
+    """pathfinder's 'MPC solver: ...' and CUDA fallback lines from the episode's ROS logs."""
+    lines = []
+    for dp, _, fns in os.walk(logdir):
+        for fn in fns:
+            try:
+                with open(os.path.join(dp, fn), errors="replace") as f:
+                    lines += [ln.strip() for ln in f if "MPC solver:" in ln or "CUDA MPC unavailable" in ln]
+            except OSError:
+                pass
+    return "\n".join(dict.fromkeys(lines))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser()
+    for a in ("episodes", "out", "sif", "engine", "stack", "work", "timeline", "done"):
+        p.add_argument("--" + a, required=True)
+    p.add_argument("--workers", type=int, required=True)
+    p.add_argument("--gpus", type=int, default=0)
+    a = p.parse_args(argv)
+    with open(a.episodes) as f:
+        q = queue.Queue()
+        for e in json.load(f):   # the host already ordered them, longest first
+            q.put(e)
+    os.makedirs(a.out, exist_ok=True)
+    lock, t0 = threading.Lock(), time.time()
+    devs = [d for d in os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",") if d][:a.gpus] or [str(n) for n in range(a.gpus)]
+
+    def log(**ev):
+        with lock, open(a.timeline, "a") as f:
+            f.write(json.dumps(dict(ev, t=round(time.time() - t0, 3))) + "\n")
+
+    def worker(i):
+        time.sleep(i * STAGGER_S)
+        while True:
+            try:
+                e = q.get_nowait()
+            except queue.Empty:
+                return
+            key, work = e["key"], os.path.join(a.work, e["key"])
+            stage, ep = os.path.join(work, "stage"), os.path.join(work, "ep.json")
+            os.makedirs(stage)
+            with open(ep, "w") as f:
+                json.dump([e], f)
+            log(ev="start", key=key, worker=i)
+            gpu = devs[i % len(devs)] if devs and e["resolved"].get("recipe", {}).get("sim", {}).get("cuda") else None
+            limit = EPISODE_TIMEOUT_S * max(1, e["resolved"]["scenario"].get("laps", 1))   # per lap: 5-lap episodes run 5x longer
+            try:
+                rc = subprocess.run(worker_cmd(i, work, stage, ep, a.sif, a.engine, a.stack, gpu), stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL, timeout=limit).returncode
+            except subprocess.TimeoutExpired:
+                rc = "timeout"
+            solver = _solver(os.path.join(work, "tmp", "ros", "log"))
+            if solver and os.path.isdir(os.path.join(stage, key)):
+                with open(os.path.join(stage, key, "solver.txt"), "w") as f:
+                    f.write(solver + "\n")
+            if os.path.exists(os.path.join(stage, key, "outcome.json")):
+                tmp, dst = os.path.join(a.out, ".tmp-" + key), os.path.join(a.out, key)
+                shutil.rmtree(tmp, ignore_errors=True)
+                shutil.copytree(os.path.join(stage, key), tmp)
+                shutil.rmtree(dst, ignore_errors=True)
+                os.rename(tmp, dst)   # the host's rsync sees a key only once its directory is complete
+                with lock, open(a.done, "a") as f:
+                    f.write(key + "\n")
+            shutil.rmtree(work, ignore_errors=True)
+            log(ev="end", key=key, worker=i, rc=rc, gpu=gpu,
+                solver=solver.split("MPC solver: ")[-1] if "MPC solver: " in solver else solver or None)
+
+    def sampler(stop):
+        """Job CPU use from its cgroup, as busy cores, every SAMPLE_S."""
+        try:
+            with open("/proc/self/cgroup") as f:
+                path = "/sys/fs/cgroup" + f.read().strip().split(":")[-1] + "/cpu.stat"
+            prev = None
+            while not stop.wait(SAMPLE_S if prev else 0):
+                with open(path) as f:
+                    use = next(int(ln.split()[1]) for ln in f if ln.startswith("usage_usec"))
+                now = time.time()
+                if prev:
+                    log(ev="cpu", busy_cores=round((use - prev[0]) / 1e6 / (now - prev[1]), 2))
+                prev = (use, now)
+        except (OSError, StopIteration, ValueError):
+            pass
+
+    def gpu_sampler(stop):
+        """GPU utilisation and memory of the job's GPUs, every SAMPLE_S."""
+        while not stop.wait(SAMPLE_S):
+            try:
+                p = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"],
+                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                log(ev="gpu", **parse_smi(p.communicate(timeout=30)[0]))
+            except Exception:   # no driver or a hung query: skip this sample
+                pass
+
+    cores = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
+    log(ev="launch", workers=a.workers, cores=cores)
+    stop = threading.Event()
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(a.workers)]
+    samplers = [sampler] + ([gpu_sampler] if a.gpus else [])
+    for t in threads + [threading.Thread(target=f, args=(stop,), daemon=True) for f in samplers]:
+        t.start()
+    for t in threads:
+        t.join()
+    stop.set()
+    log(ev="done")
+
+
+if __name__ == "__main__":
+    main()

results/jobs/20261011-002644-large-ilqr-steer-learn/gautschi/3/sbatch.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+#SBATCH -p highmem -A lilly-rob1 -N 1 -n 1 -c 192 --time 177 --dependency=afterany:16948096 -J AutoSim-large-large-ilqr-steer-learn-4 --comment 20261011-002644-large-ilqr-steer-learn -o AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/3/slurm-%j.out
+W=/dev/shm/AutoSim-$SLURM_JOB_ID
+trap 'rm -rf "$W"' EXIT
+python3 $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/3/gautschi_launch.py --episodes $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/3/episodes.json --out /scratch/gautschi/manors/AutoSim/out/20261011-002644-large-ilqr-steer-learn --sif $HOME/AutoSim/images/AutoSim-99d206f40cb1.sif --engine $HOME/AutoSim/engine/b37fb519b32e564d2d8a8ea1259cbf2e695ba1a28d93504f20e4c2970a4f6f00 --stack $HOME/AutoSim/stacks/09f6048d97a12a43c7f0539e9db22b0251c622d6cafda2946841254a27f32824 --workers 96 --work $W --timeline $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/3/timeline.jsonl --done $HOME/AutoSim/jobs/20261011-002644-large-ilqr-steer-learn/3/done.txt

results/jobs/20261011-002644-large-ilqr-steer-learn/job.json

@@ -0,0 +1,133 @@
+{
+ "id": "20261011-002644-large-ilqr-steer-learn",
+ "tier": "large",
+ "tier_version": 3,
+ "recipe": {
+  "name": "large-ilqr-steer-learn",
+  "source": {
+   "repo": "AutonomousKart",
+   "ref": "worktree:ilqr-steer-learn"
+  },
+  "params": {
+   "pathfinder_node": {
+    "planner": "ilqr",
+    "mpc.num_samples": 16,
+    "mpc.use_steer_map": true,
+    "mpc.steer_map_cmd_deg": [
+     -60.0,
+     -30.0,
+     -18.0,
+     -15.0,
+     -12.0,
+     -9.0,
+     -6.0,
+     -3.0,
+     0.0,
+     3.0,
+     6.0,
+     9.0,
+     12.0,
+     15.0,
+     18.0,
+     30.0,
+     60.0
+    ],
+    "mpc.adaptive_gain.map": true,
+    "mpc.adaptive_gain.understeer": false
+   }
+  },
+  "sim": {},
+  "notes": "large-ilqr-fast with a learned steer map: the rollout starts from each kart design's scalar gain (small-angle slope of the steer-map fit: 0.635, 0.357, 0.537) and RLS on IMU yaw rate learns the 17 knots, used as learned; no separate K_us (the starting gain is measured at driving speed, so K_us on top double counts understeer; the map absorbs it as in the predefined map)",
+  "params_by_kart": {
+   "kart1": {
+    "pathfinder_node": {
+     "mpc.steer_map_wheel_deg": [
+      -38.112,
+      -19.056,
+      -11.4336,
+      -9.528,
+      -7.6224,
+      -5.7168,
+      -3.8112,
+      -1.9056,
+      0.0,
+      1.9056,
+      3.8112,
+      5.7168,
+      7.6224,
+      9.528,
+      11.4336,
+      19.056,
+      38.112
+     ]
+    }
+   },
+   "kart2": {
+    "pathfinder_node": {
+     "mpc.steer_map_wheel_deg": [
+      -21.408,
+      -10.704,
+      -6.4224,
+      -5.352,
+      -4.2816,
+      -3.2112,
+      -2.1408,
+      -1.0704,
+      0.0,
+      1.0704,
+      2.1408,
+      3.2112,
+      4.2816,
+      5.352,
+      6.4224,
+      10.704,
+      21.408
+     ]
+    }
+   },
+   "kart3": {
+    "pathfinder_node": {
+     "mpc.steer_map_wheel_deg": [
+      -32.19,
+      -16.095,
+      -9.657,
+      -8.0475,
+      -6.438,
+      -4.8285,
+      -3.219,
+      -1.6095,
+      0.0,
+      1.6095,
+      3.219,
+      4.8285,
+      6.438,
+      8.0475,
+      9.657,
+      16.095,
+      32.19
+     ]
+    }
+   }
+  }
+ },
+ "user": "shay",
+ "notes": "large v3: gradient MPC (tuned iLQR) with a learned steer map from each kart's scalar gain, no separate K_us",
+ "where": "gautschi",
+ "status": "done",
+ "submitted_at": "2026-10-11T07:26:44.062+00:00",
+ "started_at": "2026-10-11T07:26:44.062+00:00",
+ "finished_at": "2026-10-11T10:43:35.296+00:00",
+ "total": 32076,
+ "done": 32076,
+ "errors": 0,
+ "build_log": null,
+ "workers": 96,
+ "slurm_id": "16948095",
+ "slurm_ids": [
+  "16948095",
+  "16948096",
+  "16948097",
+  "16948098"
+ ],
+ "engine_version": "b37fb519b32e564d2d8a8ea1259cbf2e695ba1a28d93504f20e4c2970a4f6f00"
+}

results/jobs/20261011-002644-large-ilqr-steer-learn/summary.json

@@ -0,0 +1,156 @@
+{
+ "cte_p50": {
+  "value": 0.2552608991174732,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.25633914555450693,
+   "kart2": 0.2637971133562128,
+   "kart3": 0.24591111109514402
+  }
+ },
+ "cte_p90": {
+  "value": 0.6531442435271917,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.6177555232560475,
+   "kart2": 0.7046212720671666,
+   "kart3": 0.6430703814654682
+  }
+ },
+ "cte_p99": {
+  "value": 1.9560502261935768,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 1.6952816371973014,
+   "kart2": 2.2640839730209477,
+   "kart3": 1.835355438009065
+  }
+ },
+ "recovery_rate": {
+  "value": 0.8544575725026853,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.8576794657762938,
+   "kart2": 0.8528756130182791,
+   "kart3": 0.8525514089870525
+  }
+ },
+ "recovery_s_median": {
+  "value": 1.8330000000000002,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 1.700000000000001,
+   "kart2": 2.0,
+   "kart3": 1.7829999999999995
+  }
+ },
+ "safety": {
+  "value": 0.7865614544147589,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.8033688004913537,
+   "kart2": 0.7643699467653093,
+   "kart3": 0.7910023696197255
+  }
+ },
+ "unsafe_lat": {
+  "value": 0.0008100744378086672,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.0009748219416854327,
+   "kart2": 0.00016791706477997157,
+   "kart3": 0.0012876468298441749
+  }
+ },
+ "unsafe_rate": {
+  "value": 0.10755605785217116,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.08795546667239557,
+   "kart2": 0.12872840156041418,
+   "kart3": 0.10718860624766931
+  }
+ },
+ "unsafe_travel": {
+  "value": 0.0,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.0,
+   "kart2": 0.0,
+   "kart3": 0.0
+  }
+ },
+ "unsafe_spin": {
+  "value": 4.33257619551897e-05,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 6.40591177002288e-05,
+   "kart2": 9.23310106895697e-06,
+   "kart3": 5.5670323256263886e-05
+  }
+ },
+ "unsafe_off": {
+  "value": 0.12161829590158763,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 0.12119628851357575,
+   "kart2": 0.12605832473090897,
+   "kart3": 0.11753792858437581
+  }
+ },
+ "osc_10": {
+  "value": 30.974468731870164,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 31.635404949154676,
+   "kart2": 28.866101006293306,
+   "kart3": 32.41218645676043
+  }
+ },
+ "osc_20": {
+  "value": 14.129465059035974,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 14.408636060336132,
+   "kart2": 11.939973476954647,
+   "kart3": 16.06446251200385
+  }
+ },
+ "osc_30": {
+  "value": 6.509328309410818,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 6.6665432118483485,
+   "kart2": 4.905023900496261,
+   "kart3": 7.978541095562408
+  }
+ },
+ "laps_pct": {
+  "value": 50.26063100137174,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 50.946502057613166,
+   "kart2": 50.864197530864196,
+   "kart3": 48.97119341563786
+  }
+ },
+ "failures": {
+  "value": 4304,
+  "worst_kart": null,
+  "per_kart": {
+   "kart1": 1471,
+   "kart2": 1506,
+   "kart3": 1327
+  }
+ },
+ "n": {
+  "value": 32076,
+  "worst_kart": null,
+  "per_kart": {}
+ },
+ "errors": {
+  "value": 0,
+  "worst_kart": null,
+  "per_kart": {}
+ }
+}

results/leaderboard/large-3__b37fb519b32e.json

@@ -0,0 +1,48 @@
+[
+ {
+  "job_id": "20261011-002644-large-ilqr-steer-learn",
+  "recipe": "large-ilqr-steer-learn",
+  "notes": "large v3: gradient MPC (tuned iLQR) with a learned steer map from each kart's scalar gain, no separate K_us",
+  "user": "shay",
+  "ran_at": "2026-10-11T10:43:35.296+00:00",
+  "duration_s": 11811.234,
+  "cte_p50": 0.2552608991174732,
+  "cte_p90": 0.6531442435271917,
+  "cte_p99": 1.9560502261935768,
+  "recovery_rate": 0.8544575725026853,
+  "recovery_s_median": 1.8330000000000002,
+  "safety": 0.7865614544147589,
+  "unsafe_lat": 0.0008100744378086672,
+  "unsafe_rate": 0.10755605785217116,
+  "unsafe_travel": 0.0,
+  "unsafe_spin": 4.33257619551897e-05,
+  "unsafe_off": 0.12161829590158763,
+  "osc_10": 30.974468731870164,
+  "osc_20": 14.129465059035974,
+  "osc_30": 6.509328309410818,
+  "laps_pct": 50.26063100137174,
+  "failures": 4304,
+  "n": 32076,
+  "errors": 0,
+  "worst": {
+   "cte_p50": 0.2637971133562128,
+   "cte_p90": 0.7046212720671666,
+   "cte_p99": 2.2640839730209477,
+   "recovery_rate": 0.8525514089870525,
+   "recovery_s_median": 2.0,
+   "safety": 0.7643699467653093,
+   "unsafe_lat": 0.0012876468298441749,
+   "unsafe_rate": 0.12872840156041418,
+   "unsafe_travel": 0.0,
+   "unsafe_spin": 6.40591177002288e-05,
+   "unsafe_off": 0.12605832473090897,
+   "osc_10": 32.41218645676043,
+   "osc_20": 16.06446251200385,
+   "osc_30": 7.978541095562408,
+   "laps_pct": 48.97119341563786,
+   "failures": 1506,
+   "n": 32076,
+   "errors": 0
+  }
+ }
+]