{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a1b2c3d4e5f6",
   "metadata": {},
   "source": [
    "# Lifted Transforms and High-Level Optimizers\n",
    "\n",
    "In the previous tutorial, we learned about the functional API with explicit state management using graph operations. While powerful, that approach requires manual state handling. This tutorial introduces **lifted transforms** - a higher-level API that automatically manages states while preserving JAX's functional programming benefits.\n",
    "\n",
    "## Learning Objectives\n",
    "\n",
    "By the end of this tutorial, you will:\n",
    "- Understand the difference between functional API and lifted transforms\n",
    "- Use BrainTools optimizers for automatic state management\n",
    "- Leverage `brainstate.transform` for state-aware JAX transformations\n",
    "- Build cleaner training loops with less boilerplate code\n",
    "- Apply the lifted API to the same polynomial regression problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2c3d4e5f6a7",
   "metadata": {},
   "source": [
    "## Setup and Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c3d4e5f6a7b8",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:54.218943Z",
     "start_time": "2025-10-11T10:13:54.214808Z"
    }
   },
   "outputs": [],
   "source": [
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import brainstate\n",
    "import braintools\n",
    "\n",
    "# Set random seed for reproducibility\n",
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4e5f6a7b8c9",
   "metadata": {},
   "source": [
    "## The Same Problem: Polynomial Regression\n",
    "\n",
    "We'll use the same dataset as the previous tutorial to highlight the differences in approach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e5f6a7b8c9d0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:54.303888Z",
     "start_time": "2025-10-11T10:13:54.218943Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate synthetic data: y = 0.8 * x^2 + 0.1 + noise\n",
    "X = np.linspace(0, 1, 100)[:, None]\n",
    "Y = 0.8 * X ** 2 + 0.1 + np.random.normal(0, 0.1, size=X.shape)\n",
    "\n",
    "def dataset(batch_size):\n",
    "    \"\"\"Generator that yields random batches from the dataset.\"\"\"\n",
    "    while True:\n",
    "        idx = np.random.choice(len(X), size=batch_size)\n",
    "        yield X[idx], Y[idx]\n",
    "\n",
    "# Visualize the data\n",
    "plt.figure(figsize=(8, 5))\n",
    "plt.scatter(X, Y, alpha=0.5, label='Data')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.title('Synthetic Dataset for Polynomial Regression')\n",
    "plt.legend()\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6a7b8c9d0e1",
   "metadata": {},
   "source": [
    "## Building the Model with Lifted Transforms\n",
    "\n",
    "### Step 1: Define the Model Components\n",
    "\n",
    "The model definition is similar, but we'll use it differently:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a7b8c9d0e1f2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:54.313850Z",
     "start_time": "2025-10-11T10:13:54.308705Z"
    }
   },
   "outputs": [],
   "source": [
    "class Linear(brainstate.nn.Module):\n",
    "    \"\"\"A simple linear layer: y = x @ w + b\"\"\"\n",
    "    \n",
    "    def __init__(self, din: int, dout: int):\n",
    "        super().__init__()\n",
    "        self.w = brainstate.ParamState(brainstate.random.rand(din, dout))\n",
    "        self.b = brainstate.ParamState(jnp.zeros((dout,)))\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        return x @ self.w.value + self.b.value\n",
    "\n",
    "\n",
    "class Count(brainstate.State):\n",
    "    \"\"\"Custom state type for tracking function calls.\"\"\"\n",
    "    pass\n",
    "\n",
    "\n",
    "class MLP(brainstate.nn.Module):\n",
    "    \"\"\"Multi-layer perceptron with call counting.\n",
    "    \n",
    "    Note: Now inherits from nn.Module instead of graph.Node.\n",
    "    This enables automatic state management.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, din, dhidden, dout):\n",
    "        super().__init__()  # Important: call parent __init__\n",
    "        \n",
    "        self.count = Count(jnp.array(0))\n",
    "        self.linear1 = Linear(din, dhidden)\n",
    "        self.linear2 = Linear(dhidden, dout)\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        self.count.value += 1\n",
    "        x = self.linear1(x)\n",
    "        x = jax.nn.relu(x)\n",
    "        x = self.linear2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8c9d0e1f2a3",
   "metadata": {},
   "source": [
    "### Step 2: Create Model and Optimizer\n",
    "\n",
    "Now we create the model and use a **BrainTools optimizer** that automatically manages parameter states:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c9d0e1f2a3b4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:54.338249Z",
     "start_time": "2025-10-11T10:13:54.329864Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model created:\n",
      "MLP(\n",
      "  count=Count(\n",
      "    value=ShapedArray(int32[], weak_type=True)\n",
      "  ),\n",
      "  linear1=Linear(\n",
      "    w=ParamState(\n",
      "      value=ShapedArray(float32[1,32])\n",
      "    ),\n",
      "    b=ParamState(\n",
      "      value=ShapedArray(float32[32])\n",
      "    )\n",
      "  ),\n",
      "  linear2=Linear(\n",
      "    w=ParamState(\n",
      "      value=ShapedArray(float32[32,1])\n",
      "    ),\n",
      "    b=ParamState(\n",
      "      value=ShapedArray(float32[1])\n",
      "    )\n",
      "  )\n",
      ")\n",
      "\n",
      "Optimizer registered with parameters:\n",
      "{('linear1', 'b'): (), ('linear1', 'w'): (), ('linear2', 'b'): (), ('linear2', 'w'): ()}\n"
     ]
    }
   ],
   "source": [
    "# Create the model\n",
    "model = MLP(din=1, dhidden=32, dout=1)\n",
    "\n",
    "# Create optimizer and register trainable weights\n",
    "optimizer = braintools.optim.SGD(lr=1e-3)\n",
    "optimizer.register_trainable_weights(model.states(brainstate.ParamState))\n",
    "\n",
    "print(\"Model created:\")\n",
    "print(model)\n",
    "print(\"\\nOptimizer registered with parameters:\")\n",
    "print(jax.tree.map(jnp.shape, optimizer.param_states.to_pytree()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0e1f2a3b4c5",
   "metadata": {},
   "source": [
    "**Key Differences from Functional API:**\n",
    "\n",
    "1. **No Manual State Splitting**: We don't need to call `treefy_split` - the model and optimizer manage states internally\n",
    "2. **Optimizer Handles Parameters**: The optimizer automatically tracks and updates parameters\n",
    "3. **Simpler Code**: Less boilerplate, more readable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1f2a3b4c5d6",
   "metadata": {},
   "source": [
    "## Training with Lifted Transforms\n",
    "\n",
    "### Understanding Lifted Transforms\n",
    "\n",
    "**Lifted transforms** automatically handle state management:\n",
    "- `brainstate.transform.jit`: JIT compilation with automatic state threading\n",
    "- `brainstate.transform.grad`: Gradients with automatic state differentiation\n",
    "- States are implicitly updated during function execution\n",
    "\n",
    "### Step 1: Define Training Step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f2a3b4c5d6e7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:54.359128Z",
     "start_time": "2025-10-11T10:13:54.352130Z"
    }
   },
   "outputs": [],
   "source": [
    "@brainstate.transform.jit\n",
    "def train_step(batch):\n",
    "    \"\"\"Perform one training step.\n",
    "    \n",
    "    Notice how much simpler this is compared to the functional API!\n",
    "    No need to pass/return states explicitly.\n",
    "    \"\"\"\n",
    "    x, y = batch\n",
    "    \n",
    "    def loss_fn():\n",
    "        # Simply call the model - states are managed automatically\n",
    "        return jnp.mean((y - model(x)) ** 2)\n",
    "    \n",
    "    # Compute gradients\n",
    "    # The grad transform knows which states to differentiate\n",
    "    grads = brainstate.transform.grad(\n",
    "        loss_fn, \n",
    "        optimizer.param_states.to_pytree()\n",
    "    )()\n",
    "    \n",
    "    # Update parameters using the optimizer\n",
    "    optimizer.update(grads)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3b4c5d6e7f8",
   "metadata": {},
   "source": [
    "**Compare with Functional API:**\n",
    "\n",
    "Functional API (previous tutorial):\n",
    "```python\n",
    "def train_step(params, counts, batch):\n",
    "    x, y = batch\n",
    "    def loss_fn(params):\n",
    "        model = brainstate.graph.treefy_merge(graphdef, params, counts)\n",
    "        y_pred = model(x)\n",
    "        new_counts = brainstate.graph.treefy_states(model, Count)\n",
    "        loss = jnp.mean((y - y_pred) ** 2)\n",
    "        return loss, new_counts\n",
    "    grad, counts = jax.grad(loss_fn, has_aux=True)(params)\n",
    "    params = jax.tree.map(lambda w, g: w - 0.1 * g, params, grad)\n",
    "    return params, counts\n",
    "```\n",
    "\n",
    "Lifted API (this tutorial):\n",
    "```python\n",
    "def train_step(batch):\n",
    "    x, y = batch\n",
    "    def loss_fn():\n",
    "        return jnp.mean((y - model(x)) ** 2)\n",
    "    grads = brainstate.transform.grad(loss_fn, optimizer.param_states.to_pytree())()\n",
    "    optimizer.update(grads)\n",
    "```\n",
    "\n",
    "**Much cleaner!**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4c5d6e7f8a9",
   "metadata": {},
   "source": [
    "### Step 2: Define Evaluation Step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c5d6e7f8a9b0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:54.373538Z",
     "start_time": "2025-10-11T10:13:54.369136Z"
    }
   },
   "outputs": [],
   "source": [
    "@brainstate.transform.jit\n",
    "def eval_step(batch):\n",
    "    \"\"\"Evaluate the model on a batch.\"\"\"\n",
    "    x, y = batch\n",
    "    y_pred = model(x)\n",
    "    loss = jnp.mean((y - y_pred) ** 2)\n",
    "    return {'loss': loss}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6e7f8a9b0c1",
   "metadata": {},
   "source": [
    "### Step 3: Run Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e7f8a9b0c1d2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:55.612940Z",
     "start_time": "2025-10-11T10:13:54.378781Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training the model...\n",
      "\n",
      "Step:     0, Loss: 17.077118\n",
      "Step:  1000, Loss: 0.050319\n",
      "Step:  2000, Loss: 0.018055\n",
      "Step:  3000, Loss: 0.010365\n",
      "Step:  4000, Loss: 0.008487\n",
      "Step:  5000, Loss: 0.007985\n",
      "Step:  6000, Loss: 0.007841\n",
      "Step:  7000, Loss: 0.007793\n",
      "Step:  8000, Loss: 0.007769\n",
      "Step:  9000, Loss: 0.007754\n",
      "\n",
      "Training complete!\n"
     ]
    }
   ],
   "source": [
    "# Training parameters\n",
    "total_steps = 10_000\n",
    "\n",
    "# Training loop - notice how clean this is!\n",
    "print(\"Training the model...\\n\")\n",
    "for step, batch in enumerate(dataset(32)):\n",
    "    # Simply call train_step - no state management needed!\n",
    "    train_step(batch)\n",
    "    \n",
    "    # Log progress every 1000 steps\n",
    "    if step % 1000 == 0:\n",
    "        logs = eval_step((X, Y))\n",
    "        print(f\"Step: {step:5d}, Loss: {logs['loss']:.6f}\")\n",
    "    \n",
    "    # Stop after total_steps\n",
    "    if step >= total_steps - 1:\n",
    "        break\n",
    "\n",
    "print(\"\\nTraining complete!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8a9b0c1d2e3",
   "metadata": {},
   "source": [
    "**Compare Training Loops:**\n",
    "\n",
    "Functional API:\n",
    "```python\n",
    "for step, batch in enumerate(dataset(32)):\n",
    "    params_, counts_ = train_step(params_, counts_, batch)  # Manual state threading\n",
    "    if step % 1000 == 0:\n",
    "        logs = eval_step(params_, counts_, (X, Y))  # Pass states explicitly\n",
    "```\n",
    "\n",
    "Lifted API:\n",
    "```python\n",
    "for step, batch in enumerate(dataset(32)):\n",
    "    train_step(batch)  # States handled automatically\n",
    "    if step % 1000 == 0:\n",
    "        logs = eval_step((X, Y))  # No state arguments needed\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9b0c1d2e3f4",
   "metadata": {},
   "source": [
    "## Analyzing Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b0c1d2e3f4a5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:55.651923Z",
     "start_time": "2025-10-11T10:13:55.647132Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total model calls during training: 10010\n",
      "Final predictions shape: (100, 1)\n"
     ]
    }
   ],
   "source": [
    "# The model already contains the trained parameters!\n",
    "# No need to merge states like in functional API\n",
    "\n",
    "print(f\"Total model calls during training: {model.count.value}\")\n",
    "\n",
    "# Make predictions\n",
    "y_pred = model(X)\n",
    "\n",
    "print(f\"Final predictions shape: {y_pred.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1d2e3f4a5b6",
   "metadata": {},
   "source": [
    "### Visualize Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d2e3f4a5b6c7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:55.779281Z",
     "start_time": "2025-10-11T10:13:55.667930Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "\n",
    "# Plot data points\n",
    "plt.scatter(X, Y, color='blue', alpha=0.5, label='Training Data', s=30)\n",
    "\n",
    "# Plot predictions\n",
    "plt.plot(X, y_pred, color='red', linewidth=2, label='Model Prediction')\n",
    "\n",
    "# Plot true function\n",
    "X_true = np.linspace(0, 1, 100)[:, None]\n",
    "Y_true = 0.8 * X_true ** 2 + 0.1\n",
    "plt.plot(X_true, Y_true, color='green', linewidth=2, \n",
    "         linestyle='--', label='True Function', alpha=0.7)\n",
    "\n",
    "plt.xlabel('X', fontsize=12)\n",
    "plt.ylabel('Y', fontsize=12)\n",
    "plt.title('Polynomial Regression with Lifted Transforms', fontsize=14, fontweight='bold')\n",
    "plt.legend(fontsize=10)\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f4a5b6c7d8",
   "metadata": {},
   "source": [
    "## Advanced: Using Different Optimizers\n",
    "\n",
    "BrainTools provides many optimizers. Let's try Adam optimizer with learning rate scheduling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f4a5b6c7d8e9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:55.825805Z",
     "start_time": "2025-10-11T10:13:55.787288Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adam optimizer created with learning rate scheduling!\n"
     ]
    }
   ],
   "source": [
    "# Create a new model\n",
    "brainstate.random.seed(0)\n",
    "model_adam = MLP(din=1, dhidden=32, dout=1)\n",
    "\n",
    "# Create Adam optimizer with exponential decay learning rate\n",
    "lr_schedule = braintools.optim.ExponentialDecayLR(\n",
    "    1e-2,           # Initial learning rate\n",
    "    decay_steps=100,   # Decay every 100 steps\n",
    "    decay_rate=0.99    # Multiply by 0.99 each decay\n",
    ")\n",
    "\n",
    "optimizer_adam = braintools.optim.Adam(lr=lr_schedule)\n",
    "optimizer_adam.register_trainable_weights(model_adam.states(brainstate.ParamState))\n",
    "\n",
    "print(\"Adam optimizer created with learning rate scheduling!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a5b6c7d8e9f0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:13:55.835613Z",
     "start_time": "2025-10-11T10:13:55.831811Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define training step with the new optimizer\n",
    "@brainstate.transform.jit\n",
    "def train_step_adam(batch):\n",
    "    x, y = batch\n",
    "    \n",
    "    def loss_fn():\n",
    "        return jnp.mean((y - model_adam(x)) ** 2)\n",
    "    \n",
    "    grads = brainstate.transform.grad(\n",
    "        loss_fn, \n",
    "        optimizer_adam.param_states.to_pytree()\n",
    "    )()\n",
    "    \n",
    "    optimizer_adam.update(grads)\n",
    "\n",
    "@brainstate.transform.jit\n",
    "def eval_step_adam(batch):\n",
    "    x, y = batch\n",
    "    y_pred = model_adam(x)\n",
    "    loss = jnp.mean((y - y_pred) ** 2)\n",
    "    return {'loss': loss}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b6c7d8e9f0a1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-11T10:14:48.645931Z",
     "start_time": "2025-10-11T10:14:47.974226Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training with Adam optimizer...\n",
      "\n",
      "Step:     0, Loss: 5.806739, LR: 0.010000\n",
      "Step:   500, Loss: 0.007895, LR: 0.010000\n",
      "Step:  1000, Loss: 0.007700, LR: 0.010000\n",
      "Step:  1500, Loss: 0.007669, LR: 0.010000\n",
      "Step:  2000, Loss: 0.007656, LR: 0.010000\n",
      "Step:  2500, Loss: 0.007796, LR: 0.010000\n",
      "Step:  3000, Loss: 0.007845, LR: 0.010000\n",
      "Step:  3500, Loss: 0.007663, LR: 0.010000\n",
      "Step:  4000, Loss: 0.007980, LR: 0.010000\n",
      "Step:  4500, Loss: 0.007653, LR: 0.010000\n",
      "\n",
      "Training complete!\n"
     ]
    }
   ],
   "source": [
    "# Training with Adam\n",
    "total_steps = 5_000\n",
    "\n",
    "print(\"Training with Adam optimizer...\\n\")\n",
    "for step, batch in enumerate(dataset(32)):\n",
    "    train_step_adam(batch)\n",
    "    \n",
    "    if step % 500 == 0:\n",
    "        logs = eval_step_adam((X, Y))\n",
    "        current_lr = optimizer_adam.current_lr\n",
    "        print(f\"Step: {step:5d}, Loss: {logs['loss']:.6f}, LR: {current_lr:.6f}\")\n",
    "    \n",
    "    if step >= total_steps - 1:\n",
    "        break\n",
    "\n",
    "print(\"\\nTraining complete!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7d8e9f0a1b2",
   "metadata": {},
   "source": [
    "## Comparison: Functional API vs Lifted Transforms\n",
    "\n",
    "| Aspect | Functional API | Lifted Transforms |\n",
    "|--------|----------------|-------------------|\n",
    "| **State Management** | Manual (explicit split/merge) | Automatic (implicit) |\n",
    "| **Code Complexity** | Higher (more boilerplate) | Lower (cleaner code) |\n",
    "| **Control** | Full control over states | Managed by framework |\n",
    "| **Learning Curve** | Steeper (need to understand graph ops) | Gentler (similar to PyTorch) |\n",
    "| **Use Cases** | Custom algorithms, research | Standard training, production |\n",
    "| **Performance** | Same (both compile to XLA) | Same (both compile to XLA) |\n",
    "| **Debugging** | Easier to trace states | Harder (implicit state flow) |\n",
    "| **Flexibility** | Maximum | High (sufficient for most cases) |\n",
    "\n",
    "### When to Use Each?\n",
    "\n",
    "**Use Functional API when:**\n",
    "- Implementing novel optimization algorithms\n",
    "- Need fine-grained control over state updates\n",
    "- Debugging complex state interactions\n",
    "- Research requiring custom gradient computations\n",
    "\n",
    "**Use Lifted Transforms when:**\n",
    "- Standard training workflows\n",
    "- Production deployments\n",
    "- Rapid prototyping\n",
    "- When code readability is priority"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8e9f0a1b2c3",
   "metadata": {},
   "source": [
    "## Key Concepts Summary\n",
    "\n",
    "### Lifted Transforms\n",
    "\n",
    "1. **Automatic State Management**:\n",
    "   - States are implicitly threaded through computations\n",
    "   - No need for manual split/merge operations\n",
    "   - Cleaner, more readable code\n",
    "\n",
    "2. **BrainTools Optimizers**:\n",
    "   - Handle parameter registration and updates\n",
    "   - Support learning rate scheduling\n",
    "   - Implement various algorithms (SGD, Adam, AdamW, etc.)\n",
    "\n",
    "3. **BrainState Transforms**:\n",
    "   - `brainstate.transform.jit`: JIT compilation with state handling\n",
    "   - `brainstate.transform.grad`: Gradients with automatic state differentiation\n",
    "   - `brainstate.transform.for_loop`: Efficient loops over sequences\n",
    "\n",
    "### Best Practices\n",
    "\n",
    "1. **Start with Lifted API**: Begin with lifted transforms for most projects\n",
    "2. **Use BrainTools Optimizers**: They handle state management for you\n",
    "3. **Drop to Functional API when needed**: For advanced control\n",
    "4. **Profile before optimizing**: Both APIs have same performance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9f0a1b2c3d4",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "Try these exercises to deepen your understanding:\n",
    "\n",
    "1. **Experiment with Optimizers**:\n",
    "   - Try different optimizers (AdamW, RMSprop)\n",
    "   - Compare convergence speeds\n",
    "   - Visualize learning curves\n",
    "\n",
    "2. **Add Regularization**:\n",
    "   - Implement L2 regularization in the loss function\n",
    "   - Add dropout layers to the MLP\n",
    "   - Compare generalization performance\n",
    "\n",
    "3. **Learning Rate Scheduling**:\n",
    "   - Implement cosine annealing schedule\n",
    "   - Try step decay\n",
    "   - Plot learning rate vs. step\n",
    "\n",
    "4. **Gradient Clipping**:\n",
    "   - Add gradient clipping to prevent exploding gradients\n",
    "   - Monitor gradient norms during training"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0a1b2c3d4e5",
   "metadata": {},
   "source": [
    "## Next Steps\n",
    "\n",
    "Now that you understand both functional and lifted APIs, you can:\n",
    "\n",
    "1. **Build Complex Models**: Apply these concepts to CNNs, RNNs, and Transformers\n",
    "2. **Explore Advanced Training**: Learn about mixed precision, gradient accumulation\n",
    "3. **Dive into Brain Models**: Use these techniques for spiking neural networks\n",
    "4. **Checkpointing and Deployment**: Save and load trained models\n",
    "\n",
    "## References\n",
    "\n",
    "- [BrainState Transform API](https://brainstate.readthedocs.io/en/latest/apis/transform.html)\n",
    "- [BrainTools Optimizers](https://braintools.readthedocs.io/en/latest/apis/optim.html)\n",
    "- [JAX Documentation](https://jax.readthedocs.io/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ecosystem-py",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}