{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ca4afc8d",
   "metadata": {},
   "source": [
    "# A training loop with `braintools.trainer`\n",
    "\n",
    "`braintools.trainer` wraps the usual training boilerplate around a `brainstate` model: batching, the jit-compiled gradient step, validation, callbacks, checkpoints and metric logging. Its interface follows PyTorch Lightning: the model is a `LightningModule` that defines what one step does, and a `Trainer` runs the loop.\n",
    "\n",
    "```{note}\n",
    "`braintools.trainer` is in **maintenance mode**. It is a lightweight training loop for small and medium models: bugs are fixed, but no new features are planned. For custom training schemes, write the loop directly with `brainstate.transform` and a `braintools.optim` optimizer (see the optimizer tutorials).\n",
    "```\n",
    "\n",
    "This tutorial trains a small classifier on a toy data set and covers:\n",
    "\n",
    "1. **Data**: arrays wrapped in a `DataLoader`.\n",
    "2. **The model**: a `LightningModule` with training, validation, test and prediction steps.\n",
    "3. **Training** with `EarlyStopping`, `ModelCheckpoint` and a `CSVLogger`.\n",
    "4. **The logged curves**, read back from the CSV file.\n",
    "5. **Reloading the best checkpoint** and evaluating it on held-out data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6ad25c6c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:01.443508Z",
     "iopub.status.busy": "2026-10-19T16:26:01.443289Z",
     "iopub.status.idle": "2026-10-19T16:26:06.281060Z",
     "shell.execute_reply": "2026-10-19T16:26:06.280269Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "import tempfile\n",
    "\n",
    "import brainstate\n",
    "import jax.numpy as jnp\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import braintools\n",
    "from braintools import trainer as bt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ef9100",
   "metadata": {},
   "source": [
    "## 1. Data\n",
    "\n",
    "The task is to tell apart two interleaved spirals in the plane. With few training points and noisy coordinates, a flexible network can fit the training set better than it generalizes, which is what early stopping and checkpointing are for.\n",
    "\n",
    "The labels are stored one-hot, so every sample is a pair of small arrays `(x, y)` with shapes `(2,)` and `(2,)`. All randomness below is seeded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "548a86de",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:06.283966Z",
     "iopub.status.busy": "2026-10-19T16:26:06.283413Z",
     "iopub.status.idle": "2026-10-19T16:26:06.444995Z",
     "shell.execute_reply": "2026-10-19T16:26:06.443976Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train / val / test: 150 200 200\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def make_spirals(n_per_class, noise, rng):\n",
    "    # Two interleaved spirals, scaled to about [-1, 1]^2.\n",
    "    t = np.sqrt(rng.uniform(0.05, 1.0, size=(2, n_per_class))) * 3 * np.pi\n",
    "    points, labels = [], []\n",
    "    for c in range(2):\n",
    "        angle = t[c] + c * np.pi\n",
    "        xy = np.stack([t[c] * np.cos(angle), t[c] * np.sin(angle)], axis=1) / (3 * np.pi)\n",
    "        points.append(xy + noise * rng.normal(size=xy.shape))\n",
    "        labels.append(np.full(n_per_class, c))\n",
    "    X = np.concatenate(points).astype(np.float32)\n",
    "    y = np.concatenate(labels)\n",
    "    order = rng.permutation(len(y))\n",
    "    return X[order], y[order]\n",
    "\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "X, labels = make_spirals(275, noise=0.08, rng=rng)\n",
    "Y = np.eye(2, dtype=np.float32)[labels]          # one-hot targets\n",
    "\n",
    "X_train, Y_train = X[:150], Y[:150]\n",
    "X_val, Y_val = X[150:350], Y[150:350]\n",
    "X_test, Y_test = X[350:], Y[350:]\n",
    "print('train / val / test:', len(X_train), len(X_val), len(X_test))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(4, 4))\n",
    "for c, color in enumerate(['tab:blue', 'tab:orange']):\n",
    "    m = Y_train[:, 1] == c\n",
    "    ax.scatter(*X_train[m].T, s=12, color=color, label=f'class {c}')\n",
    "ax.set_aspect('equal'); ax.legend(fontsize=8, loc='upper right'); ax.set_title('training set')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aafa2f5b",
   "metadata": {},
   "source": [
    "`DataLoader` accepts a tuple of arrays directly (it wraps them in an `ArrayDataset`) and yields batches with the same structure, stacked along a new leading axis. `shuffle=True` with a `seed` reshuffles every epoch in a reproducible order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c778c20a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:06.447267Z",
     "iopub.status.busy": "2026-10-19T16:26:06.447056Z",
     "iopub.status.idle": "2026-10-19T16:26:06.533985Z",
     "shell.execute_reply": "2026-10-19T16:26:06.532915Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batches per epoch: 6  batch shapes: (25, 2) (25, 2)\n"
     ]
    }
   ],
   "source": [
    "train_loader = bt.DataLoader((X_train, Y_train), batch_size=25, shuffle=True, seed=0)\n",
    "val_loader = bt.DataLoader((X_val, Y_val), batch_size=200)\n",
    "test_loader = bt.DataLoader((X_test, Y_test), batch_size=200)\n",
    "\n",
    "x_batch, y_batch = next(iter(train_loader))\n",
    "print('batches per epoch:', len(train_loader), ' batch shapes:', x_batch.shape, y_batch.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59bf7fe1",
   "metadata": {},
   "source": [
    "## 2. The model\n",
    "\n",
    "A `LightningModule` is a `brainstate.nn.Module`, so layers are declared as attributes as usual. On top of `__call__` it defines the steps the trainer calls:\n",
    "\n",
    "- `training_step(batch, batch_idx)` returns a dict with the `'loss'` to differentiate. The trainer runs it inside `brainstate.transform.grad` and `jit`, so it must be traceable. `self.log(name, value)` records extra metrics; they are logged at every step.\n",
    "- `validation_step` and `test_step` return a dict of metrics. The trainer averages them over the batches and adds a `val_` or `test_` prefix.\n",
    "- `predict_step` returns anything; `Trainer.predict` collects the results.\n",
    "- `configure_optimizers` returns a `braintools.optim` optimizer. Here it is SGD with momentum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0d0dbbde",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:06.536816Z",
     "iopub.status.busy": "2026-10-19T16:26:06.536556Z",
     "iopub.status.idle": "2026-10-19T16:26:06.543665Z",
     "shell.execute_reply": "2026-10-19T16:26:06.542616Z"
    }
   },
   "outputs": [],
   "source": [
    "class SpiralClassifier(bt.LightningModule):\n",
    "    def __init__(self, hidden=128, lr=0.02):\n",
    "        super().__init__()\n",
    "        self.lr = lr\n",
    "        self.l1 = brainstate.nn.Linear(2, hidden)\n",
    "        self.l2 = brainstate.nn.Linear(hidden, hidden)\n",
    "        self.l3 = brainstate.nn.Linear(hidden, 2)\n",
    "\n",
    "    def __call__(self, x):\n",
    "        h = jnp.tanh(self.l1(x))\n",
    "        h = jnp.tanh(self.l2(h))\n",
    "        return self.l3(h)                      # logits\n",
    "\n",
    "    def _loss_and_acc(self, batch):\n",
    "        x, y = batch\n",
    "        logits = self(x)\n",
    "        loss = braintools.metric.softmax_cross_entropy(logits, y).mean()\n",
    "        acc = jnp.mean(jnp.argmax(logits, -1) == jnp.argmax(y, -1))\n",
    "        return loss, acc\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        loss, acc = self._loss_and_acc(batch)\n",
    "        self.log('loss', loss)\n",
    "        self.log('acc', acc)\n",
    "        return {'loss': loss}\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        loss, acc = self._loss_and_acc(batch)\n",
    "        return {'loss': loss, 'acc': acc}\n",
    "\n",
    "    def test_step(self, batch, batch_idx):\n",
    "        loss, acc = self._loss_and_acc(batch)\n",
    "        return {'loss': loss, 'acc': acc}\n",
    "\n",
    "    def predict_step(self, batch, batch_idx):\n",
    "        x, _ = batch\n",
    "        return jnp.argmax(self(x), axis=-1)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        return braintools.optim.SGD(lr=self.lr, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b907155",
   "metadata": {},
   "source": [
    "## 3. Training with callbacks and a CSV logger\n",
    "\n",
    "Everything the run writes goes to a temporary directory:\n",
    "\n",
    "- `ModelCheckpoint` saves a checkpoint after every validation whose `val_loss` is among the `save_top_k=2` best seen so far (older ones are deleted), and `last.ckpt` at the end of the run. The file name template can use `{epoch}` and any metric.\n",
    "- `EarlyStopping` stops the run once `val_loss` has not improved by more than `min_delta` for `patience` epochs.\n",
    "- `CSVLogger` writes every logged metric to `<save_dir>/<name>/<version>/metrics.csv`, and the trainer's hyperparameters to `hparams.yaml`.\n",
    "\n",
    "`enable_progress_bar=False` keeps the output short. Checkpoints are saved only by a `ModelCheckpoint` callback; `enable_checkpointing` is kept for compatibility and has no effect. `default_root_dir` points the trainer's own files at the temporary directory too (by default it is the current working directory)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "526417e5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:06.545949Z",
     "iopub.status.busy": "2026-10-19T16:26:06.545758Z",
     "iopub.status.idle": "2026-10-19T16:26:26.734513Z",
     "shell.execute_reply": "2026-10-19T16:26:26.733120Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stopped after epoch 319 (1920 steps)\n",
      "final metrics: {'train_loss': 0.0494, 'train_acc': 0.98, 'val_loss': 0.2511, 'val_acc': 0.915}\n"
     ]
    }
   ],
   "source": [
    "run_dir = tempfile.mkdtemp(prefix='braintools_trainer_')\n",
    "\n",
    "checkpoint = bt.ModelCheckpoint(\n",
    "    dirpath=os.path.join(run_dir, 'checkpoints'),\n",
    "    filename='epoch{epoch:03d}-val{val_loss:.4f}',\n",
    "    monitor='val_loss', mode='min', save_top_k=2,\n",
    ")\n",
    "early_stopping = bt.EarlyStopping(monitor='val_loss', mode='min', patience=30, min_delta=1e-4)\n",
    "logger = bt.CSVLogger(run_dir, name='spirals', version='run0')\n",
    "\n",
    "brainstate.random.seed(0)\n",
    "model = SpiralClassifier()\n",
    "trainer = bt.Trainer(\n",
    "    max_epochs=400,\n",
    "    callbacks=[checkpoint, early_stopping],\n",
    "    logger=logger,\n",
    "    enable_progress_bar=False,\n",
    "    enable_checkpointing=False,\n",
    "    default_root_dir=run_dir,\n",
    "    seed=0,\n",
    ")\n",
    "trainer.fit(model, train_loader, val_loader)\n",
    "\n",
    "print('stopped after epoch', trainer.current_epoch, f'({trainer.global_step} steps)')\n",
    "print('final metrics:', {k: round(v, 4) for k, v in trainer.callback_metrics.items()})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c0956ae",
   "metadata": {},
   "source": [
    "`trainer.callback_metrics` holds the latest epoch averages. The callbacks keep their own state: the early-stopping epoch, and the best checkpoint with its score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88c14133",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:26.738575Z",
     "iopub.status.busy": "2026-10-19T16:26:26.737981Z",
     "iopub.status.idle": "2026-10-19T16:26:26.744702Z",
     "shell.execute_reply": "2026-10-19T16:26:26.743704Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "early stopping fired at epoch: 319\n",
      "best val_loss: 0.2189\n",
      "best checkpoint: epoch289-val0.2189.ckpt\n",
      "checkpoint dir: ['epoch280-val0.2226.ckpt', 'epoch289-val0.2189.ckpt', 'last.ckpt']\n",
      "log dir: ['hparams.yaml', 'metrics.csv']\n"
     ]
    }
   ],
   "source": [
    "print('early stopping fired at epoch:', early_stopping.stopped_epoch)\n",
    "print('best val_loss:', round(float(checkpoint.best_score), 4))\n",
    "print('best checkpoint:', os.path.basename(checkpoint.best_model_path))\n",
    "print('checkpoint dir:', sorted(os.listdir(checkpoint.dirpath)))\n",
    "print('log dir:', sorted(os.listdir(logger.log_dir)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "997662ca",
   "metadata": {},
   "source": [
    "## 4. The logged curves\n",
    "\n",
    "`metrics.csv` has one row per training step (columns `loss` and `acc`) and one row per validation run (columns `val_loss` and `val_acc`), indexed by the global step. Each validation row is written at the step count reached at the end of its epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9890660e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:26.748370Z",
     "iopub.status.busy": "2026-10-19T16:26:26.748031Z",
     "iopub.status.idle": "2026-10-19T16:26:26.780377Z",
     "shell.execute_reply": "2026-10-19T16:26:26.778926Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2240, 5)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>step</th>\n",
       "      <th>loss</th>\n",
       "      <th>acc</th>\n",
       "      <th>val_loss</th>\n",
       "      <th>val_acc</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0.603733</td>\n",
       "      <td>0.68</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0.628377</td>\n",
       "      <td>0.60</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>0.651708</td>\n",
       "      <td>0.60</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>0.628534</td>\n",
       "      <td>0.56</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>0.721221</td>\n",
       "      <td>0.56</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>0.670406</td>\n",
       "      <td>0.64</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.640779</td>\n",
       "      <td>0.645</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>6</td>\n",
       "      <td>0.603613</td>\n",
       "      <td>0.64</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>7</td>\n",
       "      <td>0.668528</td>\n",
       "      <td>0.60</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>8</td>\n",
       "      <td>0.597569</td>\n",
       "      <td>0.60</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   step      loss   acc  val_loss  val_acc\n",
       "0     0  0.603733  0.68       NaN      NaN\n",
       "1     1  0.628377  0.60       NaN      NaN\n",
       "2     2  0.651708  0.60       NaN      NaN\n",
       "3     3  0.628534  0.56       NaN      NaN\n",
       "4     4  0.721221  0.56       NaN      NaN\n",
       "5     5  0.670406  0.64       NaN      NaN\n",
       "6     6       NaN   NaN  0.640779    0.645\n",
       "7     6  0.603613  0.64       NaN      NaN\n",
       "8     7  0.668528  0.60       NaN      NaN\n",
       "9     8  0.597569  0.60       NaN      NaN"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(logger.metrics_file_path)\n",
    "print(df.shape)\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8a765013",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:26.784692Z",
     "iopub.status.busy": "2026-10-19T16:26:26.784258Z",
     "iopub.status.idle": "2026-10-19T16:26:27.640951Z",
     "shell.execute_reply": "2026-10-19T16:26:27.639687Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best epoch from the CSV: 289\n",
      "train / val loss at the end: 0.0494 / 0.2511\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x340 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_batches = len(train_loader)\n",
    "train_rows = df.dropna(subset=['loss'])\n",
    "val_rows = df.dropna(subset=['val_loss'])\n",
    "\n",
    "# Average the per-step training metrics over each epoch.\n",
    "train_epoch = train_rows.groupby(train_rows['step'] // n_batches)[['loss', 'acc']].mean()\n",
    "val_epoch = val_rows['step'].to_numpy() // n_batches - 1\n",
    "best_epoch = int(val_epoch[np.argmin(val_rows['val_loss'].to_numpy())])\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(10, 3.4))\n",
    "axes[0].plot(train_rows['step'] / n_batches, train_rows['loss'], color='0.8', lw=0.6, label='train (per step)')\n",
    "axes[0].plot(train_epoch.index, train_epoch['loss'], label='train (epoch mean)')\n",
    "axes[0].plot(val_epoch, val_rows['val_loss'], label='validation')\n",
    "axes[0].set_yscale('log'); axes[0].set_ylabel('cross-entropy')\n",
    "axes[1].plot(train_epoch.index, train_epoch['acc'], label='train (epoch mean)')\n",
    "axes[1].plot(val_epoch, val_rows['val_acc'], label='validation')\n",
    "axes[1].set_ylabel('accuracy'); axes[1].set_ylim(0.4, 1.02)\n",
    "for ax in axes:\n",
    "    ax.axvline(best_epoch, color='k', ls='--', lw=0.8, label=f'best epoch ({best_epoch})')\n",
    "    ax.set_xlabel('epoch'); ax.legend(fontsize=8)\n",
    "plt.tight_layout()\n",
    "\n",
    "print('best epoch from the CSV:', best_epoch)\n",
    "print('train / val loss at the end: %.4f / %.4f' % (train_epoch['loss'].iloc[-1], val_rows['val_loss'].iloc[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa5bd224",
   "metadata": {},
   "source": [
    "The training loss keeps falling (to 0.049 over the last epoch), while the validation loss levels off well above it from roughly epoch 200 on: with only 150 training points, the network starts fitting their noise. The lowest validation loss, 0.2189, came at epoch 289. No improvement larger than `min_delta` followed in the next 30 epochs (`patience=30`), so early stopping ended the run at epoch 319. Single steps are noisy (SGD with momentum on batches of 25 points), which is why the epoch means are drawn on top."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "811ffb8a",
   "metadata": {},
   "source": [
    "## 5. Reloading the best checkpoint\n",
    "\n",
    "A checkpoint is a msgpack file holding the parameter values (`model_state_dict`), the optimizer state, the epoch, the metrics at save time and the callback states. `load_checkpoint` reads it as a dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cbc66f19",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:27.643628Z",
     "iopub.status.busy": "2026-10-19T16:26:27.643331Z",
     "iopub.status.idle": "2026-10-19T16:26:27.727478Z",
     "shell.execute_reply": "2026-10-19T16:26:27.726385Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['callbacks', 'epoch', 'global_step', 'metrics', 'model_state_dict', 'optimizer_state_dict']\n",
      "epoch: 289  metrics: {'val_acc': 0.935, 'val_loss': 0.2189}\n",
      "parameters: [\"('l1', 'weight')\", \"('l2', 'weight')\", \"('l3', 'weight')\"]\n"
     ]
    }
   ],
   "source": [
    "ckpt = bt.load_checkpoint(checkpoint.best_model_path)\n",
    "print(sorted(ckpt))\n",
    "print('epoch:', ckpt['epoch'], ' metrics:', {k: round(float(v), 4) for k, v in ckpt['metrics'].items()})\n",
    "print('parameters:', sorted(ckpt['model_state_dict']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d577e25",
   "metadata": {},
   "source": [
    "To evaluate the best weights, build a fresh model with the same architecture and pass the checkpoint to `Trainer.test(..., ckpt_path=...)`, which loads it before running `test_step` on every batch. A separate `Trainer` with logging off is used for evaluation, so the training run's logs stay as they are. For comparison, the training trainer still holds the model as it was at the end of training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "250ef2a7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:27.734729Z",
     "iopub.status.busy": "2026-10-19T16:26:27.734376Z",
     "iopub.status.idle": "2026-10-19T16:26:27.884768Z",
     "shell.execute_reply": "2026-10-19T16:26:27.882383Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final weights: test_loss = 0.1624, test_acc = 0.960\n",
      "best weights:  test_loss = 0.1390, test_acc = 0.965\n"
     ]
    }
   ],
   "source": [
    "final_metrics = trainer.test(dataloaders=test_loader, verbose=False)\n",
    "\n",
    "evaluator = bt.Trainer(logger=False, enable_progress_bar=False, enable_checkpointing=False,\n",
    "                       default_root_dir=run_dir)\n",
    "best_model = SpiralClassifier()\n",
    "best_metrics = evaluator.test(best_model, test_loader, ckpt_path=checkpoint.best_model_path, verbose=False)\n",
    "\n",
    "print('final weights: test_loss = %.4f, test_acc = %.3f' % (final_metrics['test_loss'], final_metrics['test_acc']))\n",
    "print('best weights:  test_loss = %.4f, test_acc = %.3f' % (best_metrics['test_loss'], best_metrics['test_acc']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7024c69",
   "metadata": {},
   "source": [
    "On the 200 held-out test points, the best checkpoint does a little better than the final weights: a test loss of 0.139 against 0.162, and an accuracy of 0.965 against 0.960. The gap is small because the validation loss rose only slightly after its minimum, but the checkpoint was chosen on validation data alone, without looking at the test set.\n",
    "\n",
    "`Trainer.predict` returns the output of `predict_step` for every batch. Below, both models classify a grid of points (a single batched call per model) and the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1af523e5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:27.888079Z",
     "iopub.status.busy": "2026-10-19T16:26:27.887742Z",
     "iopub.status.idle": "2026-10-19T16:26:28.592865Z",
     "shell.execute_reply": "2026-10-19T16:26:28.591791Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x420 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid = np.linspace(-1.3, 1.3, 200, dtype=np.float32)\n",
    "gx, gy = np.meshgrid(grid, grid)\n",
    "grid_points = np.stack([gx.ravel(), gy.ravel()], axis=1)\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(9, 4.2))\n",
    "for ax, (title, m, metrics) in zip(axes, [('final weights', model, final_metrics),\n",
    "                                          ('best checkpoint', best_model, best_metrics)]):\n",
    "    pred_test = np.concatenate(evaluator.predict(m, test_loader))\n",
    "    region = np.asarray(jnp.argmax(m(grid_points), axis=-1)).reshape(gx.shape)\n",
    "    ax.contourf(gx, gy, region, levels=[-0.5, 0.5, 1.5], colors=['#c6dbef', '#fdd0a2'])\n",
    "    wrong = pred_test != Y_test.argmax(1)\n",
    "    ax.scatter(*X_test[~wrong].T, s=8, c=np.where(Y_test[~wrong, 1] == 1, 'tab:orange', 'tab:blue'))\n",
    "    ax.scatter(*X_test[wrong].T, s=40, facecolors='none', edgecolors='k', label=f'{wrong.sum()} errors')\n",
    "    ax.set_title(f\"{title}: test acc {metrics['test_acc']:.3f}\")\n",
    "    ax.set_aspect('equal'); ax.legend(loc='upper right', fontsize=8)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73f88991",
   "metadata": {},
   "source": [
    "Finally, remove the run directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "98308b84",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:26:28.596303Z",
     "iopub.status.busy": "2026-10-19T16:26:28.595943Z",
     "iopub.status.idle": "2026-10-19T16:26:28.622606Z",
     "shell.execute_reply": "2026-10-19T16:26:28.621339Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "shutil.rmtree(run_dir)\n",
    "print(os.path.exists(run_dir))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af34e516",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "- A `LightningModule` defines `training_step` (traced under `jit` and `grad`, logs with `self.log`), `validation_step` / `test_step` (return metric dicts that the trainer averages and prefixes) and `configure_optimizers`.\n",
    "- `DataLoader` batches plain arrays; give it a `seed` when shuffling.\n",
    "- `ModelCheckpoint` keeps the `save_top_k` best checkpoints by a monitored metric plus `last.ckpt`; `EarlyStopping` ends the run when that metric stalls; `CSVLogger` writes a `metrics.csv` that pandas reads directly.\n",
    "- `Trainer.test(model, loader, ckpt_path=...)` (and `validate` / `predict`) evaluates a fresh model from a saved checkpoint.\n",
    "\n",
    "For anything beyond this loop (custom update rules, online learning, multi-optimizer schemes) drive the model directly with `brainstate.transform` and the `braintools.optim` optimizers; see the {doc}`optimization tutorials <../optim/index>`."
   ]
  }
 ],
 "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.13.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
