{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "72e0b509",
   "metadata": {},
   "source": [
    "{download}`Download this notebook <6_logical_gates.ipynb>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17685ace",
   "metadata": {},
   "source": [
    "## Toy recurrent network learning logical gates\n",
    "> **Main `gradnet` concepts demonstrated below**\n",
    "> - Discrete dynamical loss\n",
    "> - Directed networks\n",
    "> - Training on toy data\n",
    "\n",
    "### Problem setup\n",
    "Short circuit-style networks trained with GradNet's built-in trainer. We allow positive/negative edges and rely on leaky-ReLU dynamics plus a bias node to fit XOR."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a59617b",
   "metadata": {},
   "source": [
    "### Install\n",
    "install the required dependencies silently"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c329b29c",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "!pip install 'gradnet[examples]'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28e95da5",
   "metadata": {},
   "source": [
    "### Imports and helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e9f402e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import TwoSlopeNorm\n",
    "\n",
    "from gradnet import GradNet, fit\n",
    "from gradnet.utils import plot_adjacency_heatmap, random_seed\n",
    "\n",
    "random_seed(3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f2f6aa8",
   "metadata": {},
   "source": [
    "### Truth tables and directed network\n",
    "Layout: A, B, H, OUT. The initial state loads the two inputs and zeros elsewhere. We unroll `state = relu(A @ state)` for a few rounds and read the last node as the output. No clamping or masks beyond the zero diagonal from GradNet defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "19e101b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cpu\")\n",
    "inputs = torch.tensor([[0.,0.],[0.,1.],[1.,0.],[1.,1.]], device=device)\n",
    "\n",
    "gate_targets = {\n",
    "    \"AND\": inputs.new_tensor([0.,0.,0.,1.]),\n",
    "    \"OR\":  inputs.new_tensor([0.,1.,1.,1.]),\n",
    "    \"XOR\": inputs.new_tensor([0.,1.,1.,0.]),\n",
    "}\n",
    "\n",
    "# Layout: A, B, H, OUT\n",
    "num_nodes = 4\n",
    "input_idx = (0, 1)\n",
    "output_idx = num_nodes - 1\n",
    "num_rounds = 2\n",
    "budget = 11\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4471e32f",
   "metadata": {},
   "source": [
    "### Propagation, loss, and training via `fit`\n",
    "Unroll `state = tanh(A @ state)` for `num_rounds` starting from the input-loaded state; the output is the last node passed through a sigmoid and BCE loss. No clamping beyond the initial state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b3b555f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def propagate(A, x, rounds=num_rounds):\n",
    "    # Initialize all nodes to zero, then inject input values at input nodes\n",
    "    state = torch.zeros(num_nodes, device=A.device, dtype=A.dtype)\n",
    "    state[list(input_idx)] = x\n",
    "    # Unroll the recurrence: state = tanh(A @ state)\n",
    "    for _ in range(rounds):\n",
    "        state = torch.tanh(A @ state)\n",
    "    return state[output_idx]  # return the output node's activation\n",
    "\n",
    "\n",
    "def gate_loss(gn, targets):\n",
    "    A = gn()  # get current adjacency matrix\n",
    "    preds = torch.stack([propagate(A, x) for x in inputs])  # run all 4 input combos\n",
    "    loss = F.mse_loss(preds, targets)\n",
    "    acc = ((preds > 0.5) == (targets > 0.5)).float().mean()\n",
    "    return loss, {\"acc\": acc}\n",
    "\n",
    "\n",
    "def train_gate(name, targets, num_updates=2000, lr=0.01):\n",
    "    # Fresh GradNet: directed, free-sign edges, near-zero init, soft budget\n",
    "    gn = GradNet(\n",
    "        num_nodes=num_nodes,\n",
    "        budget=budget,\n",
    "        directed=True,\n",
    "        delta_sign=\"free\",\n",
    "        rand_init_weights=1e-9,\n",
    "        strict_budget=False,\n",
    "    )\n",
    "\n",
    "    fit(\n",
    "        gn=gn,\n",
    "        loss_fn=lambda g: gate_loss(g, targets),\n",
    "        num_updates=num_updates,\n",
    "        optim_cls=torch.optim.Adam,\n",
    "        optim_kwargs={\"lr\": lr},\n",
    "        logger=False,\n",
    "        accelerator=\"cpu\",\n",
    "    )\n",
    "\n",
    "    with torch.no_grad():\n",
    "        A = gn()\n",
    "        preds = torch.stack([propagate(A, x) for x in inputs]).cpu()\n",
    "    return gn, A.detach().cpu(), preds, targets.detach().cpu()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "677175bb",
   "metadata": {},
   "source": [
    "### Train AND, OR, and XOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "65994b1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (mps), used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training AND gate\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e17a34e2cb7d476cae63ca356b5ce400",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Updates:   0%|          | 0/2000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "  | Name | Type    | Params | Mode \n",
      "-----------------------------------------\n",
      "0 | gn   | GradNet | 16     | train\n",
      "-----------------------------------------\n",
      "16        Trainable params\n",
      "0         Non-trainable params\n",
      "16        Total params\n",
      "0.000     Total estimated model params size (MB)\n",
      "`Trainer.fit` stopped: `max_epochs=2000` reached.\n",
      "GPU available: True (mps), used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training OR gate\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "528ea3d6f0d643f79a5305dec65f8f03",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Updates:   0%|          | 0/2000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "  | Name | Type    | Params | Mode \n",
      "-----------------------------------------\n",
      "0 | gn   | GradNet | 16     | train\n",
      "-----------------------------------------\n",
      "16        Trainable params\n",
      "0         Non-trainable params\n",
      "16        Total params\n",
      "0.000     Total estimated model params size (MB)\n",
      "`Trainer.fit` stopped: `max_epochs=2000` reached.\n",
      "GPU available: True (mps), used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training XOR gate\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "632e889787174dfbbdd78460f6bf7407",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Updates:   0%|          | 0/2000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "  | Name | Type    | Params | Mode \n",
      "-----------------------------------------\n",
      "0 | gn   | GradNet | 16     | train\n",
      "-----------------------------------------\n",
      "16        Trainable params\n",
      "0         Non-trainable params\n",
      "16        Total params\n",
      "0.000     Total estimated model params size (MB)\n",
      "`Trainer.fit` stopped: `max_epochs=2000` reached.\n"
     ]
    }
   ],
   "source": [
    "gate_results = {}\n",
    "for name, targets in gate_targets.items():\n",
    "    print(f\"Training {name} gate\")\n",
    "    gn, adj, preds, tgts = train_gate(name, targets)\n",
    "    gate_results[name] = {\"model\": gn, \"adj\": adj, \"preds\": preds, \"targets\": tgts}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42a426ce",
   "metadata": {},
   "source": [
    "### Check truth tables after training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f26613d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AND gate outputs\n",
      "[0, 0] -> pred=0.000 (binary 0), target=0\n",
      "[0, 1] -> pred=0.013 (binary 0), target=0\n",
      "[1, 0] -> pred=0.013 (binary 0), target=0\n",
      "[1, 1] -> pred=0.900 (binary 1), target=1\n",
      "OR gate outputs\n",
      "[0, 0] -> pred=0.000 (binary 0), target=0\n",
      "[0, 1] -> pred=0.994 (binary 1), target=1\n",
      "[1, 0] -> pred=0.996 (binary 1), target=1\n",
      "[1, 1] -> pred=1.000 (binary 1), target=1\n",
      "XOR gate outputs\n",
      "[0, 0] -> pred=0.000 (binary 0), target=0\n",
      "[0, 1] -> pred=0.813 (binary 1), target=1\n",
      "[1, 0] -> pred=0.813 (binary 1), target=1\n",
      "[1, 1] -> pred=0.096 (binary 0), target=0\n"
     ]
    }
   ],
   "source": [
    "for name, res in gate_results.items():\n",
    "    print(f\"{name} gate outputs\")\n",
    "    for combo, pred, target in zip(inputs.cpu().tolist(), res[\"preds\"], res[\"targets\"]):\n",
    "        bits = [int(v) for v in combo]\n",
    "        print(f\"{bits} -> pred={pred.item():.3f} (binary {int(pred > 0.5)}), target={int(target.item())}\")\n",
    "\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbd73dbb",
   "metadata": {},
   "source": [
    "### Plot the adjacencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6d9e2c38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "abs_max = max(float(res[\"adj\"].abs().max()) for res in gate_results.values())\n",
    "abs_max = max(abs_max, 1e-6)\n",
    "norm = TwoSlopeNorm(vmin=-abs_max, vcenter=0.0, vmax=abs_max)\n",
    "imshow_kwargs = {\"cmap\": \"RdBu\", \"norm\": norm}\n",
    "\n",
    "# Node labels for ticks: A, B, hidden(s) as H/H1..., and O for output\n",
    "hidden_counter = 0\n",
    "node_labels = []\n",
    "for n in range(num_nodes):\n",
    "    if n == input_idx[0]:\n",
    "        node_labels.append(\"A\")\n",
    "    elif len(input_idx) > 1 and n == input_idx[1]:\n",
    "        node_labels.append(\"B\")\n",
    "    elif n == output_idx:\n",
    "        node_labels.append(\"O\")\n",
    "    else:\n",
    "        label = \"H\" if hidden_counter == 0 else f\"H{hidden_counter}\"\n",
    "        node_labels.append(label)\n",
    "        hidden_counter += 1\n",
    "\n",
    "fig, axs = plt.subplots(1, 3, figsize=(6, 2.5), dpi=200, constrained_layout=True)\n",
    "for ax, (name, res) in zip(axs, gate_results.items()):\n",
    "    plot_adjacency_heatmap(res[\"adj\"], ax=ax, title=f\"{name} gate\", imshow_kwargs=imshow_kwargs, add_colorbar=False)\n",
    "    ax.set_xlabel(None)\n",
    "    ax.set_ylabel(None)\n",
    "    ax.set_xticks(range(num_nodes), node_labels)\n",
    "    ax.set_yticks(range(num_nodes), node_labels)\n",
    "\n",
    "cbar = fig.colorbar(axs[-1].images[0], ax=axs, location=\"right\", shrink=0.9)\n",
    "cbar.set_label(\"$A_{ij}$\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5f18c1",
   "metadata": {},
   "source": [
    "### Plot as networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1e0719e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/72/79vqt54j447byqmvb80g_n3w0000gn/T/ipykernel_96387/3576067285.py:9: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n",
      "  edge_cmap = mpl.cm.get_cmap('RdBu')  # red = negative, blue = positive\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Plot each learned gate as a small directed graph\n",
    "import math\n",
    "import matplotlib as mpl\n",
    "\n",
    "# Re-compute a shared scale so widths/colors are comparable across gates\n",
    "edge_abs_max = max(float(res['adj'].abs().max()) for res in gate_results.values())\n",
    "edge_abs_max = max(edge_abs_max, 1e-8)\n",
    "edge_norm = mpl.colors.TwoSlopeNorm(vmin=-edge_abs_max, vcenter=0.0, vmax=edge_abs_max)\n",
    "edge_cmap = mpl.cm.get_cmap('RdBu')  # red = negative, blue = positive\n",
    "\n",
    "dx = 0.4\n",
    "dy = 1.6\n",
    "\n",
    "node_labels = {0: 'A', 1: 'B', output_idx: 'O'}\n",
    "if num_nodes >= 3:\n",
    "    node_labels.setdefault(2, 'H')\n",
    "\n",
    "\n",
    "def layout_positions(num_nodes, input_idx, output_idx):\n",
    "    # Inputs stacked on the left (x=0)\n",
    "    inputs = list(input_idx)\n",
    "    y_inputs = [(((len(inputs) - 1) / 2) - i)*dy for i in range(len(inputs))]\n",
    "    positions = {idx: (0.0, y) for idx, y in zip(inputs, y_inputs)}\n",
    "\n",
    "    # Middle layer for all other non-output nodes\n",
    "    mid_nodes = [i for i in range(num_nodes) if i not in inputs and i != output_idx]\n",
    "    if mid_nodes:\n",
    "        y_mid = [(((len(mid_nodes) - 1) / 2) - i)*dy for i in range(len(mid_nodes))]\n",
    "        for idx, y in zip(mid_nodes, y_mid):\n",
    "            positions[idx] = (dx, y)\n",
    "\n",
    "    # Output on the right (x=2) centered relative to current nodes\n",
    "    if positions:\n",
    "        min_y = min(y for _, y in positions.values())\n",
    "        max_y = max(y for _, y in positions.values())\n",
    "        out_y = 0.5 * (min_y + max_y)\n",
    "    else:\n",
    "        out_y = 0.0\n",
    "    positions[output_idx] = (2.5*dx, out_y)\n",
    "    return positions\n",
    "\n",
    "\n",
    "def draw_gate_graph(name, adj, ax):\n",
    "    adj_np = adj.detach().cpu().numpy()\n",
    "    pos = layout_positions(adj_np.shape[0], input_idx, output_idx)\n",
    "    threshold = 1e-2\n",
    "    curve_rad = 0.20  # clockwise bend for bidirectional pairs\n",
    "\n",
    "    # Draw directed edges j -> i with styling from weight\n",
    "    for i in range(adj_np.shape[0]):\n",
    "        for j in range(adj_np.shape[1]):\n",
    "            w = adj_np[i, j]\n",
    "            if abs(w) < threshold:\n",
    "                continue\n",
    "            (x0, y0), (x1, y1) = pos[j], pos[i]\n",
    "            width = 6.0 * (abs(w) / edge_abs_max)\n",
    "            color = edge_cmap(edge_norm(w))\n",
    "\n",
    "            has_reverse = i != j and abs(adj_np[j, i]) >= threshold\n",
    "            rad = curve_rad if has_reverse else 0.0\n",
    "\n",
    "            ax.annotate(\n",
    "                '',\n",
    "                xy=(x1, y1), xytext=(x0, y0),\n",
    "                arrowprops=dict(\n",
    "                    arrowstyle='-|>',\n",
    "                    color=color,\n",
    "                    lw=width,\n",
    "                    alpha=1,\n",
    "                    shrinkA=9, shrinkB=9,\n",
    "                    connectionstyle=f'arc3,rad={rad}',\n",
    "                ),\n",
    "                zorder=1,\n",
    "            )\n",
    "\n",
    "    # Draw nodes on top of edges\n",
    "    for idx, (x, y) in pos.items():\n",
    "        kind = 'input' if idx in input_idx else ('output' if idx == output_idx else 'hidden')\n",
    "        facecolor = {'input': '#86c5da', 'hidden': '#cccccc', 'output': '#f4b400'}[kind]\n",
    "        ax.scatter(x, y, s=520, color=facecolor, edgecolor='k', zorder=2)\n",
    "        label = node_labels.get(idx, f'n{idx}')\n",
    "        ax.text(x, y, label, ha='center', va='center', weight='bold', fontsize=13)\n",
    "\n",
    "    ys = [y for _, y in pos.values()]\n",
    "    y_margin = 0.6 if len(ys) > 1 else 0.4\n",
    "    ax.set_title(f\"{name} gate\")\n",
    "    ax.set_xlim(-0.5, 2.5*dx + 0.5)\n",
    "    ax.set_ylim(min(ys) - y_margin, max(ys) + y_margin)\n",
    "    ax.axis('off')\n",
    "\n",
    "\n",
    "fig, axes = plt.subplots(1, len(gate_results), figsize=(4 * len(gate_results), 3), dpi=200)\n",
    "if len(gate_results) == 1:\n",
    "    axes = [axes]\n",
    "\n",
    "for ax, (name, res) in zip(axes, gate_results.items()):\n",
    "    draw_gate_graph(name, res['adj'], ax)\n",
    "\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "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
}