{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60001",
   "metadata": {},
   "source": [
    "# RNN Online Learning\n",
    "\n",
    "**Train a GRU network on the copying task using D-RTRL**\n",
    "\n",
    "This quickstart tutorial demonstrates how to train a Gated Recurrent Unit (GRU) network using online learning with `braintrace`. We will:\n",
    "\n",
    "1. Define the **copying task**, a standard benchmark for testing sequential memory in RNNs.\n",
    "2. Build a GRU model using `braintrace.nn` components.\n",
    "3. Train the model with **D-RTRL** (Diagonal Real-Time Recurrent Learning), an online learning algorithm that computes approximate gradients without storing the full computation graph.\n",
    "4. Compare the online learning approach with standard **Backpropagation Through Time (BPTT)**.\n",
    "\n",
    "Online learning is especially useful when:\n",
    "- Memory is limited and storing the full unrolled computation graph is prohibitive.\n",
    "- You need to update parameters on-the-fly as data arrives.\n",
    "- You want biologically plausible learning rules for recurrent networks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60002",
   "metadata": {},
   "source": [
    "## 1. Setup\n",
    "\n",
    "First, we import the required packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a1b2c3d4e5f60003",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:46.982104Z",
     "iopub.status.busy": "2026-07-27T05:27:46.980600Z",
     "iopub.status.idle": "2026-07-27T05:27:49.244214Z",
     "shell.execute_reply": "2026-07-27T05:27:49.244214Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ.setdefault(\"JAX_PLATFORMS\", \"cpu\")\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import brainstate\n",
    "import braintools\n",
    "import braintrace\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "brainstate.random.seed(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60004",
   "metadata": {},
   "source": [
    "## 2. The Copying Task\n",
    "\n",
    "The copying task is a classic benchmark for evaluating whether an RNN can memorize and recall information over a delay period.\n",
    "\n",
    "**How it works:**\n",
    "\n",
    "1. The model receives a sequence of 10 random digits (values 1-8) encoded as one-hot vectors.\n",
    "2. This is followed by a delay period filled with zeros (the \"wait\" phase).\n",
    "3. A special trigger symbol (value 9) signals the model to reproduce the original 10 digits.\n",
    "\n",
    "```\n",
    "Input:    [3 7 1 5 2 8 4 6 1 3] [0 0 ... 0 0] [9 9 9 9 9 9 9 9 9 9]\n",
    "                 memorize          wait/delay         recall trigger\n",
    "\n",
    "Target:   [3 7 1 5 2 8 4 6 1 3]\n",
    "```\n",
    "\n",
    "The longer the delay (`time_lag`), the harder the task. The model must retain information in its hidden state across the entire delay period."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a1b2c3d4e5f60005",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:49.246229Z",
     "iopub.status.busy": "2026-07-27T05:27:49.246229Z",
     "iopub.status.idle": "2026-07-27T05:27:49.251251Z",
     "shell.execute_reply": "2026-07-27T05:27:49.251251Z"
    }
   },
   "outputs": [],
   "source": [
    "def make_copy_batches(n_epochs=200, time_lag=20, batch_size=32):\n",
    "    \"\"\"Create all fixed-seed copying batches without a Python iterator.\"\"\"\n",
    "    sequence_length = time_lag + 20\n",
    "    digits = brainstate.random.randint(\n",
    "        1, 9, size=(n_epochs, batch_size, 10)\n",
    "    )\n",
    "    symbol_ids = jnp.zeros(\n",
    "        (n_epochs, batch_size, sequence_length), dtype=jnp.int32\n",
    "    )\n",
    "    symbol_ids = symbol_ids.at[..., :10].set(digits)\n",
    "    symbol_ids = symbol_ids.at[..., -10:].set(9)\n",
    "    inputs = jax.nn.one_hot(symbol_ids, 10, dtype=jnp.float32)\n",
    "    inputs = jnp.transpose(inputs, (0, 2, 1, 3))\n",
    "    targets = jnp.transpose(digits, (0, 2, 1))\n",
    "    return inputs, targets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60006",
   "metadata": {},
   "source": [
    "## 3. Model Definition\n",
    "\n",
    "We define a GRU network using `braintrace.nn.GRUCell` for the recurrent layer and `braintrace.nn.Linear` for the output layer. These modules are designed to work with `braintrace`'s online learning algorithms -- they expose the internal structure needed for eligibility trace computation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a1b2c3d4e5f60007",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:49.253612Z",
     "iopub.status.busy": "2026-07-27T05:27:49.253612Z",
     "iopub.status.idle": "2026-07-27T05:27:49.257060Z",
     "shell.execute_reply": "2026-07-27T05:27:49.257060Z"
    }
   },
   "outputs": [],
   "source": [
    "class GRUNet(brainstate.nn.Module):\n",
    "    \"\"\"A multi-layer GRU network with a linear readout.\n",
    "\n",
    "    Args:\n",
    "        n_in: Input feature dimension.\n",
    "        n_rec: Hidden state dimension.\n",
    "        n_out: Output dimension.\n",
    "        n_layer: Number of stacked GRU layers.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, n_in, n_rec, n_out, n_layer=1):\n",
    "        super().__init__()\n",
    "        layers = []\n",
    "        for _ in range(n_layer):\n",
    "            layers.append(braintrace.nn.GRUCell(n_in, n_rec))\n",
    "            n_in = n_rec\n",
    "        self.rnn = brainstate.nn.Sequential(*layers)\n",
    "        self.readout = braintrace.nn.Linear(n_rec, n_out)\n",
    "\n",
    "    def update(self, x):\n",
    "        return self.readout(self.rnn(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60008",
   "metadata": {},
   "source": [
    "## 4. Online Training with D-RTRL\n",
    "\n",
    "D-RTRL (Diagonal Real-Time Recurrent Learning) is an online learning algorithm\n",
    "provided by `braintrace`. Unlike BPTT, which requires storing the entire\n",
    "computation graph across all time steps, D-RTRL computes approximate gradients\n",
    "incrementally using **eligibility traces**. It is not generally\n",
    "gradient-equivalent to BPTT outside the assumptions of its diagonal Jacobian\n",
    "approximation.\n",
    "\n",
    "The key steps in the online training loop are:\n",
    "\n",
    "1. **Map once**: Create `brainstate.nn.Map(model, init_map_size=B)` and call\n",
    "   `mapped_model.init_all_states()`.\n",
    "2. **Compile directly**: Construct `braintrace.D_RTRL(mapped_model)` and compile\n",
    "   from one complete batched time step.\n",
    "3. **Warm up**: Use `learner.etrace_evolve(...)` to advance hidden states and\n",
    "   eligibility traces without computing a loss gradient.\n",
    "4. **Learn**: Use `learner.etrace_grad(..., step_fn=step_loss)` to accumulate\n",
    "   online gradients, then update the parameters.\n",
    "\n",
    "An already mapped model must not be passed to\n",
    "`braintrace.compile(..., vmap=True)`, because that would apply a second mapping\n",
    "layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a1b2c3d4e5f60009",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:49.258618Z",
     "iopub.status.busy": "2026-07-27T05:27:49.258618Z",
     "iopub.status.idle": "2026-07-27T05:27:49.263968Z",
     "shell.execute_reply": "2026-07-27T05:27:49.263968Z"
    }
   },
   "outputs": [],
   "source": [
    "def train_online(input_batches, target_batches, time_lag=20, lr=2e-3):\n",
    "    \"\"\"Train one GRU with D-RTRL over precomputed copying batches.\"\"\"\n",
    "    brainstate.random.seed(21)\n",
    "    model = GRUNet(10, 64, 10)\n",
    "    batch_size = input_batches.shape[2]\n",
    "\n",
    "    mapped_model = brainstate.nn.Map(model, init_map_size=batch_size)\n",
    "    mapped_model.init_all_states()\n",
    "    learner = braintrace.D_RTRL(mapped_model)\n",
    "    learner.compile_graph(input_batches[0])\n",
    "\n",
    "    opt = braintools.optim.Adam(lr)\n",
    "    opt.register_trainable_weights(learner.param_states)\n",
    "\n",
    "    @brainstate.transform.jit\n",
    "    def train_step(inputs, targets):\n",
    "        brainstate.nn.reset_all_states(mapped_model)\n",
    "        learner.reset_state()\n",
    "\n",
    "        # The loss for ONE step. `etrace_grad` owns the loop; this owns the\n",
    "        # model call, so multi-head models and regularizers need no special\n",
    "        # support.\n",
    "        def step_loss(inp, tar):\n",
    "            out = learner(inp)\n",
    "            return braintools.metric.softmax_cross_entropy_with_integer_labels(out, tar).mean()\n",
    "\n",
    "        # Warm-up: drive the model and its eligibility traces forward without\n",
    "        # computing a gradient, so the recall period starts from a settled state.\n",
    "        n_sim = time_lag + 10\n",
    "        learner.etrace_evolve(inputs[:n_sim])\n",
    "\n",
    "        # Learning phase: one call slices the sequence, differentiates each\n",
    "        # step's loss online, and accumulates the per-step gradients.\n",
    "        # `reduction='sum'` keeps the accumulated scale this example's learning\n",
    "        # rate was tuned at.\n",
    "        grads, losses = learner.etrace_grad(\n",
    "            inputs[n_sim:], targets, step_fn=step_loss,\n",
    "            reduction='sum', return_value=True,\n",
    "        )\n",
    "        opt.update(grads)\n",
    "        return losses.mean()\n",
    "\n",
    "    return brainstate.transform.for_loop(\n",
    "        train_step, input_batches, target_batches\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60010",
   "metadata": {},
   "source": [
    "## 5. BPTT Baseline (for Comparison)\n",
    "\n",
    "To appreciate the advantages of online learning, we also implement a standard BPTT trainer. BPTT unrolls the full computation graph across all time steps, computes the loss, and backpropagates through the entire sequence. This requires storing all intermediate activations, resulting in memory usage that scales linearly with sequence length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a1b2c3d4e5f60011",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:49.266996Z",
     "iopub.status.busy": "2026-07-27T05:27:49.266996Z",
     "iopub.status.idle": "2026-07-27T05:27:49.272213Z",
     "shell.execute_reply": "2026-07-27T05:27:49.272213Z"
    }
   },
   "outputs": [],
   "source": [
    "def train_bptt(input_batches, target_batches, time_lag=20, lr=2e-3):\n",
    "    \"\"\"Train a matched GRU with full-sequence BPTT.\"\"\"\n",
    "    brainstate.random.seed(21)\n",
    "    model = GRUNet(10, 64, 10)\n",
    "    opt = braintools.optim.Adam(lr)\n",
    "    weights = model.states().subset(brainstate.ParamState)\n",
    "    opt.register_trainable_weights(weights)\n",
    "\n",
    "    @brainstate.transform.jit\n",
    "    def train_step(inputs, targets):\n",
    "        mapped_model = brainstate.nn.Map(\n",
    "            model, init_map_size=inputs.shape[1]\n",
    "        )\n",
    "        mapped_model.init_all_states()\n",
    "\n",
    "        def run_step(inp, tar):\n",
    "            out = mapped_model(inp)\n",
    "            loss = braintools.metric.softmax_cross_entropy_with_integer_labels(out, tar).mean()\n",
    "            return out, loss\n",
    "\n",
    "        def bptt_forward():\n",
    "            n_sim = time_lag + 10\n",
    "            brainstate.transform.for_loop(mapped_model, inputs[:n_sim])\n",
    "            outs, losses = brainstate.transform.for_loop(run_step, inputs[n_sim:], targets)\n",
    "            return losses.mean(), outs\n",
    "\n",
    "        grads, loss, outs = brainstate.transform.grad(\n",
    "            bptt_forward, weights, has_aux=True, return_value=True\n",
    "        )()\n",
    "        opt.update(grads)\n",
    "        return loss\n",
    "\n",
    "    return brainstate.transform.for_loop(\n",
    "        train_step, input_batches, target_batches\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60012",
   "metadata": {},
   "source": [
    "## 6. Run Training\n",
    "\n",
    "Train the online (D-RTRL) and offline (BPTT) models on the same 200 fixed-seed batches. A 20-step delay preserves the temporal credit-assignment problem while the longer run makes the convergence comparison easier to inspect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a1b2c3d4e5f60013",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:49.274229Z",
     "iopub.status.busy": "2026-07-27T05:27:49.274229Z",
     "iopub.status.idle": "2026-07-27T05:27:54.070741Z",
     "shell.execute_reply": "2026-07-27T05:27:54.070741Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0, Loss: 2.2856\n",
      "Step 100, Loss: 2.0735\n",
      "Step 199, Loss: 2.0434\n"
     ]
    }
   ],
   "source": [
    "brainstate.random.seed(101)\n",
    "copy_inputs, copy_targets = make_copy_batches(\n",
    "    n_epochs=200, time_lag=20, batch_size=32\n",
    ")\n",
    "online_losses = train_online(copy_inputs, copy_targets)\n",
    "print(f\"Step 0, Loss: {float(online_losses[0]):.4f}\")\n",
    "print(f\"Step 100, Loss: {float(online_losses[100]):.4f}\")\n",
    "print(f\"Step 199, Loss: {float(online_losses[-1]):.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a1b2c3d4e5f60014",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:54.072280Z",
     "iopub.status.busy": "2026-07-27T05:27:54.072280Z",
     "iopub.status.idle": "2026-07-27T05:27:55.212903Z",
     "shell.execute_reply": "2026-07-27T05:27:55.212358Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0, Loss: 2.2856\n",
      "Step 100, Loss: 2.0601\n",
      "Step 199, Loss: 2.0104\n"
     ]
    }
   ],
   "source": [
    "bptt_losses = train_bptt(copy_inputs, copy_targets)\n",
    "print(f\"Step 0, Loss: {float(bptt_losses[0]):.4f}\")\n",
    "print(f\"Step 100, Loss: {float(bptt_losses[100]):.4f}\")\n",
    "print(f\"Step 199, Loss: {float(bptt_losses[-1]):.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60015",
   "metadata": {},
   "source": [
    "## 7. Visualization\n",
    "\n",
    "Plot the training loss curves to compare online learning (D-RTRL) with BPTT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a1b2c3d4e5f60016",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-27T05:27:55.215534Z",
     "iopub.status.busy": "2026-07-27T05:27:55.215534Z",
     "iopub.status.idle": "2026-07-27T05:27:55.379695Z",
     "shell.execute_reply": "2026-07-27T05:27:55.379695Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with plt.style.context(\"default\"), plt.rc_context({\n",
    "    \"figure.facecolor\": \"white\",\n",
    "    \"axes.facecolor\": \"white\",\n",
    "    \"savefig.facecolor\": \"white\",\n",
    "}):\n",
    "    fig, ax = plt.subplots(figsize=(8, 4))\n",
    "    ax.plot(online_losses, label=\"D-RTRL (online)\")\n",
    "    ax.plot(bptt_losses, label=\"BPTT (offline)\")\n",
    "    ax.set(xlabel=\"Training step\", ylabel=\"Cross-entropy loss\")\n",
    "    ax.set_title(\"GRU copying task: online and offline learning\")\n",
    "    ax.legend()\n",
    "    ax.grid(True, alpha=0.3)\n",
    "    fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f60017",
   "metadata": {},
   "source": [
    "## 8. Summary\n",
    "\n",
    "In this tutorial, we demonstrated online learning of a GRU on the copying task.\n",
    "\n",
    "**Key takeaways:**\n",
    "\n",
    "- **D-RTRL** provides approximate online gradients with `O(B * theta)`\n",
    "  complexity, where `B` is the batch size and `theta` is the number of\n",
    "  parameters. Unlike BPTT, it does not store the full unrolled graph.\n",
    "- Batched online learning creates one `brainstate.nn.Map`, initializes it, and\n",
    "  passes it directly to `braintrace.D_RTRL` before `compile_graph` is called on\n",
    "  a complete batched time step.\n",
    "- Do not pass an already mapped model to `compile(..., vmap=True)`.\n",
    "- Use `learner.etrace_evolve` for gradient-free prefixes and\n",
    "  `learner.etrace_grad` for sequence objectives.\n",
    "\n",
    "For more details, see:\n",
    "- [Key Concepts](../quickstart/concepts.ipynb) for the theoretical background.\n",
    "- [SNN Online Learning](./snn_online_learning.ipynb) for spiking networks."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}