{ "cells": [ { "cell_type": "markdown", "id": "fff53522", "metadata": {}, "source": [ "# Batched iLQR: many tracking problems at once\n", "\n", "Many applications solve the same optimal control problem for many datasets: one input trajectory per recorded\n", "trial, or one per datapoint in every training step of an iLQR-VAE. Only a few leaves of the parameters change\n", "from problem to problem (the observations, the reference trajectory, the initial state), while the model is\n", "shared.\n", "\n", "`diffilqrax.batch` maps the solvers over such a batch. This notebook checks that batched solves equal\n", "one-at-a-time solves and measures wall-clock time on two datasets:\n", "\n", "1. **Zebrafish tail bouts**: the six bouts of the MGU2 fixture, with the model of the\n", " [zebrafish reconstruction](zebrafish_tail_reconstruction.ipynb) notebook;\n", "2. **Simulated tracking**: a tanh RNN tracking references simulated from the system itself with known\n", " inputs, for batch sizes up to 256.\n", "\n", "**Why batching works now.** The solver has three nested loops: the iterations, the regularisation retries and\n", "the line search. They run as `lax.while_loop`s (`loop=\"while\"`, the default), so under `jax.vmap` the batch\n", "stops once its slowest problem has converged. The older fixed-length `lax.scan` + `lax.cond` loops become\n", "`select`s under `vmap`, so every problem paid for all `max_iter` iterations, every retry and every line-search\n", "step. `while_loop` cannot be reverse-differentiated, but it doesn't need to be: `dilqr` and\n", "`batch.batched_dilqr` differentiate the solution implicitly (see\n", "[gradients through iLQR](gradients_through_ilqr.ipynb))." ] }, { "cell_type": "code", "execution_count": 1, "id": "a517330d", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:41:23.129357Z", "iopub.status.busy": "2026-10-20T00:41:23.128485Z", "iopub.status.idle": "2026-10-20T00:41:24.097809Z", "shell.execute_reply": "2026-10-20T00:41:24.098493Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "jax 0.4.38, devices: [CpuDevice(id=0)]\n" ] } ], "source": [ "import sys\n", "import time\n", "from pathlib import Path\n", "\n", "import jax\n", "import jax.numpy as jnp\n", "import matplotlib.pyplot as plt\n", "import numpy as onp\n", "\n", "from diffilqrax import batch\n", "from diffilqrax.diff_ilqr import dilqr\n", "from diffilqrax.ilqr import ilqr_simulate, ilqr_solver\n", "from diffilqrax.typs import ModelDims, System, Theta, iLQRParams\n", "\n", "jax.config.update(\"jax_enable_x64\", True)\n", "\n", "REPO = Path.cwd().parents[2] # docs/source/examples -> repository root; tests/ is not part of the installed package\n", "sys.path.insert(0, str(REPO))\n", "from tests.mgu2_model import load_fixture, make_system, make_theta # the model of the zebrafish notebook\n", "\n", "print(f\"jax {jax.__version__}, devices: {jax.devices()}\")" ] }, { "cell_type": "markdown", "id": "48c2b36d", "metadata": {}, "source": [ "## Timing\n", "\n", "`timeit` compiles the function once (reported separately) and then reports the median wall-clock time of\n", "`n_rep` runs of the compiled function. `jax.block_until_ready` waits for the asynchronous result." ] }, { "cell_type": "code", "execution_count": 2, "id": "b4ac20c9", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:41:24.107014Z", "iopub.status.busy": "2026-10-20T00:41:24.106147Z", "iopub.status.idle": "2026-10-20T00:41:24.108375Z", "shell.execute_reply": "2026-10-20T00:41:24.109196Z" } }, "outputs": [], "source": [ "def timeit(fn, *args, n_rep=3):\n", " t0 = time.perf_counter()\n", " compiled = jax.jit(fn).lower(*args).compile()\n", " t_compile = time.perf_counter() - t0\n", " times = []\n", " for _ in range(n_rep):\n", " t0 = time.perf_counter()\n", " out = jax.block_until_ready(compiled(*args))\n", " times.append(time.perf_counter() - t0)\n", " return out, t_compile, float(onp.median(times))\n", "\n", "\n", "def n_iterations(history):\n", " # once converged the cost history repeats the final cost\n", " h = onp.asarray(history)\n", " return onp.array([int(onp.nonzero(row != row[-1])[0].max(initial=-1)) + 1 for row in h.reshape(-1, h.shape[-1])])\n", "\n", "\n", "COLORS = [\"#2a78d6\", \"#eb6834\", \"#1baf7a\", \"#eda100\"] # validated categorical slots, in fixed order\n", "MARKERS = [\"o\", \"s\", \"^\", \"D\"]" ] }, { "cell_type": "markdown", "id": "a315476c", "metadata": {}, "source": [ "## 1. Zebrafish bouts\n", "\n", "Only `theta.obs` differs between bouts. `in_axes` says so as a pytree prefix: 0 for the batched leaf, None for\n", "the shared ones, as in `jax.vmap`. All bouts start from zero inputs, as in the reconstruction notebook." ] }, { "cell_type": "code", "execution_count": 3, "id": "dc6b3e47", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:41:24.117594Z", "iopub.status.busy": "2026-10-20T00:41:24.116789Z", "iopub.status.idle": "2026-10-20T00:41:24.350292Z", "shell.execute_reply": "2026-10-20T00:41:24.350873Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "6 bouts, T=171, latents n=120, inputs m=10\n" ] } ], "source": [ "ocaml_params, data = load_fixture(REPO / \"tests\" / \"fixtures\" / \"ocaml_mgu.npz\")\n", "N_BEG = 12\n", "all_obs = jnp.asarray(data[\"saved_tail\"]) # (6, 160, 7)\n", "theta = make_theta(ocaml_params, data[\"saved_tail\"][0], N_BEG)\n", "n, m, T = theta.uh.shape[0], theta.B.shape[0], data[\"ilqr_u\"].shape[1]\n", "fish = make_system(n, m, T)\n", "fish_params = iLQRParams(x0=jnp.zeros(n), theta=theta)\n", "fish_axes = (iLQRParams(x0=None, theta=jax.tree.map(lambda _: None, theta)._replace(obs=0)), None)\n", "U0_fish = jnp.zeros((T, m))\n", "KW = dict(max_iter=1000, alpha_init=2.0, kkt_tol=1e-6)\n", "\n", "\n", "def fish_batch(obs):\n", " return fish_params._replace(theta=theta._replace(obs=obs))\n", "\n", "\n", "def solve_one(obs):\n", " return ilqr_solver(fish, fish_batch(obs), U0_fish, **KW)\n", "\n", "\n", "def solve_batch(obs, **kw):\n", " return batch.batched_ilqr_solver(fish, fish_batch(obs), U0_fish, fish_axes, **{**KW, **kw})\n", "\n", "\n", "print(f\"{all_obs.shape[0]} bouts, T={T}, latents n={n}, inputs m={m}\")" ] }, { "cell_type": "markdown", "id": "fadb3785", "metadata": {}, "source": [ "The reference is a Python loop over one compiled single-bout solve. The batched strategies are `lax.map`\n", "(one bout at a time, or `batch_size` bouts vectorised together), `vmap`, and `vmap` with the parallel line\n", "search. The parallel line search rolls out 8 step sizes at once and keeps the largest accepted one, so it\n", "takes the same steps as backtracking." ] }, { "cell_type": "code", "execution_count": 4, "id": "e24c6604", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:41:24.369567Z", "iopub.status.busy": "2026-10-20T00:41:24.368768Z", "iopub.status.idle": "2026-10-20T00:51:26.060995Z", "shell.execute_reply": "2026-10-20T00:51:26.061566Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "strategy compile (s) run (s) max |dU| max rel dJ\n", "python loop 85.8\n", "lax.map 2.8 86.6 1.1e-15 1.8e-16\n", "lax.map, batch_size=3 7.1 85.3 2.0e-15 3.5e-16\n", "vmap 4.3 107.1 4.6e-16 3.5e-16\n", "vmap + parallel line search 5.2 121.2 3.5e-15 1.8e-16\n" ] } ], "source": [ "solve_one_c = jax.jit(solve_one).lower(all_obs[0]).compile()\n", "t0 = time.perf_counter()\n", "loop_out = [jax.block_until_ready(solve_one_c(o)) for o in all_obs]\n", "t_loop = time.perf_counter() - t0\n", "(_, Us_loop, _), J_loop, hist_loop = jax.tree.map(lambda *xs: jnp.stack(xs), *loop_out)\n", "\n", "fish_runs = {\"python loop\": (None, None, t_loop)}\n", "strategies = {\n", " \"lax.map\": dict(strategy=\"map\"),\n", " \"lax.map, batch_size=3\": dict(strategy=\"map\", batch_size=3),\n", " \"vmap\": dict(strategy=\"vmap\"),\n", " \"vmap + parallel line search\": dict(strategy=\"vmap\", linesearch=\"parallel\"),\n", "}\n", "if len(jax.devices()) > 1:\n", " strategies[\"shard\"] = dict(strategy=\"shard\")\n", "for name, kw in strategies.items():\n", " fish_runs[name] = timeit(lambda obs, kw=kw: solve_batch(obs, **kw), all_obs, n_rep=1)\n", "\n", "print(f\"{'strategy':<30}{'compile (s)':>12}{'run (s)':>10}{'max |dU|':>11}{'max rel dJ':>12}\")\n", "for name, (out, t_c, t_r) in fish_runs.items():\n", " if out is None:\n", " print(f\"{name:<30}{'':>12}{t_r:>10.1f}\")\n", " continue\n", " (_, Us, _), J, _ = out\n", " dU = float(jnp.abs(Us - Us_loop).max())\n", " dJ = float(jnp.abs((J - J_loop) / J_loop).max())\n", " print(f\"{name:<30}{t_c:>12.1f}{t_r:>10.1f}{dU:>11.1e}{dJ:>12.1e}\")" ] }, { "cell_type": "markdown", "id": "7d0e8ccb", "metadata": {}, "source": [ "Every batched strategy reaches the per-bout solutions, to round-off. With only six bouts of very different\n", "lengths (see section 3), vectorising gains little on a CPU: `vmap` costs about as much as the loop, because\n", "every bout waits for the slowest one. Its advantage is on many problems (section 2), on GPU, and in training,\n", "where the batch must be solved inside one compiled, differentiable step. Against the OCaml reference the costs agree as in the\n", "reconstruction notebook: bouts with a non-zero difference stopped in another local optimum of the non-convex\n", "objective." ] }, { "cell_type": "code", "execution_count": 6, "id": "f8639710", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:51:26.076172Z", "iopub.status.busy": "2026-10-20T00:51:26.075393Z", "iopub.status.idle": "2026-10-20T00:51:26.152850Z", "shell.execute_reply": "2026-10-20T00:51:26.153441Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "bout cost OCaml rel diff iterations\n", "0 -10188.690 -10215.129 2.6e-03 54\n", "1 -10302.552 -10297.255 5.1e-04 51\n", "2 -10263.757 -10270.089 6.2e-04 77\n", "3 -10544.964 -10545.906 8.9e-05 40\n", "4 -10313.109 -10312.940 1.6e-05 40\n", "5 -10403.917 -10403.917 9.0e-14 53\n" ] } ], "source": [ "rel_ocaml = onp.abs(onp.asarray(J_loop) - data[\"ilqr_cost\"]) / onp.abs(data[\"ilqr_cost\"])\n", "iters_fish = n_iterations(hist_loop)\n", "print(f\"{'bout':<6}{'cost':>12}{'OCaml':>12}{'rel diff':>10}{'iterations':>12}\")\n", "for b in range(all_obs.shape[0]):\n", " print(f\"{b:<6}{float(J_loop[b]):>12.3f}{data['ilqr_cost'][b]:>12.3f}{rel_ocaml[b]:>10.1e}{iters_fish[b]:>12}\")" ] }, { "cell_type": "markdown", "id": "3f131ac3", "metadata": {}, "source": [ "**The cost of the old loops.** With `loop=\"scan\"` the same `vmap` executes every iteration, retry and\n", "line-search step for every bout. At an equal budget of 20 iterations, which no bout reaches convergence in,\n", "both versions do the same number of outer iterations, so the gap is the inner loops alone." ] }, { "cell_type": "code", "execution_count": 7, "id": "c4993df3", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:51:26.589196Z", "iopub.status.busy": "2026-10-20T00:51:26.314342Z", "iopub.status.idle": "2026-10-20T00:57:49.841147Z", "shell.execute_reply": "2026-10-20T00:57:49.841718Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "vmap, 20 iterations: while 35.6 s, scan 327.6 s (9x slower)\n" ] } ], "source": [ "short = dict(strategy=\"vmap\", max_iter=20)\n", "_, _, t_while20 = timeit(lambda obs: solve_batch(obs, **short), all_obs, n_rep=1)\n", "_, _, t_scan20 = timeit(lambda obs: solve_batch(obs, loop=\"scan\", **short), all_obs, n_rep=1)\n", "print(f\"vmap, 20 iterations: while {t_while20:.1f} s, scan {t_scan20:.1f} s ({t_scan20 / t_while20:.0f}x slower)\")" ] }, { "cell_type": "markdown", "id": "3a5189cb", "metadata": {}, "source": [ "## 2. Simulated tracking problems\n", "\n", "A tanh RNN $x_{t+1} = \\tanh(U_h x_t + W_h u_t)$ with $n=8$ latents and $m=3$ inputs tracks references\n", "$\\bar x^{(b)}$ that it generated itself from smooth random inputs $\\bar u^{(b)}$ and random initial states.\n", "The cost is $\\sum_t \\|x_t - \\bar x^{(b)}_t\\|^2 + 10^{-3}\\|u_t\\|^2$. Because the references are reachable,\n", "the solution should recover the true inputs. The references sit in `theta.Q` and the initial states in\n", "`x0`, the batched leaves." ] }, { "cell_type": "code", "execution_count": 8, "id": "7d4ef268", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:57:49.861218Z", "iopub.status.busy": "2026-10-20T00:57:49.860420Z", "iopub.status.idle": "2026-10-20T00:57:53.167604Z", "shell.execute_reply": "2026-10-20T00:57:53.168204Z" } }, "outputs": [], "source": [ "n_r, m_r, T_r = 8, 3, 50\n", "k1, k2, k3, k4, k5 = jax.random.split(jax.random.PRNGKey(0), 5)\n", "rnn_theta = Theta(\n", " Uh=1.2 * jax.random.normal(k1, (n_r, n_r)) / jnp.sqrt(n_r),\n", " Wh=jax.random.normal(k2, (n_r, m_r)) / jnp.sqrt(n_r),\n", " sigma=jnp.zeros(n_r),\n", " Q=jnp.zeros((T_r + 1, n_r)), # replaced by the references\n", ")\n", "rnn_dynamics = lambda t, x, u, th: jnp.tanh(th.Uh @ x + th.Wh @ u)\n", "rnn = System(\n", " lambda t, x, u, th: jnp.sum((x - th.Q[t]) ** 2) + 1e-3 * jnp.sum(u**2),\n", " lambda x, th: jnp.sum((x - th.Q[-1]) ** 2),\n", " rnn_dynamics,\n", " ModelDims(horizon=T_r, n=n_r, m=m_r, dt=0.1),\n", ")\n", "rnn_axes = (iLQRParams(x0=0, theta=Theta(Uh=None, Wh=None, sigma=None, Q=0)), None)\n", "U0_rnn = jnp.zeros((T_r, m_r))\n", "\n", "\n", "def simulate_references(n_batch, key=k3):\n", " ka, kb, kc = jax.random.split(key, 3)\n", " x0s = 0.5 * jax.random.normal(ka, (n_batch, n_r))\n", " t = jnp.arange(T_r)[None, :, None, None]\n", " freqs = jnp.arange(1, 4)[None, None, None, :]\n", " amps = 0.5 * jax.random.normal(kb, (n_batch, 1, m_r, 3)) / freqs\n", " phases = jax.random.uniform(kc, (n_batch, 1, m_r, 3), maxval=2 * jnp.pi)\n", " Us_true = jnp.sum(amps * jnp.sin(2 * jnp.pi * freqs * t / T_r + phases), axis=-1)\n", " refs = jax.vmap(lambda x0, us: ilqr_simulate(rnn, us, iLQRParams(x0, rnn_theta))[0][0])(x0s, Us_true)\n", " return iLQRParams(x0=x0s, theta=rnn_theta._replace(Q=refs)), Us_true\n", "\n", "\n", "rnn_params, Us_true = simulate_references(256)\n", "\n", "\n", "def take(p, B):\n", " # the first B problems of a batch\n", " return iLQRParams(p.x0[:B], p.theta._replace(Q=p.theta.Q[:B]))" ] }, { "cell_type": "markdown", "id": "2cf605dd", "metadata": {}, "source": [ "First a correctness check on 16 problems: the vmapped solve equals the one-at-a-time solves, every problem\n", "converges, and the inputs are recovered." ] }, { "cell_type": "code", "execution_count": 9, "id": "16fb0f5d", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:57:53.186062Z", "iopub.status.busy": "2026-10-20T00:57:53.185276Z", "iopub.status.idle": "2026-10-20T00:58:10.055339Z", "shell.execute_reply": "2026-10-20T00:58:10.055906Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "converged: 16/16, max |U_vmap - U_one| = 1.0e-15\n", "relative input error: median 3.0e-03, max 1.1e-02\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "p16 = take(rnn_params, 16)\n", "(Xs, Us, _), J, hist, conv = batch.batched_ilqr_solver(rnn, p16, U0_rnn, rnn_axes, max_iter=200, return_converged=True)\n", "one = jax.jit(lambda p: ilqr_solver(rnn, p, U0_rnn, max_iter=200))\n", "Us_one = jnp.stack([one(iLQRParams(p16.x0[b], p16.theta._replace(Q=p16.theta.Q[b])))[0][1] for b in range(16)])\n", "rel_u = jnp.linalg.norm(Us - Us_true[:16], axis=(1, 2)) / jnp.linalg.norm(Us_true[:16], axis=(1, 2))\n", "print(f\"converged: {int(conv.sum())}/16, max |U_vmap - U_one| = {float(jnp.abs(Us - Us_one).max()):.1e}\")\n", "print(f\"relative input error: median {float(jnp.median(rel_u)):.1e}, max {float(rel_u.max()):.1e}\")\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 2.8), layout=\"constrained\")\n", "for ax, b in zip(axes, [0, 1]):\n", " for j in range(m_r):\n", " ax.plot(Us_true[b, :, j], c=COLORS[j], lw=2, alpha=0.4)\n", " ax.plot(Us[b, :, j], c=COLORS[j], lw=1, ls=\"--\")\n", " ax.set(title=f\"problem {b}: true (solid) vs recovered (dashed) inputs\", xlabel=\"time step\")\n", " ax.title.set_fontsize(9)\n", "axes[0].set_ylabel(\"$u_t$\");" ] }, { "cell_type": "markdown", "id": "89af2ebc", "metadata": {}, "source": [ "### Scaling with the batch size\n", "\n", "Wall time of a Python loop over one compiled solve, `lax.map` and `vmap`, for batch sizes 1 to 256. The loop\n", "and `lax.map` cost the same per problem at every size. `vmap` amortises the per-iteration overhead of these\n", "small problems over the batch, so its cost per problem falls until the vectorised work dominates." ] }, { "cell_type": "code", "execution_count": 10, "id": "07248c5f", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T00:58:10.073887Z", "iopub.status.busy": "2026-10-20T00:58:10.073071Z", "iopub.status.idle": "2026-10-20T01:00:09.217781Z", "shell.execute_reply": "2026-10-20T01:00:09.218359Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " B python loop lax.map vmap\n", " 1 0.038s 0.035s 0.036s\n", " 4 0.134s 0.140s 0.070s\n", " 16 0.549s 0.573s 0.201s\n", " 64 2.228s 2.255s 0.835s\n", " 256 8.880s 8.705s 3.375s\n" ] } ], "source": [ "sizes = [1, 4, 16, 64, 256]\n", "rnn_kw = dict(max_iter=200)\n", "one_c = jax.jit(lambda p: ilqr_solver(rnn, p, U0_rnn, **rnn_kw))\n", "scaling = {\"python loop\": [], \"lax.map\": [], \"vmap\": []}\n", "rnn_hist = {}\n", "for B in sizes:\n", " pB = take(rnn_params, B)\n", " singles = [iLQRParams(pB.x0[b], pB.theta._replace(Q=pB.theta.Q[b])) for b in range(B)]\n", " jax.block_until_ready(one_c(singles[0])) # compile\n", " t0 = time.perf_counter()\n", " for p in singles:\n", " jax.block_until_ready(one_c(p))\n", " scaling[\"python loop\"].append(time.perf_counter() - t0)\n", " for name, strat in [(\"lax.map\", \"map\"), (\"vmap\", \"vmap\")]:\n", " out, _, t_r = timeit(lambda p, s=strat: batch.batched_ilqr_solver(rnn, p, U0_rnn, rnn_axes, strategy=s, **rnn_kw), pB)\n", " scaling[name].append(t_r)\n", " rnn_hist[B] = out[2]\n", "\n", "print(f\"{'B':>5}\" + \"\".join(f\"{k:>14}\" for k in scaling))\n", "for i, B in enumerate(sizes):\n", " print(f\"{B:>5}\" + \"\".join(f\"{scaling[k][i]:>13.3f}s\" for k in scaling))" ] }, { "cell_type": "code", "execution_count": 11, "id": "510832f2", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T01:00:09.260064Z", "iopub.status.busy": "2026-10-20T01:00:09.259193Z", "iopub.status.idle": "2026-10-20T01:00:10.574643Z", "shell.execute_reply": "2026-10-20T01:00:10.575226Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(1, 2, figsize=(10, 3.4), layout=\"constrained\")\n", "for c, (name, ts) in enumerate(scaling.items()):\n", " ts = onp.asarray(ts)\n", " for ax, y in zip(axes, [ts, ts / onp.asarray(sizes)]):\n", " ax.plot(sizes, y, c=COLORS[c], lw=2, marker=MARKERS[c], ms=8, label=name)\n", "axes[0].set(xscale=\"log\", yscale=\"log\", xlabel=\"batch size B\", ylabel=\"wall time (s)\", title=\"total\")\n", "axes[1].set(xscale=\"log\", yscale=\"log\", xlabel=\"batch size B\", ylabel=\"wall time per problem (s)\", title=\"per problem\")\n", "for ax in axes:\n", " ax.grid(True, which=\"major\", c=\"0.9\", lw=0.6)\n", " ax.spines[[\"top\", \"right\"]].set_visible(False)\n", "axes[0].legend(frameon=False, fontsize=8);" ] }, { "cell_type": "markdown", "id": "162dac5a", "metadata": {}, "source": [ "## 3. Lockstep efficiency\n", "\n", "Under `vmap` the batch runs until its slowest problem has converged, and finished problems wait. The\n", "efficiency is the mean number of iterations over the maximum: the fraction of the vectorised work that was\n", "needed. `lax.map` with `batch_size`, or sharding over devices, limits the waiting to one chunk." ] }, { "cell_type": "code", "execution_count": 12, "id": "12dd342a", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T01:00:10.638573Z", "iopub.status.busy": "2026-10-20T01:00:10.614786Z", "iopub.status.idle": "2026-10-20T01:00:11.103194Z", "shell.execute_reply": "2026-10-20T01:00:11.103761Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "zebrafish (6 bouts) iterations 40-77, efficiency mean/max = 68%\n", "simulated RNN (256 problems) iterations 33-42, efficiency mean/max = 88%\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "iters_rnn = n_iterations(rnn_hist[256])\n", "for name, its in [(\"zebrafish (6 bouts)\", iters_fish), (\"simulated RNN (256 problems)\", iters_rnn)]:\n", " print(f\"{name:<30} iterations {its.min()}-{its.max()}, efficiency mean/max = {its.mean() / its.max():.0%}\")\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 2.8), layout=\"constrained\")\n", "axes[0].bar(onp.arange(len(iters_fish)), iters_fish, color=COLORS[0], width=0.6)\n", "axes[0].axhline(iters_fish.max(), c=\"0.4\", lw=1, ls=\"--\")\n", "axes[0].set(xlabel=\"bout\", ylabel=\"iterations\", title=\"zebrafish: iterations per bout (dashed: batch max)\")\n", "counts = onp.bincount(iters_rnn)\n", "its = onp.nonzero(counts)[0]\n", "axes[1].bar(its, counts[its], color=COLORS[0], width=0.6)\n", "axes[1].axvline(iters_rnn.max(), c=\"0.4\", lw=1, ls=\"--\")\n", "axes[1].set(xlabel=\"iterations\", ylabel=\"problems\", title=\"simulated RNN: iterations per problem\")\n", "for ax in axes:\n", " ax.title.set_fontsize(9)\n", " ax.spines[[\"top\", \"right\"]].set_visible(False)" ] }, { "cell_type": "markdown", "id": "5accb60e", "metadata": {}, "source": [ "## 4. Gradients through a batch\n", "\n", "`batch.batched_dilqr` returns the optimal trajectories with implicit gradients. The batch is solved without\n", "gradients, then each solution gets its gradient from one LQR solve. Reverse mode never enters the while\n", "loops, so `jax.grad` of a loss summed over the batch works with every strategy. Here the gradient wrt the\n", "shared recurrent weights equals the sum of the per-problem `dilqr` gradients." ] }, { "cell_type": "code", "execution_count": 13, "id": "aedf016f", "metadata": { "execution": { "iopub.execute_input": "2026-10-20T01:00:11.113643Z", "iopub.status.busy": "2026-10-20T01:00:11.112789Z", "iopub.status.idle": "2026-10-20T01:00:47.240838Z", "shell.execute_reply": "2026-10-20T01:00:47.240277Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "vmap relative difference to the summed gradients: 8.4e-16\n", "map relative difference to the summed gradients: 1.5e-16\n" ] } ], "source": [ "p4 = take(rnn_params, 4)\n", "\n", "\n", "def batch_loss(Uh, strategy):\n", " p = p4._replace(theta=p4.theta._replace(Uh=Uh))\n", " return jnp.sum(batch.batched_dilqr(rnn, p, U0_rnn, rnn_axes, strategy=strategy, max_iter=200) ** 2)\n", "\n", "\n", "def single_loss(Uh, b):\n", " p = iLQRParams(p4.x0[b], p4.theta._replace(Uh=Uh, Q=p4.theta.Q[b]))\n", " return jnp.sum(dilqr(rnn, p, U0_rnn, max_iter=200) ** 2)\n", "\n", "\n", "g_sum = sum(jax.grad(single_loss)(rnn_theta.Uh, b) for b in range(4))\n", "for strategy in [\"vmap\", \"map\"]:\n", " g = jax.jit(jax.grad(batch_loss), static_argnums=1)(rnn_theta.Uh, strategy)\n", " print(f\"{strategy:<5} relative difference to the summed gradients: {float(jnp.linalg.norm(g - g_sum) / jnp.linalg.norm(g_sum)):.1e}\")" ] }, { "cell_type": "markdown", "id": "711280e4", "metadata": {}, "source": [ "## How to adapt\n", "\n", "- **Choosing a strategy.** On CPU, `lax.map` (`strategy=\"map\"`, optionally with `batch_size`) avoids\n", " vectorised work on finished problems; `vmap` pays off when the problems are small and many, or on GPU, where\n", " the vectorised work is cheap and the sequential loop is not. On several devices `strategy=\"shard\"` splits\n", " the batch with `shard_map`, so each device stops on its own shard. After `jax.distributed.initialize()`,\n", " `jax.devices()` spans every host.\n", "- **Parallel line search.** `linesearch=\"parallel\"` replaces up to `n_parallel` sequential rollouts by one\n", " vectorised rollout. It mostly helps on GPU; on CPU it does extra work.\n", "- **Warm starts.** In training, start each problem from its previous solution. The iteration counts then\n", " shrink and even out, which improves the lockstep efficiency of `vmap`.\n", "- **Convergence.** Implicit gradients assume converged solutions. `return_converged=True` returns a\n", " per-problem flag to check or mask with." ] } ], "metadata": { "kernelspec": { "display_name": "venv (3.11.11)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.11" } }, "nbformat": 4, "nbformat_minor": 5 }