4.attention_bitnet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "98401197-5502-4471-9814-c1d21912922b",
   "metadata": {},
   "source": [
    "# Attention intuition - BitNet\n",
    "\n",
    "The lecture notes on Deep Learning from [Francois Fleuret](https://fleuret.org/dlc/materials/dlc-handout-13-2-attention-mechanisms.pdf) contain a very nice intuition on why and where the attention mechanism works better than conv nets.\n",
    "\n",
    "In this example we implement a simple bitnet to show the intuition behind the attention mechanism.\n",
    "\n",
    "BitNet: Scaling 1-bit Transformers for Large Language Models from [Google Research](https://arxiv.org/abs/2310.11453)\n",
    "\n",
    "\n",
    "\n",
    "![](images/data2_example.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1f324fd-ecee-4d11-860b-f631986709ad",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "\n",
    "Follow below one example of the dataset with the input and its corresponding target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d795d803-ad0f-4266-a664-a2712a6c7213",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb41c28b670>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from dataclasses import dataclass\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Please, set the device according to your setup\n",
    "DEVICE = \"cuda\"\n",
    "SIZE = 200\n",
    "\n",
    "np.random.seed(39)\n",
    "\n",
    "\n",
    "def norm_0_1(X):\n",
    "    return (X - X.min()) / (X.max() - X.min())\n",
    "\n",
    "def norm_height(X, max_height):\n",
    "    #return (X - X.min()) / (X.max() - X.min())\n",
    "    return X / max_height\n",
    "\n",
    "\n",
    "def positional_encoding(max_position, d_model, min_freq=1e-4):\n",
    "    # With sinusoidal positional encoding\n",
    "    position = np.arange(max_position)\n",
    "    freqs = min_freq**(2*(np.arange(d_model)//2)/d_model)\n",
    "    pos_enc = position.reshape(-1,1)*freqs.reshape(1,-1)\n",
    "    pos_enc[:, ::2] = np.cos(pos_enc[:, ::2])\n",
    "    pos_enc[:, 1::2] = np.sin(pos_enc[:, 1::2])\n",
    "    return pos_enc\n",
    "\n",
    "\n",
    "def positional_encoding_simple(max_position, d_model, min_freq=1e-4):\n",
    "    # With sinusoidal positional encoding\n",
    "    pos_enc = np.expand_dims(np.arange(max_position)/max_position, axis=1)\n",
    "    return pos_enc\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class ShapeLog:\n",
    "    \"\"\"\n",
    "    A class to store the information about the shapes in the image\n",
    "    \"\"\"\n",
    "\n",
    "    shape_type: str\n",
    "    base_point: int\n",
    "    width: int\n",
    "    height: int\n",
    "\n",
    "\n",
    "def generate_pair(size: int = 100, max_height: int = 50, noise_std: float = 0.3, num_shapes:int = 4):\n",
    "    \"\"\"\n",
    "    Generate a pair of images. One with the randomly generated sequence of triangles and/or rectangles\n",
    "    and the other one with the average hights of the shapes in the first image.\n",
    "\n",
    "    Args:\n",
    "        size: The size of the image on the x axis\n",
    "        max_height: The maximum hight of the shapes\n",
    "\n",
    "    Returns:\n",
    "        A tuple of two images. The first one is the image with the shapes and the second one is the image with the average hight of the shapes\n",
    "    \"\"\"\n",
    "\n",
    "    min_height = 5\n",
    "    base_size_range = [3, 10]\n",
    "\n",
    "    shape_choices = [\"triangle\", \"rectangle\"]\n",
    "    # shape_choices = [\"triangle\"]\n",
    "    #convert_to_bin = lambda decimal: [int(s) for s in str(bin(decimal).replace(\"0b\", \"\")).zfill(7)]\n",
    "    shape_logs = []\n",
    "\n",
    "    input = np.zeros(size)\n",
    "\n",
    "    def draw(input, shape_log):\n",
    "        if shape_log.shape_type == \"triangle\":\n",
    "            pick_point = (shape_log.base_point + (shape_log.base_point + shape_log.width)) // 2\n",
    "            input[pick_point] = shape_log.height\n",
    "\n",
    "            # Computing the triangle's first ramp\n",
    "            num_points = pick_point - shape_log.base_point\n",
    "            values = np.linspace(0, shape_log.height, num=num_points, endpoint=False, dtype=int)\n",
    "            input[shape_log.base_point : (shape_log.base_point + shape_log.width // 2)] = values\n",
    "\n",
    "            # Computing the triangle's second ramp\n",
    "            num_points = (shape_log.base_point + shape_log.width) - pick_point\n",
    "            values = np.linspace(shape_log.height, 0, num=num_points, endpoint=False, dtype=int)\n",
    "            \n",
    "            word_size = min(size, shape_log.base_point + shape_log.width) - (\n",
    "                shape_log.base_point + shape_log.width // 2\n",
    "            )\n",
    "            input[\n",
    "                (shape_log.base_point + shape_log.width // 2) : min(size, shape_log.base_point + shape_log.width)\n",
    "            ] = values[0:word_size]\n",
    "\n",
    "\n",
    "        else:\n",
    "            # Rectangle\n",
    "            input[shape_log.base_point : (shape_log.base_point + shape_log.width)] = shape_log.height\n",
    "\n",
    "        return input\n",
    "\n",
    "    def average_shapelogs(shape_logs):\n",
    "        # Average the two left most and the two right most        \n",
    "        half_way = len(shape_logs) // 2        \n",
    "        mean_0 = np.mean([shape_logs[i].height for i in range(half_way)])        \n",
    "        mean_1 = np.mean([shape_logs[i].height for i in range(half_way,len(shape_logs))])\n",
    "        \n",
    "        for i in range(half_way):\n",
    "            shape_logs[i].height = mean_0\n",
    "\n",
    "        for i in range(half_way,len(shape_logs)):\n",
    "            shape_logs[i].height = mean_1\n",
    "\n",
    "        input_averages = np.zeros(size)\n",
    "        for shape in shape_logs:\n",
    "            input_averages = draw(input_averages, shape)\n",
    "\n",
    "        return input_averages\n",
    "    \n",
    "    def remove_overlaps(shape_logs):\n",
    "        # Removing basic overlaps (it has some flaws, but f*** *t)\n",
    "        \n",
    "        for i in range(len(shape_logs)-1):            \n",
    "            \n",
    "            # Check overlap\n",
    "            if shape_logs[i].base_point+shape_logs[i].width > shape_logs[i+1].base_point:\n",
    "                if i<num_shapes//2:\n",
    "                    shape_logs[i].base_point -= max(0,shape_logs[i].base_point+shape_logs[i].width)-shape_logs[i+1].base_point-1\n",
    "                else:\n",
    "                    shape_logs[i].base_point += min(size,shape_logs[i].base_point+shape_logs[i].width)-shape_logs[i+1].base_point+1\n",
    "        \n",
    "        # Treating the last one\n",
    "        if shape_logs[-1].base_point+shape_logs[-1].width > shape_logs[-2].base_point:\n",
    "            shape_logs[-1].base_point = min(size,shape_logs[-2].base_point+shape_logs[-2].width)+1\n",
    "\n",
    "        return shape_logs\n",
    "            \n",
    "    \n",
    "    \n",
    "    # Picking the middle points\n",
    "    #base_points = sorted(np.random.uniform(0,100, size=num_shapes).astype(\"uint\"))                \n",
    "    seeds = [(i*(size//num_shapes), i*(size//num_shapes) + size//num_shapes) for i in range(num_shapes)]    \n",
    "    base_points = [np.random.randint(mi, ma) for mi,ma in seeds]        \n",
    "    widths = np.random.randint(base_size_range[0], base_size_range[1], size=num_shapes)\n",
    "    heights = np.random.randint(min_height, max_height, size=num_shapes)                       \n",
    "    shapes = np.random.choice(shape_choices, num_shapes)\n",
    "    \n",
    "    shape_logs = [\n",
    "        ShapeLog(shape_type, base_point, width, height)\n",
    "        for shape_type, base_point, width, height in zip(shapes, base_points, widths, heights)\n",
    "    ]\n",
    "    \n",
    "    shape_logs = remove_overlaps(shape_logs)\n",
    "\n",
    "    for shape in shape_logs:\n",
    "        input = draw(input, shape)\n",
    "                         \n",
    "    input += np.random.normal(0, noise_std, size)\n",
    "\n",
    "    target = average_shapelogs(shape_logs) + np.random.normal(0, noise_std, size)\n",
    "\n",
    "    input = norm_height(input, max_height) \n",
    "    target = norm_height(target, max_height)\n",
    "\n",
    "    \n",
    "    # Creating the absolute position encoding\n",
    "    #pe = positional_encoding_fn(size, 1).T[0]        \n",
    "        \n",
    "\n",
    "    input = np.expand_dims(input, axis=0).astype(np.float32)\n",
    "    #pe = np.expand_dims(pe, axis=0).astype(np.float32)\n",
    "    target = np.expand_dims(target, axis=0).astype(np.float32)\n",
    "\n",
    "    return input, target\n",
    "\n",
    "\n",
    "\n",
    "class ShapeDataset(Dataset):\n",
    "    def __init__(self, max_samples=1000, size=100, max_height=50, noise_std=0.3):\n",
    "        \"\"\"\n",
    "        Shape dataset.\n",
    "        It generates a pair of images. One with the randomly generated sequence of triangles and/or rectangles\n",
    "        and the other one with the average hights of the shapes in the first image.\n",
    "\n",
    "        Args:\n",
    "            max_samples: The number of samples to generate\n",
    "            size: The size of the image on the x axis\n",
    "            max_hight: The maximum hight of the shapes\n",
    "            noise_std: The standard deviation of the noise to add to the images\n",
    "\n",
    "        \"\"\"\n",
    "        self.images = [generate_pair(size=size, max_height=max_height, noise_std=noise_std) for _ in range(max_samples)]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.images)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.images[idx][0], self.images[idx][1]\n",
    "\n",
    "\n",
    "\n",
    "positional_encoding_fn = positional_encoding_simple\n",
    "#positional_encoding_fn = positional_encoding\n",
    "original, target = generate_pair(max_height=100, size=SIZE)\n",
    "\n",
    "# Plotting the dataset\n",
    "fig = plt.figure()\n",
    "#pe = positional_encoding_fn(SIZE, 1).T[0]\n",
    "plt.plot(range(len(original[0])), original[0], label=\"input\")\n",
    "plt.plot(range(len(target[0])), target[0], label=\"target\")\n",
    "plt.legend()    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eea1cd90-1498-4abd-9cbf-6f44cf18085c",
   "metadata": {},
   "source": [
    "## Training the models\n",
    "\n",
    "In this example, I'm using the standard positional encoding from the Transformer architecture. The positional encoding is a tensor of shape (1, seq_len, d_model) where seq_len is the length of the sequence and d_model is the dimension of the model. The positional encoding is added to the input tensor before the first layer of the model.\n",
    "\n",
    "As we can see, positional encoding has a better convergency than vanilla self attention."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3f805d4c-6f43-422d-a78c-85fad782bb10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training with attention model WITH NO positional encoding\n",
      "Epoch: 0, Loss: 0.0045610154047608376\n",
      "Epoch: 10, Loss: 0.0023988212924450636\n",
      "Epoch: 20, Loss: 0.002517537446692586\n",
      "Epoch: 30, Loss: 0.0018084502080455422\n",
      "Epoch: 40, Loss: 0.0029751898255199194\n",
      "Training with attention model WITH positional encoding\n",
      "Epoch: 0, Loss: 0.004117781296372414\n",
      "Epoch: 10, Loss: 0.0015379803953692317\n",
      "Epoch: 20, Loss: 0.0010360627202317119\n",
      "Epoch: 30, Loss: 0.001225918298587203\n",
      "Epoch: 40, Loss: 0.0005472598713822663\n",
      "Training with BitNet model WITH positional encoding\n",
      "Epoch: 0, Loss: 84.75437927246094\n",
      "Epoch: 10, Loss: 0.04162261262536049\n",
      "Epoch: 20, Loss: 0.07048942148685455\n",
      "Epoch: 30, Loss: 0.7557918429374695\n",
      "Epoch: 40, Loss: 0.37931951880455017\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Implementation of the self attention layer\n",
    "class SelfAttentionLayer(nn.Module):\n",
    "    \"\"\"\n",
    "    Scale Dot-Product attention: SoftMax((QK^T/sqrt(d_k))*V)\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, in_dim, out_dim, key_dim):\n",
    "        super().__init__()\n",
    "        self.conv_Q = nn.Conv1d(in_dim, key_dim, kernel_size=1, bias=False)\n",
    "        self.conv_K = nn.Conv1d(in_dim, key_dim, kernel_size=1, bias=False)\n",
    "        self.conv_V = nn.Conv1d(in_dim, out_dim, kernel_size=1, bias=False)\n",
    "\n",
    "    def forward(self, x):\n",
    "        Q = self.conv_Q(x)\n",
    "        K = self.conv_K(x)\n",
    "        V = self.conv_V(x)\n",
    "        A = (Q.transpose(1, 2) @ K) / np.sqrt(K.shape[1])\n",
    "        A = F.softmax(A, dim=2)        \n",
    "        y = (A@(V.transpose(1, 2))).transpose(1, 2)\n",
    "        return y\n",
    "    \n",
    "    def forward_attention(self, x):\n",
    "        Q = self.conv_Q(x)\n",
    "        K = self.conv_K(x)        \n",
    "        A = F.softmax(Q.transpose(1, 2)@K, 2)\n",
    "        return A\n",
    "    \n",
    "def train_model(model, epochs=20, device=\"cuda\"):\n",
    "    \"\"\"\n",
    "    Training shebang\n",
    "    \"\"\"\n",
    "\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        dataset=ShapeDataset(size=100, max_height=50, noise_std=0.3, max_samples=10000),\n",
    "        batch_size=32,\n",
    "        shuffle=True,\n",
    "        num_workers=4,\n",
    "        pin_memory=True,\n",
    "    )\n",
    "\n",
    "    model.train()\n",
    "    model.to(device)\n",
    "\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "    criterion = torch.nn.MSELoss()\n",
    "    loss_per_epoch = []    \n",
    "    for epoch in range(epochs):\n",
    "        for i, (input, target) in enumerate(train_loader):\n",
    "            input = input.to(device)\n",
    "            target = target.to(device)\n",
    "            #pe = pe.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            output = model(input)\n",
    "            loss = criterion(output, target)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        if epoch%10==0:\n",
    "            print(f\"Epoch: {epoch}, Loss: {loss.item()}\")\n",
    "        loss_per_epoch.append(loss.item())\n",
    "\n",
    "    return loss_per_epoch\n",
    "\n",
    "\n",
    "\n",
    "class ModelWithNOPE(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\"),\n",
    "            nn.GELU(),\n",
    "            SelfAttentionLayer(in_dim=64, out_dim=64, key_dim=64),\n",
    "            nn.GELU(),\n",
    "            nn.Conv1d(64, 1, kernel_size=(5,), padding=\"same\"),\n",
    "        )\n",
    "    \n",
    "    def forward(self, x):        \n",
    "        return self.model(x)\n",
    "\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return iter(self.model)\n",
    "\n",
    "\n",
    "class ModelWithPE(nn.Module):\n",
    "    def __init__(self, positional_encoding_fn=positional_encoding_simple):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.positional_encoding_fn = positional_encoding_fn\n",
    "        self.conv1_pe = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.conv2_no_pe = nn.Sequential(    \n",
    "            nn.GELU(),\n",
    "            SelfAttentionLayer(in_dim=64, out_dim=64, key_dim=64),\n",
    "            nn.GELU(),\n",
    "            nn.Conv1d(64, 1, kernel_size=(5,), padding=\"same\")\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        pe = self.positional_encoding_fn(x.shape[-1], 1).T[0]\n",
    "        pe = torch.Tensor(pe).unsqueeze(0).to(x.device)\n",
    "\n",
    "        data = self.conv1(x)\n",
    "        pe = self.conv1_pe(pe)\n",
    "\n",
    "        return self.conv2_no_pe(data + pe)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self.conv2_no_pe)\n",
    "\n",
    "\n",
    "\n",
    "class BitLinear(nn.Module):\n",
    "    \"\"\"\n",
    "    BitLinear module as described in the BitNet architecture from Figure 2(a) of the paper\n",
    "\n",
    "    https://arxiv.org/pdf/2310.11453.pdf\n",
    "\n",
    "    It performs:\n",
    "      - linear transformation with 1-bit quantized weights.\n",
    "      - quantization step\n",
    "      - matrix multiplication,\n",
    "      - dequantization step. \n",
    "      \n",
    "    Quantization and dequantization are learnable parameters\n",
    "\n",
    "    Args:\n",
    "    - in_features: size of each input sample\n",
    "    - out_features: size of each output sample\n",
    "    - gamma: scaling factor for absmax quantization (learnable parameter)\n",
    "    - beta: scaling factor for dequantization (learnable parameter)\n",
    "    - weight: the 1-bit quantized weights of the linear transformation\n",
    "    - bias: the bias term for the linear transformation (optional)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, in_features, out_features, bias=True):\n",
    "        super().__init__()\n",
    "        self.in_features = in_features\n",
    "        self.out_features = out_features\n",
    "\n",
    "        # Initialize weights and bias\n",
    "        self.weight = nn.Parameter(torch.randn(out_features, in_features))\n",
    "        if bias:\n",
    "            self.bias = nn.Parameter(torch.randn(out_features))\n",
    "        else:\n",
    "            self.register_parameter(\"bias\", None)\n",
    "\n",
    "        # quantization and dequantization parameters\n",
    "        self.gamma = nn.Parameter(torch.ones(in_features))\n",
    "        self.beta = nn.Parameter(torch.ones(out_features))\n",
    "\n",
    "    def forward(self, input):\n",
    "        # Apply Layer Normalization (Fig 2(a) from the paper)\n",
    "        input_norm = F.layer_norm(input, (self.in_features,))\n",
    "\n",
    "        # Absmax Quantization (Fig 2(a) from the paper)\n",
    "        quant_scale = torch.max(torch.abs(input_norm), dim=1, keepdim=True).values\n",
    "        input_quant = torch.sign(input_norm) * (quant_scale / self.gamma) # (Eq 2)\n",
    "\n",
    "        # 1-bit Quantization\n",
    "        weight_quant = torch.sign(self.weight) # (Eq 3)\n",
    "\n",
    "        # MatMul with 1-bit weights\n",
    "        output = torch.matmul(input_quant, weight_quant.t())# (Eq 4)\n",
    "\n",
    "        # Adding bias if it exists\n",
    "        if self.bias is not None:\n",
    "            output += self.bias.unsqueeze(0).expand_as(output)\n",
    "\n",
    "        # Dequantization with learnable parameters\n",
    "        output = output * self.beta.unsqueeze(0).expand_as(output)\n",
    "\n",
    "        return output  \n",
    "\n",
    "\n",
    "class BitFeedForward(nn.Module):\n",
    "    \"\"\"\n",
    "    BitFeedForward module applies feed-forward from Figure 2(b) in the paper\n",
    "    https://arxiv.org/pdf/2310.11453.pdf\n",
    "\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input_dim: int, n_features: int = 4, *args, **kwargs):\n",
    "        super().__init__()\n",
    "        hidden_dim = input_dim * n_features\n",
    "\n",
    "        self.layer = nn.Sequential(\n",
    "            BitLinear(input_dim, hidden_dim, *args, **kwargs),\n",
    "            nn.GELU(),\n",
    "            BitLinear(hidden_dim, input_dim, *args, **kwargs),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.layer(x)\n",
    "\n",
    "\n",
    "class ModelBitNet(nn.Module):\n",
    "    \"\"\"\n",
    "    Applying transformers with BitNet\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, positional_encoding_fn=positional_encoding_simple):        \n",
    "        super().__init__()\n",
    "\n",
    "\n",
    "        self.conv1 = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.positional_encoding_fn = positional_encoding_fn\n",
    "        self.conv1_pe = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.transformer = nn.Sequential(    \n",
    "            SelfAttentionLayer(in_dim=64, out_dim=64, key_dim=64),\n",
    "            nn.Flatten(),\n",
    "            BitFeedForward(6400, n_features=4)\n",
    "        )\n",
    "\n",
    "        self.conv2 = nn.Conv1d(64, 1, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "    def forward(self, x):\n",
    "        input_size = x.shape[-1]\n",
    "        n_channels = 64\n",
    "        pe = self.positional_encoding_fn(x.shape[-1], 1).T[0]\n",
    "        pe = torch.Tensor(pe).unsqueeze(0).to(x.device)\n",
    "\n",
    "        data = self.conv1(x)\n",
    "        pe = self.conv1_pe(pe)\n",
    "\n",
    "        embedding = data + pe\n",
    "\n",
    "        transformed = self.transformer(embedding)\n",
    "        # Reshaping to the original numbers of channels and size\n",
    "        reshaping = transformed.view(-1, n_channels, input_size)\n",
    "\n",
    "        output = self.conv2(reshaping)\n",
    "\n",
    "        return output\n",
    "\n",
    "\n",
    "\n",
    "# Training with self attention\n",
    "print(\"Training with attention model WITH NO positional encoding\")\n",
    "attention_model = ModelWithNOPE()\n",
    "loss_per_epoch_attention = train_model(attention_model, epochs=50, device=DEVICE)\n",
    "\n",
    "print(\"Training with attention model WITH positional encoding\")\n",
    "attention_model_pe = ModelWithPE(positional_encoding_fn=positional_encoding_fn)\n",
    "loss_per_epoch_attention_pe = train_model(attention_model_pe, epochs=50, device=DEVICE)\n",
    "\n",
    "print(\"Training with BitNet model WITH positional encoding\")\n",
    "bitnet_model = ModelBitNet(positional_encoding_fn=positional_encoding_fn)\n",
    "loss_per_epoch_bitnet = train_model(bitnet_model, epochs=50, device=DEVICE)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "53653f15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb2f9325ba0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.semilogy(loss_per_epoch_attention, label=\"With Attention, no PE\")\n",
    "plt.semilogy(loss_per_epoch_attention_pe, label=\"With Attention, WITH PE\")\n",
    "plt.semilogy(loss_per_epoch_bitnet, label=\"BitNet\")\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60821676-a218-42c3-92f4-620bf1059b76",
   "metadata": {},
   "source": [
    "## Visualizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2a193b75-b2cf-4afd-a8d1-0e6e87dba778",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb2f931b340>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x800 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(1000)\n",
    "input, target = generate_pair(max_height=100, size=SIZE)\n",
    "\n",
    "input = np.expand_dims(input, axis=0)\n",
    "target = np.expand_dims(target, axis=0)\n",
    "\n",
    "attention_model.eval()\n",
    "attention_model_pe.eval()\n",
    "\n",
    "input = torch.tensor(input)\n",
    "\n",
    "input_tensor = input.to(DEVICE)\n",
    "\n",
    "\n",
    "def extract_attention(model, input_tensor, with_pe=False):\n",
    "    # It is a little bit improvised, but it is for educational purposes\n",
    "    attention = []\n",
    "    if with_pe:\n",
    "\n",
    "        pe = positional_encoding_fn(input_tensor.shape[-1], 1).T[0]\n",
    "        pe = torch.Tensor(pe).unsqueeze(0).to(input_tensor.device)\n",
    "        \n",
    "        x = model.conv1(input_tensor)\n",
    "        pe = model.conv1_pe(pe)\n",
    "\n",
    "        x = x + pe\n",
    "\n",
    "    else:\n",
    "        x = input_tensor\n",
    "\n",
    "    for layer in model:\n",
    "        if isinstance(layer, SelfAttentionLayer):\n",
    "            attention.append(layer.forward_attention(x))        \n",
    "        x = layer(x)\n",
    "    return attention\n",
    "\n",
    "\n",
    "attention = extract_attention(attention_model, input_tensor)[0]\n",
    "attention = attention.detach().to(\"cpu\").numpy()[0]\n",
    "predicted = attention_model(input_tensor)[0][0].detach().to(\"cpu\").numpy()\n",
    "\n",
    "\n",
    "attention_pe = extract_attention(attention_model_pe, input_tensor, with_pe=True)[0]\n",
    "attention_pe = attention_pe.detach().to(\"cpu\").numpy()[0]\n",
    "predicted_pe = attention_model_pe(input_tensor)[0][0].detach().to(\"cpu\").numpy()\n",
    "\n",
    "input = input.detach().to(\"cpu\").numpy()\n",
    "#target = target.detach().to(\"cpu\").numpy()\n",
    "#print(input[0][0])\n",
    "\n",
    "fig, (ax1, ax2, ax3) = plt.subplots(3,1, figsize=(16,8))\n",
    "ax1.imshow(attention)\n",
    "ax2.imshow(attention_pe)\n",
    "ax3.plot(range(len(input[0][0])), input[0][0], label=\"input\")\n",
    "ax3.plot(range(len(target[0][0])), target[0][0], label=\"target\")\n",
    "ax3.plot(range(len(predicted)), predicted, label=\"predicted target, attention NO PE\")\n",
    "ax3.plot(range(len(predicted_pe)), predicted_pe, label=\"predicted target, attention WITH PE\")\n",
    "plt.legend()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "2f9d9e6eb49d62606f5e03e9ead32f50f14df44f9930d8630da1fdfce2c5ab4e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}