Efficient_Attention.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mrigankpawagi/EfficientAttention-TermPaper/blob/main/Efficient_Attention.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IT2uXIBELQ0f"
      },
      "source": [
        "Contributors: Rohit Jorige, Mrigank Pawagi, Nagasai, Sahil Chaudhary\n",
        "\n",
        "Advisor: Dhruva Kashyap\n",
        "\n",
        "**Efficient Attention**\n",
        "\n",
        "The dominant sequence transduction models are based on complex recurrent or convulational neural networks that include an encoder and decoder. Vashwani et. al. proposed new simple network architecture, the Transformer based solely on attention mechanism dispensing with recurrence and convulations entirely. There is a scope of improvement on the mechanism proposed by vaswant et. al.\n",
        "\n",
        "Attention is a very important mechanism introduce in the field of LLMs and understanding the improvement in attention is very important. The time complexity of simple attention mechanism is quadratic in nature and its a problematic time complexity for a very large number of data. Thus, Approv vyas et. al. proposed a linear transformer for the same introducing kernels to similarity function.\n",
        "\n",
        "This Google Collab includes the experiments done around\n",
        "1. Attention\n",
        "2. Linear Transformer\n",
        "3. Improving attention using LoRA\n",
        "4. (And others???)\n",
        "\n",
        "We have tried various experiments around MNIST, cifar-10 and compare the time required to perform forward and backward pass for variety of sequence lengths and batch sizes.\n",
        "\n",
        "**Credits**\n",
        "1. https://github.com/idiap/fast-transformers?tab=readme-ov-file\n",
        "2. https://github.com/lucidrains/linear-attention-transformer\n",
        "3. https://github.com/EugenHotaj/pytorch-generative/blob/master/pytorch_generative/nn/attention.py\n",
        "4. https://github.com/davidsvy/cosformer-pytorch\n",
        "5. https://github.com/kyle-gao/TF_Transformer\n",
        "\n",
        "**Papers Followed:**\n",
        "1. Attention is all you need: https://arxiv.org/pdf/1706.03762.pdf\n",
        "2. Transformers are RNNs: https: //arxiv.org/pdf/2006.16236.pdf\n",
        "3. LoRA: https://arxiv.org/pdf/2106.09685.pdf"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G0mo0btDOnOs"
      },
      "source": [
        "# Installation and First Steps\n",
        "The installation is directly from PyPI. This will take several minutes since it compiles several custom CUDA kernels, not only for linear autoregressive attention. Maybe grab a coffee (if you are into these things).\n",
        "\n",
        "Bare with me. It takes 20 minutes to just install it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YSW2PtZoLPsv",
        "outputId": "3ac6f8aa-63ea-4907-e5c3-5ed6e8ec33d1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting pytorch-fast-transformers\n",
            "  Downloading pytorch-fast-transformers-0.4.0.tar.gz (93 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/93.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m93.6/93.6 kB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from pytorch-fast-transformers) (2.2.1+cu121)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch->pytorch-fast-transformers) (3.13.3)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch->pytorch-fast-transformers) (4.10.0)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->pytorch-fast-transformers) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->pytorch-fast-transformers) (3.2.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->pytorch-fast-transformers) (3.1.3)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch->pytorch-fast-transformers) (2023.6.0)\n",
            "Collecting nvidia-cuda-nvrtc-cu12==12.1.105 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (23.7 MB)\n",
            "Collecting nvidia-cuda-runtime-cu12==12.1.105 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (823 kB)\n",
            "Collecting nvidia-cuda-cupti-cu12==12.1.105 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (14.1 MB)\n",
            "Collecting nvidia-cudnn-cu12==8.9.2.26 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl (731.7 MB)\n",
            "Collecting nvidia-cublas-cu12==12.1.3.1 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl (410.6 MB)\n",
            "Collecting nvidia-cufft-cu12==11.0.2.54 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl (121.6 MB)\n",
            "Collecting nvidia-curand-cu12==10.3.2.106 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl (56.5 MB)\n",
            "Collecting nvidia-cusolver-cu12==11.4.5.107 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl (124.2 MB)\n",
            "Collecting nvidia-cusparse-cu12==12.1.0.106 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl (196.0 MB)\n",
            "Collecting nvidia-nccl-cu12==2.19.3 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_nccl_cu12-2.19.3-py3-none-manylinux1_x86_64.whl (166.0 MB)\n",
            "Collecting nvidia-nvtx-cu12==12.1.105 (from torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (99 kB)\n",
            "Requirement already satisfied: triton==2.2.0 in /usr/local/lib/python3.10/dist-packages (from torch->pytorch-fast-transformers) (2.2.0)\n",
            "Collecting nvidia-nvjitlink-cu12 (from nvidia-cusolver-cu12==11.4.5.107->torch->pytorch-fast-transformers)\n",
            "  Using cached nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->pytorch-fast-transformers) (2.1.5)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->pytorch-fast-transformers) (1.3.0)\n",
            "Building wheels for collected packages: pytorch-fast-transformers\n",
            "  Building wheel for pytorch-fast-transformers (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pytorch-fast-transformers: filename=pytorch_fast_transformers-0.4.0-cp310-cp310-linux_x86_64.whl size=20054885 sha256=e8b8ee88822f8bba3c08c6b6acbd16a08c914e45f62fe32d9a5f01209b957f32\n",
            "  Stored in directory: /root/.cache/pip/wheels/99/6b/6d/4abca344e31b65962d8e9d6fe298a5d2b89ff448493edc0df5\n",
            "Successfully built pytorch-fast-transformers\n",
            "Installing collected packages: nvidia-nvtx-cu12, nvidia-nvjitlink-cu12, nvidia-nccl-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12, pytorch-fast-transformers\n",
            "Successfully installed nvidia-cublas-cu12-12.1.3.1 nvidia-cuda-cupti-cu12-12.1.105 nvidia-cuda-nvrtc-cu12-12.1.105 nvidia-cuda-runtime-cu12-12.1.105 nvidia-cudnn-cu12-8.9.2.26 nvidia-cufft-cu12-11.0.2.54 nvidia-curand-cu12-10.3.2.106 nvidia-cusolver-cu12-11.4.5.107 nvidia-cusparse-cu12-12.1.0.106 nvidia-nccl-cu12-2.19.3 nvidia-nvjitlink-cu12-12.4.127 nvidia-nvtx-cu12-12.1.105 pytorch-fast-transformers-0.4.0\n"
          ]
        }
      ],
      "source": [
        "!pip install pytorch-fast-transformers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q7tsd_agQsy2"
      },
      "source": [
        "Try validating freshly installed package by creating a small transformer encoder and running it on dummy data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0FNJ2mEKetE-"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torchvision\n",
        "from torchvision.datasets import MNIST\n",
        "from torchvision import transforms\n",
        "from torch.utils.data import DataLoader\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uLyaAYJw-RL5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1912c1f3-b572-4bd6-b3f5-d9a199fd7521"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9912422/9912422 [00:00<00:00, 207264018.41it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 28881/28881 [00:00<00:00, 100360972.51it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1648877/1648877 [00:00<00:00, 68581458.09it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4542/4542 [00:00<00:00, 17771015.64it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n"
          ]
        }
      ],
      "source": [
        "#Load MNIST\n",
        "transform = transforms.Compose([transforms.ToTensor()])\n",
        "batch_size = 64\n",
        "train_dataset = MNIST(root='./data', train=True, download=True, transform=transform)\n",
        "test_dataset = MNIST(root='./data', train=False, download=True, transform=transform)\n",
        "train_dataloader = DataLoader(\n",
        "    train_dataset, batch_size=batch_size, shuffle=True, num_workers=2\n",
        ")\n",
        "test_dataloader = DataLoader(\n",
        "    test_dataset, batch_size=batch_size, shuffle=False, num_workers=2\n",
        ")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VM3ShNm2MF7x",
        "outputId": "1485a9d4-9480-41b8-acdd-b044c2fda26d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "If you reached here, everything works torch.Size([10, 100, 128])\n"
          ]
        }
      ],
      "source": [
        "from fast_transformers.builders import TransformerEncoderBuilder\n",
        "from fast_transformers.masking import LengthMask, TriangularCausalMask\n",
        "import torch\n",
        "\n",
        "model = TransformerEncoderBuilder.from_kwargs(\n",
        "    n_layers=4,\n",
        "    n_heads=4,\n",
        "    feed_forward_dimensions=128,\n",
        "    query_dimensions=32,\n",
        "    value_dimensions=32,\n",
        "    attention_type=\"full\" # this means normal softmax attention\n",
        ").get()\n",
        "\n",
        "x = torch.rand(\n",
        "    10,  # batch size\n",
        "    100, # sequence length\n",
        "    128  # feature dimensions\n",
        ")\n",
        "y = model(x) # calling without masks which means attend to everything\n",
        "y = model(\n",
        "    x,\n",
        "    attn_mask=TriangularCausalMask(100),   # causal masking\n",
        "    length_mask=LengthMask(torch.tensor([\n",
        "        100, 70, 60, 30, 80, 100,          # The sequence length for every\n",
        "        50, 40, 10, 20                     # sample in the batch\n",
        "    ]))\n",
        ")\n",
        "print(\"If you reached here, everything works\", y.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Autoregressive Generation for MNIST\n",
        "\n",
        "We define two modules for autoregressive image generation for general purposes. One uses a recurrent formulation(since we are trying to prove Linear Transformers are RNNS) AND the other similar to the default PyTourch implementation that just accepts the whole sequence.\n",
        "\n",
        "Both of the implementation involves wrapping a transformer with an input embedding layer and a prediction layer."
      ],
      "metadata": {
        "id": "e4ddumEVf-rk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "from fast_transformers.builders import RecurrentEncoderBuilder\n",
        "\n",
        "class RecurrentGenerator(torch.nn.Module):\n",
        "    class PositionalEncoding(torch.nn.Module):\n",
        "        def __init__(self, d_model, dropout=0.0, max_len=5000):\n",
        "            super(RecurrentGenerator.PositionalEncoding, self).__init__()\n",
        "            self.dropout = torch.nn.Dropout(p=dropout)\n",
        "            self.d_model = d_model\n",
        "            pe = torch.zeros(max_len, d_model)\n",
        "            position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)\n",
        "            div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))\n",
        "            pe[:, 0::2] = torch.sin(position * div_term)\n",
        "            pe[:, 1::2] = torch.cos(position * div_term)\n",
        "            pe = pe.unsqueeze(0)\n",
        "            self.register_buffer('pe', pe)\n",
        "\n",
        "        def forward(self, x, i):\n",
        "            pos_embedding =  self.pe[0, i:i+1]\n",
        "            x = torch.cat(\n",
        "                [x, pos_embedding.expand_as(x)],\n",
        "                dim=1\n",
        "            )\n",
        "            return self.dropout(x)\n",
        "\n",
        "    def __init__(self, d_model, sequence_length, mixtures,\n",
        "                 attention_type=\"full\", n_layers=4, n_heads=4,\n",
        "                 d_query=32, dropout=0.1, softmax_temp=None,\n",
        "                 attention_dropout=0.1):\n",
        "        super(RecurrentGenerator, self).__init__()\n",
        "\n",
        "        self.pos_embedding = self.PositionalEncoding(\n",
        "            d_model//2,\n",
        "            max_len=sequence_length\n",
        "        )\n",
        "        self.value_embedding = torch.nn.Embedding(\n",
        "            256,\n",
        "            d_model//2\n",
        "        )\n",
        "        self.transformer = RecurrentEncoderBuilder.from_kwargs(\n",
        "            attention_type=attention_type,\n",
        "            n_layers=n_layers,\n",
        "            n_heads=n_heads,\n",
        "            feed_forward_dimensions=n_heads*d_query*4,\n",
        "            query_dimensions=d_query,\n",
        "            value_dimensions=d_query,\n",
        "            dropout=dropout,\n",
        "            softmax_temp=softmax_temp,\n",
        "            attention_dropout=attention_dropout\n",
        "        ).get()\n",
        "        self.predictor = torch.nn.Linear(\n",
        "            d_model,\n",
        "            mixtures * 3\n",
        "        )\n",
        "\n",
        "    def forward(self, x, i=0, memory=None):\n",
        "        x = x.view(x.shape[0])\n",
        "        x = self.value_embedding(x)\n",
        "        x = self.pos_embedding(x, i)\n",
        "        y_hat, memory = self.transformer(x, memory)\n",
        "        y_hat = self.predictor(y_hat)\n",
        "\n",
        "        return y_hat, memory\n"
      ],
      "metadata": {
        "id": "3IikL7Ynf7PY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Generator(torch.nn.Module):\n",
        "    class PositionalEncoding(torch.nn.Module):\n",
        "        def __init__(self, d_model, dropout=0.0, max_len=5000):\n",
        "            super(Generator.PositionalEncoding, self).__init__()\n",
        "            self.dropout = torch.nn.Dropout(p=dropout)\n",
        "            self.d_model = d_model\n",
        "            pe = torch.zeros(max_len, d_model)\n",
        "            position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)\n",
        "            div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))\n",
        "            pe[:, 0::2] = torch.sin(position * div_term)\n",
        "            pe[:, 1::2] = torch.cos(position * div_term)\n",
        "            pe = pe.unsqueeze(0)\n",
        "            self.register_buffer('pe', pe)\n",
        "\n",
        "        def forward(self, x):\n",
        "            pos_embedding =  self.pe[:, :x.size(1), :]\n",
        "            pos_embedding = torch.repeat_interleave(pos_embedding, x.shape[0], dim=0)\n",
        "            x =  torch.cat([x, pos_embedding], dim=2)\n",
        "            return self.dropout(x)\n",
        "\n",
        "    def __init__(self, d_model, sequence_length, mixtures,\n",
        "                 attention_type=\"full\", n_layers=4, n_heads=4,\n",
        "                 d_query=32, dropout=0.1, softmax_temp=None,\n",
        "                 attention_dropout=0.1):\n",
        "        super(Generator, self).__init__()\n",
        "\n",
        "        self.pos_embedding = self.PositionalEncoding(\n",
        "            d_model//2,\n",
        "            max_len=sequence_length\n",
        "        )\n",
        "        self.value_embedding = torch.nn.Embedding(\n",
        "            256,\n",
        "            d_model//2\n",
        "        )\n",
        "\n",
        "        self.transformer = TransformerEncoderBuilder.from_kwargs(\n",
        "            attention_type=attention_type,\n",
        "            n_layers=n_layers,\n",
        "            n_heads=n_heads,\n",
        "            feed_forward_dimensions=n_heads*d_query*4,\n",
        "            query_dimensions=d_query,\n",
        "            value_dimensions=d_query,\n",
        "            dropout=dropout,\n",
        "            softmax_temp=softmax_temp,\n",
        "            attention_dropout=attention_dropout\n",
        "        ).get()\n",
        "\n",
        "        hidden_size = n_heads*d_query\n",
        "        self.predictor = torch.nn.Linear(\n",
        "            hidden_size,\n",
        "            mixtures * 3\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = x.view(x.shape[0], -1)\n",
        "        x = self.value_embedding(x)\n",
        "        x = self.pos_embedding(x)\n",
        "        triangular_mask = TriangularCausalMask(x.shape[1], device=x.device)\n",
        "        y_hat = self.transformer(x, attn_mask=triangular_mask)\n",
        "        y_hat = self.predictor(y_hat)\n",
        "\n",
        "        return y_hat"
      ],
      "metadata": {
        "id": "RUPrP4-zf90g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ktNWXnjSgZU"
      },
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O0KgXDqVQ19u"
      },
      "outputs": [],
      "source": [
        "def sample_mol(y_hat, num_classes=256):\n",
        "    \"\"\"Sample from mixture of logistics.\n",
        "\n",
        "    y_hat: NxC where C is 3*number of logistics\n",
        "    \"\"\"\n",
        "    assert len(y_hat.shape) == 2\n",
        "\n",
        "    N = y_hat.size(0)\n",
        "    nr_mix = y_hat.size(1) // 3\n",
        "\n",
        "    probs = torch.softmax(y_hat[:, :nr_mix], dim=-1)\n",
        "    means = y_hat[:, nr_mix:2 * nr_mix]\n",
        "    scales = torch.nn.functional.elu(y_hat[:, 2*nr_mix:3*nr_mix]) + 1.0001\n",
        "\n",
        "    indices = torch.multinomial(probs, 1).squeeze()\n",
        "    batch_indices = torch.arange(N, device=probs.device)\n",
        "    mu = means[batch_indices, indices]\n",
        "    s = scales[batch_indices, indices]\n",
        "    u = torch.rand(N, device=probs.device)\n",
        "    preds = mu + s*(torch.log(u) - torch.log(1-u))\n",
        "\n",
        "    return torch.min(\n",
        "        torch.max(\n",
        "            torch.round((preds+1)/2*(num_classes-1)),\n",
        "            preds.new_zeros(1),\n",
        "        ),\n",
        "        preds.new_ones(1)*(num_classes-1)\n",
        "    ).long().view(N, 1)\n",
        "\n",
        "\n",
        "def predict_with_recurrent(model, images, n):\n",
        "    memory = None\n",
        "    y_hat = []\n",
        "    x_hat = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for i in range(n):\n",
        "\n",
        "            x_hat.append(images[:,i:i+1])\n",
        "            yi, memory = model(x_hat[i], i=i, memory=memory)\n",
        "            y_hat.append(yi)\n",
        "\n",
        "        for i in range(n, images.shape[1]):\n",
        "            x_hat.append(sample_mol(y_hat[-1], 256))\n",
        "            yi, memory = model(x_hat[-1], i=i, memory=memory)\n",
        "            y_hat.append(yi)\n",
        "\n",
        "        x_hat.append(sample_mol(y_hat[-1], 256))\n",
        "        x_hat = torch.stack(x_hat, dim=1)\n",
        "\n",
        "    return x_hat\n",
        "\n",
        "\n",
        "def predict(model, images, n):\n",
        "    N, L = images.shape\n",
        "    x_hat = images.new_zeros(N, L+1, dtype=torch.long)\n",
        "    x_hat[:, :n] = images[:, :n]\n",
        "    with torch.no_grad():\n",
        "        for i in range(n, L):\n",
        "            y_hat = model(x_hat[:, :i])\n",
        "            x_hat[:, i:i+1] = sample_mol(y_hat[:,-1,:], 256)\n",
        "        x_hat[:, -1:] = sample_mol(y_hat[:,-1,:], 256)\n",
        "    return x_hat"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Load Pretrained Models for MNIST\n",
        "\n",
        "Angelos Katharopoulos et. al has already trained the model. So we are just importing the model from google drive which they have already pretrain."
      ],
      "metadata": {
        "id": "ACIDWF02g4aY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "\n",
        "LINEAR_MODEL = \"https://drive.google.com/uc?export=download&id=17fc94TzytTdAwNMVCE7qOg75-CWLGi_p\"\n",
        "SOFTMAX_MODEL = \"https://drive.google.com/uc?export=download&id=1L47Ode6GxCMQbVMK33_ANjCu2iA4rf8l\"\n",
        "\n",
        "linear_weights = torch.load(io.BytesIO(requests.get(LINEAR_MODEL).content))\n",
        "softmax_weights = torch.load(io.BytesIO(requests.get(SOFTMAX_MODEL).content))"
      ],
      "metadata": {
        "id": "TvC7ikDjg4KD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yYldeqJiQ9lf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And Now, we can create the model and generate some images. Note that we are creating recurrent model for softmax. This means that we save all keys and values to avoid computing again which is not something easily done for every transformer implementation.\n",
        "\n",
        "On the other hand, for linear attention the state has fixed size and it is natural to implement it as a recurrent model since the Attention is causal masked.\n",
        "\n",
        "#Image Generation"
      ],
      "metadata": {
        "id": "cJTN_RjEhK2e"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UU65Jkd8Q0oA",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 326
        },
        "outputId": "8b73394b-c633-4c71-c530-40485da05b1e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x78e67296c700>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "linear = RecurrentGenerator(256, 783, 10, \"linear\", 8, 8)\n",
        "linear.load_state_dict(linear_weights)\n",
        "linear.eval()\n",
        "full = RecurrentGenerator(256, 783, 10, \"full\", 8, 8)\n",
        "full.load_state_dict(softmax_weights)\n",
        "full.eval()\n",
        "\n",
        "\n",
        "images_linear = predict_with_recurrent(linear, torch.zeros(1, 783, dtype=torch.int64), 1)\n",
        "images_full = predict_with_recurrent(full, torch.zeros(1, 783, dtype=torch.int64), 1)\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "fig, ax = plt.subplots(1, 2)\n",
        "ax[0].set_title(\"Linear\")\n",
        "ax[0].imshow(images_linear[0].cpu().numpy().reshape(28, 28))\n",
        "ax[1].set_title(\"Softmax\")\n",
        "ax[1].imshow(images_full[0].cpu().numpy().reshape(28, 28))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(torch.zeros(1, 783, dtype=torch.int64).shape)\n",
        "print(images_linear.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xl3n28M-dNlQ",
        "outputId": "0fd8b14c-eadb-41e7-ce84-6d03c857c2fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 783])\n",
            "torch.Size([1, 784, 1])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Image Completion\n",
        "\n",
        "We will sample any 5 numbers from 0-10 and access the image corresponding to it and give it as a input to predict_with_recurrent to check if it can regenerate the same image given half of the information about the image. We choose 0,1,2,3,4 to test on experiment around the occulated data."
      ],
      "metadata": {
        "id": "Q7xbNysXhugL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code takes the dataset for the num 0,1,2,3,4 and visualises the dataset for the same"
      ],
      "metadata": {
        "id": "oCa2df680ugj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create occulated images of the dataset. We will now only store information about half of this image. or say, stop the data visualisation at just half."
      ],
      "metadata": {
        "id": "gEDeUY7B1BHZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Replace 'your_file.csv' with the actual filename\n",
        "data = pd.read_csv('/content/sample_data/mnist_test.csv')\n",
        "data=np.array(data)\n",
        "\n"
      ],
      "metadata": {
        "id": "Ox4DgjkK5Z5e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "list=[]\n",
        "\n",
        "for x in data:\n",
        "    if x[0]==0:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==1:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==2:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==3:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==4:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==5:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==6:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==7:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==8:\n",
        "      list.append(x)\n",
        "      break\n",
        "for x in data:\n",
        "    if x[0]==9:\n",
        "      list.append(x)\n",
        "      break\n",
        "\n"
      ],
      "metadata": {
        "id": "xpY6ZKr26h5v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for x in list:\n",
        "  x=x[1:]\n",
        "  # x=torch.tensor([x])\n",
        "  x=x.reshape(28, 28)\n",
        "   # Display the image using matplotlib\n",
        "  plt.imshow(x, cmap='gray')  # Use 'gray' for grayscale images\n",
        "  plt.show()\n",
        "  x=torch.tensor([x])\n",
        "  x=x.squeeze()\n",
        "  print(x.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "66X7Mur194Ir",
        "outputId": "606f8a80-cc00-4d07-e1ba-af0c600596ff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAa/UlEQVR4nO3df2xV9f3H8dct0CtKe7ta2tvyywIijh/FodQGYTgaSreoKHHozAKLgcCKE5mydZmgbksVk824MN0fC9VM/EEYEM3SqIWWOFsMCCPE2dCukzraMlm4F4otpP18/+DrnVda8Fzu5d3ePh/JJ6H3ng/3vbObPj29txefc84JAIArLMV6AADA4ESAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACAiaHWA3xVT0+Pjh07prS0NPl8PutxAAAeOed06tQp5eXlKSWl7+ucfhegY8eOacyYMdZjAAAuU0tLi0aPHt3n/f3uR3BpaWnWIwAA4uBS388TFqBNmzbpuuuu01VXXaXCwkJ98MEHX2sfP3YDgORwqe/nCQnQ66+/rrVr12rDhg368MMPVVBQoJKSEh0/fjwRDwcAGIhcAsyaNcuVlZVFvu7u7nZ5eXmuoqLikntDoZCTxGKxWKwBvkKh0EW/38f9Cujs2bPav3+/iouLI7elpKSouLhYdXV1Fxzf1dWlcDgctQAAyS/uAfrss8/U3d2tnJycqNtzcnLU1tZ2wfEVFRUKBAKRxTvgAGBwMH8XXHl5uUKhUGS1tLRYjwQAuALi/ntAWVlZGjJkiNrb26Nub29vVzAYvOB4v98vv98f7zEAAP1c3K+AUlNTNXPmTFVXV0du6+npUXV1tYqKiuL9cACAASohn4Swdu1aLV26VDfffLNmzZql5557Th0dHfrRj36UiIcDAAxACQnQkiVL9J///Efr169XW1ubZsyYoaqqqgvemAAAGLx8zjlnPcSXhcNhBQIB6zEAAJcpFAopPT29z/vN3wUHABicCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATCfk0bAAXl5Li/b/9MjIyPO95+OGHPe+RpJtuusnznjvvvDOmx8LgxRUQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATPBp2ICBSZMmed7z0Ucfed7T2dnpeY8klZWVxbQP8IIrIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABB9GClyme++91/Oe3/zmNwmY5EKPP/54TPs2b94c50mAC3EFBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCY4MNIgct04403et4zceJEz3s++eQTz3teeuklz3uAK4UrIACACQIEADAR9wA98cQT8vl8UWvy5MnxfhgAwACXkNeApkyZonffffd/DzKUl5oAANESUoahQ4cqGAwm4q8GACSJhLwGdOTIEeXl5Wn8+PF64IEHdPTo0T6P7erqUjgcjloAgOQX9wAVFhaqsrJSVVVVeuGFF9Tc3Kw5c+bo1KlTvR5fUVGhQCAQWWPGjIn3SACAfijuASotLdW9996r6dOnq6SkRH/961918uRJvfHGG70eX15erlAoFFktLS3xHgkA0A8l/N0BGRkZmjRpkhobG3u93+/3y+/3J3oMAEA/k/DfAzp9+rSampqUm5ub6IcCAAwgcQ/Qo48+qtraWv3rX//S+++/r7vvvltDhgzR/fffH++HAgAMYHH/Edynn36q+++/XydOnNDIkSN12223qb6+XiNHjoz3QwEABjCfc85ZD/Fl4XBYgUDAegzga/vnP//peU8svyf3wx/+0POebdu2ed4DxEsoFFJ6enqf9/NZcAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACAiYT/g3TAQLJs2TLPe8aNG+d5T1VVlec9fLAokg1XQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADDhc8456yG+LBwOKxAIWI+BQaqpqcnzntGjR3vec/vtt3ve8/7773veA1gKhUJKT0/v836ugAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAE0OtBwASYebMmTHtGzlypOc9Tz/9tOc9fLAowBUQAMAIAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCDyNFUlqzZk1M+0aMGBHfQQD0iSsgAIAJAgQAMOE5QHv27NEdd9yhvLw8+Xw+7dixI+p+55zWr1+v3NxcDR8+XMXFxTpy5Ei85gUAJAnPAero6FBBQYE2bdrU6/0bN27U888/rxdffFF79+7VNddco5KSEnV2dl72sACA5OH5TQilpaUqLS3t9T7nnJ577jn98pe/1F133SVJevnll5WTk6MdO3bovvvuu7xpAQBJI66vATU3N6utrU3FxcWR2wKBgAoLC1VXV9frnq6uLoXD4agFAEh+cQ1QW1ubJCknJyfq9pycnMh9X1VRUaFAIBBZY8aMiedIAIB+yvxdcOXl5QqFQpHV0tJiPRIA4AqIa4CCwaAkqb29Per29vb2yH1f5ff7lZ6eHrUAAMkvrgHKz89XMBhUdXV15LZwOKy9e/eqqKgong8FABjgPL8L7vTp02psbIx83dzcrIMHDyozM1Njx47VmjVr9Otf/1rXX3+98vPz9fjjjysvL0+LFi2K59wAgAHOc4D27dun22+/PfL12rVrJUlLly5VZWWl1q1bp46ODq1YsUInT57UbbfdpqqqKl111VXxmxoAMOD5nHPOeogvC4fDCgQC1mNggDt48GBM+woKCjzvmTFjhuc9f//73z3vAQaaUCh00df1zd8FBwAYnAgQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGDC8z/HAFxpt956q+c9EyZMiOmxtm3b5nnP4cOHY3osYLDjCggAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMMGHkaLfmzNnjuc9I0aMiOmxWltbPe/p7u6O6bGAwY4rIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADAhM8556yH+LJwOKxAIGA9BhJkxowZnvfs3bvX855hw4Z53iNJ3/zmNz3v+fjjj2N6LCDZhUIhpaen93k/V0AAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgImh1gNgcElNTb0ie2L9jN2Ojo6Y9gHwjisgAIAJAgQAMOE5QHv27NEdd9yhvLw8+Xw+7dixI+r+ZcuWyefzRa2FCxfGa14AQJLwHKCOjg4VFBRo06ZNfR6zcOFCtba2Rtarr756WUMCAJKP5zchlJaWqrS09KLH+P1+BYPBmIcCACS/hLwGVFNTo+zsbN1www1atWqVTpw40eexXV1dCofDUQsAkPziHqCFCxfq5ZdfVnV1tZ555hnV1taqtLRU3d3dvR5fUVGhQCAQWWPGjIn3SACAfijuvwd03333Rf48bdo0TZ8+XRMmTFBNTY3mz59/wfHl5eVau3Zt5OtwOEyEAGAQSPjbsMePH6+srCw1Njb2er/f71d6enrUAgAkv4QH6NNPP9WJEyeUm5ub6IcCAAwgnn8Ed/r06airmebmZh08eFCZmZnKzMzUk08+qcWLFysYDKqpqUnr1q3TxIkTVVJSEtfBAQADm+cA7du3T7fffnvk6y9ev1m6dKleeOEFHTp0SC+99JJOnjypvLw8LViwQL/61a/k9/vjNzUAYMDzuVg/tTFBwuGwAoGA9RhIkJycHM979uzZ43nPpEmTPO+RpLFjx3re09LS4nnPkCFDPO8ZNWqU5z033XST5z2StHPnzpj2QTG9jp2sv34SCoUuej74LDgAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYiPs/yQ1cTHt7u+c9Bw4c8Lzn+uuv97xHku68807Pe7Zt2+Z5z9SpUz3vefvttz3v+fnPf+55TzJKTU2Nad+8efM871m6dKnnPQ888IDnPcmAKyAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQfRop+r7Ky0vOe73//+zE91rp16zzvufXWWz3vieXDJ9977z3Pe2I5d8no4YcfjmnfM88843nP7t27Y3qswYgrIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABB9Gin6vrq7O857169fH9FhPPfWU5z2xfLBoLA4ePOh5z5AhQ+I/iLEpU6Z43nPzzTfH9Fj19fWe9zz77LMxPdZgxBUQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGDC55xz1kN8WTgcViAQsB4DA1xaWlpM+zZs2OB5z09+8hPPe4YOvTKfA9zW1hbTvjNnzsR5kvjJzMz0vGfYsGExPdbixYs973n77bdjeqxkFAqFlJ6e3uf9XAEBAEwQIACACU8Bqqio0C233KK0tDRlZ2dr0aJFamhoiDqms7NTZWVluvbaazVixAgtXrxY7e3tcR0aADDweQpQbW2tysrKVF9fr3feeUfnzp3TggUL1NHRETnmkUce0ZtvvqmtW7eqtrZWx44d0z333BP3wQEAA5unV0Krqqqivq6srFR2drb279+vuXPnKhQK6U9/+pO2bNmi73znO5KkzZs368Ybb1R9fb1uvfXW+E0OABjQLus1oFAoJOl/70rZv3+/zp07p+Li4sgxkydP1tixY/v8Z5W7uroUDoejFgAg+cUcoJ6eHq1Zs0azZ8/W1KlTJZ1/y2dqaqoyMjKijs3Jyenz7aAVFRUKBAKRNWbMmFhHAgAMIDEHqKysTIcPH9Zrr712WQOUl5crFApFVktLy2X9fQCAgSGm34ZbvXq13nrrLe3Zs0ejR4+O3B4MBnX27FmdPHky6iqovb1dwWCw17/L7/fL7/fHMgYAYADzdAXknNPq1au1fft27dq1S/n5+VH3z5w5U8OGDVN1dXXktoaGBh09elRFRUXxmRgAkBQ8XQGVlZVpy5Yt2rlzp9LS0iKv6wQCAQ0fPlyBQEAPPvig1q5dq8zMTKWnp+uhhx5SUVER74ADAETxFKAXXnhBkjRv3ryo2zdv3qxly5ZJkn73u98pJSVFixcvVldXl0pKSvSHP/whLsMCAJIHH0YKXKY777zT854dO3bEf5Be/Pvf/45p3969ez3v+e9//+t5z4kTJzzviUWsHxC6e/fuOE8yuPBhpACAfokAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAm+DRsAEBC8GnYAIB+iQABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGDCU4AqKip0yy23KC0tTdnZ2Vq0aJEaGhqijpk3b558Pl/UWrlyZVyHBgAMfJ4CVFtbq7KyMtXX1+udd97RuXPntGDBAnV0dEQdt3z5crW2tkbWxo0b4zo0AGDgG+rl4KqqqqivKysrlZ2drf3792vu3LmR26+++moFg8H4TAgASEqX9RpQKBSSJGVmZkbd/sorrygrK0tTp05VeXm5zpw50+ff0dXVpXA4HLUAAIOAi1F3d7f73ve+52bPnh11+x//+EdXVVXlDh065P785z+7UaNGubvvvrvPv2fDhg1OEovFYrGSbIVCoYt2JOYArVy50o0bN861tLRc9Ljq6monyTU2NvZ6f2dnpwuFQpHV0tJiftJYLBaLdfnrUgHy9BrQF1avXq233npLe/bs0ejRoy96bGFhoSSpsbFREyZMuOB+v98vv98fyxgAgAHMU4Ccc3rooYe0fft21dTUKD8//5J7Dh48KEnKzc2NaUAAQHLyFKCysjJt2bJFO3fuVFpamtra2iRJgUBAw4cPV1NTk7Zs2aLvfve7uvbaa3Xo0CE98sgjmjt3rqZPn56Q/wEAgAHKy+s+6uPnfJs3b3bOOXf06FE3d+5cl5mZ6fx+v5s4caJ77LHHLvlzwC8LhULmP7dksVgs1uWvS33v9/1/WPqNcDisQCBgPQYA4DKFQiGlp6f3eT+fBQcAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMNHvAuScsx4BABAHl/p+3u8CdOrUKesRAABxcKnv5z7Xzy45enp6dOzYMaWlpcnn80XdFw6HNWbMGLW0tCg9Pd1oQnuch/M4D+dxHs7jPJzXH86Dc06nTp1SXl6eUlL6vs4ZegVn+lpSUlI0evToix6Tnp4+qJ9gX+A8nMd5OI/zcB7n4Tzr8xAIBC55TL/7ERwAYHAgQAAAEwMqQH6/Xxs2bJDf77cexRTn4TzOw3mch/M4D+cNpPPQ796EAAAYHAbUFRAAIHkQIACACQIEADBBgAAAJgZMgDZt2qTrrrtOV111lQoLC/XBBx9Yj3TFPfHEE/L5fFFr8uTJ1mMl3J49e3THHXcoLy9PPp9PO3bsiLrfOaf169crNzdXw4cPV3FxsY4cOWIzbAJd6jwsW7bsgufHwoULbYZNkIqKCt1yyy1KS0tTdna2Fi1apIaGhqhjOjs7VVZWpmuvvVYjRozQ4sWL1d7ebjRxYnyd8zBv3rwLng8rV640mrh3AyJAr7/+utauXasNGzboww8/VEFBgUpKSnT8+HHr0a64KVOmqLW1NbLee+8965ESrqOjQwUFBdq0aVOv92/cuFHPP/+8XnzxRe3du1fXXHONSkpK1NnZeYUnTaxLnQdJWrhwYdTz49VXX72CEyZebW2tysrKVF9fr3feeUfnzp3TggUL1NHRETnmkUce0ZtvvqmtW7eqtrZWx44d0z333GM4dfx9nfMgScuXL496PmzcuNFo4j64AWDWrFmurKws8nV3d7fLy8tzFRUVhlNdeRs2bHAFBQXWY5iS5LZv3x75uqenxwWDQffss89Gbjt58qTz+/3u1VdfNZjwyvjqeXDOuaVLl7q77rrLZB4rx48fd5JcbW2tc+78//fDhg1zW7dujRzzj3/8w0lydXV1VmMm3FfPg3POffvb33YPP/yw3VBfQ7+/Ajp79qz279+v4uLiyG0pKSkqLi5WXV2d4WQ2jhw5ory8PI0fP14PPPCAjh49aj2SqebmZrW1tUU9PwKBgAoLCwfl86OmpkbZ2dm64YYbtGrVKp04ccJ6pIQKhUKSpMzMTEnS/v37de7cuajnw+TJkzV27Nikfj589Tx84ZVXXlFWVpamTp2q8vJynTlzxmK8PvW7DyP9qs8++0zd3d3KycmJuj0nJ0cff/yx0VQ2CgsLVVlZqRtuuEGtra168sknNWfOHB0+fFhpaWnW45loa2uTpF6fH1/cN1gsXLhQ99xzj/Lz89XU1KRf/OIXKi0tVV1dnYYMGWI9Xtz19PRozZo1mj17tqZOnSrp/PMhNTVVGRkZUccm8/Oht/MgST/4wQ80btw45eXl6dChQ/rZz36mhoYG/eUvfzGcNlq/DxD+p7S0NPLn6dOnq7CwUOPGjdMbb7yhBx980HAy9Af33Xdf5M/Tpk3T9OnTNWHCBNXU1Gj+/PmGkyVGWVmZDh8+PCheB72Yvs7DihUrIn+eNm2acnNzNX/+fDU1NWnChAlXesxe9fsfwWVlZWnIkCEXvIulvb1dwWDQaKr+ISMjQ5MmTVJjY6P1KGa+eA7w/LjQ+PHjlZWVlZTPj9WrV+utt97S7t27o/75lmAwqLNnz+rkyZNRxyfr86Gv89CbwsJCSepXz4d+H6DU1FTNnDlT1dXVkdt6enpUXV2toqIiw8nsnT59Wk1NTcrNzbUexUx+fr6CwWDU8yMcDmvv3r2D/vnx6aef6sSJE0n1/HDOafXq1dq+fbt27dql/Pz8qPtnzpypYcOGRT0fGhoadPTo0aR6PlzqPPTm4MGDktS/ng/W74L4Ol577TXn9/tdZWWl++ijj9yKFStcRkaGa2trsx7tivrpT3/qampqXHNzs/vb3/7miouLXVZWljt+/Lj1aAl16tQpd+DAAXfgwAEnyf32t791Bw4ccJ988olzzrmnn37aZWRkuJ07d7pDhw65u+66y+Xn57vPP//cePL4uth5OHXqlHv00UddXV2da25udu+++6771re+5a6//nrX2dlpPXrcrFq1ygUCAVdTU+NaW1sj68yZM5FjVq5c6caOHet27drl9u3b54qKilxRUZHh1PF3qfPQ2NjonnrqKbdv3z7X3Nzsdu7c6caPH+/mzp1rPHm0AREg55z7/e9/78aOHetSU1PdrFmzXH19vfVIV9ySJUtcbm6uS01NdaNGjXJLlixxjY2N1mMl3O7du52kC9bSpUudc+ffiv3444+7nJwc5/f73fz5811DQ4Pt0AlwsfNw5swZt2DBAjdy5Eg3bNgwN27cOLd8+fKk+4+03v73S3KbN2+OHPP555+7H//4x+4b3/iGu/rqq93dd9/tWltb7YZOgEudh6NHj7q5c+e6zMxM5/f73cSJE91jjz3mQqGQ7eBfwT/HAAAw0e9fAwIAJCcCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwMT/AUMFjRNUPlB3AAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def occlude_half_image2(image):\n",
        "  \"\"\"Ocludes half of the image (top half by default).\n",
        "\n",
        "  Args:\n",
        "      image: A PyTorch tensor representing the image (channels, height, width).\n",
        "\n",
        "  Returns:\n",
        "      A PyTorch tensor representing the occluded image.\n",
        "  \"\"\"\n",
        "  image_size = image.shape[1]  # Get image height or width (assuming square images)\n",
        "  mask = torch.zeros_like(image)  # Create a mask with the same size as the image\n",
        "  mask[:, :image_size // 2] = 1  # Set half of the mask to 1 (top half)\n",
        "  return image * mask  # Apply the mask\n",
        "\n",
        "def occlude_half_image(image):\n",
        "    \"\"\"\n",
        "    Ocludes half of the image (top half by default).\n",
        "\n",
        "    Args:\n",
        "        image: A PyTorch tensor representing the image (channels, height, width).\n",
        "\n",
        "    Returns:\n",
        "        A PyTorch tensor representing the occluded image.\n",
        "    \"\"\"\n",
        "\n",
        "    # Get image height\n",
        "    image_size = image.shape[1]\n",
        "\n",
        "    # Create a mask with the same size as the image\n",
        "    mask = torch.zeros_like(image)\n",
        "\n",
        "    # Set half of the mask to 1 (top half by default)\n",
        "    mask[:, :image_size // 2] = 1\n",
        "\n",
        "    # Apply the mask to occlude half of the image\n",
        "    return image * mask\n"
      ],
      "metadata": {
        "id": "FNGIwsQUsCVX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "images_to_visualize = []\n",
        "\n",
        "for label in range(10):  # Collect images with labels 0 to 9 (inclusive)\n",
        "  for x in data:\n",
        "    if x[0] == label:\n",
        "      images_to_visualize.append(x[1:])  # Extract image data and skip label\n",
        "      break  # Stop after finding one image for each label\n",
        "\n",
        "for image in images_to_visualize:\n",
        "  image_tensor = torch.from_numpy(image.reshape(28, 28))  # Create tensor\n",
        "  occluded_image = occlude_half_image(image_tensor.unsqueeze(0))  # Add batch dim, occlude\n",
        "  occluded_image = occluded_image.squeeze()  # Remove batch dim (if needed)\n",
        "\n",
        "  plt.imshow(occluded_image.numpy(), cmap='gray')\n",
        "  plt.show()\n",
        "\n",
        "  print(occluded_image.shape)"
      ],
      "metadata": {
        "id": "KZGXbpHYArgR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "67999ed0-40fe-4721-8429-0d997329e4eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([28, 28])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "occluded_dataset=[]\n",
        "for image in images_to_visualize:\n",
        "  image_tensor = torch.from_numpy(image.reshape(28, 28))  # Create tensor\n",
        "  occluded_image = occlude_half_image(image_tensor.unsqueeze(0))\n",
        "  occluded_dataset.append(occluded_image)  # Add batch dim, occlude\n",
        "\n",
        "print(occluded_dataset[0].shape)\n"
      ],
      "metadata": {
        "id": "XBWQu4jpDYQm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d65d9be-2242-4047-d000-55efad2be374"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 28, 28])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now test the model"
      ],
      "metadata": {
        "id": "lbP2V6gG3BOI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def prepare_image_for_model(image):\n",
        "  \"\"\"\n",
        "  Flattens the image tensor for model input.\n",
        "\n",
        "  Args:\n",
        "      image: A PyTorch tensor representing the image (channels, height, width).\n",
        "\n",
        "  Returns:\n",
        "      A PyTorch tensor representing the flattened image (channels * height * width).\n",
        "  \"\"\"\n",
        "\n",
        "  # Assuming the image has a single channel (modify if channels > 1)\n",
        "  return image.view(image.shape[0], -1)  # Flatten all dimensions except the first (batch size)\n",
        "\n"
      ],
      "metadata": {
        "id": "faFHTkuD3A39"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "flatten_image=[]\n",
        "for images in occluded_dataset:\n",
        "  flat=prepare_image_for_model(images)\n",
        "  flat=flat[:,:-1]\n",
        "  flatten_image.append(flat)\n",
        "\n",
        "print(flatten_image[0].shape)"
      ],
      "metadata": {
        "id": "noJ8nt-j4PcJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d20c1cf6-f4a6-436d-83f3-71c62abc0460"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 783])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "linear = RecurrentGenerator(256, 783, 10, \"linear\", 8, 8)\n",
        "linear.load_state_dict(linear_weights)\n",
        "linear.eval()\n",
        "full = RecurrentGenerator(256, 783, 10, \"full\", 8, 8)\n",
        "full.load_state_dict(softmax_weights)\n",
        "full.eval()\n",
        "\n",
        "for i in range(10):\n",
        "  image=flatten_image[i]\n",
        "  images_linear = predict_with_recurrent(linear, image, 392)\n",
        "  images_full = predict_with_recurrent(full, image, 392)\n",
        "\n",
        "  import numpy as np\n",
        "  import matplotlib.pyplot as plt\n",
        "  fig, ax = plt.subplots(1, 2)\n",
        "  ax[0].set_title(\"Linear\")\n",
        "  ax[0].imshow(images_linear[0].cpu().numpy().reshape(28, 28))\n",
        "  ax[1].set_title(\"Softmax\")\n",
        "  ax[1].imshow(images_full[0].cpu().numpy().reshape(28, 28))"
      ],
      "metadata": {
        "id": "KC8F_-2yy4Li",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "ccf7e064-31ad-43b8-f7cf-35e1d2fbf99a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAEjCAYAAACSDWOaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkZklEQVR4nO3df1hUdd7/8deAMqDgkD+AUETCUlOzblKWtfyxmaT90rRd220v8t5NLaTbvFvLrsrU+47WdjetTNe9XShvLde+mdsvK3/h3SqmmJlt+VUzoxRc/QoYKiDz+f7R7SyTeMaB4QwDz8d1neuK8z4z580R3r04M+eMwxhjBAAAYJOwYDcAAABaF8IHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgfq9dVXX8nhcCg/Pz/YrQAIUc8884wuu+wyhYeH6+qrrw52O2hGCB+tVH5+vhwOh3bs2BHsVgA0E59++qnGjx+v5ORkRUZGqmvXrrrxxhv1/PPP+/1c77//vmbMmKHBgwcrLy9PTz31lA4fPqwnn3xSu3btCnzzCCltgt0Amqfk5GSdPn1abdu2DXYrAGywZcsWDR8+XN27d9e9996rhIQEFRcXq7CwUAsWLFBOTo5fz7dhwwaFhYVp6dKlioiIkCTt2LFDs2fPVo8ePTgT0soRPlAvh8OhyMjIYLdh6dSpU2rXrl2w2wBahP/8z/+Uy+XS9u3bFRsb61U7evSo38939OhRRUVFeYIHUBcvu6Be9b3n45577lF0dLS+/fZbjRkzRtHR0erSpYseeugh1dbWej3e7XZr/vz56tu3ryIjIxUfH6/JkyfrxIkTXtutWbNGN998sxITE+V0OpWamqq5c+ee93zDhg1Tv379VFRUpCFDhqhdu3Z69NFHm+z7B1qbAwcOqG/fvucFD0mKi4vz/PfZs2c1d+5cpaamyul0qkePHnr00UdVVVXl2cbhcCgvL0+VlZVyOByeWTJw4EBJ0sSJE73WS//8Hd+9e7eGDh2qdu3aqWfPnnrttdckSQUFBUpPT1dUVJR69eqldevWefV46NAh3X///erVq5eioqLUqVMn3Xnnnfrqq6882xhjNHz4cHXp0sUrUFVXV6t///5KTU1VZWVlYw8lLgLhA36pra1VZmamOnXqpN/97ncaOnSofv/732vJkiVe202ePFm/+c1vNHjwYC1YsEATJ07U8uXLlZmZqZqaGs92+fn5io6O1vTp07VgwQKlpaXpiSee0COPPHLevo8fP65Ro0bp6quv1vz58zV8+PAm/36B1iI5OVlFRUXas2eP5Xa//vWv9cQTT+hf/uVf9Oyzz2ro0KHKzc3VhAkTPNssW7ZM119/vZxOp5YtW6Zly5apT58+mjNnjiRp0qRJnvVDhgzxPO7EiRO65ZZblJ6ernnz5snpdGrChAlauXKlJkyYoNGjR+vpp59WZWWlxo8fr5MnT3oeu337dm3ZskUTJkzQc889pylTpmj9+vUaNmyYTp06Jen7UPTnP/9ZZ86c0ZQpUzyPnTVrlj777DPl5eWpffv2ATme8MGgVcrLyzOSzPbt2+utHzx40EgyeXl5nnVZWVlGkpkzZ47Xttdcc41JS0vzfP0///M/RpJZvny513Zr1649b/2pU6fO2/fkyZNNu3btzJkzZzzrhg4daiSZxYsX+/V9Arg477//vgkPDzfh4eEmIyPDzJgxw7z33numurras82uXbuMJPPrX//a67EPPfSQkWQ2bNjgWZeVlWXat2/vtd327dvPmyvnnPsdX7FihWfdF198YSSZsLAwU1hY6Fn/3nvvnfc89c2SrVu3Gknm5Zdf9lr/xz/+0Ugy//3f/20KCwtNeHi4mTZtmvUBQkBx5gN+q/sXgyRdf/31+vLLLz1fr1q1Si6XSzfeeKOOHTvmWdLS0hQdHa2NGzd6to2KivL898mTJ3Xs2DFdf/31OnXqlL744guv/TidTk2cOLGJviugdbvxxhu1detW3Xbbbfrkk080b948ZWZmqmvXrvrrX/8qSXrnnXckSdOnT/d67L//+79Lkt5+++1G9RAdHe11BqVXr16KjY1Vnz59lJ6e7ll/7r/rzp26s6SmpkbHjx9Xz549FRsbq507d3rtZ9KkScrMzFROTo5++ctfKjU1VU899VSjeod/eMMp/BIZGakuXbp4rbvkkku83suxb98+lZeXe71OXFfd11o/++wzPfbYY9qwYYMqKiq8tisvL/f6umvXrrx5DWhCAwcO1Ouvv67q6mp98sknWr16tZ599lmNHz9eu3bt0qFDhxQWFqaePXt6PS4hIUGxsbE6dOhQo/bfrVs3ORwOr3Uul0tJSUnnrZPkNXdOnz6t3Nxc5eXl6dtvv5UxxlP74SyRpKVLlyo1NVX79u3Tli1bvMILmh7hA34JDw/3uY3b7VZcXJyWL19eb/1ceCkrK9PQoUPVoUMHzZkzR6mpqYqMjNTOnTv18MMPy+12ez2O4QDYIyIiQgMHDtTAgQN1xRVXaOLEiVq1apWn/sOAECgXmi8XWl83YOTk5CgvL0/Tpk1TRkaGXC6XHA6HJkyYcN4skaRNmzZ53iT76aefKiMjIwDfAS4W4QMBl5qaqnXr1mnw4MGWgWHTpk06fvy4Xn/9da83nR08eNCONgFchGuvvVaSdOTIESUnJ8vtdmvfvn3q06ePZ5vS0lKVlZUpOTnZ8rmaKrRI0muvvaasrCz9/ve/96w7c+aMysrKztv2yJEjysnJ0ciRIxUREaGHHnpImZmZPvtH4PCeDwTcT3/6U9XW1mru3Lnn1c6ePesZBuf+mqn710t1dbVefPFFW/oE8E8bN270+l0859z7PHr16qXRo0dLkubPn++1zR/+8AdJ0s0332y5j3NXktQXCBorPDz8vP6ff/758y7bl6R7771XbrdbS5cu1ZIlS9SmTRv96le/qvf7R9PgzEcr9+c//1lr1649b/3tt9/e4OccOnSoJk+erNzcXO3atUsjR45U27ZttW/fPq1atUoLFizQ+PHj9eMf/1iXXHKJsrKy9MADD8jhcGjZsmUMACAIcnJydOrUKY0dO1a9e/dWdXW1tmzZopUrV6pHjx6aOHGiYmNjlZWVpSVLlnheNv3oo4/00ksvacyYMT4vf09NTVVsbKwWL16smJgYtW/fXunp6UpJSWl0/7fccouWLVsml8ulK6+8Ulu3btW6devUqVMnr+3y8vL09ttvKz8/X926dZP0fUi5++67tWjRIt1///2N7gUXIYhX2iCIzl1qe6Hl3OWyP7zU9oeXzhljzKxZs0x9P0pLliwxaWlpJioqysTExJj+/fubGTNmmMOHD3u2+dvf/mZ+9KMfmaioKJOYmOi5vE+S2bhxo2e7oUOHmr59+wb0GAD4p3fffdf867/+q+ndu7eJjo42ERERpmfPniYnJ8eUlpZ6tqupqTGzZ882KSkppm3btiYpKcnMnDnT69J4Yy48L9asWWOuvPJK06ZNG68Zc6Hf8eTkZHPzzTeft16Syc7O9nx94sQJM3HiRNO5c2cTHR1tMjMzzRdffGGSk5NNVlaWMcaY4uJi43K5zK233nre840dO9a0b9/efPnllxd1vNA4DmP4MxMAANiH93wAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANiq2d1kzO126/Dhw4qJiWnSW/ECuDBjjE6ePKnExESFhYXG3yjMDiC4/JobTXUDkRdeeMEkJycbp9NpBg0aZLZt23ZRjysuLra8+RULC4t9S3FxcVONiHo1dG4Yw+xgYWkuy8XMjSY587Fy5UpNnz5dixcvVnp6uubPn6/MzEzt3bv3gh+zfk5MTIwk6TqNVhu1bYr2APhwVjX6UO94fh/t0Ji5ITE7gGDzZ240yR1O09PTNXDgQL3wwguSvj8dmpSUpJycHD3yyCOWj62oqJDL5dIw3a42DgYIEAxnTY02aY3Ky8vVoUMHW/bZmLkhMTuAYPNnbgT8xdzq6moVFRVpxIgR/9xJWJhGjBihrVu3nrd9VVWVKioqvBYArYu/c0NidgChLODh49ixY6qtrVV8fLzX+vj4eJWUlJy3fW5urlwul2dJSkoKdEsAmjl/54bE7ABCWdDfxj5z5kyVl5d7luLi4mC3BCAEMDuA0BXwN5x27txZ4eHhKi0t9VpfWlqqhISE87Z3Op1yOp2BbgNACPF3bkjMDiCUBfzMR0REhNLS0rR+/XrPOrfbrfXr1ysjIyPQuwPQAjA3gNalSS61nT59urKysnTttddq0KBBmj9/viorKzVx4sSm2B2AFoC5AbQeTRI+fvazn+kf//iHnnjiCZWUlOjqq6/W2rVrz3szGQCcw9wAWo8muc9HY3CtPhB8wbjPR2MxO4DgCup9PgAAAKwQPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWxE+AACArQgfAADAVoQPAABgK8IHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGCrNsFuAAiGAyuutqz/24CNlvW1N/X3uY+zxd/40xKAEMDsCAzOfAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbMV9PtAqxf010rI+aeh+y/off36zz310/W3Lv1YfaG2YHYER8DMfTz75pBwOh9fSu3fvQO8GQAvC3ABalyY589G3b1+tW7funztpwwkWANaYG0Dr0SS/3W3atFFCQkJTPDWAFoq5AbQeTfKG03379ikxMVGXXXaZfvGLX+jrr7++4LZVVVWqqKjwWgC0Pv7MDYnZAYSygIeP9PR05efna+3atVq0aJEOHjyo66+/XidPnqx3+9zcXLlcLs+SlJQU6JYANHP+zg2J2QGEsoCHj1GjRunOO+/UVVddpczMTL3zzjsqKyvTX/7yl3q3nzlzpsrLyz1LcXFxoFsC0Mz5OzckZgcQypr8HV2xsbG64oortH9//ZcfOZ1OOZ3Opm4DQAjxNTckZgcQypo8fHz33Xc6cOCAfvnLXzb1rmwTHuuyrH8x1/oSwW7rjM99RK35yK+e4J9L/mZ9Hf1blZ0s62EZJwLZDn6gJc4NidnREjA7AiPgL7s89NBDKigo0FdffaUtW7Zo7NixCg8P11133RXoXQFoIZgbQOsS8DMf33zzje666y4dP35cXbp00XXXXafCwkJ16dIl0LsC0EIwN4DWJeDh49VXXw30UwJo4ZgbQOvCB8sBAABbET4AAICtCB8AAMBWhA8AAGArPjayAUb97SvL+urYdZb1O347xuc+zvrRD/x3ttj6Wv2iyh6W9VuSP/O5jyKyPX6A2RH6mB2B0fK/QwAA0KwQPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtuImY/X4cl6GZf3+2IWW9cy7J1vWw7/Z6XdPAJo/ZgdwcTjzAQAAbEX4AAAAtiJ8AAAAWxE+AACArQgfAADAVoQPAABgK8IHAACwVau8z0ebpG6W9afHLLesb68ylvWIkpOW9VrLKuzg62cgrf1my3pRZY8AdoNQwewAsyMwOPMBAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALCV3/f52Lx5s5555hkVFRXpyJEjWr16tcaMGeOpG2M0a9Ys/elPf1JZWZkGDx6sRYsW6fLLLw9k341y5vJ4y/pt7U9Y1mcdvcayXvv5Pr97gr3OXNG4nwGu1fdPS5gbErMDzI5A8fvMR2VlpQYMGKCFCxfWW583b56ee+45LV68WNu2bVP79u2VmZmpM2fONLpZAKGJuQGgLr/PfIwaNUqjRo2qt2aM0fz58/XYY4/p9ttvlyS9/PLLio+P1xtvvKEJEyY0rlsAIYm5AaCugL7n4+DBgyopKdGIESM861wul9LT07V169Z6H1NVVaWKigqvBUDr0ZC5ITE7gFAW0PBRUlIiSYqP935NLD4+3lP7odzcXLlcLs+SlJQUyJYANHMNmRsSswMIZUG/2mXmzJkqLy/3LMXFxcFuCUAIYHYAoSug4SMhIUGSVFpa6rW+tLTUU/shp9OpDh06eC0AWo+GzA2J2QGEsoCGj5SUFCUkJGj9+vWedRUVFdq2bZsyMjICuSsALQRzA2h9/L7a5bvvvtP+/fs9Xx88eFC7du1Sx44d1b17d02bNk3/8R//ocsvv1wpKSl6/PHHlZiY6HVNf3PnljvYLaCJHRxj/aPPz0BgtYa5IfFz0xowOwLD7/CxY8cODR8+3PP19OnTJUlZWVnKz8/XjBkzVFlZqUmTJqmsrEzXXXed1q5dq8jIyMB1DSCkMDcA1OV3+Bg2bJiMMResOxwOzZkzR3PmzGlUYwBaDuYGgLqCfrULAABoXQgfAADAVoQPAABgK8IHAACwFeEDAADYyu+rXVqDMB+ZrKvzhGV9V4cUy3otH4AVdImX/8Oy7utnAKgPs6PlY3YEBkcJAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGCrVnmfD+eOfZb1hWWplvXs2AOW9dVpN1rWwzfutKyj8b6cl2FZ/3v/Fyzrbrkt629+1c9nD4n6u89tEFqYHS0fs8MenPkAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANiqVd7no7aiwrL+bt9Yy3rOtw7L+vFppyzriV8mWdYl6eyhYp/btGZVowZa1vPHL7Ssh8n637DPpkmW9dRffGxZR8vka3b818ujLes5D1jfI+L0w2WW9dj93SzrknS2+Buf2zRGeM8Uy3pV945Nuv/GOjjG+n97e8dZ/xv5mh2+/qZPzA338fjWgTMfAADAVoQPAABgK8IHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbtcr7fDTWWdVa1j+6drll/a8fXOJzH4+s/oVl/bL/8531E3z0qc99NGdtkqzvZzBpwUrL+iCnsawXVllfq9/jv3xdyw+cL3n5Icu6+wHrn8sN/a1/rmf/Nc1nDzXG+j4SbR3W88uXtPbrLeu3tT9hWXfLbVkP8/E3cVM/3rr6/R6sLCxLtX54iM/mQPH7zMfmzZt16623KjExUQ6HQ2+88YZX/Z577pHD4fBabrrppkD1CyAEMTcA1OV3+KisrNSAAQO0cOGF7yB500036ciRI57llVdeaVSTAEIbcwNAXX6/7DJq1CiNGjXKchun06mEhIQGNwWgZWFuAKirSd5wumnTJsXFxalXr1667777dPz48QtuW1VVpYqKCq8FQOvjz9yQmB1AKAt4+Ljpppv08ssva/369frtb3+rgoICjRo1SrW19b/JKTc3Vy6Xy7MkJfn+0DUALYu/c0NidgChLOBXu0yYMMHz3/3799dVV12l1NRUbdq0STfccMN528+cOVPTp0/3fF1RUcEQAVoZf+eGxOwAQlmT3+fjsssuU+fOnbV///56606nUx06dPBaALRuvuaGxOwAQlmT3+fjm2++0fHjx3XppZc29a5sk/bcv1nWP3ngBcu6r+vgJem2u62fI+xu6/tQuGV9P4EwWT/+xbIUy/qCT4Zb1pOXWt9roOo31segoP9rlvXGfn9/LB1mWQ/fuNOyjqYVqnPj7DffWtZvuP8+y/rv5l/4aiBJmhu3y2cPjf3daOzjHz96jWXdl1eKBlnW2++LsKzv+bcXLes11t+eT3fuH21ZPz20tHE7aCX8Dh/fffed118jBw8e1K5du9SxY0d17NhRs2fP1rhx45SQkKADBw5oxowZ6tmzpzIzMwPaOIDQwdwAUJff4WPHjh0aPvyff/Wee801KytLixYt0u7du/XSSy+prKxMiYmJGjlypObOnSun0xm4rgGEFOYGgLr8Dh/Dhg2TMRc+b/Xee+81qiEALQ9zA0BdfLAcAACwFeEDAADYivABAABsRfgAAAC2avL7fLREycsPWdavrZxqWS+cucDnPsJ85MKzuvBtpy+O9fNPir3wzZ0kacrQLy3r7qFuH3v39f019vHWx2fnG/0s6121xbIONETUmo8s60/+359b1qsTYgLZTpNo7D1yrtCORj2+5gHr3323j9nycZX1bKme4utmdtzn42Jw5gMAANiK8AEAAGxF+AAAALYifAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvu89EAZ7/51rIe94J1vV/3B3zu4/2fPWNZ/9P/+7Fl/c2vrO9jYQpjffbQGJHHLvwhYpLUaenWRj3/O9/6upeAda6OPG7dHxAMtZ/vs6yHf25TI83Yl/MyLOthatxsuOv9+yzrV3xufa8WXBzOfAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbMV9PoLgshm+73Fx3yrra83N9k8t64n6u189NTuD+luW3SqyrC8sS7Wsd/qvxt1nBEBw3Hnj3yzrblnfw8fXbLhiCvfxsANnPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtuI+H82Ur/t4tHRHHj1rWW/rCLesv7RotGU9Tlv87glA0zv7kzTL+m2uJZZ1X7PhhV3DLeup+tiyjsDw68xHbm6uBg4cqJiYGMXFxWnMmDHau3ev1zZnzpxRdna2OnXqpOjoaI0bN06lpaUBbRpAaGF2AKjLr/BRUFCg7OxsFRYW6oMPPlBNTY1GjhypyspKzzYPPvig3nzzTa1atUoFBQU6fPiw7rjjjoA3DiB0MDsA1OXXyy5r1671+jo/P19xcXEqKirSkCFDVF5erqVLl2rFihX6yU9+IknKy8tTnz59VFhYqB/96EeB6xxAyGB2AKirUW84LS8vlyR17NhRklRUVKSamhqNGDHCs03v3r3VvXt3bd1a/2dpVFVVqaKiwmsB0LIxO4DWrcHhw+12a9q0aRo8eLD69esnSSopKVFERIRiY2O9to2Pj1dJSUm9z5ObmyuXy+VZkpKSGtoSgBDA7ADQ4PCRnZ2tPXv26NVXX21UAzNnzlR5eblnKS4ubtTzAWjemB0AGnSp7dSpU/XWW29p8+bN6tatm2d9QkKCqqurVVZW5vUXTGlpqRISEup9LqfTKafT2ZA2AIQYZgcAyc/wYYxRTk6OVq9erU2bNiklJcWrnpaWprZt22r9+vUaN26cJGnv3r36+uuvlZGREbiuEfLaJFufIp915duW9RpTa1nv9NkZv3tC02F24GL1eGqvZf0ap9uyXmMC2Q2ail/hIzs7WytWrNCaNWsUExPjeS3W5XIpKipKLpdLv/rVrzR9+nR17NhRHTp0UE5OjjIyMni3OtCKMTsA1OVX+Fi0aJEkadiwYV7r8/LydM8990iSnn32WYWFhWncuHGqqqpSZmamXnzxxYA0CyA0MTsA1OX3yy6+REZGauHChVq4cGGDmwLQsjA7ANTFB8sBAABbET4AAICtCB8AAMBWhA8AAGArwgcAALBVg+5wCjTWmZ5xlvXb2p+wrLd1hFvWI0pOWtatb1EGIFiWJG22rLt9/M086+g1lvVeDx+1rJ+1rCJQOPMBAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV9/lAcPj4kFO33Jb1wbvvtKy7vi31tyMAzcCQT8db1t3GYVnvMOqAjz1862dHaAqc+QAAALYifAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2Ir7fCAo2mwosqzf1nWgZT1aX1rWa/3uCEBzEH2T9e82WgbOfAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbOVX+MjNzdXAgQMVExOjuLg4jRkzRnv37vXaZtiwYXI4HF7LlClTAto0gNDC7ABQl1/ho6CgQNnZ2SosLNQHH3ygmpoajRw5UpWVlV7b3XvvvTpy5IhnmTdvXkCbBhBamB0A6vLrDqdr1671+jo/P19xcXEqKirSkCFDPOvbtWunhISEwHQIIOQxOwDU1aj3fJSXl0uSOnbs6LV++fLl6ty5s/r166eZM2fq1KlTF3yOqqoqVVRUeC0AWjZmB9C6NfizXdxut6ZNm6bBgwerX79+nvU///nPlZycrMTERO3evVsPP/yw9u7dq9dff73e58nNzdXs2bMb2gaAEMPsAOAwxpiGPPC+++7Tu+++qw8//FDdunW74HYbNmzQDTfcoP379ys1NfW8elVVlaqqqjxfV1RUKCkpScN0u9o42jakNQCNdNbUaJPWqLy8XB06dAjoczM7gJbJn7nRoDMfU6dO1VtvvaXNmzdbDg9JSk9Pl6QLDhCn0ymn09mQNgCEGGYHAMnP8GGMUU5OjlavXq1NmzYpJSXF52N27dolSbr00ksb1CCA0MfsAFCXX+EjOztbK1as0Jo1axQTE6OSkhJJksvlUlRUlA4cOKAVK1Zo9OjR6tSpk3bv3q0HH3xQQ4YM0VVXXdUk3wCA5o/ZAaAuv97z4XA46l2fl5ene+65R8XFxbr77ru1Z88eVVZWKikpSWPHjtVjjz120a8bV1RUyOVy8botEESBfs8HswNo+ZrsPR++ckpSUpIKCgr8eUoArQCzA0BdfLYLAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANiK8AEAAGxF+AAAALby64Pl7HDuA6jOqka66M/bBRBIZ1UjyfcHwjUnzA4guPyZG80ufJw8eVKS9KHeCXInAE6ePCmXyxXsNi4KswNoHi5mbjhMM/vTxu126/Dhw4qJiZHD4VBFRYWSkpJUXFysDh06BLu9kMQxbJzWePyMMTp58qQSExMVFhYar84yOwKL49d4re0Y+jM3mt2Zj7CwMHXr1u289R06dGgV/3hNiWPYOK3t+IXKGY9zmB1Ng+PXeK3pGF7s3AiNP2kAAECLQfgAAAC2avbhw+l0atasWXI6ncFuJWRxDBuH4xea+HdrHI5f43EML6zZveEUAAC0bM3+zAcAAGhZCB8AAMBWhA8AAGArwgcAALAV4QMAANiq2YePhQsXqkePHoqMjFR6ero++uijYLfUbG3evFm33nqrEhMT5XA49MYbb3jVjTF64okndOmllyoqKkojRozQvn37gtNsM5Sbm6uBAwcqJiZGcXFxGjNmjPbu3eu1zZkzZ5Sdna1OnTopOjpa48aNU2lpaZA6xoUwNy4ec6NxmBsN06zDx8qVKzV9+nTNmjVLO3fu1IABA5SZmamjR48Gu7VmqbKyUgMGDNDChQvrrc+bN0/PPfecFi9erG3btql9+/bKzMzUmTNnbO60eSooKFB2drYKCwv1wQcfqKamRiNHjlRlZaVnmwcffFBvvvmmVq1apYKCAh0+fFh33HFHELvGDzE3/MPcaBzmRgOZZmzQoEEmOzvb83Vtba1JTEw0ubm5QewqNEgyq1ev9nztdrtNQkKCeeaZZzzrysrKjNPpNK+88koQOmz+jh49aiSZgoICY8z3x6tt27Zm1apVnm0+//xzI8ls3bo1WG3iB5gbDcfcaDzmxsVptmc+qqurVVRUpBEjRnjWhYWFacSIEdq6dWsQOwtNBw8eVElJidfxdLlcSk9P53heQHl5uSSpY8eOkqSioiLV1NR4HcPevXure/fuHMNmgrkRWMwN/zE3Lk6zDR/Hjh1TbW2t4uPjvdbHx8erpKQkSF2FrnPHjON5cdxut6ZNm6bBgwerX79+kr4/hhEREYqNjfXalmPYfDA3Aou54R/mxsVrE+wGgOYoOztbe/bs0YcffhjsVgCECObGxWu2Zz46d+6s8PDw894RXFpaqoSEhCB1FbrOHTOOp29Tp07VW2+9pY0bN6pbt26e9QkJCaqurlZZWZnX9hzD5oO5EVjMjYvH3PBPsw0fERERSktL0/r16z3r3G631q9fr4yMjCB2FppSUlKUkJDgdTwrKiq0bds2juf/MsZo6tSpWr16tTZs2KCUlBSvelpamtq2bet1DPfu3auvv/6aY9hMMDcCi7nhG3OjgYL9jlcrr776qnE6nSY/P9/8/e9/N5MmTTKxsbGmpKQk2K01SydPnjQff/yx+fjjj40k84c//MF8/PHH5tChQ8YYY55++mkTGxtr1qxZY3bv3m1uv/12k5KSYk6fPh3kzpuH++67z7hcLrNp0yZz5MgRz3Lq1CnPNlOmTDHdu3c3GzZsMDt27DAZGRkmIyMjiF3jh5gb/mFuNA5zo2Gadfgwxpjnn3/edO/e3URERJhBgwaZwsLCYLfUbG3cuNFIOm/Jysoyxnx/2dzjjz9u4uPjjdPpNDfccIPZu3dvcJtuRuo7dpJMXl6eZ5vTp0+b+++/31xyySWmXbt2ZuzYsebIkSPBaxr1Ym5cPOZG4zA3GsZhjDH2nWcBAACtXbN9zwcAAGiZCB8AAMBWhA8AAGArwgcAALAV4QMAANiK8AEAAGxF+AAAALYifAAAAFsRPgAAgK0IHwAAwFaEDwAAYKv/Dx2MoNZzNInaAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAEjCAYAAACSDWOaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkfUlEQVR4nO3df1RVdb7/8dcB5YgCh/wBSCISlpZazZARmb8mk+zHqOnM2Ewt8lZaEV1jHBtblalzo2ymtDKd7tdg8urkdb6a04+x8gc4pZhSZjbpNTOjFBy98SNUQM7n+0dfz3ACNx447MOB52OtvZZnvz9n7w+7eK8X++y9j8MYYwQAAGCTkEBPAAAAdCyEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWxE+AACArQgfAADAVoQPNOrLL7+Uw+FQXl5eoKcCIEg9/fTTuuCCCxQaGqrLL7880NNBG0L46KDy8vLkcDi0c+fOQE8FQBvxySefaPLkyUpMTFSXLl10/vnn67rrrtPzzz/v87beeecdzZo1S8OGDVNubq6eeOIJHT58WI8//rh27drl/8kjqHQK9ATQNiUmJurkyZPq3LlzoKcCwAZbt27V6NGj1bdvX919992Ki4tTcXGxCgsLtWjRImVlZfm0vU2bNikkJETLli1TWFiYJGnnzp2aO3eu+vXrx5mQDo7wgUY5HA516dIl0NOwdOLECXXt2jXQ0wDahf/4j/+Qy+XSjh07FB0d7VU7evSoz9s7evSowsPDPcEDqI+PXdCoxq75uOOOOxQREaFvvvlGEyZMUEREhHr16qWZM2eqrq7O6/1ut1sLFy7UoEGD1KVLF8XGxmr69On69ttvvcatW7dON954o+Lj4+V0OpWcnKz58+c32N6oUaM0ePBgFRUVacSIEeratasefvjhVvv5gY7mwIEDGjRoUIPgIUkxMTGef58+fVrz589XcnKynE6n+vXrp4cffljV1dWeMQ6HQ7m5uaqqqpLD4fD0kqFDh0qSpk6d6rVe+tfv+O7duzVy5Eh17dpV/fv311/+8hdJUkFBgVJTUxUeHq4BAwZow4YNXnM8dOiQ7rvvPg0YMEDh4eHq0aOHfvazn+nLL7/0jDHGaPTo0erVq5dXoKqpqdGQIUOUnJysqqqqlh5KnAPCB3xSV1en9PR09ejRQ7///e81cuRI/eEPf9BLL73kNW769On6zW9+o2HDhmnRokWaOnWqVqxYofT0dNXW1nrG5eXlKSIiQtnZ2Vq0aJFSUlL02GOP6be//W2DfR8/flzjxo3T5ZdfroULF2r06NGt/vMCHUViYqKKioq0Z88ey3F33XWXHnvsMf34xz/Ws88+q5EjRyonJ0dTpkzxjFm+fLmGDx8up9Op5cuXa/ny5br44os1b948SdK0adM860eMGOF537fffqubbrpJqampWrBggZxOp6ZMmaJVq1ZpypQpuuGGG/Tkk0+qqqpKkydPVmVlpee9O3bs0NatWzVlyhQ999xzuueee7Rx40aNGjVKJ06ckPR9KHr55Zd16tQp3XPPPZ73zpkzR59++qlyc3PVrVs3vxxPNMGgQ8rNzTWSzI4dOxqtHzx40Egyubm5nnUZGRlGkpk3b57X2B/96EcmJSXF8/rvf/+7kWRWrFjhNW79+vUN1p84caLBvqdPn266du1qTp065Vk3cuRII8ksXbrUp58TwLl55513TGhoqAkNDTVpaWlm1qxZ5u233zY1NTWeMbt27TKSzF133eX13pkzZxpJZtOmTZ51GRkZplu3bl7jduzY0aCvnHHmd3zlypWedXv37jWSTEhIiCksLPSsf/vttxtsp7Fesm3bNiPJvPLKK17r//jHPxpJ5r/+679MYWGhCQ0NNTNmzLA+QPArznzAZ/X/YpCk4cOH64svvvC8Xr16tVwul6677jodO3bMs6SkpCgiIkKbN2/2jA0PD/f8u7KyUseOHdPw4cN14sQJ7d2712s/TqdTU6dObaWfCujYrrvuOm3btk0//elP9fHHH2vBggVKT0/X+eefr7/+9a+SpLfeekuSlJ2d7fXeX//615KkN998s0VziIiI8DqDMmDAAEVHR+viiy9WamqqZ/2Zf9fvO/V7SW1trY4fP67+/fsrOjpaH374odd+pk2bpvT0dGVlZen2229XcnKynnjiiRbNHb7hglP4pEuXLurVq5fXuvPOO8/rWo79+/ervLzc63Pi+up/1vrpp5/qkUce0aZNm1RRUeE1rry83Ov1+eefz8VrQCsaOnSo1qxZo5qaGn388cdau3atnn32WU2ePFm7du3SoUOHFBISov79+3u9Ly4uTtHR0Tp06FCL9t+nTx85HA6vdS6XSwkJCQ3WSfLqOydPnlROTo5yc3P1zTffyBjjqf2wl0jSsmXLlJycrP3792vr1q1e4QWtj/ABn4SGhjY5xu12KyYmRitWrGi0fia8lJWVaeTIkYqKitK8efOUnJysLl266MMPP9RDDz0kt9vt9T6aA2CPsLAwDR06VEOHDtVFF12kqVOnavXq1Z76DwOCv5ytv5xtff2AkZWVpdzcXM2YMUNpaWlyuVxyOByaMmVKg14iSfn5+Z6LZD/55BOlpaX54SfAuSJ8wO+Sk5O1YcMGDRs2zDIw5Ofn6/jx41qzZo3XRWcHDx60Y5oAzsEVV1whSTpy5IgSExPldru1f/9+XXzxxZ4xpaWlKisrU2JiouW2Wiu0SNJf/vIXZWRk6A9/+INn3alTp1RWVtZg7JEjR5SVlaWxY8cqLCxMM2fOVHp6epPzh/9wzQf87uc//7nq6uo0f/78BrXTp097msGZv2bq//VSU1OjF1980ZZ5AviXzZs3e/0unnHmOo8BAwbohhtukCQtXLjQa8wzzzwjSbrxxhst93HmTpLGAkFLhYaGNpj/888/3+C2fUm6++675Xa7tWzZMr300kvq1KmT7rzzzkZ/frQOznx0cC+//LLWr1/fYP348eObvc2RI0dq+vTpysnJ0a5duzR27Fh17txZ+/fv1+rVq7Vo0SJNnjxZV199tc477zxlZGTogQcekMPh0PLly2kAQABkZWXpxIkTmjhxogYOHKiamhpt3bpVq1atUr9+/TR16lRFR0crIyNDL730kudj0w8++EB/+tOfNGHChCZvf09OTlZ0dLSWLl2qyMhIdevWTampqUpKSmrx/G+66SYtX75cLpdLl1xyibZt26YNGzaoR48eXuNyc3P15ptvKi8vT3369JH0fUi57bbbtGTJEt13330tngvOQQDvtEEAnbnV9mzLmdtlf3ir7Q9vnTPGmDlz5pjG/ld66aWXTEpKigkPDzeRkZFmyJAhZtasWebw4cOeMe+//7656qqrTHh4uImPj/fc3ifJbN682TNu5MiRZtCgQX49BgD+5W9/+5v5t3/7NzNw4EATERFhwsLCTP/+/U1WVpYpLS31jKutrTVz5841SUlJpnPnziYhIcHMnj3b69Z4Y87eL9atW2cuueQS06lTJ68ec7bf8cTERHPjjTc2WC/JZGZmel5/++23ZurUqaZnz54mIiLCpKenm71795rExESTkZFhjDGmuLjYuFwuc/PNNzfY3sSJE023bt3MF198cU7HCy3jMIY/MwEAgH245gMAANiK8AEAAGxF+AAAALYifAAAAFsRPgAAgK0IHwAAwFZt7iFjbrdbhw8fVmRkZKs+ihfA2RljVFlZqfj4eIWEBMffKPQOILB86hut9QCRF154wSQmJhqn02muvPJKs3379nN6X3FxseXDr1hYWOxbiouLW6tFNKq5fcMYegcLS1tZzqVvtMqZj1WrVik7O1tLly5VamqqFi5cqPT0dO3bt++sX7N+RmRkpCTpGt2gTurcGtMD0ITTqtV7esvz+2iHlvQNid4BBJovfaNVnnCampqqoUOH6oUXXpD0/enQhIQEZWVl6be//a3leysqKuRyuTRK49XJQQMBAuG0qVW+1qm8vFxRUVG27LMlfUOidwCB5kvf8PuHuTU1NSoqKtKYMWP+tZOQEI0ZM0bbtm1rML66uloVFRVeC4COxde+IdE7gGDm9/Bx7Ngx1dXVKTY21mt9bGysSkpKGozPycmRy+XyLAkJCf6eEoA2zte+IdE7gGAW8MvYZ8+erfLycs9SXFwc6CkBCAL0DiB4+f2C0549eyo0NFSlpaVe60tLSxUXF9dgvNPplNPp9Pc0AAQRX/uGRO8Agpnfz3yEhYUpJSVFGzdu9Kxzu93auHGj0tLS/L07AO0AfQPoWFrlVtvs7GxlZGToiiuu0JVXXqmFCxeqqqpKU6dObY3dAWgH6BtAx9Eq4eMXv/iF/vnPf+qxxx5TSUmJLr/8cq1fv77BxWQAcAZ9A+g4WuU5Hy3BvfpA4AXiOR8tRe8AAiugz/kAAACwQvgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANiK8AEAAGxF+AAAALYifAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWxE+AACArQgfAADAVoQPAABgK8IHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWfg8fjz/+uBwOh9cycOBAf+8GQDtC3wA6lk6tsdFBgwZpw4YN/9pJp1bZDYB2hL4BdByt8tvdqVMnxcXFtcamAbRT9A2g42iVaz7279+v+Ph4XXDBBfrVr36lr7766qxjq6urVVFR4bUA6Hh86RsSvQMIZn4PH6mpqcrLy9P69eu1ZMkSHTx4UMOHD1dlZWWj43NycuRyuTxLQkKCv6cEoI3ztW9I9A4gmDmMMaY1d1BWVqbExEQ988wzuvPOOxvUq6urVV1d7XldUVGhhIQEjdJ4dXJ0bs2pATiL06ZW+Vqn8vJyRUVF2b7/pvqGRO8A2hpf+karX9EVHR2tiy66SJ9//nmjdafTKafT2drTABBEmuobEr0DCGatHj6+++47HThwQLfffntr7wo+CO3R3bK+//m+lvXHU163rP8q8rhlvc64Lev/fjjNsr5/aLVlHcGNvtF20TvgD36/5mPmzJkqKCjQl19+qa1bt2rixIkKDQ3Vrbfe6u9dAWgn6BtAx+L3Mx9ff/21br31Vh0/fly9evXSNddco8LCQvXq1cvfuwLQTtA3gI7F7+Hj1Vdf9fcmAbRz9A2gY+G7XQAAgK0IHwAAwFaEDwAAYCvCBwAAsBVfG9lO1aRfYVm/YO5ey/q6hGUt2n+dcVjW3bJ+sO6AriWW9f06z+c5AWgavQN24MwHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArHjLWTqU9+YFlfW7MR5b1j2rclvW8Y8Mt638rutSyfsvQnZb1fl2OW9YDLSQyssXbcFdW+mEmgH/RO1oXveN7nPkAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANiK53wEqW8eutqy/lbMC5b1Afl3WdYveuCQZb3u+P9av1/Wzwr4NGWQZX3DCJdlPU5bLetN6RQXa1n/7NF+lvXpIzY1uY/t31pv4+SN1u9vD/fyo+2hd9A72gLOfAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbOXzcz62bNmip59+WkVFRTpy5IjWrl2rCRMmeOrGGM2ZM0f/+Z//qbKyMg0bNkxLlizRhRde6M95t3shXbta1ifc+nfL+qWFt1vWk3/1kWW9zrLacqboU8t6XFHLtl/5i6ss6z9/bL1l/a/Rf2vZBCT9rIl79TsS+oZ96B0t2z69wx4+n/moqqrSZZddpsWLFzdaX7BggZ577jktXbpU27dvV7du3ZSenq5Tp061eLIAghN9A0B9Pp/5GDdunMaNG9dozRijhQsX6pFHHtH48eMlSa+88opiY2P12muvacqUKS2bLYCgRN8AUJ9fr/k4ePCgSkpKNGbMGM86l8ul1NRUbdu2rdH3VFdXq6KiwmsB0HE0p29I9A4gmPk1fJSUlEiSYmO9n30fGxvrqf1QTk6OXC6XZ0lISPDnlAC0cc3pGxK9AwhmAb/bZfbs2SovL/csxcXFgZ4SgCBA7wCCl1/DR1xcnCSptLTUa31paamn9kNOp1NRUVFeC4COozl9Q6J3AMHMr+EjKSlJcXFx2rhxo2ddRUWFtm/frrS0NH/uCkA7Qd8AOh6f73b57rvv9Pnnn3teHzx4ULt27VL37t3Vt29fzZgxQ7/73e904YUXKikpSY8++qji4+O97ulH00Jie1nW5/Syvlf//X9e4M/p2M6RMsiy/j8POC3r74/+vWW9Z2i4Zb3CXW1Z//Fb/25Zl6SBM/da1t2VlU1uo72gb9iH3kHvCAY+h4+dO3dq9OjRntfZ2dmSpIyMDOXl5WnWrFmqqqrStGnTVFZWpmuuuUbr169Xly5d/DdrAEGFvgGgPp/Dx6hRo2SMOWvd4XBo3rx5mjdvXosmBqD9oG8AqC/gd7sAAICOhfABAABsRfgAAAC2InwAAABbET4AAICtfL7bBfaoO3z277SQpNu/vM6y/n8uWmFZf+D8n1vWT39z2LLeUgdfvdSyXnD1i5b1pu61D1FXy/qPd/zKsh73ZGfL+kWFOyzrkuRucgTgf/QOekcw4MwHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWPOejjTLV1Zb1ytt7W9b7/d36XvXDE/pZ1mMWt+xe/QMrfmRZLxz2gmU9t/wyy3revqss69GrIi3r8X/dZVl3nzplWQfaKnoHvSMYcOYDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArnvMRpE5/8aVlvf9f77Gsf/6w9b3yi+7tb1nfdyLWsv5Erz9a1sf/+teW9Yj/LrSs99GnlvWmuFv0biB4NdU78k91tqzvbKJ3XKH7LevVoyss6/vSllnWR++5zbIemXHCst6nhN7RFnDmAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWxE+AACArQgfAADAVoQPAABgK57z0U4N/PUey/rSkYmW9azz9lvvoIn6rV/cYFlv6jkeAAJj9rxplvX3n7B+zsfrDy2wrMeGhlvW+79+r2X9ovuKLOun3XWWdbQNPp/52LJli26++WbFx8fL4XDotdde86rfcccdcjgcXsv111/vr/kCCEL0DQD1+Rw+qqqqdNlll2nx4sVnHXP99dfryJEjnuXPf/5ziyYJILjRNwDU5/PHLuPGjdO4ceMsxzidTsXFxTV7UgDaF/oGgPpa5YLT/Px8xcTEaMCAAbr33nt1/Pjxs46trq5WRUWF1wKg4/Glb0j0DiCY+T18XH/99XrllVe0ceNGPfXUUyooKNC4ceNUV9f4RUA5OTlyuVyeJSEhwd9TAtDG+do3JHoHEMz8frfLlClTPP8eMmSILr30UiUnJys/P1/XXnttg/GzZ89Wdna253VFRQVNBOhgfO0bEr0DCGat/pyPCy64QD179tTnn3/eaN3pdCoqKsprAdCxNdU3JHoHEMxa/TkfX3/9tY4fP67evXu39q5Qj/vECcv677dYX/w37eYlLdp/fHi5Zf1/nE7LuqmubtH+EdzoG4HjrHBb1muN9XM0mnqOxxPHhljWL3n8kGWd53i0Dz6Hj++++87rr5GDBw9q165d6t69u7p37665c+dq0qRJiouL04EDBzRr1iz1799f6enpfp04gOBB3wBQn8/hY+fOnRo9erTn9ZnPXDMyMrRkyRLt3r1bf/rTn1RWVqb4+HiNHTtW8+fPl7OJv3QBtF/0DQD1+Rw+Ro0aJWPMWetvv/12iyYEoP2hbwCojy+WAwAAtiJ8AAAAWxE+AACArQgfAADAVq3+nA8ERu2YFMv6Uz9ZZVmfc/RHlvVRkZ9Z1p/tvd2y/tPeEyzrp7/8yrIOoHVEfnLUsn7o9GnLev/OoZb1d3433LIeUWLdO9A+cOYDAADYivABAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArnvPRTk1bvMayHuaos6x/PK63ZT3inWrL+rXh1s8Bqe7X07IeynM+gICIyKuwrF/UuYtl/bj7pGU9/J+1Ps8J7Q9nPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtuI5H0Hq+F1plvVJEUWW9QFr77OsX1iy3bL+8ts/saz/5pf/sKwfmGL9v95F+ZZlAM1UcetVlvW3kl60rN9VPNKyfnRylGU99OsPLevoGDjzAQAAbEX4AAAAtiJ8AAAAWxE+AACArQgfAADAVoQPAABgK8IHAACwFc/5CFJjM9+3rC8uS7asD5ht/RwOdxP7D61uYkAToj7jfz2gNTg6Wf9uDfz3T1u0/X3PDrKsR35d2KLto2Pw6cxHTk6Ohg4dqsjISMXExGjChAnat2+f15hTp04pMzNTPXr0UEREhCZNmqTS0lK/ThpAcKF3AKjPp/BRUFCgzMxMFRYW6t1331Vtba3Gjh2rqqoqz5gHH3xQr7/+ulavXq2CggIdPnxYt9xyi98nDiB40DsA1OfTue/169d7vc7Ly1NMTIyKioo0YsQIlZeXa9myZVq5cqV+8pPvH7+dm5uriy++WIWFhbrqKuvH+gJon+gdAOpr0QWn5eXlkqTu3btLkoqKilRbW6sxY8Z4xgwcOFB9+/bVtm3bGt1GdXW1KioqvBYA7Ru9A+jYmh0+3G63ZsyYoWHDhmnw4MGSpJKSEoWFhSk6OtprbGxsrEpKShrdTk5Ojlwul2dJSEho7pQABAF6B4Bmh4/MzEzt2bNHr776aosmMHv2bJWXl3uW4uLiFm0PQNtG7wDQrPsd77//fr3xxhvasmWL+vTp41kfFxenmpoalZWVef0FU1paqri4uEa35XQ65XQ6mzMNAEGG3gFA8jF8GGOUlZWltWvXKj8/X0lJSV71lJQUde7cWRs3btSkSZMkSfv27dNXX32ltLQ0/826Awi5dKBlfX7MSsv6JS9nWtb7VTb+ObpdIo409SQRtCf0DvuEJpxvWX8pYU0TW3BYVs/bftiyfrqJrQOSj+EjMzNTK1eu1Lp16xQZGen5LNblcik8PFwul0t33nmnsrOz1b17d0VFRSkrK0tpaWlcrQ50YPQOAPX5FD6WLFkiSRo1apTX+tzcXN1xxx2SpGeffVYhISGaNGmSqqurlZ6erhdffNEvkwUQnOgdAOrz+WOXpnTp0kWLFy/W4sWLmz0pAO0LvQNAfXyxHAAAsBXhAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWzXrCadofSH/LLOshzqsc+NHUxdZ1gdHPWBZD+tdZVn/xzDrOxLGfjbRsh7x34WWdQDNU3ptvGU9pImHiI3ff6Nl/fSXX/k8J+CHOPMBAABsRfgAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAVz/loo04fKbGsF1XXWNYvDQu1rO+bbP2cjqaeBZBz/BLLuvv3sZZ1iWcFAK2h7uZvLeuf1NRa1msejrGsO3TE5zkBP8SZDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWxE+AACArXjOR5C66+kZlvUlM5+3rKc4rbc/IP9O6/qsUst62Dc7rHcAoFVMStplWc/732GWdcfWj/04G6BxnPkAAAC2InwAAABbET4AAICtCB8AAMBWhA8AAGArwgcAALAV4QMAANjKp+d85OTkaM2aNdq7d6/Cw8N19dVX66mnntKAAQM8Y0aNGqWCggKv902fPl1Lly71z4whSYp5catl/c7oLMv6rkzr54BEFIZb1k9/c9iyDtRH77DPsu3DLeuzr3nTsv6ZYvw5HaBRPp35KCgoUGZmpgoLC/Xuu++qtrZWY8eOVVVVlde4u+++W0eOHPEsCxYs8OukAQQXegeA+nw687F+/Xqv13l5eYqJiVFRUZFGjBjhWd+1a1fFxcX5Z4YAgh69A0B9Lbrmo7y8XJLUvXt3r/UrVqxQz549NXjwYM2ePVsnTpw46zaqq6tVUVHhtQBo3+gdQMfW7O92cbvdmjFjhoYNG6bBgwd71v/yl79UYmKi4uPjtXv3bj300EPat2+f1qxZ0+h2cnJyNHfu3OZOA0CQoXcAaHb4yMzM1J49e/Tee+95rZ82bZrn30OGDFHv3r117bXX6sCBA0pOTm6wndmzZys7O9vzuqKiQgkJCc2dFoA2jt4BoFnh4/7779cbb7yhLVu2qE+fPpZjU1NTJUmff/55ow3E6XTK6WziK1YBtAv0DgCSj+HDGKOsrCytXbtW+fn5SkpKavI9u3btkiT17t27WRMEEPzoHQDq8yl8ZGZmauXKlVq3bp0iIyNVUlIiSXK5XAoPD9eBAwe0cuVK3XDDDerRo4d2796tBx98UCNGjNCll17aKj8AGtfnCevngNz0RIplPVbW7wd8Qe+wz0V377Cs/1+e44E2wGGMMec82OFodH1ubq7uuOMOFRcX67bbbtOePXtUVVWlhIQETZw4UY888oiioqLOaR8VFRVyuVwapfHq5Oh8rlMD4EenTa3ytU7l5eXn/Ltrhd4BtH++9A2fP3axkpCQ0OAJhQBA7wBQH9/tAgAAbEX4AAAAtiJ8AAAAWxE+AACArQgfAADAVoQPAABgK8IHAACwFeEDAADYivABAABsRfgAAAC2InwAAABbET4AAICtfPpiOTuc+QKq06qVzvn7dgH402nVSmr6C+HaEnoHEFi+9I02Fz4qKyslSe/prQDPBEBlZaVcLlegp3FO6B1A23AufcNh2tifNm63W4cPH1ZkZKQcDocqKiqUkJCg4uJiRUVFBXp6QYlj2DId8fgZY1RZWan4+HiFhATHp7P0Dv/i+LVcRzuGvvSNNnfmIyQkRH369GmwPioqqkP8x2tNHMOW6WjHL1jOeJxB72gdHL+W60jH8Fz7RnD8SQMAANoNwgcAALBVmw8fTqdTc+bMkdPpDPRUghbHsGU4fsGJ/24tw/FrOY7h2bW5C04BAED71ubPfAAAgPaF8AEAAGxF+AAAALYifAAAAFsRPgAAgK3afPhYvHix+vXrpy5duig1NVUffPBBoKfUZm3ZskU333yz4uPj5XA49Nprr3nVjTF67LHH1Lt3b4WHh2vMmDHav39/YCbbBuXk5Gjo0KGKjIxUTEyMJkyYoH379nmNOXXqlDIzM9WjRw9FRERo0qRJKi0tDdCMcTb0jXNH32gZ+kbztOnwsWrVKmVnZ2vOnDn68MMPddlllyk9PV1Hjx4N9NTapKqqKl122WVavHhxo/UFCxboueee09KlS7V9+3Z169ZN6enpOnXqlM0zbZsKCgqUmZmpwsJCvfvuu6qtrdXYsWNVVVXlGfPggw/q9ddf1+rVq1VQUKDDhw/rlltuCeCs8UP0Dd/QN1qGvtFMpg278sorTWZmpud1XV2diY+PNzk5OQGcVXCQZNauXet57Xa7TVxcnHn66ac968rKyozT6TR//vOfAzDDtu/o0aNGkikoKDDGfH+8OnfubFavXu0Z89lnnxlJZtu2bYGaJn6AvtF89I2Wo2+cmzZ75qOmpkZFRUUaM2aMZ11ISIjGjBmjbdu2BXBmwengwYMqKSnxOp4ul0upqakcz7MoLy+XJHXv3l2SVFRUpNraWq9jOHDgQPXt25dj2EbQN/yLvuE7+sa5abPh49ixY6qrq1NsbKzX+tjYWJWUlARoVsHrzDHjeJ4bt9utGTNmaNiwYRo8eLCk749hWFiYoqOjvcZyDNsO+oZ/0Td8Q984d50CPQGgLcrMzNSePXv03nvvBXoqAIIEfePctdkzHz179lRoaGiDK4JLS0sVFxcXoFkFrzPHjOPZtPvvv19vvPGGNm/erD59+njWx8XFqaamRmVlZV7jOYZtB33Dv+gb546+4Zs2Gz7CwsKUkpKijRs3eta53W5t3LhRaWlpAZxZcEpKSlJcXJzX8ayoqND27ds5nv+fMUb333+/1q5dq02bNikpKcmrnpKSos6dO3sdw3379umrr77iGLYR9A3/om80jb7RTIG+4tXKq6++apxOp8nLyzP/+Mc/zLRp00x0dLQpKSkJ9NTapMrKSvPRRx+Zjz76yEgyzzzzjPnoo4/MoUOHjDHGPPnkkyY6OtqsW7fO7N6924wfP94kJSWZkydPBnjmbcO9995rXC6Xyc/PN0eOHPEsJ06c8Iy55557TN++fc2mTZvMzp07TVpamklLSwvgrPFD9A3f0Ddahr7RPG06fBhjzPPPP2/69u1rwsLCzJVXXmkKCwsDPaU2a/PmzUZSgyUjI8MY8/1tc48++qiJjY01TqfTXHvttWbfvn2BnXQb0tixk2Ryc3M9Y06ePGnuu+8+c95555muXbuaiRMnmiNHjgRu0mgUfePc0Tdahr7RPA5jjLHvPAsAAOjo2uw1HwAAoH0ifAAAAFsRPgAAgK0IHwAAwFaEDwAAYCvCBwAAsBXhAwAA2IrwAQAAbEX4AAAAtiJ8AAAAWxE+AACArf4fANy+fDoYPt4AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Testing accuracy in MNIST for linear and softmax based attention\n",
        "\n",
        "I mean of course both of the models were able to complete the task but to test which one is better what we can do is complete the image for all of the possible images in the training data and now train a new neural network on this data and then test the MNIST test dataset."
      ],
      "metadata": {
        "id": "AvantEK5S5bX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Load the whole training MNIST dataset"
      ],
      "metadata": {
        "id": "DQ6NnFahTf-S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Replace 'your_file.csv' with the actual filename\n",
        "data = pd.read_csv('/content/sample_data/mnist_train_small.csv')\n",
        "data=np.array(data)\n",
        "\n",
        "train_x=[ ]\n",
        "train_y=[ ]\n",
        "\n",
        "for x in data[:500]:\n",
        "  x=x[1:]\n",
        "  # x=torch.tensor([x])\n",
        "  x=x.reshape(28, 28)\n",
        "  # x=torch.tensor([x])\n",
        "  # x=x.squeeze()\n",
        "  train_x.append(x)\n",
        "\n",
        "print(len(train_x))\n",
        "\n"
      ],
      "metadata": {
        "id": "_7cy9ghqS44l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "206f4532-a473-4a4a-ad00-626f42bf12ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Occlude the whole set of training data and prepare for completion"
      ],
      "metadata": {
        "id": "06TYPUxjwToT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x in data[:500]:\n",
        "  x=x[0]\n",
        "  train_y.append(x)\n",
        "\n",
        "print(len(train_y))"
      ],
      "metadata": {
        "id": "gip8sFS7wnhg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf4d0d08-8678-427e-ab7e-de2d5e039588"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "occluded_dataset=[]\n",
        "for image in train_x:\n",
        "  image_tensor = torch.from_numpy(image.reshape(28, 28))  # Create tensor\n",
        "  occluded_image = occlude_half_image(image_tensor.unsqueeze(0))\n",
        "  occluded_dataset.append(occluded_image)  # Add batch dim, occlude\n",
        "\n",
        "print(len(occluded_dataset))\n"
      ],
      "metadata": {
        "id": "hmcstGtLNodZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df3ecec4-618f-4e34-dd93-5e7ac78c80b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "flatten_image=[]\n",
        "for images in occluded_dataset:\n",
        "  flat=prepare_image_for_model(images)\n",
        "  flat=flat[:,:-1]\n",
        "  flatten_image.append(flat)\n",
        "print(len(flatten_image))\n",
        "print(flatten_image[0].shape)"
      ],
      "metadata": {
        "id": "5iEmoVoeY6gh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b88ebe85-2dd8-4f67-a4ff-0d32799bc589"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "500\n",
            "torch.Size([1, 783])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Complete the images."
      ],
      "metadata": {
        "id": "iblf3Gf0NoAw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "linear = RecurrentGenerator(256, 783, 10, \"linear\", 8, 8)\n",
        "linear.load_state_dict(linear_weights)\n",
        "linear.eval()\n",
        "full = RecurrentGenerator(256, 783, 10, \"full\", 8, 8)\n",
        "full.load_state_dict(softmax_weights)\n",
        "full.eval()\n",
        "\n",
        "\n",
        "image_linear_train=[]\n",
        "image_full_train=[]\n",
        "for i in range(len(flatten_image)):\n",
        "  print(i)\n",
        "  image=flatten_image[i]\n",
        "  images_linear = predict_with_recurrent(linear, image, 392)\n",
        "  image_linear_train.append(images_linear)\n",
        "  images_full = predict_with_recurrent(full, image, 392)\n",
        "  image_full_train.append(images_full)\n",
        "\n",
        "print(len(image_linear_train))\n",
        "print(len(image_full_train))\n"
      ],
      "metadata": {
        "id": "_5wRuXGCNvcY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d6082ba-61ea-4f84-b31b-7a4e80b3c5cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "13\n",
            "14\n",
            "15\n",
            "16\n",
            "17\n",
            "18\n",
            "19\n",
            "20\n",
            "21\n",
            "22\n",
            "23\n",
            "24\n",
            "25\n",
            "26\n",
            "27\n",
            "28\n",
            "29\n",
            "30\n",
            "31\n",
            "32\n",
            "33\n",
            "34\n",
            "35\n",
            "36\n",
            "37\n",
            "38\n",
            "39\n",
            "40\n",
            "41\n",
            "42\n",
            "43\n",
            "44\n",
            "45\n",
            "46\n",
            "47\n",
            "48\n",
            "49\n",
            "50\n",
            "51\n",
            "52\n",
            "53\n",
            "54\n",
            "55\n",
            "56\n",
            "57\n",
            "58\n",
            "59\n",
            "60\n",
            "61\n",
            "62\n",
            "63\n",
            "64\n",
            "65\n",
            "66\n",
            "67\n",
            "68\n",
            "69\n",
            "70\n",
            "71\n",
            "72\n",
            "73\n",
            "74\n",
            "75\n",
            "76\n",
            "77\n",
            "78\n",
            "79\n",
            "80\n",
            "81\n",
            "82\n",
            "83\n",
            "84\n",
            "85\n",
            "86\n",
            "87\n",
            "88\n",
            "89\n",
            "90\n",
            "91\n",
            "92\n",
            "93\n",
            "94\n",
            "95\n",
            "96\n",
            "97\n",
            "98\n",
            "99\n",
            "100\n",
            "101\n",
            "102\n",
            "103\n",
            "104\n",
            "105\n",
            "106\n",
            "107\n",
            "108\n",
            "109\n",
            "110\n",
            "111\n",
            "112\n",
            "113\n",
            "114\n",
            "115\n",
            "116\n",
            "117\n",
            "118\n",
            "119\n",
            "120\n",
            "121\n",
            "122\n",
            "123\n",
            "124\n",
            "125\n",
            "126\n",
            "127\n",
            "128\n",
            "129\n",
            "130\n",
            "131\n",
            "132\n",
            "133\n",
            "134\n",
            "135\n",
            "136\n",
            "137\n",
            "138\n",
            "139\n",
            "140\n",
            "141\n",
            "142\n",
            "143\n",
            "144\n",
            "145\n",
            "146\n",
            "147\n",
            "148\n",
            "149\n",
            "150\n",
            "151\n",
            "152\n",
            "153\n",
            "154\n",
            "155\n",
            "156\n",
            "157\n",
            "158\n",
            "159\n",
            "160\n",
            "161\n",
            "162\n",
            "163\n",
            "164\n",
            "165\n",
            "166\n",
            "167\n",
            "168\n",
            "169\n",
            "170\n",
            "171\n",
            "172\n",
            "173\n",
            "174\n",
            "175\n",
            "176\n",
            "177\n",
            "178\n",
            "179\n",
            "180\n",
            "181\n",
            "182\n",
            "183\n",
            "184\n",
            "185\n",
            "186\n",
            "187\n",
            "188\n",
            "189\n",
            "190\n",
            "191\n",
            "192\n",
            "193\n",
            "194\n",
            "195\n",
            "196\n",
            "197\n",
            "198\n",
            "199\n",
            "200\n",
            "201\n",
            "202\n",
            "203\n",
            "204\n",
            "205\n",
            "206\n",
            "207\n",
            "208\n",
            "209\n",
            "210\n",
            "211\n",
            "212\n",
            "213\n",
            "214\n",
            "215\n",
            "216\n",
            "217\n",
            "218\n",
            "219\n",
            "220\n",
            "221\n",
            "222\n",
            "223\n",
            "224\n",
            "225\n",
            "226\n",
            "227\n",
            "228\n",
            "229\n",
            "230\n",
            "231\n",
            "232\n",
            "233\n",
            "234\n",
            "235\n",
            "236\n",
            "237\n",
            "238\n",
            "239\n",
            "240\n",
            "241\n",
            "242\n",
            "243\n",
            "244\n",
            "245\n",
            "246\n",
            "247\n",
            "248\n",
            "249\n",
            "250\n",
            "251\n",
            "252\n",
            "253\n",
            "254\n",
            "255\n",
            "256\n",
            "257\n",
            "258\n",
            "259\n",
            "260\n",
            "261\n",
            "262\n",
            "263\n",
            "264\n",
            "265\n",
            "266\n",
            "267\n",
            "268\n",
            "269\n",
            "270\n",
            "271\n",
            "272\n",
            "273\n",
            "274\n",
            "275\n",
            "276\n",
            "277\n",
            "278\n",
            "279\n",
            "280\n",
            "281\n",
            "282\n",
            "283\n",
            "284\n",
            "285\n",
            "286\n",
            "287\n",
            "288\n",
            "289\n",
            "290\n",
            "291\n",
            "292\n",
            "293\n",
            "294\n",
            "295\n",
            "296\n",
            "297\n",
            "298\n",
            "299\n",
            "300\n",
            "301\n",
            "302\n",
            "303\n",
            "304\n",
            "305\n",
            "306\n",
            "307\n",
            "308\n",
            "309\n",
            "310\n",
            "311\n",
            "312\n",
            "313\n",
            "314\n",
            "315\n",
            "316\n",
            "317\n",
            "318\n",
            "320\n",
            "321\n",
            "322\n",
            "323\n",
            "324\n",
            "325\n",
            "326\n",
            "327\n",
            "328\n",
            "329\n",
            "330\n",
            "331\n",
            "332\n",
            "333\n",
            "334\n",
            "335\n",
            "336\n",
            "337\n",
            "338\n",
            "339\n",
            "340\n",
            "341\n",
            "342\n",
            "343\n",
            "344\n",
            "345\n",
            "346\n",
            "347\n",
            "348\n",
            "349\n",
            "350\n",
            "351\n",
            "352\n",
            "353\n",
            "354\n",
            "355\n",
            "356\n",
            "357\n",
            "358\n",
            "359\n",
            "360\n",
            "361\n",
            "362\n",
            "363\n",
            "364\n",
            "365\n",
            "366\n",
            "367\n",
            "368\n",
            "369\n",
            "370\n",
            "371\n",
            "372\n",
            "373\n",
            "374\n",
            "375\n",
            "376\n",
            "377\n",
            "378\n",
            "379\n",
            "380\n",
            "381\n",
            "382\n",
            "383\n",
            "384\n",
            "385\n",
            "386\n",
            "387\n",
            "388\n",
            "389\n",
            "390\n",
            "391\n",
            "392\n",
            "393\n",
            "394\n",
            "395\n",
            "396\n",
            "397\n",
            "398\n",
            "399\n",
            "400\n",
            "401\n",
            "402\n",
            "403\n",
            "404\n",
            "405\n",
            "406\n",
            "407\n",
            "409\n",
            "410\n",
            "411\n",
            "412\n",
            "413\n",
            "414\n",
            "415\n",
            "416\n",
            "417\n",
            "418\n",
            "419\n",
            "420\n",
            "421\n",
            "422\n",
            "423\n",
            "424\n",
            "425\n",
            "426\n",
            "427\n",
            "428\n",
            "429\n",
            "430\n",
            "431\n",
            "432\n",
            "433\n",
            "434\n",
            "435\n",
            "436\n",
            "437\n",
            "438\n",
            "439\n",
            "440\n",
            "441\n",
            "442\n",
            "443\n",
            "444\n",
            "445\n",
            "446\n",
            "447\n",
            "448\n",
            "449\n",
            "450\n",
            "451\n",
            "452\n",
            "453\n",
            "454\n",
            "455\n",
            "456\n",
            "457\n",
            "458\n",
            "459\n",
            "460\n",
            "461\n",
            "462\n",
            "463\n",
            "464\n",
            "465\n",
            "466\n",
            "467\n",
            "468\n",
            "469\n",
            "470\n",
            "471\n",
            "472\n",
            "473\n",
            "474\n",
            "475\n",
            "476\n",
            "477\n",
            "478\n",
            "479\n",
            "480\n",
            "481\n",
            "482\n",
            "483\n",
            "484\n",
            "485\n",
            "486\n",
            "487\n",
            "488\n",
            "489\n",
            "490\n",
            "491\n",
            "492\n",
            "493\n",
            "494\n",
            "495\n",
            "496\n",
            "497\n",
            "498\n",
            "499\n",
            "500\n",
            "500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Train any neural network\n"
      ],
      "metadata": {
        "id": "iU0ynVAFNt8Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "metadata": {
        "id": "_mGPqHsxA9VS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "# Assuming train_x is a list of tensors of size (784,) and train_y is a list of integer labels\n",
        "\n",
        "# Hyperparameters\n",
        "num_epochs = 10\n",
        "batch_size = 20\n",
        "learning_rate = 0.001\n",
        "\n",
        "# Model definition\n",
        "class NeuralNetwork(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(NeuralNetwork, self).__init__()\n",
        "        self.fc1 = nn.Linear(784, 128)\n",
        "        self.relu1 = nn.ReLU()\n",
        "        self.fc2 = nn.Linear(128, 64)\n",
        "        self.relu2 = nn.ReLU()\n",
        "        self.fc3 = nn.Linear(64, 10)  # 10 output neurons for 10 digits\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.fc1(x)\n",
        "        x = self.relu1(x)\n",
        "        x = self.fc2(x)\n",
        "        x = self.relu2(x)\n",
        "        x = self.fc3(x)  # No activation for output layer (softmax will be applied later)\n",
        "        return x\n",
        "\n"
      ],
      "metadata": {
        "id": "Z0iB2XfZilQc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_model(model, x, y,optimizer, loss_function, num_epochs):\n",
        "  model.train()\n",
        "  for epoch in range(num_epochs):\n",
        "    pred = model(x)\n",
        "    loss = loss_function(pred, labels)\n",
        "    predictions = torch.argmax(pred, dim=1)\n",
        "    accuracy = (predictions == labels).sum() / len(labels)\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "    print(f\"Epoch: {epoch+1}, Loss: {loss.item():.4f}, Accuracy: {accuracy}\")\n"
      ],
      "metadata": {
        "id": "0FEEO5r-LN0b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images_linear = []\n",
        "for image in image_linear_train:\n",
        "  images_linear.append(image.squeeze())\n",
        "images_linear = torch.stack(images_linear)\n",
        "\n",
        "labels = torch.tensor(train_y)"
      ],
      "metadata": {
        "id": "9RWZFwH1_D7j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(train_y))\n",
        "print(labels.shape)"
      ],
      "metadata": {
        "id": "lY-wNE8RUFy1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "60ecf445-2c30-46db-919b-7bc5bba94c8d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "500\n",
            "torch.Size([500])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn_linear = NeuralNetwork()\n",
        "nn_linear.to(device)\n",
        "images_linear = images_linear.to(device, dtype=torch.float32)\n",
        "labels = labels.to(device, dtype=torch.long)\n",
        "loss_func_linear = nn.CrossEntropyLoss()\n",
        "loss_func_linear.to(device)\n",
        "optimizer_linear = torch.optim.Adam(nn_linear.parameters(), lr=learning_rate)\n"
      ],
      "metadata": {
        "id": "NQTfvNxfAhPg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_model(nn_linear, images_linear, labels, optimizer_linear, loss_func_linear, num_epochs)"
      ],
      "metadata": {
        "id": "ZrsUDmtuBdw7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36122d17-262a-4e11-f713-ca5d7e4453f4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 1, Loss: 16.7323, Accuracy: 0.1120000034570694\n",
            "Epoch: 2, Loss: 10.2123, Accuracy: 0.15000000596046448\n",
            "Epoch: 3, Loss: 6.9178, Accuracy: 0.19200000166893005\n",
            "Epoch: 4, Loss: 4.6589, Accuracy: 0.2900000214576721\n",
            "Epoch: 5, Loss: 3.5561, Accuracy: 0.3720000088214874\n",
            "Epoch: 6, Loss: 2.5892, Accuracy: 0.49000000953674316\n",
            "Epoch: 7, Loss: 1.8522, Accuracy: 0.5879999995231628\n",
            "Epoch: 8, Loss: 1.4062, Accuracy: 0.656000018119812\n",
            "Epoch: 9, Loss: 1.1499, Accuracy: 0.6880000233650208\n",
            "Epoch: 10, Loss: 0.9796, Accuracy: 0.7140000462532043\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "images_full = []\n",
        "for image in image_full_train:\n",
        "  images_full.append(image.squeeze())\n",
        "images_full = torch.stack(images_full)"
      ],
      "metadata": {
        "id": "KRaWalcPMAvT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nn_full = NeuralNetwork()\n",
        "nn_full.to(device)\n",
        "images_full = images_full.to(device, dtype=torch.float32)\n",
        "labels = labels.to(device, dtype=torch.long)\n",
        "loss_func_full = nn.CrossEntropyLoss()\n",
        "loss_func_full.to(device)\n",
        "optimizer_full = torch.optim.Adam(nn_full.parameters(), lr=learning_rate)"
      ],
      "metadata": {
        "id": "PVe7rKMFMomY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273
        },
        "id": "LsGrMnFRnS5F",
        "outputId": "ec0851cc-9983-4007-ba0f-55176ef27205"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "'CrossEntropyLoss' object has no attribute 'device'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-72-89595ca9f819>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mloss_func_full\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m   1686\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodules\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1687\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mmodules\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1688\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"'{type(self).__name__}' object has no attribute '{name}'\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1689\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1690\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Module'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'CrossEntropyLoss' object has no attribute 'device'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_model(nn_full, images_full, labels, optimizer_full, loss_func_full, num_epochs)"
      ],
      "metadata": {
        "id": "0BCggZXXM84_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "af135ac2-bc4b-4c3b-c93c-1a4f7d5d52cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 1, Loss: 8.9511, Accuracy: 0.12600000202655792\n",
            "Epoch: 2, Loss: 5.1766, Accuracy: 0.2600000202655792\n",
            "Epoch: 3, Loss: 3.1241, Accuracy: 0.41600000858306885\n",
            "Epoch: 4, Loss: 1.6821, Accuracy: 0.5300000309944153\n",
            "Epoch: 5, Loss: 1.1917, Accuracy: 0.6780000329017639\n",
            "Epoch: 6, Loss: 1.0582, Accuracy: 0.7120000123977661\n",
            "Epoch: 7, Loss: 0.8400, Accuracy: 0.7740000486373901\n",
            "Epoch: 8, Loss: 0.6465, Accuracy: 0.8160000443458557\n",
            "Epoch: 9, Loss: 0.4992, Accuracy: 0.8500000238418579\n",
            "Epoch: 10, Loss: 0.3871, Accuracy: 0.878000020980835\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Prepare the testdata"
      ],
      "metadata": {
        "id": "nuYTOkD-N3OC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Replace 'your_file.csv' with the actual filename\n",
        "data = pd.read_csv('/content/sample_data/mnist_test.csv')\n",
        "data=np.array(data)\n",
        "\n",
        "# test_x=[ ]\n",
        "# test_y=[ ]\n",
        "\n",
        "# for x in data:\n",
        "#   test_x.append(x[1:])\n",
        "#   test_y.append(x[0])\n",
        "\n",
        "#   test_y.append(y)\n",
        "\n",
        "test_x = torch.tensor(data[:, 1:], dtype=torch.float32).to(device)\n",
        "test_y = torch.tensor(data[:, 0]).to(device)\n",
        "\n",
        "print(len(test_x))\n",
        "print(len(test_y))\n"
      ],
      "metadata": {
        "id": "0U19IsyIo-0T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e97aa09f-73da-4e5c-dc26-11ef58248695"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9999\n",
            "9999\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Test the data"
      ],
      "metadata": {
        "id": "A_mJQY1JN50V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluate_model(model, test_images, test_labels, loss_func):\n",
        "  \"\"\"\n",
        "  Evaluates the model on the given test data and labels.\n",
        "\n",
        "  Args:\n",
        "      model (nn.Module): The PyTorch model to evaluate.\n",
        "      test_images (torch.Tensor): The test data tensor.\n",
        "      test_labels (torch.Tensor): The test labels tensor.\n",
        "      loss_func (nn.Module): The loss function to use.\n",
        "\n",
        "  Returns:\n",
        "      float: The accuracy of the model on the test data.\n",
        "      float: The loss of the model on the test data.\n",
        "  \"\"\"\n",
        "  model.eval()\n",
        "  with torch.no_grad():  # Deactivate gradient calculation for evaluation\n",
        "    predictions = model(test_images)\n",
        "    loss = loss_func(predictions, test_labels)\n",
        "    predicted_labels = torch.argmax(predictions, dim=1)\n",
        "    num_correct = (predicted_labels == test_labels).sum().item()\n",
        "    accuracy = num_correct / len(test_labels)\n",
        "    print(f\"Accuracy: {accuracy:.4f}, Loss: {loss.item():.4f}\")\n",
        "  return accuracy, loss\n"
      ],
      "metadata": {
        "id": "rdCntVjXRFuB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "LRP8lNIuqwFi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "evaluate_model(nn_linear, test_x, test_y, nn.CrossEntropyLoss())"
      ],
      "metadata": {
        "id": "sFyCysVwqdnE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c691ec5-8291-44ae-ada3-3e89016cb404"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.6370, Loss: 1.4057\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.636963696369637, tensor(1.4057, device='cuda:0'))"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "evaluate_model(nn_full, test_x, test_y, nn.CrossEntropyLoss())"
      ],
      "metadata": {
        "id": "b1nfeGydrAnj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f7ebb6f-28be-427f-bedc-4ccc625a67b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.7498, Loss: 1.0735\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7497749774977498, tensor(1.0735, device='cuda:0'))"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Train the model on these test dataset and check if the generated label is correct though using trained model"
      ],
      "metadata": {
        "id": "dTW4bSt-n6YF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "optimizer_test = torch.optim.Adam(nn_linear.parameters(), lr=learning_rate)\n",
        "loss_func_test = nn.CrossEntropyLoss()\n",
        "num_epochs = 50"
      ],
      "metadata": {
        "id": "hlLcmT7Bn55z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "image_test = test_x\n",
        "print(test_x.shape)\n",
        "labels = torch.tensor(test_y)"
      ],
      "metadata": {
        "id": "kV0cTODZoD_O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nn_test = NeuralNetwork()\n",
        "nn_test.to(device)\n",
        "image_test = image_test.to(device, dtype=torch.float32)\n",
        "labels = labels.to(device, dtype=torch.long)\n",
        "loss_func_test = nn.CrossEntropyLoss()\n",
        "loss_func_test.to(device)\n",
        "optimizer_test = torch.optim.Adam(nn_test.parameters(), lr=learning_rate)"
      ],
      "metadata": {
        "id": "i2e1DHe0oGVb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_model(nn_test, test_x, test_y, optimizer_test, loss_func_test, num_epochs)"
      ],
      "metadata": {
        "id": "pwG29puAoIkR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(images_linear.shape)\n",
        "print(images_full.shape)"
      ],
      "metadata": {
        "id": "oui9u6fwoKhp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images_linear = []\n",
        "for image in image_linear_train:\n",
        "  images_linear.append(image.squeeze())\n",
        "images_linear = torch.stack(images_linear).to(device, dtype=torch.float32)\n",
        "\n",
        "labels_linear = torch.tensor(train_y).to(device, dtype=torch.long)"
      ],
      "metadata": {
        "id": "OXyASbu4oMVE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images_full = []\n",
        "for image in image_full_train:\n",
        "  images_full.append(image.squeeze())\n",
        "images_full = torch.stack(images_full).to(device, dtype=torch.float32)\n",
        "\n",
        "labels_full = torch.tensor(train_y).to(device, dtype=torch.long)"
      ],
      "metadata": {
        "id": "G8vcwyIXoOg0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "evaluate_model(nn_test, images_linear, labels_linear, nn.CrossEntropyLoss())"
      ],
      "metadata": {
        "id": "n7095y83oQt4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "evaluate_model(nn_test, images_full, labels_full, nn.CrossEntropyLoss())"
      ],
      "metadata": {
        "id": "hFjLuW1roRbK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Time Measurements"
      ],
      "metadata": {
        "id": "admcZcl1oVp1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We measure the time take for random sequences while training for forward pass and backward pass to test the claims made in the paper and indeed the plot comes to be the same"
      ],
      "metadata": {
        "id": "kLk3yw3NpfBw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def bench_one(model, x):\n",
        "  # warmup the caches\n",
        "  y = model(x)\n",
        "  y.sum().backward()\n",
        "\n",
        "  start = torch.cuda.Event(enable_timing=True)\n",
        "  end = torch.cuda.Event(enable_timing=True)\n",
        "  start.record()\n",
        "  y = model(x)\n",
        "  y.sum().backward()\n",
        "  end.record()\n",
        "  torch.cuda.synchronize()\n",
        "\n",
        "  return start.elapsed_time(end)/1000\n",
        "\n",
        "def bench(model, batches, sequence_lengths):\n",
        "  time = []\n",
        "  for b, s in zip(batches, sequence_lengths):\n",
        "    x = torch.rand(b, s, 768).cuda()\n",
        "    time.append(bench_one(model, x)/b)\n",
        "  return time"
      ],
      "metadata": {
        "id": "lci6M3lyoVW7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "builder = TransformerEncoderBuilder.from_kwargs(\n",
        "    n_layers=1,\n",
        "    n_heads=12,\n",
        "    query_dimensions=64,\n",
        "    value_dimensions=64,\n",
        "    feed_forward_dimensions=768\n",
        ")\n",
        "\n",
        "builder.attention_type = \"full\"\n",
        "full = builder.get().cuda()\n",
        "builder.attention_type = \"linear\"\n",
        "linear = builder.get().cuda()"
      ],
      "metadata": {
        "id": "U5Vk0V3BpKS_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sequence_lengths = [2**i for i in range(7, 13)]\n",
        "linear_batches = [1000, 500, 250, 125, 62, 31]\n",
        "softmax_batches = [1000, 300, 100, 25, 5, 1]\n",
        "\n",
        "linear_time = bench(linear, linear_batches, sequence_lengths)\n",
        "softmax_time = bench(full, softmax_batches, sequence_lengths)\n",
        "\n",
        "plt.plot(sequence_lengths, softmax_time, label=\"softmax\")\n",
        "plt.plot(sequence_lengths, linear_time, label=\"linear\")\n",
        "plt.xlabel(\"Sequence Length\")\n",
        "plt.ylabel(\"Seconds\")\n",
        "plt.legend()"
      ],
      "metadata": {
        "id": "vUJ_H_GtpMSG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following time measurement is at inference."
      ],
      "metadata": {
        "id": "eX9si8hxpZ6q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from fast_transformers.builders import TransformerEncoderBuilder\n",
        "\n",
        "# Create the builder for our transformers\n",
        "builder = TransformerEncoderBuilder.from_kwargs(\n",
        "    n_layers=8,\n",
        "    n_heads=8,\n",
        "    query_dimensions=64,\n",
        "    value_dimensions=64,\n",
        "    feed_forward_dimensions=1024\n",
        ")\n",
        "\n",
        "# Build a transformer with softmax attention\n",
        "builder.attention_type = \"full\"\n",
        "softmax_model = builder.get()\n",
        "\n",
        "# Build a transformer with linear attention\n",
        "builder.attention_type = \"linear\"\n",
        "linear_model = builder.get()"
      ],
      "metadata": {
        "id": "MXcRsKDepUbL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "runs = 5\n",
        "lengths = [1000, 1500, 2000, 2500, 3000]\n",
        "softmax_time_taken = []\n",
        "linear_time_taken = []\n",
        "\n",
        "for length in lengths:\n",
        "    print(f\"-------- Length of string: {length}----------\")\n",
        "    softmax_time_taken.append([])\n",
        "    linear_time_taken.append([])\n",
        "    for run in range(runs):\n",
        "\n",
        "      # Construct the dummy input\n",
        "      X = torch.rand(10, length, 8*64)\n",
        "\n",
        "      # Prepare everythin for CUDA\n",
        "      X = X.cuda()\n",
        "      softmax_model.cuda()\n",
        "      softmax_model.eval()\n",
        "      linear_model.cuda()\n",
        "      linear_model.eval()\n",
        "\n",
        "      # Warmup the GPU\n",
        "      with torch.no_grad():\n",
        "          softmax_model(X)\n",
        "          linear_model(X)\n",
        "      torch.cuda.synchronize()\n",
        "\n",
        "      # Measure the execution time\n",
        "      softmax_start = torch.cuda.Event(enable_timing=True)\n",
        "      softmax_end = torch.cuda.Event(enable_timing=True)\n",
        "      linear_start = torch.cuda.Event(enable_timing=True)\n",
        "      linear_end = torch.cuda.Event(enable_timing=True)\n",
        "\n",
        "      print(f\"Run {run}: \", end=\"    \")\n",
        "\n",
        "      with torch.no_grad():\n",
        "        softmax_start.record()\n",
        "        y = softmax_model(X)\n",
        "        softmax_end.record()\n",
        "        torch.cuda.synchronize()\n",
        "        print(\"Softmax: \", softmax_start.elapsed_time(softmax_end), \"ms\", end=\"     \")\n",
        "        softmax_time_taken[-1].append(softmax_start.elapsed_time(softmax_end))\n",
        "\n",
        "      with torch.no_grad():\n",
        "          linear_start.record()\n",
        "          y = linear_model(X)\n",
        "          linear_end.record()\n",
        "          torch.cuda.synchronize()\n",
        "          print(\"Linear: \", linear_start.elapsed_time(linear_end), \"ms\")\n",
        "          linear_time_taken[-1].append(linear_start.elapsed_time(linear_end))\n"
      ],
      "metadata": {
        "id": "3cPyaAJBpWwF"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}