{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "04a72c0e",
   "metadata": {},
   "source": [
    "# The Continuous Thought Machine – Tutorial 01: MNIST [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/SakanaAI/continuous-thought-machines/blob/main/examples/01_mnist.ipynb) [![arXiv](https://img.shields.io/badge/arXiv-2505.05522-b31b1b.svg)](https://arxiv.org/abs/2505.05522)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d88fc6d1",
   "metadata": {},
   "source": [
    "Modern deep learning models ignore time as a core computational element. In contrast, the **Continuous Thought Machine (CTM)** introduces internal recurrence and neural synchronization to model *thinking as a temporal process*.\n",
    "\n",
    "### Key Ideas\n",
    "\n",
    "- **Internal Ticks**: The CTM runs over a self-generated temporal axis (independent of input), which we view as a dimension over which thought can unfold.\n",
    "- **Neuron-Level Models**: Each neuron has a private MLP that processes its own history of pre-activations over time.\n",
    "- **Synchronization as Representation**: CTMs compute neuron-to-neuron synchronization over time and use these signals for attention and output.\n",
    "\n",
    "### Why It Matters\n",
    "\n",
    "- Enables **interpretable, dynamic reasoning**\n",
    "- Supports **adaptive compute** (e.g. more ticks for harder tasks)\n",
    "- Works across tasks: classification, reasoning, memory, RL—*without changing the core mechanisms*.\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b05cf27b",
   "metadata": {},
   "source": [
    "### MNIST Classification\n",
    "\n",
    "In this tutorial we walk through a simple example; training a CTM to classify MNIST digits. We cover:\n",
    "- Defining the model\n",
    "- Constructing the loss function\n",
    "- Training\n",
    "- Building visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c257dbd3",
   "metadata": {},
   "source": [
    "Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a7bfbfe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "import random\n",
    "from scipy.special import softmax\n",
    "import math\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, clear_output\n",
    "import seaborn as sns\n",
    "import imageio\n",
    "import mediapy\n",
    "\n",
    "import torch._dynamo as dynamo\n",
    "\n",
    "dynamo.config.suppress_errors = False  # Raise errors on fallback"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97220107",
   "metadata": {},
   "source": [
    "Set the seed for reproducability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "88b75133",
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_seed(seed=42, deterministic=True):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.deterministic = deterministic\n",
    "    torch.backends.cudnn.benchmark = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "5a9f123b",
   "metadata": {},
   "outputs": [],
   "source": [
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ee6aa63",
   "metadata": {},
   "source": [
    "We start by defining some helper classes, which we will use in the CTM.\n",
    "\n",
    "Of note is the SuperLinear class, which implements N unique linear transformations. This SuperLinear class will be used for the neuron-level models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "50c9ac82",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Identity(nn.Module):\n",
    "    \"\"\"Identity Module.\"\"\"\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "    def forward(self, x):\n",
    "        return x\n",
    "\n",
    "class Squeeze(nn.Module):\n",
    "    \"\"\"Squeeze Module.\"\"\"\n",
    "    def __init__(self, dim):\n",
    "        super().__init__()\n",
    "        self.dim = dim\n",
    "\n",
    "    def forward(self, x):\n",
    "        return x.squeeze(self.dim)\n",
    "\n",
    "class SuperLinear(nn.Module):\n",
    "    \"\"\"SuperLinear Layer: Implements Neuron-Level Models (NLMs) for the CTM.\"\"\"\n",
    "    def __init__(self, in_dims, out_dims, N, dropout=0.0):\n",
    "        super().__init__()\n",
    "        self.in_dims = in_dims\n",
    "        self.dropout = nn.Dropout(dropout) if dropout > 0 else Identity()\n",
    "        self.register_parameter('w1', nn.Parameter(\n",
    "            torch.empty((in_dims, out_dims, N)).uniform_(\n",
    "                -1/math.sqrt(in_dims + out_dims),\n",
    "                 1/math.sqrt(in_dims + out_dims)\n",
    "            ), requires_grad=True)\n",
    "        )\n",
    "        self.register_parameter('b1', nn.Parameter(torch.zeros((1, N, out_dims)), requires_grad=True))\n",
    "\n",
    "    def forward(self, x):\n",
    "            out = self.dropout(x)\n",
    "            out = torch.einsum('BDM,MHD->BDH', out, self.w1) + self.b1\n",
    "            out = out.squeeze(-1)\n",
    "            return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0eb50ea",
   "metadata": {},
   "source": [
    "Next, we define a helper function `compute_normalized_entropy`. We will use this function inside the CTM to compute the certainty of the model at each internal tick as `certainty = 1 - normalized entropy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4eedd9ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_normalized_entropy(logits, reduction='mean'):\n",
    "    \"\"\"Computes the normalized entropy for certainty-loss.\"\"\"\n",
    "    preds = F.softmax(logits, dim=-1)\n",
    "    log_preds = torch.log_softmax(logits, dim=-1)\n",
    "    entropy = -torch.sum(preds * log_preds, dim=-1)\n",
    "    num_classes = preds.shape[-1]\n",
    "    max_entropy = torch.log(torch.tensor(num_classes, dtype=torch.float32))\n",
    "    normalized_entropy = entropy / max_entropy\n",
    "    if len(logits.shape)>2 and reduction == 'mean':\n",
    "        normalized_entropy = normalized_entropy.flatten(1).mean(-1)\n",
    "    return normalized_entropy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f89b70a8",
   "metadata": {},
   "source": [
    "## CTM Architecture Overview\n",
    "\n",
    "The CTM implementation is initialized with the following core parameters:\n",
    "\n",
    "- `iterations`: Number of internal ticks (recurrent steps).\n",
    "- `d_model`: Total number of neurons.\n",
    "- `d_input`: Input and attention embedding dimension.\n",
    "- `memory_length`: Length of the sliding activation window used by each neuron.\n",
    "- `heads`: Number of attention heads.\n",
    "- `n_synch_out`: Number of neurons used for output synchronization.\n",
    "- `n_synch_action`: Number of neurons used for computing attention queries.\n",
    "- `out_dims`: Dimensionality of the model's output.\n",
    "\n",
    "### Key Components\n",
    "\n",
    "Upon initialization, the CTM builds the following modules:\n",
    "\n",
    "- **Backbone**: A CNN feature extractor for the input (e.g. image).\n",
    "- **Synapses**: A communication layer allowing neurons to interact.\n",
    "- **Trace Processor**: A neuron-level model that operates on each neuron's temporal activation trace.\n",
    "- **Synchronization Buffers**: For tracking decay.\n",
    "- **Learned Initial States**: Starting activations and traces for the system.\n",
    "\n",
    "---\n",
    "\n",
    "## Forward Pass Mechanics\n",
    "\n",
    "At each internal tick `stepi`, the CTM executes the following procedure:\n",
    "\n",
    "1. **Initialize recurrent state**:\n",
    "    - `state_trace`: Memory trace per neuron.\n",
    "    - `activated_state`: Current post-activations.\n",
    "    - `decay_alpha_out`, `decay_beta_out`: Values for calculating synchronization.\n",
    "\n",
    "2. **Featurize input**:\n",
    "    - Use the CNN backbone to extract key-value attention pairs `kv`.\n",
    "\n",
    "3. **Internal Loop** (for each tick `stepi`):\n",
    "    1. Compute `synchronisation_action` from `n_synch_action` neurons.\n",
    "    2. Generate attention query `q` from this synchronization.\n",
    "    3. Perform multi-head cross-attention over `kv`.\n",
    "    4. Concatenate attention output with the current neuron activations.\n",
    "    5. Update neurons via the synaptic module.\n",
    "    6. Append new activation to the trace window.\n",
    "    7. Update neuron states using the `trace_processor`.\n",
    "    8. Compute `synchronisation_out` from `n_synch_out` neurons.\n",
    "    9. Project to the output space via `output_projector`.\n",
    "    10. Compute prediction certainty from normalized entropy.\n",
    "\n",
    "This inner loop is repeated for the configured number of internal ticks. The CTM emits **predictions and certainties at every internal tick**.\n",
    "\n",
    "> For detailed mathematical formulation of the synchronization mechanism, please refer to the technical report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f357853f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContinuousThoughtMachine(nn.Module):\n",
    "    def __init__(self,\n",
    "                 iterations,\n",
    "                 d_model,\n",
    "                 d_input,\n",
    "                 memory_length,\n",
    "                 heads,\n",
    "                 n_synch_out,\n",
    "                 n_synch_action,\n",
    "                 out_dims,\n",
    "                 memory_hidden_dims,\n",
    "                 dropout=0.0\n",
    "                 ):\n",
    "        super(ContinuousThoughtMachine, self).__init__()\n",
    "\n",
    "        # --- Core Parameters ---\n",
    "        self.iterations = iterations\n",
    "        self.d_model = d_model\n",
    "        self.d_input = d_input\n",
    "        self.memory_length = memory_length\n",
    "        self.n_synch_out = n_synch_out\n",
    "        self.n_synch_action = n_synch_action\n",
    "        self.out_dims = out_dims\n",
    "        self.memory_length = memory_length\n",
    "        self.memory_hidden_dims = memory_hidden_dims\n",
    "\n",
    "        # --- Input Processing  ---\n",
    "        self.backbone = nn.Sequential(\n",
    "            nn.LazyConv2d(d_input, kernel_size=3, stride=1, padding=1),\n",
    "            nn.BatchNorm2d(d_input),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2, 2),\n",
    "            nn.LazyConv2d(d_input, kernel_size=3, stride=1, padding=1),\n",
    "            nn.BatchNorm2d(d_input),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2, 2),\n",
    "        )\n",
    "        self.attention = nn.MultiheadAttention(self.d_input, heads, dropout, batch_first=True)\n",
    "        self.kv_proj = nn.Sequential(nn.LazyLinear(self.d_input), nn.LayerNorm(self.d_input))\n",
    "        self.q_proj = nn.LazyLinear(self.d_input)\n",
    "\n",
    "        # --- Core CTM Modules ---\n",
    "        self.synapses = nn.Sequential(\n",
    "                nn.Dropout(dropout),\n",
    "                nn.LazyLinear(d_model * 2),\n",
    "                nn.GLU(),\n",
    "                nn.LayerNorm(d_model)\n",
    "            )\n",
    "        self.trace_processor = nn.Sequential(\n",
    "            SuperLinear(in_dims=memory_length, out_dims=2 * memory_hidden_dims, N=d_model, dropout=dropout),\n",
    "            nn.GLU(),\n",
    "            SuperLinear(in_dims=memory_hidden_dims, out_dims=2, N=d_model, dropout=dropout),\n",
    "            nn.GLU(),\n",
    "            Squeeze(-1)\n",
    "        )\n",
    "\n",
    "        #  --- Start States ---\n",
    "        self.register_parameter('start_activated_state', nn.Parameter(\n",
    "                torch.zeros((d_model)).uniform_(-math.sqrt(1/(d_model)), math.sqrt(1/(d_model))),\n",
    "                requires_grad=True\n",
    "            ))\n",
    "\n",
    "        self.register_parameter('start_trace', nn.Parameter(\n",
    "            torch.zeros((d_model, memory_length)).uniform_(-math.sqrt(1/(d_model+memory_length)), math.sqrt(1/(d_model+memory_length))),\n",
    "            requires_grad=True\n",
    "        ))\n",
    "\n",
    "        # --- Synchronisation ---\n",
    "        self.synch_representation_size_action = (self.n_synch_action * (self.n_synch_action+1))//2\n",
    "        self.synch_representation_size_out = (self.n_synch_out * (self.n_synch_out+1))//2\n",
    "\n",
    "        for synch_type, size in [('action', self.synch_representation_size_action), ('out', self.synch_representation_size_out)]:\n",
    "            print(f\"Synch representation size {synch_type}: {size}\")\n",
    "\n",
    "        self.set_synchronisation_parameters('out')\n",
    "        self.set_synchronisation_parameters('action')\n",
    "\n",
    "        # --- Output Procesing ---\n",
    "        self.output_projector = nn.Sequential(nn.LazyLinear(self.out_dims))\n",
    "\n",
    "    def set_synchronisation_parameters(self, synch_type: str):\n",
    "        synch_representation_size = self.synch_representation_size_action if synch_type == 'action' else self.synch_representation_size_out\n",
    "        self.register_parameter(f'decay_params_{synch_type}', nn.Parameter(torch.zeros(synch_representation_size), requires_grad=True))\n",
    "\n",
    "\n",
    "    def compute_synchronisation(self, activated_state, decay_alpha, decay_beta, r, synch_type):\n",
    "        if synch_type == 'action':\n",
    "            n_synch = self.n_synch_action\n",
    "            selected_left = selected_right = activated_state[:, -n_synch:]\n",
    "        elif synch_type == 'out':\n",
    "            n_synch = self.n_synch_out\n",
    "            selected_left = selected_right = activated_state[:, :n_synch]\n",
    "\n",
    "        outer = selected_left.unsqueeze(2) * selected_right.unsqueeze(1)\n",
    "        i, j = torch.triu_indices(n_synch, n_synch)\n",
    "        pairwise_product = outer[:, i, j]\n",
    "\n",
    "        if decay_alpha is None or decay_beta is None:\n",
    "            decay_alpha = pairwise_product\n",
    "            decay_beta = torch.ones_like(pairwise_product)\n",
    "        else:\n",
    "            decay_alpha = r * decay_alpha + pairwise_product\n",
    "            decay_beta = r * decay_beta + 1\n",
    "\n",
    "        synchronisation = decay_alpha / (torch.sqrt(decay_beta))\n",
    "        return synchronisation, decay_alpha, decay_beta\n",
    "\n",
    "    def compute_features(self, x):\n",
    "        input_features = self.backbone(x)\n",
    "        kv = self.kv_proj(input_features.flatten(2).transpose(1, 2))\n",
    "        return kv\n",
    "\n",
    "    def compute_certainty(self, current_prediction):\n",
    "        ne = compute_normalized_entropy(current_prediction)\n",
    "        current_certainty = torch.stack((ne, 1-ne), -1)\n",
    "        return current_certainty\n",
    "\n",
    "    def forward(self, x, track=False):\n",
    "        B = x.size(0)\n",
    "        device = x.device\n",
    "\n",
    "        # --- Tracking Initialization ---\n",
    "        pre_activations_tracking = []\n",
    "        post_activations_tracking = []\n",
    "        synch_out_tracking = []\n",
    "        synch_action_tracking = []\n",
    "        attention_tracking = []\n",
    "\n",
    "        # --- Featurise Input Data ---\n",
    "        kv = self.compute_features(x)\n",
    "\n",
    "        # --- Initialise Recurrent State ---\n",
    "        state_trace = self.start_trace.unsqueeze(0).expand(B, -1, -1) # Shape: (B, H, T)\n",
    "        activated_state = self.start_activated_state.unsqueeze(0).expand(B, -1) # Shape: (B, H)\n",
    "\n",
    "        # --- Storage for outputs per iteration\n",
    "        predictions = torch.empty(B, self.out_dims, self.iterations, device=device, dtype=x.dtype)\n",
    "        certainties = torch.empty(B, 2, self.iterations, device=device, dtype=x.dtype)\n",
    "\n",
    "        decay_alpha_action, decay_beta_action = None, None\n",
    "        r_action, r_out = torch.exp(-self.decay_params_action).unsqueeze(0).repeat(B, 1), torch.exp(-self.decay_params_out).unsqueeze(0).repeat(B, 1)\n",
    "\n",
    "        _, decay_alpha_out, decay_beta_out = self.compute_synchronisation(activated_state, None, None, r_out, synch_type='out')\n",
    "\n",
    "        # --- Recurrent Loop  ---\n",
    "        for stepi in range(self.iterations):\n",
    "\n",
    "            # --- Calculate Synchronisation for Input Data Interaction ---\n",
    "            synchronisation_action, decay_alpha_action, decay_beta_action = self.compute_synchronisation(activated_state, decay_alpha_action, decay_beta_action, r_action, synch_type='action')\n",
    "\n",
    "            # --- Interact with Data via Attention ---\n",
    "            q = self.q_proj(synchronisation_action).unsqueeze(1)\n",
    "            attn_out, attn_weights = self.attention(q, kv, kv, average_attn_weights=False, need_weights=True)\n",
    "            attn_out = attn_out.squeeze(1)\n",
    "            pre_synapse_input = torch.concatenate((attn_out, activated_state), dim=-1)\n",
    "\n",
    "            # --- Apply Synapses ---\n",
    "            state = self.synapses(pre_synapse_input)\n",
    "            state_trace = torch.cat((state_trace[:, :, 1:], state.unsqueeze(-1)), dim=-1)\n",
    "\n",
    "            # --- Activate ---\n",
    "            activated_state = self.trace_processor(state_trace)\n",
    "\n",
    "            # --- Calculate Synchronisation for Output Predictions ---\n",
    "            synchronisation_out, decay_alpha_out, decay_beta_out = self.compute_synchronisation(activated_state, decay_alpha_out, decay_beta_out, r_out, synch_type='out')\n",
    "\n",
    "            # --- Get Predictions and Certainties ---\n",
    "            current_prediction = self.output_projector(synchronisation_out)\n",
    "            current_certainty = self.compute_certainty(current_prediction)\n",
    "\n",
    "            predictions[..., stepi] = current_prediction\n",
    "            certainties[..., stepi] = current_certainty\n",
    "\n",
    "            # --- Tracking ---\n",
    "            if track:\n",
    "                pre_activations_tracking.append(state_trace[:,:,-1].detach().cpu().numpy())\n",
    "                post_activations_tracking.append(activated_state.detach().cpu().numpy())\n",
    "                attention_tracking.append(attn_weights.detach().cpu().numpy())\n",
    "                synch_out_tracking.append(synchronisation_out.detach().cpu().numpy())\n",
    "                synch_action_tracking.append(synchronisation_action.detach().cpu().numpy())\n",
    "\n",
    "        # --- Return Values ---\n",
    "        if track:\n",
    "            return predictions, certainties, (np.array(synch_out_tracking), np.array(synch_action_tracking)), np.array(pre_activations_tracking), np.array(post_activations_tracking), np.array(attention_tracking)\n",
    "        return predictions, certainties, synchronisation_out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a049b6a",
   "metadata": {},
   "source": [
    "## Certainty-Based Loss Function\n",
    "\n",
    "The CTM produces outputs at each internal tick, so the question arises: **how do we optimize the model across this internal temporal dimension?**\n",
    "\n",
    "Our answer is a simple but effective **certainty-based loss** that encourages the model to reason meaningfully across time. Instead of relying on the final tick alone, we aggregate loss from two key internal ticks:\n",
    "\n",
    "1. The tick where the **prediction loss** is lowest.\n",
    "2. The tick where the **certainty** (1 - normalized entropy) is highest.\n",
    "\n",
    "We then take the **average of the losses** at these two points.\n",
    "\n",
    "This approach encourages the CTM to both make accurate predictions and express high confidence in them—while supporting adaptive, interpretable computation over time.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0f463eb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_loss(predictions, certainties, targets, use_most_certain=True):\n",
    "    \"\"\"use_most_certain will select either the most certain point or the final point.\"\"\"\n",
    "\n",
    "    losses = nn.CrossEntropyLoss(reduction='none')(predictions,\n",
    "                                                   torch.repeat_interleave(targets.unsqueeze(-1), predictions.size(-1), -1))\n",
    "\n",
    "    loss_index_1 = losses.argmin(dim=1)\n",
    "    loss_index_2 = certainties[:,1].argmax(-1)\n",
    "    if not use_most_certain:\n",
    "        loss_index_2[:] = -1\n",
    "\n",
    "    batch_indexer = torch.arange(predictions.size(0), device=predictions.device)\n",
    "    loss_minimum_ce = losses[batch_indexer, loss_index_1].mean()\n",
    "    loss_selected = losses[batch_indexer, loss_index_2].mean()\n",
    "\n",
    "    loss = (loss_minimum_ce + loss_selected)/2\n",
    "    return loss, loss_index_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e54afe0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_accuracy(predictions, targets, where_most_certain):\n",
    "    \"\"\"Calculate the accuracy based on the prediction at the most certain internal tick.\"\"\"\n",
    "    B = predictions.size(0)\n",
    "    device = predictions.device\n",
    "\n",
    "    predictions_at_most_certain_internal_tick = predictions.argmax(1)[torch.arange(B, device=device), where_most_certain].detach().cpu().numpy()\n",
    "    accuracy = (targets.detach().cpu().numpy() == predictions_at_most_certain_internal_tick).mean()\n",
    "\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c1371279",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data():\n",
    "    transform = transforms.Compose([\n",
    "        transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1)),\n",
    "        transforms.RandomRotation(10),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize((0.1307,), (0.3081,))\n",
    "    ])\n",
    "    train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n",
    "    test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n",
    "    trainloader = torch.utils.data.DataLoader(train_data, batch_size=256, shuffle=True, num_workers=1)\n",
    "    testloader = torch.utils.data.DataLoader(test_data, batch_size=256, shuffle=True, num_workers=1, drop_last=False)\n",
    "    return trainloader, testloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2e3fc4d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_training_curve_plot(fig, ax1, ax2, train_losses, test_losses, train_accuracies, test_accuracies, steps):\n",
    "    clear_output(wait=True)\n",
    "    \n",
    "    # Plot loss\n",
    "    ax1.clear()\n",
    "    ax1.plot(range(len(train_losses)), train_losses, 'b-', alpha=0.7, label=f'Train Loss: {train_losses[-1]:.3f}')\n",
    "    ax1.plot(steps, test_losses, 'r-', marker='o', label=f'Test Loss: {test_losses[-1]:.3f}')\n",
    "    ax1.set_title('Loss')\n",
    "    ax1.set_xlabel('Step')\n",
    "    ax1.set_ylabel('Loss')\n",
    "    ax1.legend()\n",
    "    ax1.grid(True, alpha=0.3)\n",
    "\n",
    "    # Plot accuracy\n",
    "    ax2.clear()\n",
    "    ax2.plot(range(len(train_accuracies)), train_accuracies, 'b-', alpha=0.7, label=f'Train Accuracy: {train_accuracies[-1]:.3f}')\n",
    "    ax2.plot(steps, test_accuracies, 'r-', marker='o', label=f'Test Accuracy: {test_accuracies[-1]:.3f}')\n",
    "    ax2.set_title('Accuracy')\n",
    "    ax2.set_xlabel('Step')\n",
    "    ax2.set_ylabel('Accuracy')\n",
    "    ax2.legend()\n",
    "    ax2.grid(True, alpha=0.3)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    display(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a492b058",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, trainloader, testloader, iterations, test_every, device):\n",
    "\n",
    "  optimizer = torch.optim.AdamW(params=list(model.parameters()), lr=0.0001, eps=1e-8)\n",
    "  iterator = iter(trainloader)\n",
    "  model.train()\n",
    "  \n",
    "  train_losses = []\n",
    "  test_losses = []\n",
    "  train_accuracies = []\n",
    "  test_accuracies = []\n",
    "  steps = []\n",
    "\n",
    "  plt.ion()\n",
    "  fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))\n",
    "\n",
    "  with tqdm(total=iterations, initial=0, dynamic_ncols=True) as pbar:\n",
    "      test_loss = None\n",
    "      test_accuracy = None\n",
    "      for stepi in range(iterations):\n",
    "\n",
    "          try:\n",
    "              inputs, targets = next(iterator)\n",
    "          except StopIteration:\n",
    "              iterator = iter(trainloader)\n",
    "              inputs, targets = next(iterator)\n",
    "          inputs, targets = inputs.to(device), targets.to(device)\n",
    "          predictions, certainties, _ = model(inputs, track=False)\n",
    "          train_loss, where_most_certain = get_loss(predictions, certainties, targets)\n",
    "          train_accuracy = calculate_accuracy(predictions, targets, where_most_certain)\n",
    "\n",
    "          train_losses.append(train_loss.item())\n",
    "          train_accuracies.append(train_accuracy)\n",
    "\n",
    "          train_loss.backward()\n",
    "          optimizer.step()\n",
    "          optimizer.zero_grad()\n",
    "\n",
    "\n",
    "          if stepi % test_every == 0 or stepi == iterations - 1:\n",
    "            model.eval()\n",
    "            with torch.inference_mode():\n",
    "                all_test_predictions = []\n",
    "                all_test_targets = []\n",
    "                all_test_where_most_certain = []\n",
    "                all_test_losses = []\n",
    "\n",
    "                for inputs, targets in testloader:\n",
    "                    inputs, targets = inputs.to(device), targets.to(device)\n",
    "                    predictions, certainties, _ = model(inputs, track=False)\n",
    "                    test_loss, where_most_certain = get_loss(predictions, certainties, targets)\n",
    "                    all_test_losses.append(test_loss.item())\n",
    "\n",
    "                    all_test_predictions.append(predictions)\n",
    "                    all_test_targets.append(targets)\n",
    "                    all_test_where_most_certain.append(where_most_certain)\n",
    "\n",
    "                all_test_predictions = torch.cat(all_test_predictions, dim=0)\n",
    "                all_test_targets = torch.cat(all_test_targets, dim=0)\n",
    "                all_test_where_most_certain = torch.cat(all_test_where_most_certain, dim=0)\n",
    "\n",
    "                test_accuracy = calculate_accuracy(all_test_predictions, all_test_targets, all_test_where_most_certain)\n",
    "                test_loss = sum(all_test_losses) / len(all_test_losses)\n",
    "\n",
    "                test_losses.append(test_loss)\n",
    "                test_accuracies.append(test_accuracy)\n",
    "                steps.append(stepi)\n",
    "            model.train()\n",
    "\n",
    "            update_training_curve_plot(fig, ax1, ax2, train_losses, test_losses, train_accuracies, test_accuracies, steps)\n",
    "\n",
    "          pbar.set_description(f'Train Loss: {train_loss:.3f}, Train Accuracy: {train_accuracy:.3f} Test Loss: {test_loss:.3f}, Test Accuracy: {test_accuracy:.3f}')\n",
    "          pbar.update(1)\n",
    "\n",
    "  plt.ioff()\n",
    "  plt.close(fig)\n",
    "  return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "2d1658a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synch representation size action: 136\n",
      "Synch representation size out: 136\n",
      "Model parameters: 343,658\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "trainloader, testloader = prepare_data()\n",
    "\n",
    "model = ContinuousThoughtMachine(\n",
    "    iterations=15,\n",
    "    d_model=128,\n",
    "    d_input=128,\n",
    "    memory_length=10,\n",
    "    heads=2,\n",
    "    n_synch_out=16,\n",
    "    n_synch_action=16,\n",
    "    memory_hidden_dims=8,\n",
    "    out_dims=10,\n",
    "    dropout=0.0\n",
    ").to(device)\n",
    "\n",
    "sample_batch = next(iter(trainloader))\n",
    "dummy_input = sample_batch[0][:1].to(device)\n",
    "with torch.no_grad():\n",
    "    _ = model(dummy_input)\n",
    "\n",
    "# Now compile the model\n",
    "model = torch.compile(model)\n",
    "\n",
    "def clamp_decay_params(module, _input):\n",
    "    with torch.no_grad():\n",
    "        module.decay_params_action.data.clamp_(0, 15)\n",
    "        module.decay_params_out.data.clamp_(0, 15)\n",
    "\n",
    "model.register_forward_pre_hook(clamp_decay_params)\n",
    "\n",
    "print(f'Model parameters: {sum(p.numel() for p in model.parameters()):,}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ce6d7f20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.075, Train Accuracy: 0.969 Test Loss: 0.080, Test Accuracy: 0.968: 100%|██████████| 10000/10000 [35:10<00:00,  4.74it/s]\n"
     ]
    }
   ],
   "source": [
    "model = train(model=model, trainloader=trainloader, testloader=testloader, iterations=10000, test_every=500, device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af7e308f",
   "metadata": {},
   "source": [
    "## Visualizing CTM Dynamics\n",
    "\n",
    "We define a function to create GIFs that show how the CTMs dynamics. These visualizations include:\n",
    "\n",
    "- **Neuron activations** at each internal tick  \n",
    "- **Attention patterns** across the input  \n",
    "- **Predictions and certainty** at every step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3fbae96",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_gif(predictions, certainties, targets, pre_activations, post_activations, attention, inputs_to_model, filename):\n",
    "    def reshape_attention_weights(attention, target_size=28):\n",
    "        # The num_positions will not be a perfect square if the input size is not a perfect square. If d_input is not a perfect sqaure, interpolate\n",
    "        T, B, num_heads, _, num_positions = attention.shape\n",
    "        attention = torch.tensor(attention, dtype=torch.float32).mean(dim=2).squeeze(2)\n",
    "        height = int(num_positions**0.5)\n",
    "        while num_positions % height != 0: height -= 1\n",
    "        width = num_positions // height\n",
    "        attention = attention.view(T, B, height, width)\n",
    "        return F.interpolate(attention, size=(target_size, target_size), mode='bilinear', align_corners=False)\n",
    "\n",
    "    batch_index = 0\n",
    "    n_neurons_to_visualise = 16\n",
    "    figscale = 0.28\n",
    "    n_steps = len(pre_activations)\n",
    "    heCTMap_cmap = sns.color_palette(\"viridis\", as_cmap=True)\n",
    "    frames = []\n",
    "\n",
    "    attention = reshape_attention_weights(attention)\n",
    "\n",
    "    these_pre_acts = pre_activations[:, batch_index, :]\n",
    "    these_post_acts = post_activations[:, batch_index, :]\n",
    "    these_inputs = inputs_to_model[batch_index,:, :, :]\n",
    "    these_attention_weights = attention[:, batch_index, :, :]\n",
    "    these_predictions = predictions[batch_index, :, :]\n",
    "    these_certainties = certainties[batch_index, :, :]\n",
    "    this_target = targets[batch_index]\n",
    "\n",
    "    class_labels = [str(i) for i in range(these_predictions.shape[0])]\n",
    "\n",
    "    mosaic = [['img_data', 'img_data', 'attention', 'attention', 'probs', 'probs', 'probs', 'probs'] for _ in range(2)] + \\\n",
    "             [['img_data', 'img_data', 'attention', 'attention', 'probs', 'probs', 'probs', 'probs'] for _ in range(2)] + \\\n",
    "             [['certainty'] * 8] + \\\n",
    "             [[f'trace_{ti}'] * 8 for ti in range(n_neurons_to_visualise)]\n",
    "\n",
    "    for stepi in tqdm(range(n_steps), desc=\"Processing steps\", unit=\"step\"):\n",
    "        fig_gif, axes_gif = plt.subplot_mosaic(mosaic=mosaic, figsize=(31*figscale*8/4, 76*figscale))\n",
    "        probs = softmax(these_predictions[:, stepi])\n",
    "        colors = [('g' if i == this_target else 'b') for i in range(len(probs))]\n",
    "\n",
    "        axes_gif['probs'].bar(np.arange(len(probs)), probs, color=colors, width=0.9, alpha=0.5)\n",
    "        axes_gif['probs'].set_title('Probabilities')\n",
    "        axes_gif['probs'].set_xticks(np.arange(len(probs)))\n",
    "        axes_gif['probs'].set_xticklabels(class_labels, fontsize=24)\n",
    "        axes_gif['probs'].set_yticks([])\n",
    "        axes_gif['probs'].tick_params(left=False, bottom=False)\n",
    "        axes_gif['probs'].set_ylim([0, 1])\n",
    "        for spine in axes_gif['probs'].spines.values():\n",
    "            spine.set_visible(False)\n",
    "        axes_gif['probs'].tick_params(left=False, bottom=False)\n",
    "        axes_gif['probs'].spines['top'].set_visible(False)\n",
    "        axes_gif['probs'].spines['right'].set_visible(False)\n",
    "        axes_gif['probs'].spines['left'].set_visible(False)\n",
    "        axes_gif['probs'].spines['bottom'].set_visible(False)\n",
    "\n",
    "        # Certainty\n",
    "        axes_gif['certainty'].plot(np.arange(n_steps), these_certainties[1], 'k-', linewidth=2)\n",
    "        axes_gif['certainty'].set_xlim([0, n_steps-1])\n",
    "        axes_gif['certainty'].axvline(x=stepi, color='black', linewidth=1, alpha=0.5)\n",
    "        axes_gif['certainty'].set_xticklabels([])\n",
    "        axes_gif['certainty'].set_yticklabels([])\n",
    "        axes_gif['certainty'].grid(False)\n",
    "        for spine in axes_gif['certainty'].spines.values():\n",
    "            spine.set_visible(False)\n",
    "\n",
    "        # Neuron Traces\n",
    "        for neuroni in range(n_neurons_to_visualise):\n",
    "            ax = axes_gif[f'trace_{neuroni}']\n",
    "            pre_activation = these_pre_acts[:, neuroni]\n",
    "            post_activation = these_post_acts[:, neuroni]\n",
    "            ax_pre = ax.twinx()\n",
    "\n",
    "            ax_pre.plot(np.arange(n_steps), pre_activation, color='grey', linestyle='--', linewidth=1, alpha=0.4)\n",
    "            color = 'blue' if neuroni % 2 else 'red'\n",
    "            ax.plot(np.arange(n_steps), post_activation, color=color, linewidth=2, alpha=1.0)\n",
    "\n",
    "            ax.set_xlim([0, n_steps-1])\n",
    "            ax_pre.set_xlim([0, n_steps-1])\n",
    "            ax.set_ylim([np.min(post_activation), np.max(post_activation)])\n",
    "            ax_pre.set_ylim([np.min(pre_activation), np.max(pre_activation)])\n",
    "\n",
    "            ax.axvline(x=stepi, color='black', linewidth=1, alpha=0.5)\n",
    "            ax.set_xticklabels([])\n",
    "            ax.set_yticklabels([])\n",
    "            ax.grid(False)\n",
    "            ax_pre.set_xticklabels([])\n",
    "            ax_pre.set_yticklabels([])\n",
    "            ax_pre.grid(False)\n",
    "\n",
    "            for spine in ax.spines.values():\n",
    "                spine.set_visible(False)\n",
    "            for spine in ax_pre.spines.values():\n",
    "                spine.set_visible(False)\n",
    "\n",
    "        # Input image\n",
    "        this_image = these_inputs[0]\n",
    "        this_image = (this_image - this_image.min()) / (this_image.max() - this_image.min() + 1e-8)\n",
    "        axes_gif['img_data'].set_title('Input Image')\n",
    "        axes_gif['img_data'].imshow(this_image, cmap='binary', vmin=0, vmax=1)\n",
    "        axes_gif['img_data'].axis('off')\n",
    "\n",
    "        # Attention\n",
    "        this_input_gate = these_attention_weights[stepi]\n",
    "        gate_min, gate_max = np.nanmin(this_input_gate), np.nanmax(this_input_gate)\n",
    "        if not np.isclose(gate_min, gate_max):\n",
    "            normalized_gate = (this_input_gate - gate_min) / (gate_max - gate_min + 1e-8)\n",
    "        else:\n",
    "            normalized_gate = np.zeros_like(this_input_gate)\n",
    "        attention_weights_heCTMap = heCTMap_cmap(normalized_gate)[:,:,:3]\n",
    "\n",
    "        axes_gif['attention'].imshow(attention_weights_heCTMap, vmin=0, vmax=1)\n",
    "        axes_gif['attention'].axis('off')\n",
    "        axes_gif['attention'].set_title('Attention')\n",
    "\n",
    "        fig_gif.tight_layout()\n",
    "        canvas = fig_gif.canvas\n",
    "        canvas.draw()\n",
    "        image_numpy = np.frombuffer(canvas.buffer_rgba(), dtype='uint8')\n",
    "        image_numpy = image_numpy.reshape(*reversed(canvas.get_width_height()), 4)[:, :, :3]\n",
    "        frames.append(image_numpy)\n",
    "        plt.close(fig_gif)\n",
    "\n",
    "\n",
    "    mediapy.show_video(frames, width=400, codec=\"gif\")\n",
    "    imageio.mimsave(filename, frames, fps=5, loop=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20040db6",
   "metadata": {},
   "source": [
    "The top row of the gif shows the input image, the attention weights and the models predictions.\n",
    "\n",
    "The second plot, in black, shows the models certainty over time.\n",
    "\n",
    "The red and blue lines correspond to the post-activations of different neurons, with the corresponding pre-activation shown in gray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "20040db6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"show_videos\" style=\"border-spacing:0px;\"><tr><td style=\"padding:1px;\"><img width=\"400\" height=\"490\" style=\"image-rendering:auto; object-fit:cover;\" src=\"data:image/gif;base64,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\"/></td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "logdir = f\"mnist_logs\"\n",
    "if not os.path.exists(logdir):\n",
    "    os.makedirs(logdir)\n",
    "\n",
    "model.eval()\n",
    "with torch.inference_mode():\n",
    "    inputs, targets = next(iter(testloader))\n",
    "    inputs = inputs.to(device)\n",
    "\n",
    "    predictions, certainties, (synch_out_tracking, synch_action_tracking), \\\n",
    "    pre_activations_tracking, post_activations_tracking, attention = model(inputs, track=True)\n",
    "\n",
    "    make_gif(\n",
    "        predictions.detach().cpu().numpy(),\n",
    "        certainties.detach().cpu().numpy(),\n",
    "        targets.detach().cpu().numpy(),\n",
    "        pre_activations_tracking,\n",
    "        post_activations_tracking,\n",
    "        attention,\n",
    "        inputs.detach().cpu().numpy(),\n",
    "        f\"{logdir}/prediction.gif\"\n",
    "    )"
   ]
  }
 ],
 "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.12.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}