Abdul_dl4sequences_lab_2023_2024.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rcGH4cI2GmEt"
      },
      "source": [
        "# Deep learning for sequential data - Lab\n",
        "\n",
        "**Submission deadlines:**\n",
        "\n",
        "* Get at least 5 points by Friday 01.12.2023\n",
        "* Remaining points: TBD (we will decide together on Friday)\n",
        "\n",
        "*Points:* There are in total 26.5 points. **Aim to get 20 points (i.e. 20 points = maximum grade)**. The passing grade is 10 points. If you get more than 20 points, the extra points might be counted as bonuses towards the grade of the course.\n",
        "\n",
        "## Submission instructions:\n",
        "\n",
        "You have two options for submission:\n",
        "\n",
        "1. Present in person your solutions during the session on Friday 01.12.2023, or at any point during the week from 04.12.2023 to 08.12.2023 (contact me by email in order to agree on the time. It could be by videocall depending on convenience). **You get extra 0.1 points** for every task presented this way, and no comments are required in the code.\n",
        "2. Submit your solutions through moodle by TBD (we will decide together on Friday) at the latest. Detailed written explanations are required in the comments for every task.\n",
        "\n",
        "I provide some starter code, however, you are not required to use it as long as you properly solve the tasks.\n",
        "\n",
        "Make sure you know all the quetions and answers, and that the notebook contains results (before presentation do `Runtime -> Restart and run all`).\n",
        "\n",
        "**Reach out to me at santiago.cuervo@lis-lab.fr for any question or issue you might encounter.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OgKtz93lLxNe"
      },
      "source": [
        "# Problem 1. RNNs on to the parity task\n",
        "\n",
        "We will work on a toy problem: the parity task.\n",
        "\n",
        "*Inputs:* a variable sized sequence of bits.\n",
        "\n",
        "*Outputs:* a binary indicator that is `0` if the sequence contains an even number of ones and `1` otherwise.\n",
        "\n",
        "Eg.\n",
        "\n",
        "$x_1$: `0,0,0,1,0,1` , $y_1$: `0`\n",
        "\n",
        "$x_2$: `0,0,0,1,0,1,1` , $y_2$: `1`\n",
        "\n",
        "Note that this is equivalent to the RNN learning to apply a XOR function at each time step.\n",
        "\n",
        "**Tasks**:\n",
        "\n",
        "1. **(1 pt)** Implement the vanilla RNN in PyTorch. A vanilla RNN is described by the following recurrence:\n",
        "\n",
        "    $H_t = \\tanh(W_{xh}X_t + W_{hh} H_{t-1} + b_h)$\n",
        "\n",
        "    Where $X_t$ are the inputs, $H_t$ are the states, $W_{xh}$ and $W_{hh}$ are weight matrices connecting the state to the inputs and the previous state, respectively, and $b_{h}$ is the bias term.\n",
        "\n",
        "2. **(2 pt max.)** Use your RNN implementation to solve the parity task. For this:\n",
        "    \n",
        "    * (0.5 pt) Implement the call to the forward pass of the RNN in order to compute the sequence of hidden states.\n",
        "    * (0.5 pt) Apply a simple MSE loss to train the network. Implement two training modes in which: 1) The loss is applied at each time-step and 2) The loss is applied only at the last timestep. There is a boolean flag in the code called `full_supervision` that controls this behavior.\n",
        "    * (1 pt) Here you don't have to implement any extra code. Play with the values of `full_supervision`, `max_grad_norm` and `seq_len` and analyze how it affects the training dynamics.\n",
        "\n",
        "3. **(1 pt)** Implement the LSTM cell according to the equations from the slides and apply it to the parity task. Do you notice any change in the training dynamics?\n",
        "\n",
        "3. **(0.5 pt)** In the setup without full supervision, try to train both the vanilla RNN and the LSTM in long sequences. Is there any advantage in using the LSTM?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "aFYadmCNixcm"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "vETFWkhHVb6v"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "import math\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.nn import functional as F\n",
        "import torchvision\n",
        "from torchvision import datasets, transforms\n",
        "from torch.utils.data import DataLoader\n",
        "from matplotlib.patches import Rectangle\n",
        "from tqdm.notebook import tqdm\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "XNLAfi86ixcy"
      },
      "outputs": [],
      "source": [
        "# We'll be using very small networks, so things might go slower on a GPU. Change it to True if you want to try with GPU or things go slow\n",
        "CUDA = False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "C3ewWasAixc9"
      },
      "outputs": [],
      "source": [
        "def np_to_tensor(np_var):\n",
        "    t = torch.from_numpy(np_var)\n",
        "    if CUDA:\n",
        "        t = t.cuda()\n",
        "    return t"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F85iPOdcixdD"
      },
      "source": [
        "## RNN implementation in PyTorch\n",
        "\n",
        "Please note that PyTorch has RNN implementations (http://pytorch.org/docs/master/nn.html#recurrent-layers). For future projects please use the built-in mudules. They have more features, and are faster (they use the CuDNN library supplied by Nvidia).\n",
        "\n",
        "**Attention**: in this code we will assume that the 0-th axis refers to time and that the 1-st axis refers to individual examples inside a minibatch. (This way in a C-major memory layout individual time steps occupy contiguous regions in memory)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "TCXTiCIeixdF"
      },
      "outputs": [],
      "source": [
        "class SimpleRNNCell(nn.Module):\n",
        "    def __init__(self, in_dim, hidden_dim, activation=torch.nn.Tanh(), **kwargs):\n",
        "        super(SimpleRNNCell, self).__init__(**kwargs)\n",
        "        self.activation = activation\n",
        "        # Input to hidden\n",
        "        self.Wxh = nn.Parameter(torch.Tensor(in_dim, hidden_dim))\n",
        "        # Hidden to hidden\n",
        "        self.Whh = nn.Parameter(torch.Tensor(hidden_dim, hidden_dim))\n",
        "        # Hidden bias\n",
        "        self.bh = nn.Parameter(torch.Tensor(hidden_dim))\n",
        "        self.reset_parameters()\n",
        "\n",
        "    def reset_parameters(self):\n",
        "        stdv = 1. / math.sqrt(self.Whh.size(1))\n",
        "        self.Wxh.data.uniform_(-stdv, stdv)\n",
        "        self.Whh.data.uniform_(-stdv, stdv)\n",
        "        self.bh.data.zero_()\n",
        "\n",
        "    def forward(self, input, h):\n",
        "        #\n",
        "        # TODO TASK 1\n",
        "        #\n",
        "        # Compute the activation of the RNN cell (ie. the right hand side of the vanila RNN equation)\n",
        "\n",
        "        # My task\n",
        "        # Forward pass of the RNN cell.\n",
        "\n",
        "        # Compute the pre-activation for the next hidden state.\n",
        "        pre_act = torch.matmul(input, self.Wxh) + torch.matmul(h, self.Whh) + self.bh\n",
        "        return self.activation(pre_act)\n",
        "\n",
        "\n",
        "class RNN(nn.Module):\n",
        "    def __init__(self, cell, **kwargs):\n",
        "        super(RNN, self).__init__(**kwargs)\n",
        "        self.cell = cell\n",
        "\n",
        "    def forward(self, input, hidden):\n",
        "        cell = self.cell\n",
        "        output = []\n",
        "        #\n",
        "        # TODO TASK 1\n",
        "        #\n",
        "        # Here we unroll in time and compute the recurrence\n",
        "        #\n",
        "        # My task\n",
        "        # Compute the output for each time step in the input sequence.\n",
        "        seq_len = input.shape[0]\n",
        "        for i in range(seq_len):\n",
        "          # Update hidden state using the RNN cell.\n",
        "            hidden = cell(input[i], hidden)\n",
        "            # Hack to handle LSTM\n",
        "            output.append(hidden[0] if isinstance(hidden, tuple) else hidden)\n",
        "        # Concatenate outputs along the time dimension and reshape.\n",
        "        output = torch.cat(output, 0).view(seq_len, *output[0].size())\n",
        "\n",
        "        return hidden, output"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J4YP8aEcixdJ"
      },
      "source": [
        "## The parity task\n",
        "\n",
        "Here we solve the bit parity problem. Note that we will need at least two hidden neurons, because the network has to solve a XOR problem at each step."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uewegpl7ixdM",
        "outputId": "6a0d9c4b-947b-400e-821c-a4ab8e6b2863"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X.T: [[1. 1. 1. 1. 1. 0. 0. 1. 0. 1. 1. 1. 0. 0. 0. 1. 0. 0.]] \n",
            "Y.T: [[1. 0. 1. 0. 1. 1. 1. 0. 0. 1. 0. 1. 1. 1. 1. 0. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "def gen_parity_examples(time_steps, batch_size):\n",
        "    X = (np.random.rand(time_steps, batch_size, 1) > 0.5).astype('float32')\n",
        "    Y = X.cumsum(0) % 2\n",
        "    return X, Y\n",
        "\n",
        "\n",
        "Xp, Yp = gen_parity_examples(18, 1)\n",
        "print('X.T:', Xp.reshape(Xp.shape[:-1]).T, '\\nY.T:', Yp.reshape(Yp.shape[:-1]).T)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "fCeFd-c_ixdk"
      },
      "outputs": [],
      "source": [
        "# The input variable - a 3D tensor with axes:\n",
        "# time x batch_size x num_features\n",
        "\n",
        "hidden_dim = 2\n",
        "test_net = RNN(SimpleRNNCell(in_dim=1, hidden_dim=hidden_dim))\n",
        "\n",
        "if CUDA:\n",
        "    test_net.cuda()\n",
        "\n",
        "h0 = np.zeros((1, hidden_dim), dtype='float32')  # 1 sequence in batch, 1 hidden dim\n",
        "hn, out = test_net(np_to_tensor(Xp), np_to_tensor(h0)) # The network outputs a tuple of tensors: (last hidden state, hidden state at each time step)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "U3ktZavGixdq"
      },
      "outputs": [],
      "source": [
        "class ParityNet(nn.Module):\n",
        "    def __init__(self, hidden_dim, use_lstm=False, **kwargs):\n",
        "        super(ParityNet, self).__init__(**kwargs)\n",
        "        self.hidden_dim = hidden_dim\n",
        "        self.use_lstm = use_lstm\n",
        "        if use_lstm:\n",
        "            cell = LSTMCell(in_dim=1, hidden_dim=hidden_dim)\n",
        "        else:\n",
        "            cell = SimpleRNNCell(in_dim=1, hidden_dim=hidden_dim, activation=nn.Sigmoid())\n",
        "        self.rnn = RNN(cell)\n",
        "        self.linear = nn.Linear(in_features=1 + hidden_dim,\n",
        "                                      out_features=1)\n",
        "\n",
        "    def forward(self, inputs):\n",
        "        if self.use_lstm:\n",
        "            h0 = [torch.zeros((inputs.size(1), self.hidden_dim)).to(inputs.device) for _ in range(2)]\n",
        "        else:\n",
        "            h0 = torch.zeros((inputs.size(1), self.hidden_dim)).to(inputs.device)\n",
        "        #\n",
        "        # TODO TASK 2\n",
        "        #\n",
        "        # Compute the sequence of hidden states\n",
        "        #\n",
        "        _, H = self.rnn(inputs, h0)\n",
        "        # Concatenate inputs and hidden states along the feature dimension\n",
        "        inputs_and_H = torch.cat((inputs, H), dim=2)\n",
        "        return torch.sigmoid(self.linear(inputs_and_H))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5xXK5JHEcnSD"
      },
      "source": [
        "Just to prove that the task is easily solvable, we will manually define the weights of our RNN to implement the XOR function:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "byGUrbTXixdu",
        "outputId": "01613671-dedf-4a8b-a1df-a44ffba3a8a6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "        X:  [1. 1. 1. 1. 1. 0. 0. 1. 0. 1. 1. 1. 0. 0. 0. 1. 0. 0.]\n",
            "predicted:  [1. 0. 1. 0. 1. 1. 1. 0. 0. 1. 0. 1. 1. 1. 1. 0. 0. 0.]\n",
            "        Y:  [1. 0. 1. 0. 1. 1. 1. 0. 0. 1. 0. 1. 1. 1. 1. 0. 0. 0.]\n"
          ]
        }
      ],
      "source": [
        "parity_net = ParityNet(hidden_dim=2)\n",
        "\n",
        "if CUDA:\n",
        "    parity_net.cuda()\n",
        "\n",
        "#\n",
        "# Design the net to solve parity\n",
        "#\n",
        "parity_net.rnn.cell.Wxh.data[...\n",
        "    ] = torch.FloatTensor([[2000, 1000]])\n",
        "parity_net.rnn.cell.Whh.data[...\n",
        "    ] = torch.FloatTensor([[ 1000,  1000],\n",
        "                           [-1000, -1000]])\n",
        "parity_net.rnn.cell.bh.data[...\n",
        "    ] = torch.FloatTensor([-500, -1500])\n",
        "\n",
        "parity_net.linear.weight.data[...\n",
        "    ] = torch.FloatTensor([[ 0],\n",
        "                           [ 1000],\n",
        "                           [-1000]]).transpose(0, 1)\n",
        "parity_net.linear.bias.data[...\n",
        "    ] = torch.FloatTensor([-500])\n",
        "\n",
        "predictions = parity_net(np_to_tensor(Xp)).detach().cpu().numpy().squeeze()\n",
        "print('        X: ', Xp.squeeze())\n",
        "print('predicted: ', np.round(predictions))\n",
        "print('        Y: ', Yp.squeeze())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QkNAiHuvcx9V"
      },
      "source": [
        "Now we'll try to get to the solution by learning:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "oE9pGKrHixd3"
      },
      "outputs": [],
      "source": [
        "class Trainer(object):\n",
        "    def __init__(self, network):\n",
        "        # If full_supervision == True, supervice net outputs at all steps\n",
        "        # if full_supervision == False, supervise net outputs at the last\n",
        "        # step only\n",
        "        self.full_supervision = True\n",
        "\n",
        "        # When the total gradient is above this value, scale it down\n",
        "        self.max_grad_norm = 1.0\n",
        "\n",
        "        self.network = network\n",
        "\n",
        "        # RMSprop optimization stuff\n",
        "        self.lrate = 1e-2\n",
        "        self.RMSProp_dec_rate = 0.9\n",
        "        self.RMSProp_epsilon = 1e-5\n",
        "        device = 'cuda' if CUDA else 'cpu'\n",
        "        self.gnorms = [torch.zeros(*p.size(), device=device)\n",
        "                       for p in self.network.parameters()]\n",
        "\n",
        "    def train_step(self, X, Y):\n",
        "        X = np_to_tensor(X)\n",
        "        Y = np_to_tensor(Y)\n",
        "        net = self.network\n",
        "        net.zero_grad()\n",
        "        # predictions\n",
        "        P = net(X)\n",
        "        #\n",
        "        # TODO TASK 2\n",
        "        #\n",
        "        # Implement the loss with and without full supervision.\n",
        "        # With full supervision we compute the loss at each step.\n",
        "        # Without, just at the last step\n",
        "        #\n",
        "        if self.full_supervision:\n",
        "            loss = torch.mean((P-Y)**2)  # my task\n",
        "        else:\n",
        "            loss = torch.mean((P[-1]-Y[-1])**2) # my task\n",
        "        loss.backward()\n",
        "\n",
        "        tot_gnorm = torch.FloatTensor((0.0,))\n",
        "        if CUDA:\n",
        "            tot_gnorm = tot_gnorm.cuda()\n",
        "        # We apply gradient normalization to avoid exploding gradients and do the training step\n",
        "        for p in net.parameters():\n",
        "            tot_gnorm += torch.sum(p.grad.data**2)\n",
        "        tot_gnorm = torch.sqrt(tot_gnorm)\n",
        "        g_div = torch.max(torch.FloatTensor((self.max_grad_norm,)\n",
        "                                           ).to(tot_gnorm.device), tot_gnorm)\n",
        "        for i, p in enumerate(net.parameters()):\n",
        "            g = p.grad.data / g_div\n",
        "            self.gnorms[i] *= self.RMSProp_dec_rate\n",
        "            self.gnorms[i] += (1.0 - self.RMSProp_dec_rate) * g**2\n",
        "            p.data -= self.lrate * g / torch.sqrt(self.gnorms[i] + self.RMSProp_epsilon)\n",
        "        return dict(loss=loss.item(), grad_norm=tot_gnorm.item())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vtHbUwOEixd7"
      },
      "source": [
        "## Exploration of various problems with RNN training\n",
        "\n",
        "In the following cell you can experiment with various ways of providing supervision to the network: which one is easier to train - when the net recieves feedback after each step or when it recieves feedback only at the end of training? Play with gradient clipping and the curriculum as well.\n",
        "\n",
        "Notice the dynamics of training - at the beginning the network does very little. The, suddenly it notices the input-output relationship (i.e. it learns the XOR function) from which point training starts to progress very quickly."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "jqmAFDY_i3Ux"
      },
      "outputs": [],
      "source": [
        "def train_and_eval_parity(parity_trainer, patience_max=3, max_iters=100000, learning_curriculum=True, stop_loss=1e-4):\n",
        "    max_seq_len = 100\n",
        "    seq_len = max_seq_len\n",
        "    if learning_curriculum:\n",
        "        seq_len = 10\n",
        "    patience = patience_max\n",
        "    for i in range(max_iters):\n",
        "        Xp, Yp = gen_parity_examples(np.random.randint(1, seq_len), 10)\n",
        "        ret = parity_trainer.train_step(Xp, Yp)\n",
        "        losses.append(dict(iter=i, **ret))\n",
        "        if ret['loss'] < stop_loss:\n",
        "            patience -= 1\n",
        "            if patience == 0:\n",
        "                seq_len += 10\n",
        "                if seq_len > max_seq_len:\n",
        "                    break\n",
        "                else:\n",
        "                    patience = patience_max\n",
        "                print(i, \"Increasing seq length to: \", seq_len)\n",
        "        else:\n",
        "            patience = patience_max\n",
        "        if i % 500 == 0:\n",
        "            print(i, ret)\n",
        "    losses_df = pd.DataFrame(losses)\n",
        "    plt.semilogy(losses_df['iter'], losses_df['loss'], label='loss')\n",
        "    plt.semilogy(losses_df['iter'], losses_df['grad_norm'], label='grad norm', alpha=0.5)\n",
        "    plt.legend(loc='lower left')\n",
        "    plt.title('Training loss')\n",
        "    plt.xlabel('iteration')\n",
        "\n",
        "    Xp,Yp = gen_parity_examples(10, 1)\n",
        "    model = parity_trainer.network.eval()\n",
        "    predictions = model(np_to_tensor(Xp)).detach().cpu().numpy().squeeze()\n",
        "    print('        X: ', Xp.squeeze())\n",
        "    print('predicted: ', np.round(predictions))\n",
        "    print('   target: ', Yp.squeeze())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "FtViTHApixd9",
        "outputId": "a5edd5f3-3a1a-4bcd-8374-f8e16d7f1431"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 {'loss': 0.24889662861824036, 'grad_norm': 0.11078481376171112}\n",
            "500 {'loss': 0.24296362698078156, 'grad_norm': 0.02355080470442772}\n",
            "1000 {'loss': 0.2449071854352951, 'grad_norm': 0.026167478412389755}\n",
            "1500 {'loss': 0.17764998972415924, 'grad_norm': 0.05938104912638664}\n",
            "2000 {'loss': 0.0772659033536911, 'grad_norm': 0.041415490210056305}\n",
            "2500 {'loss': 0.16942384839057922, 'grad_norm': 0.03275841847062111}\n",
            "3000 {'loss': 0.00818225834518671, 'grad_norm': 0.011179717257618904}\n",
            "3500 {'loss': 0.0011377854971215129, 'grad_norm': 0.0012982042971998453}\n",
            "4000 {'loss': 0.0005144195165485144, 'grad_norm': 0.0008852154132910073}\n",
            "4500 {'loss': 0.0003447315830271691, 'grad_norm': 0.0003314724890515208}\n",
            "5000 {'loss': 0.000171397186932154, 'grad_norm': 0.00020734874124173075}\n",
            "5500 {'loss': 0.000318118225550279, 'grad_norm': 0.00029821781208738685}\n",
            "6000 {'loss': 0.00012835919915232807, 'grad_norm': 0.00029094191268086433}\n",
            "6500 {'loss': 0.00011057256779167801, 'grad_norm': 0.00025156265473924577}\n",
            "7000 {'loss': 0.00017894206393975765, 'grad_norm': 0.00028822230524383485}\n",
            "7185 Increasing seq length to:  20\n",
            "7476 Increasing seq length to:  30\n",
            "7500 {'loss': 0.00017290677351411432, 'grad_norm': 0.00028701170231215656}\n",
            "7608 Increasing seq length to:  40\n",
            "8000 {'loss': 0.00014563824515789747, 'grad_norm': 0.0001121777095249854}\n",
            "8500 {'loss': 0.00013170087186153978, 'grad_norm': 0.00011117792746517807}\n",
            "8916 Increasing seq length to:  50\n",
            "9000 {'loss': 0.00011744307266781107, 'grad_norm': 9.558479359839112e-05}\n",
            "9483 Increasing seq length to:  60\n",
            "9500 {'loss': 0.00012105378118576482, 'grad_norm': 0.00011134771921206266}\n",
            "9580 Increasing seq length to:  70\n",
            "9704 Increasing seq length to:  80\n",
            "9887 Increasing seq length to:  90\n",
            "9902 Increasing seq length to:  100\n",
            "        X:  [1. 1. 1. 0. 1. 1. 0. 0. 1. 0.]\n",
            "predicted:  [1. 0. 1. 1. 0. 1. 1. 1. 0. 0.]\n",
            "   target:  [1. 0. 1. 1. 0. 1. 1. 1. 0. 0.]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "parity_net = ParityNet(hidden_dim=3)\n",
        "if CUDA:\n",
        "    parity_net.cuda()\n",
        "parity_trainer = Trainer(parity_net)\n",
        "parity_trainer.lrate = 1e-2\n",
        "losses = []\n",
        "# When set to True the net recieves an error signal after each step\n",
        "# When set to False the net recieves an error signal only once at the end\n",
        "parity_trainer.full_supervision = True\n",
        "# Gradient clipping\n",
        "parity_trainer.max_grad_norm = 1.0\n",
        "# This enables \"curriculum learning\" - we gradually train on\n",
        "# longer and longer sequences\n",
        "#\n",
        "learning_curriculum = True\n",
        "train_and_eval_parity(parity_trainer, learning_curriculum=learning_curriculum)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "parity_net = ParityNet(hidden_dim=3)\n",
        "if CUDA:\n",
        "    parity_net.cuda()\n",
        "parity_trainer = Trainer(parity_net)\n",
        "parity_trainer.lrate = 1e-2\n",
        "losses = []\n",
        "# When set to True the net recieves an error signal after each step\n",
        "# When set to False the net recieves an error signal only once at the end\n",
        "parity_trainer.full_supervision = True\n",
        "# Gradient clipping\n",
        "parity_trainer.max_grad_norm = 0.2\n",
        "# This enables \"curriculum learning\" - we gradually train on\n",
        "# longer and longer sequences\n",
        "#\n",
        "learning_curriculum = True\n",
        "train_and_eval_parity(parity_trainer, learning_curriculum=learning_curriculum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "JMQ9iWwFQkal",
        "outputId": "e5406cbf-f0ae-4312-e478-47e6d5d7ed23"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 {'loss': 0.322553426027298, 'grad_norm': 0.1308766007423401}\n",
            "500 {'loss': 0.23678305745124817, 'grad_norm': 0.04178516939282417}\n",
            "1000 {'loss': 0.15011446177959442, 'grad_norm': 0.03397194296121597}\n",
            "1500 {'loss': 0.06893537938594818, 'grad_norm': 0.03014850616455078}\n",
            "2000 {'loss': 0.003779069287702441, 'grad_norm': 0.011356010101735592}\n",
            "2500 {'loss': 0.16694475710391998, 'grad_norm': 0.029446961358189583}\n",
            "3000 {'loss': 0.1884736716747284, 'grad_norm': 0.08688260614871979}\n",
            "3500 {'loss': 0.10493872314691544, 'grad_norm': 0.07340175658464432}\n",
            "4000 {'loss': 0.0006617067265324295, 'grad_norm': 0.002175520174205303}\n",
            "4500 {'loss': 0.1750085949897766, 'grad_norm': 0.09036064147949219}\n",
            "5000 {'loss': 0.009605847299098969, 'grad_norm': 0.007532540243119001}\n",
            "5500 {'loss': 0.15791486203670502, 'grad_norm': 0.037349604070186615}\n",
            "6000 {'loss': 0.09840553998947144, 'grad_norm': 0.039856791496276855}\n",
            "6500 {'loss': 0.005683586932718754, 'grad_norm': 0.0050946553237736225}\n",
            "7000 {'loss': 0.00022365711629390717, 'grad_norm': 0.0007581302779726684}\n",
            "7500 {'loss': 0.13377565145492554, 'grad_norm': 0.047440361231565475}\n",
            "8000 {'loss': 0.0001877355680335313, 'grad_norm': 0.0006335859070532024}\n",
            "8500 {'loss': 0.0860447958111763, 'grad_norm': 0.03357664868235588}\n",
            "9000 {'loss': 0.16559821367263794, 'grad_norm': 0.07874452322721481}\n",
            "9500 {'loss': 0.005554958246648312, 'grad_norm': 0.0264756940305233}\n",
            "10000 {'loss': 0.07864014804363251, 'grad_norm': 0.06847548484802246}\n",
            "10500 {'loss': 0.0005845634150318801, 'grad_norm': 0.0019749330822378397}\n",
            "11000 {'loss': 0.058090321719646454, 'grad_norm': 0.02242109179496765}\n",
            "11500 {'loss': 0.0016163841355592012, 'grad_norm': 0.0030695947352796793}\n",
            "12000 {'loss': 0.02864842489361763, 'grad_norm': 0.0053681423887610435}\n",
            "12500 {'loss': 0.0002097246760968119, 'grad_norm': 0.0007130700978450477}\n",
            "13000 {'loss': 0.00013809690426569432, 'grad_norm': 0.0004717192496173084}\n",
            "13500 {'loss': 0.07771685719490051, 'grad_norm': 0.07393275201320648}\n",
            "13749 Increasing seq length to:  20\n",
            "14000 {'loss': 0.12039215117692947, 'grad_norm': 0.03175145387649536}\n",
            "14500 {'loss': 0.055310312658548355, 'grad_norm': 0.030593547970056534}\n",
            "15000 {'loss': 9.347796549263876e-06, 'grad_norm': 3.224772808607668e-05}\n",
            "15500 {'loss': 0.00876515544950962, 'grad_norm': 0.02743053063750267}\n",
            "16000 {'loss': 0.17649126052856445, 'grad_norm': 0.11540215462446213}\n",
            "16500 {'loss': 0.17478878796100616, 'grad_norm': 0.10445410013198853}\n",
            "17000 {'loss': 0.01759510114789009, 'grad_norm': 0.02065678872168064}\n",
            "17500 {'loss': 0.18119332194328308, 'grad_norm': 0.09754288196563721}\n",
            "18000 {'loss': 0.15777628123760223, 'grad_norm': 0.02830396220088005}\n",
            "18500 {'loss': 0.2175201177597046, 'grad_norm': 0.1650736927986145}\n",
            "19000 {'loss': 0.1613093763589859, 'grad_norm': 0.13333772122859955}\n",
            "19500 {'loss': 0.041826777160167694, 'grad_norm': 0.03335832804441452}\n",
            "20000 {'loss': 0.0867026299238205, 'grad_norm': 0.021661831066012383}\n",
            "20500 {'loss': 0.17027682065963745, 'grad_norm': 0.08348025381565094}\n",
            "21000 {'loss': 0.13224756717681885, 'grad_norm': 0.19589529931545258}\n",
            "21500 {'loss': 0.16059726476669312, 'grad_norm': 0.05596688389778137}\n",
            "22000 {'loss': 0.15100246667861938, 'grad_norm': 0.10992296040058136}\n",
            "22500 {'loss': 0.2439032942056656, 'grad_norm': 0.11420848220586777}\n",
            "23000 {'loss': 0.12456399202346802, 'grad_norm': 0.022002292796969414}\n",
            "23500 {'loss': 0.2346530258655548, 'grad_norm': 0.05835430324077606}\n",
            "24000 {'loss': 0.12143468856811523, 'grad_norm': 0.012597947381436825}\n",
            "24500 {'loss': 0.08496830612421036, 'grad_norm': 0.019081251695752144}\n",
            "25000 {'loss': 0.26683923602104187, 'grad_norm': 0.10884310305118561}\n",
            "25500 {'loss': 0.04185047000646591, 'grad_norm': 0.047096241265535355}\n",
            "26000 {'loss': 0.0984414741396904, 'grad_norm': 0.030961375683546066}\n",
            "26500 {'loss': 0.08915846049785614, 'grad_norm': 0.05986765772104263}\n",
            "27000 {'loss': 0.08954038470983505, 'grad_norm': 0.32136863470077515}\n",
            "27500 {'loss': 0.10308151692152023, 'grad_norm': 0.03984615579247475}\n",
            "28000 {'loss': 0.07632460445165634, 'grad_norm': 0.04252183437347412}\n",
            "28500 {'loss': 0.026138603687286377, 'grad_norm': 0.049610015004873276}\n",
            "29000 {'loss': 0.16197557747364044, 'grad_norm': 0.009578672237694263}\n",
            "29500 {'loss': 0.10887285321950912, 'grad_norm': 0.01543647050857544}\n",
            "30000 {'loss': 0.21648696064949036, 'grad_norm': 0.10982344299554825}\n",
            "30500 {'loss': 0.16127584874629974, 'grad_norm': 0.02758527733385563}\n",
            "31000 {'loss': 0.13744574785232544, 'grad_norm': 0.015237499959766865}\n",
            "31500 {'loss': 0.21447376906871796, 'grad_norm': 0.10217886418104172}\n",
            "32000 {'loss': 0.04384470731019974, 'grad_norm': 0.31301137804985046}\n",
            "32500 {'loss': 0.22481420636177063, 'grad_norm': 0.07464499771595001}\n",
            "33000 {'loss': 0.13212749361991882, 'grad_norm': 0.02497142180800438}\n",
            "33500 {'loss': 0.11618641763925552, 'grad_norm': 0.024790512397885323}\n",
            "34000 {'loss': 0.03739602491259575, 'grad_norm': 0.0407891608774662}\n",
            "34500 {'loss': 0.07134874165058136, 'grad_norm': 0.11327145248651505}\n",
            "35000 {'loss': 0.21390239894390106, 'grad_norm': 0.05271506309509277}\n",
            "35500 {'loss': 0.15640924870967865, 'grad_norm': 0.11755914986133575}\n",
            "36000 {'loss': 0.06663885712623596, 'grad_norm': 0.011095833033323288}\n",
            "36500 {'loss': 0.029010871425271034, 'grad_norm': 0.009427892044186592}\n",
            "37000 {'loss': 0.20086805522441864, 'grad_norm': 0.031128257513046265}\n",
            "37500 {'loss': 0.1580529510974884, 'grad_norm': 0.10186523199081421}\n",
            "38000 {'loss': 0.16657337546348572, 'grad_norm': 0.020517628639936447}\n",
            "38500 {'loss': 0.009727098047733307, 'grad_norm': 0.02131498046219349}\n",
            "39000 {'loss': 0.0416564866900444, 'grad_norm': 0.04642052575945854}\n",
            "39500 {'loss': 0.013370783068239689, 'grad_norm': 0.025090893730521202}\n",
            "40000 {'loss': 0.02121959626674652, 'grad_norm': 0.03668241575360298}\n",
            "40500 {'loss': 0.1549227386713028, 'grad_norm': 0.03939778357744217}\n",
            "41000 {'loss': 0.15111055970191956, 'grad_norm': 0.019244587048888206}\n",
            "41500 {'loss': 0.19846293330192566, 'grad_norm': 0.04566347226500511}\n",
            "42000 {'loss': 0.20208215713500977, 'grad_norm': 0.020613163709640503}\n",
            "42500 {'loss': 0.2102850079536438, 'grad_norm': 0.3264206349849701}\n",
            "43000 {'loss': 0.021693561226129532, 'grad_norm': 0.05737422779202461}\n",
            "43500 {'loss': 0.0853346735239029, 'grad_norm': 0.018257908523082733}\n",
            "44000 {'loss': 0.09284749627113342, 'grad_norm': 0.03308607265353203}\n",
            "44500 {'loss': 0.18643857538700104, 'grad_norm': 0.05664116144180298}\n",
            "45000 {'loss': 0.2113114446401596, 'grad_norm': 0.05171705409884453}\n",
            "45500 {'loss': 0.20983238518238068, 'grad_norm': 0.05847759172320366}\n",
            "46000 {'loss': 0.08805422484874725, 'grad_norm': 0.022380614653229713}\n",
            "46500 {'loss': 0.08846024423837662, 'grad_norm': 0.008241250179708004}\n",
            "47000 {'loss': 0.08753401041030884, 'grad_norm': 0.0437677726149559}\n",
            "47500 {'loss': 0.22300449013710022, 'grad_norm': 0.1587437242269516}\n",
            "48000 {'loss': 0.054644059389829636, 'grad_norm': 0.07864412665367126}\n",
            "48500 {'loss': 0.17405368387699127, 'grad_norm': 0.07584954053163528}\n",
            "49000 {'loss': 0.008344395086169243, 'grad_norm': 0.02091311849653721}\n",
            "49500 {'loss': 0.1929107904434204, 'grad_norm': 0.11695930361747742}\n",
            "50000 {'loss': 0.011598048731684685, 'grad_norm': 0.02901184931397438}\n",
            "50500 {'loss': 0.07187432050704956, 'grad_norm': 0.0415085144340992}\n",
            "51000 {'loss': 0.07190455496311188, 'grad_norm': 0.07229731976985931}\n",
            "51500 {'loss': 0.15807636082172394, 'grad_norm': 0.03322857245802879}\n",
            "52000 {'loss': 0.13061505556106567, 'grad_norm': 0.016932813450694084}\n",
            "52500 {'loss': 0.2938176989555359, 'grad_norm': 0.04745509475469589}\n",
            "53000 {'loss': 0.15897609293460846, 'grad_norm': 0.08098425716161728}\n",
            "53500 {'loss': 0.028555339202284813, 'grad_norm': 0.012216967530548573}\n",
            "54000 {'loss': 0.013927783817052841, 'grad_norm': 0.020224370062351227}\n",
            "54500 {'loss': 0.07236789166927338, 'grad_norm': 0.04386619105935097}\n",
            "55000 {'loss': 0.13741451501846313, 'grad_norm': 0.025960879400372505}\n",
            "55500 {'loss': 0.12257272750139236, 'grad_norm': 0.11060414463281631}\n",
            "56000 {'loss': 0.038602326065301895, 'grad_norm': 0.03798465058207512}\n",
            "56500 {'loss': 0.03879242017865181, 'grad_norm': 0.07974203675985336}\n",
            "57000 {'loss': 0.017726367339491844, 'grad_norm': 0.03583824262022972}\n",
            "57500 {'loss': 0.013034740462899208, 'grad_norm': 0.021060556173324585}\n",
            "58000 {'loss': 0.08106694370508194, 'grad_norm': 0.056557219475507736}\n",
            "58500 {'loss': 0.12672317028045654, 'grad_norm': 0.09211154282093048}\n",
            "59000 {'loss': 0.0738690122961998, 'grad_norm': 0.019573813304305077}\n",
            "59500 {'loss': 0.0011155933607369661, 'grad_norm': 0.0036819875240325928}\n",
            "60000 {'loss': 0.007835673168301582, 'grad_norm': 0.010317175649106503}\n",
            "60500 {'loss': 0.0941142812371254, 'grad_norm': 0.0519259087741375}\n",
            "61000 {'loss': 0.02473270148038864, 'grad_norm': 0.03664688766002655}\n",
            "61500 {'loss': 0.15321458876132965, 'grad_norm': 0.24265988171100616}\n",
            "62000 {'loss': 0.20649074018001556, 'grad_norm': 0.12122226506471634}\n",
            "62500 {'loss': 0.04735010117292404, 'grad_norm': 0.05610901489853859}\n",
            "63000 {'loss': 0.028884008526802063, 'grad_norm': 0.01361339446157217}\n",
            "63500 {'loss': 0.13376083970069885, 'grad_norm': 0.013684321194887161}\n",
            "64000 {'loss': 0.05120368301868439, 'grad_norm': 0.019529961049556732}\n",
            "64500 {'loss': 0.13267835974693298, 'grad_norm': 0.08504358679056168}\n",
            "65000 {'loss': 0.046181950718164444, 'grad_norm': 0.03874652087688446}\n",
            "65500 {'loss': 0.03386055678129196, 'grad_norm': 0.09841623902320862}\n",
            "66000 {'loss': 0.11031771451234818, 'grad_norm': 0.00530152628198266}\n",
            "66500 {'loss': 0.0993342399597168, 'grad_norm': 0.09169572591781616}\n",
            "67000 {'loss': 0.04128815978765488, 'grad_norm': 0.024035567417740822}\n",
            "67500 {'loss': 0.01085220742970705, 'grad_norm': 0.030719030648469925}\n",
            "68000 {'loss': 0.11369077116250992, 'grad_norm': 0.09754300862550735}\n",
            "68500 {'loss': 0.056668393313884735, 'grad_norm': 0.04034991189837456}\n",
            "69000 {'loss': 0.06756129115819931, 'grad_norm': 0.45620450377464294}\n",
            "69500 {'loss': 0.14685583114624023, 'grad_norm': 0.030598381534218788}\n",
            "70000 {'loss': 0.1992991864681244, 'grad_norm': 0.042751528322696686}\n",
            "70500 {'loss': 0.008359204977750778, 'grad_norm': 0.01952877826988697}\n",
            "71000 {'loss': 0.13318365812301636, 'grad_norm': 0.04851049184799194}\n",
            "71500 {'loss': 0.026936449110507965, 'grad_norm': 0.01656414195895195}\n",
            "72000 {'loss': 0.1352515071630478, 'grad_norm': 0.02661444991827011}\n",
            "72500 {'loss': 0.09785071015357971, 'grad_norm': 0.026730092242360115}\n",
            "73000 {'loss': 0.009055111557245255, 'grad_norm': 0.021905213594436646}\n",
            "73500 {'loss': 0.174906924366951, 'grad_norm': 0.04971671476960182}\n",
            "74000 {'loss': 0.21366839110851288, 'grad_norm': 0.13432572782039642}\n",
            "74500 {'loss': 0.06551102548837662, 'grad_norm': 0.011571151204407215}\n",
            "75000 {'loss': 0.09812008589506149, 'grad_norm': 0.01643562503159046}\n",
            "75500 {'loss': 0.12817558646202087, 'grad_norm': 0.04167213290929794}\n",
            "76000 {'loss': 0.044281959533691406, 'grad_norm': 0.016064787283539772}\n",
            "76500 {'loss': 0.2016320526599884, 'grad_norm': 0.036661941558122635}\n",
            "77000 {'loss': 0.1719062477350235, 'grad_norm': 0.029251668602228165}\n",
            "77500 {'loss': 0.0802684873342514, 'grad_norm': 0.02364269644021988}\n",
            "78000 {'loss': 0.10098359733819962, 'grad_norm': 0.016336318105459213}\n",
            "78500 {'loss': 0.0760861188173294, 'grad_norm': 0.04250568896532059}\n",
            "79000 {'loss': 0.16491451859474182, 'grad_norm': 0.029799118638038635}\n",
            "79500 {'loss': 0.005939075723290443, 'grad_norm': 0.012404375709593296}\n",
            "80000 {'loss': 0.10943198949098587, 'grad_norm': 0.014846056699752808}\n",
            "80500 {'loss': 0.13853026926517487, 'grad_norm': 0.010308637283742428}\n",
            "81000 {'loss': 0.13388946652412415, 'grad_norm': 0.07466694712638855}\n",
            "81500 {'loss': 0.0920511931180954, 'grad_norm': 0.04555532708764076}\n",
            "82000 {'loss': 0.12422177195549011, 'grad_norm': 0.09126801788806915}\n",
            "82500 {'loss': 0.012875747866928577, 'grad_norm': 0.02127493917942047}\n",
            "83000 {'loss': 0.10944243520498276, 'grad_norm': 0.07996996492147446}\n",
            "83500 {'loss': 0.10326360166072845, 'grad_norm': 0.034882593899965286}\n",
            "84000 {'loss': 0.11015647649765015, 'grad_norm': 0.09016560018062592}\n",
            "84500 {'loss': 0.0450320765376091, 'grad_norm': 0.015736443921923637}\n",
            "85000 {'loss': 0.017216185107827187, 'grad_norm': 0.032167963683605194}\n",
            "85500 {'loss': 0.0006423431332223117, 'grad_norm': 0.002099031815305352}\n",
            "86000 {'loss': 0.10378502309322357, 'grad_norm': 0.09374747425317764}\n",
            "86500 {'loss': 0.19227078557014465, 'grad_norm': 0.09313125908374786}\n",
            "87000 {'loss': 0.1571502834558487, 'grad_norm': 0.0765482559800148}\n",
            "87500 {'loss': 0.19573327898979187, 'grad_norm': 0.07966654747724533}\n",
            "88000 {'loss': 0.12029130756855011, 'grad_norm': 0.04797668382525444}\n",
            "88500 {'loss': 0.001055053435266018, 'grad_norm': 0.003486921777948737}\n",
            "89000 {'loss': 0.043369609862565994, 'grad_norm': 0.06814201176166534}\n",
            "89500 {'loss': 0.1649085283279419, 'grad_norm': 0.0483538880944252}\n",
            "90000 {'loss': 0.10450109839439392, 'grad_norm': 0.02827024832367897}\n",
            "90500 {'loss': 0.19735033810138702, 'grad_norm': 0.07403513789176941}\n",
            "91000 {'loss': 0.04746497422456741, 'grad_norm': 0.019403859972953796}\n",
            "91500 {'loss': 0.04435896873474121, 'grad_norm': 0.0420071966946125}\n",
            "92000 {'loss': 0.09315571933984756, 'grad_norm': 0.03419552743434906}\n",
            "92500 {'loss': 0.030096257105469704, 'grad_norm': 0.046244584023952484}\n",
            "93000 {'loss': 0.08796179294586182, 'grad_norm': 0.13085058331489563}\n",
            "93500 {'loss': 0.008197072893381119, 'grad_norm': 0.010706353932619095}\n",
            "94000 {'loss': 0.11242915689945221, 'grad_norm': 0.12551073729991913}\n",
            "94500 {'loss': 0.010555396787822247, 'grad_norm': 0.02501593716442585}\n",
            "95000 {'loss': 0.004931291099637747, 'grad_norm': 0.013123667798936367}\n",
            "95500 {'loss': 0.1530696451663971, 'grad_norm': 0.05236400291323662}\n",
            "96000 {'loss': 0.03410034254193306, 'grad_norm': 0.027779053896665573}\n",
            "96500 {'loss': 0.0972917303442955, 'grad_norm': 0.009873585775494576}\n",
            "97000 {'loss': 0.18385377526283264, 'grad_norm': 0.10299430042505264}\n",
            "97500 {'loss': 0.016126738861203194, 'grad_norm': 0.024886541068553925}\n",
            "98000 {'loss': 0.04064972326159477, 'grad_norm': 0.02241530455648899}\n",
            "98500 {'loss': 0.03385007008910179, 'grad_norm': 0.02397582307457924}\n",
            "99000 {'loss': 0.22282953560352325, 'grad_norm': 0.06714882701635361}\n",
            "99500 {'loss': 0.13686594367027283, 'grad_norm': 0.038000598549842834}\n",
            "        X:  [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "predicted:  [0. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
            "   target:  [0. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5FklEQVR4nO3dd3hUVfoH8O/MpPdGGiSEElqABBMSepEoRKpll3VRAV3bgsqC9aeCHXdVZFUUdRewoKCuotIUEUS6lNAJhN6SACG9ztzz+2OYyUyml2Rmku/nefLA3LnlzJ1y33vOe86RCSEEiIiIiDyQ3NUFICIiIrIXAxkiIiLyWAxkiIiIyGMxkCEiIiKPxUCGiIiIPBYDGSIiIvJYDGSIiIjIYzGQISIiIo/FQIaIiIg8FgMZInKaKVOmICkpya5tX3jhBchkMucWyEqOlJuIXIuBDFErIJPJrPrbuHGjq4tKRGQTGedaImr5Pv/8c73Hn376KdatW4fPPvtMb/lNN92EmJgYu49TX18PSZLg6+tr87ZKpRJKpRJ+fn52H99eU6ZMwcaNG3H69OlmPzYROcbL1QUgoqZ311136T3evn071q1bZ7C8saqqKgQEBFh9HG9vb7vKBwBeXl7w8uJPEhHZhk1LRAQAGDZsGHr27Indu3djyJAhCAgIwP/93/8BAL7//nuMHj0a8fHx8PX1RadOnfDyyy9DpVLp7aNxrsnp06chk8nw5ptv4qOPPkKnTp3g6+uLvn374o8//tDb1liOjEwmw/Tp07FixQr07NkTvr6+SElJwdq1aw3Kv3HjRmRkZMDPzw+dOnXChx9+6FDeTWVlJWbNmoWEhAT4+vqia9euePPNN9G4EnvdunUYNGgQwsLCEBQUhK5du2rPm8a7776LlJQUBAQEIDw8HBkZGfjiiy/sKhcR6ePtDxFpXb16FTk5OfjLX/6Cu+66S9vMtGTJEgQFBWHmzJkICgrCr7/+itmzZ6OsrAxvvPGGxf1+8cUXKC8vx4MPPgiZTIZ//etfuO2223Dy5EmLtTibN2/Gt99+i7///e8IDg7GO++8g9tvvx1nz55FZGQkAGDv3r0YNWoU4uLi8OKLL0KlUuGll15CmzZt7DoPQgiMGzcOGzZswH333Ye0tDT89NNPeOKJJ3DhwgW8/fbbAIBDhw5hzJgx6N27N1566SX4+voiPz8fW7Zs0e7r448/xqOPPoo77rgDjz32GGpqarB//37s2LEDf/3rX+0qHxHpEETU6kybNk00/voPHTpUABALFy40WL+qqspg2YMPPigCAgJETU2NdtnkyZNF+/bttY9PnTolAIjIyEhRXFysXf79998LAOLHH3/ULpszZ45BmQAIHx8fkZ+fr122b98+AUC8++672mVjx44VAQEB4sKFC9plx48fF15eXgb7NKZxuVesWCEAiFdeeUVvvTvuuEPIZDJted5++20BQFy+fNnkvsePHy9SUlIsloGI7MOmJSLS8vX1xdSpUw2W+/v7a/9fXl6OK1euYPDgwaiqqsLRo0ct7nfixIkIDw/XPh48eDAA4OTJkxa3zc7ORqdOnbSPe/fujZCQEO22KpUKv/zyCyZMmID4+Hjtep07d0ZOTo7F/RuzevVqKBQKPProo3rLZ82aBSEE1qxZAwAICwsDoG56kyTJ6L7CwsJw/vx5g6Y0InIOBjJEpNW2bVv4+PgYLD906BBuvfVWhIaGIiQkBG3atNEmCpeWllrcb2Jiot5jTVBz7do1m7fVbK/ZtqioCNXV1ejcubPBesaWWePMmTOIj49HcHCw3vLu3btrnwfUAdrAgQPxt7/9DTExMfjLX/6Cr776Si+oeeqppxAUFITMzEwkJydj2rRpek1PROQYBjJEpKVb86JRUlKCoUOHYt++fXjppZfw448/Yt26dfjnP/8JACZrInQpFAqjy4UVoz84sm1T8/f3x6ZNm/DLL7/g7rvvxv79+zFx4kTcdNNN2kTo7t27Iy8vD8uWLcOgQYPwv//9D4MGDcKcOXNcXHqiloGBDBGZtXHjRly9ehVLlizBY489hjFjxiA7O1uvqciVoqOj4efnh/z8fIPnjC2zRvv27XHx4kWUl5frLdc0o7Vv3167TC6XY8SIEZg3bx4OHz6MV199Fb/++is2bNigXScwMBATJ07E4sWLcfbsWYwePRqvvvoqampq7CofETVgIENEZmlqRHRrQOrq6vD++++7qkh6FAoFsrOzsWLFCly8eFG7PD8/X5vLYqtbbrkFKpUK7733nt7yt99+GzKZTJt7U1xcbLBtWloaAKC2thaAuieYLh8fH/To0QNCCNTX19tVPiJqwO7XRGTWgAEDEB4ejsmTJ+PRRx+FTCbDZ5995hZNOxovvPACfv75ZwwcOBAPP/ywNgjp2bMncnNzbd7f2LFjMXz4cDz77LM4ffo0UlNT8fPPP+P777/HjBkztMnHL730EjZt2oTRo0ejffv2KCoqwvvvv4927dph0KBBAICbb74ZsbGxGDhwIGJiYnDkyBG89957GD16tEEODhHZjoEMEZkVGRmJlStXYtasWXjuuecQHh6Ou+66CyNGjMDIkSNdXTwAQHp6OtasWYPHH38czz//PBISEvDSSy/hyJEjVvWqakwul+OHH37A7NmzsXz5cixevBhJSUl44403MGvWLO1648aNw+nTp7Fo0SJcuXIFUVFRGDp0KF588UWEhoYCAB588EEsXboU8+bNQ0VFBdq1a4dHH30Uzz33nNNeP1FrxrmWiKjFmjBhAg4dOoTjx4+7uihE1ESYI0NELUJ1dbXe4+PHj2P16tUYNmyYawpERM2CNTJE1CLExcVhypQp6NixI86cOYMPPvgAtbW12Lt3L5KTk11dPCJqIsyRIaIWYdSoUfjyyy9RUFAAX19f9O/fH6+99hqDGKIWjjUyRERE5LGYI0NEREQei4EMEREReawWlyMjSRIuXryI4OBgyGQyVxeHiIiIrCCEQHl5OeLj4yGXW1/P0uICmYsXLyIhIcHVxSAiIiI7nDt3Du3atbN6/RYXyGiG/D537hxCQkJcXBoiIiKyRllZGRISEmyeuqPFBTKa5qSQkBAGMkRERB7G1rQQJvsSERGRx2IgQ0RERB6LgQwRERF5LAYyRERE5LEYyBAREZHHYiBDREREHouBDBEREXksBjJERETksRjIEBERkcdiIENEREQei4EMEREReSwGMkREROSxGMgQEXkqlRKQJFeXgsilGMgQEXkiZR2w+W1g9yJXl4TIpRjIEBF5orLzgKQEKi67uiTUFMoLgNObAVW9q0vi9rxcXQAiIiJqZNdi9b9CAjoMcW1Z3BxrZIiIiNxVRZGrS+D2GMiQ69VWAJfzmLRIREQ2Y9MSud7OjwBlLZB8M9Au3dWlISIiD8IaGXI9Za3636v5ri0HGadSAod/AAoPu7okpEfm6gI0D1U9cCWfSa9kEgMZIjLvwm6g8BBw+HtXl4Rao7zVwIGvgbw1ri4JuSkGMkRkXn2lq0tArZmmJrDwkGvLQW6LgQwREdlOWQuUngeEcHVJqJVjIENuxM1/EC/sAa6ecHUpmh8vVO7jzFag6IirS6G2+xNgz2eeWVPCHpItCgMZImuUXQKO/QTs/8rVJXFMbTlw7Yz92zvjAlB6Aagqdnw/rU3pBeDkb8ChFa4uiVrVVfW/RR6WBH52B7D5LfV3mloEBjLk3s7tBA58A0gq15ajtsy1x3eWre8BuV8A107bt325gz/+NaXAnk+BHR86tp/WqL7K1SVwjKRSB2GX9rm2HCd+VffEO7bWteUgp2EgQ+4tfz1w5bhnVl+7s5Kzrjmu5i6+OUmSZ9UACQEc/wU4v9vVJXGuS/vUzWJHV7u6JNTCcEA88gwcQ4LsdehbdTDcYxwQk+Lq0phWWwHkrwOCYoDzf6iXmRsgUuZh48goa1xdAs9UU2q4TFkL5C4ForoCSQObv0xuhjUy5D6YVNq0NAMP2qzR+yJJrm/qk1SAss66da8cV/97bkfTlccZ8tcBRUfVeTBEGsZqE8/vAsoLgVObmr88boiBDHmGM1sMlxUdAYpP2r4vd7gQu8Kp352wEwFsfx/Y+q5re35sfx/4/S3rgxlnObO16QINY3feRMZISleXwK0wkCHPUNdoULaaUnXi4L7ltu1HCGDnh8C2Ba2vC2b1Ncf3oapT93yqrwbqKhzfn71qrx+7oqD5jqlSqoOYM1vV56C1qK9R56g5GjS6W42rpzXNkUkMZMg91ZSpu5ua0jiwsZakBKpL1NvXmrkDFgK4tB8ob4ILZW0FsP/rhiYPl3DVj3gzHvdKvpPH/dG5ELvkjthF79nez9RzbeWZSNJ1twDFWp5abjLAQIaajiPNN9sWqLvp6tJN+LX0I3QlX91t296Ap/gkcHQVsGuxfdsD6rt2Y+U8sV49QeaBb+zfN6DOeSk85EDuiwVHfgSOrGyafTe1+hr1/DxNOe5P9TV1QOrIuDxNpeIyUHDAORfryivqf91lID5yLiHUN1WNaxnrq9U3Ah5Qc81eS9Q0ik8B+5YBnbOBhL7O22ebLqafF0J9TN8goOCgepmXL9B9rO3HqrxsXxk1Cg6og4D4PkDXUfrP2RtcNXbkR/UPUGRnoPefGpbXVqjPgSNqKxrOYVxvx/al69hPztuXObb2kBFCHXgrrPxJFAI4ulJda3g1Hxj+jO1lbEp//Ef9r9wbiO5m/36cUSNZeVUdvMta+H1zTal6kL02XV3XbJX/C1BXpf7Ns7YMl3KBvLWAlw8weFbD8t2fqIN1Z/6GN5EW/skilznyo/rf/F+a75gVheqB3jQXYED9pXa26hLL62gSQi/udf7xNTRNU1fzG5ad3qJOxD3raA8dnTt5vbt6K38cVfXqXhW629aWOydPR4+TLhj7lwOb59n2eWnOPJm6SqD0nO3bVRSq76zLC/WXV15V13haanqrccJAkAe+Uh/HpU2pZlRcBnZ81DA5pb22vQ8c+g4oPGh5XY2io0DJOXXA6IyRhs/9oa6ltWW8Js1noHEOlOa7evmo4+VqYgxkqOWwuRrdxEWw4CBQdtH0Zts/0H98Zqu6iaGpe0IJof7hMxdIabpjnvjV/L4s3a2ZPJdWnuPdS4Bdi4Arx3Q2deMq6uJT6vdPU976GnXzZHP2bjN2zjXH3/Y+cHZ7oyetDOK2vad+L0rPNyw79K26Nqk5ptxw195Ymu/AkR/UF/7D35tfXwj1QJL1Fmr7rG1qrLyqDnz2fq5uwt69xHm98Jz5ua2vUge9x5vxptRGDGTIjVz/IVc5MZGy+CRwerP6/2WX1BM/mlN6Xl2bdDnP+mOc/E1dK6K3TRMkEhYeUv/wNQ6kLBFCnUejW3PT1DR5FbojMrtLcqUkAcd+Np7zUVGofj53qTrH5szW5i+frq3vqC9K1iYXGzvHmu+T7lAF9dW270fjzFb151C7/9rm7wbvTLpNveYG3iw8COxdqg4KnaGmxHDZmS2GtWSSUn1MVw0ZUVWsDno1gzS6IQYyZB9nXJSuHFffaWpcO6OuUdj0hjUFMCxPRaHxVU/9rq5h2b3Eck2FI0PoN2VPlrrKhuY6Wx36Fvh9nnPLY0pVcUN+hq1qK+wLYvPWqu+mrf1MFh0CLuw2PvnihT3AyQ1ARdH1dXWbGxrVgOheAJtqyof6GjNNWI1eb3UJsOXfjo8XdGmfOoAy1dRx8jd1zaBG6QX1mD4nNxquW1fp3ADW2ukNio4CeWsML/5GAz2dZHlzgYzmRqUpa5jObjdeS1ZeqK411Kj2oCk3mgEDGbLdkZXAzo8drzk58I3hj8JpIwPfWePiXvUPlynG7kBryx27y6mvMT0gn7N+vDX7sVTtDZh+LZePGV9urYIDxpcbm8Tw2Fp1zoGtqkvUuT07Ftq2nVCp3/vCw8bvcI2xlGx9bqfhstLzwPlGy3XPt6bWzxwhTAclQjieWHvqN/Xn3JqymGtaPLpanSt0+HvbklbPbDO+L2e6tK/hu1xVbPo36NB3wMVcwwkqPWnOLXOKrMxbqb6m36TYQjGQIdsVHFDXXFyx8gKprFMHGboXfWcmfRYdUd9h22rv5+omBGsYC0w2v237gHy2OLdTfWdcedW6dnebuseauEBVFKmbrqyZpNNYro7KXBODmeBO89mwNYFW932xNni0J8jc85njI/qe/l09+/i561X0yjp1crokASX2dOG2IshoHIhc3KtOLtVVfa1hgEHdwKD6mn1D4F8+1hBAlJvJNTPFXMCnUXxSPYP63k/Nr9c42HZmnpYQwMH/qZub9IZAaPT5qikzHnDZ2rPpxPqG98mSU9c/q9sXqj+7mqZeRwmhnsy08WfIxdj9mpxDUyWr8DZ87uxW9d3RxdyGbqo7PrL9GJovfnWJ+supcWgFEBhlfltTtRXmBt1ztfz11/9dZ936ZoMIKx35QX1+jTUTAIa9XwD1uZUrbD+WJKkvLNZ2edZw5l31rsWAf5jz9meOprYx/xd1d9Zt76kvgLE9gbD2TX/8a2ca7s51u+dvv14LNvwZ4HSjwEXTxGaLg/9T/2vtayo+CfiGAoGR6scnN6qbWJJvAvxCjW9zab/6X2OfR1vZW3laer6htnP3EuPrVF4Fdn4E+AYDA6arl13ar75RiEu17XhVxervZ9pfLa979YR+8FJeYPk30hrFJ4HjP6v/70ZDDrhljczKlSvRtWtXJCcn4z//sbO9nZqPJKnbyH9/y/jgScbalB25M7JnLJIT6+0/nl13H2Z+Ha29q2pK1cXqXApND4yLuddrByw0tTUOcI78qM5p0uQhmdO4JuS3f6q7PFua2bzskroZUhPAWDUOj5VXp/IC66vpbVVbrq6JNHWx1dzFF1jorlvrhC7QgHV5FY52QdZlzVg+5YXqWs2dOjc2mt5Zx9dZN2ikw824RrY/s1V9g2Ru37o5caaC66vXu5zr1jAdXaX+rhmbP84SU9+xqmLDrvI7P7Z9/5aYamZ2MberkVEqlZg5cyY2bNiA0NBQpKen49Zbb0VkZKSri0YGrn/JlTUNX/j6KvODsSlr7U9a1Si1I7HSmrFfTNn7ORAcY//2jTVOKBbCsJrZGaP1bl8IhMQbf05z8awuBtpmNOQXBUTYdgzNfk5vVv+FxOk/r/u6jPUEk1Smk7Q1NHe7VcVA1gP6z+luW3gQ6DDEcpmbJCnbSDPBkZXqC9bFXGDwTPt37a7jrzhDpR01PrlL9fOwSs8BYYn2l8FY8K5pRoztBUR2Mnz+1O/W5SKZY+47ftxMLWzjwL+uSt3MZg9bcwTddHRntwtkdu7ciZSUFLRt2xYAkJOTg59//hl33nmni0tGJp3THXxNNPq3kTNbHfthrr5mvL3ZUndSc4RQ/ziaq3mxtQpbd2C1A98A3cepR85s7OwOdU+qkHggfbL+MkdVX7Oci3Q5D4hMbnjsaLON2TtYEzUvxgI5Vb06SAlp27DM2Gs5saHh/6e3NAQy5rrP23IBqim1PyFc9yLtSK8xa5OYbWGsVtBSzZg1GncdtmWAwXN/qEfitqRxMrmyTn3c4FjAJ9D641nD1DmxNrnb3ube87tMl6fxjaC9+YblBY5NweJGnN60tGnTJowdOxbx8fGQyWRYsWKFwToLFixAUlIS/Pz8kJWVhZ07G3oDXLx4URvEAEDbtm1x4YIb5zG0FvXV6onjGvcCKLtkZKAuc/txYKTd8oKG9vzGHBn2v/ik7c1Hxn48THXLvHIcOGPih08TsJRdbGiWaxzE6Ha7dDZJZblJyBRjyYr29LzZ+7lh9+WD36rzoOypfgf0AxxHSCrrE8Iba6o5sAD1RfKizphI2z8w3kSme9NgqTl305uOfT8BxwbYy/9F3exiq4L96uMabUqROdj05MC2R36wvxemOY2DdGubHo+uAjbMVX/fr+Q376jrTczpgUxlZSVSU1OxYMECo88vX74cM2fOxJw5c7Bnzx6kpqZi5MiRKCqyo4qRms/JjeoENd3ulELYHkA48qPSVNWa9vz4GmseO73ZdDBzdkdDgqIpJ22ohXHmrNz2DnR11IoJJXUvrubee93cjOqShl5MumOiCEl9h29vcGMvYwnhxl6Lsk4d6Gu+E+ZqcgyCU3PfCyMB47VT+ue2usR4oKKbrGtpRFrAuYOuNdfdvnY0ZiO1suWX1N36Cw5ef8/s6OVmK01zq6V8I2fNx2RtQKL5/dn9iXqwRzfreeQIpzct5eTkICcnx+Tz8+bNw/3334+pU6cCABYuXIhVq1Zh0aJFePrppxEfH69XA3PhwgVkZmaa3F9tbS1qaxvufMrKnJQYR/rcYZhxRwarczZTvZ3O7wLCk4w/d/wn8z9e5/6wfqZZd6gStnY016sn1Bdea5sZzCVmH15hviu6EOabYpyVaF3cqAml/JK63Bdz1b1DMu83v/2+ZY4d31JQ3FScOeo20NAzzxG6AYmyVr95SlMjdeRHdZBpz3xVgPoz52iu0pmtQJBOrp0z5rECrPtM2zM8hQdp1l5LdXV12L17N7KzsxsKIJcjOzsb27apB1PKzMzEwYMHceHCBVRUVGDNmjUYOXKkyX3OnTsXoaGh2r+EhIQmfx1EJp3bab6G54iFWgx7f3CUdfY3ETW1/V81TGZnDXMD+FkaT+foStPNj4C6ut8ZGl+AlbXqIAZQd3t1JGfLGq5KurRq1G0r1NeoR4B29nkyN+5NyVnDWpjGwbVMpl8rpVk/9wvHy3byt+aZ28oYd/1tcJJmTfa9cuUKVCoVYmL0e4DExMTg6FF1NamXlxfeeustDB8+HJIk4cknnzTbY+mZZ57BzJkNPQLKysoYzDQbYdimXnwSkLllr/6W7fe3XF0C92CpK7O1E/o5ytZkbXMj4Noy75en2Px20+y38optwcKWf+s/VtUD24ynRdikqbr0NweV0vaxnVzMLUs7btw4jBs3zqp1fX194etrRaY7NY3GyXkWhyR3k4kDXcHZ1fJkm+acdM9VTT+tXUWBdblAgPFm3pKzzum9pTuppic5v0vd9dvb39UlsUmz3jpHRUVBoVCgsFC/K2thYSFiY2ObsyhkK3eZuZjIXo72yCH3Z20QAxgPbB0d48rTacavaeqmUSdr1kDGx8cH6enpWL++oX1ZkiSsX78e/fv3b86iUHO6mt/wf0tV/0REzcGq6Rd4A+cJnN60VFFRgfz8hgvXqVOnkJubi4iICCQmJmLmzJmYPHkyMjIykJmZifnz56OyslLbi4k8iLUDi1nbu4WoKbFWkWzlrJ5F1KScHsjs2rULw4cP1z7WJOJOnjwZS5YswcSJE3H58mXMnj0bBQUFSEtLw9q1aw0SgMnNXDttuMyRYf+JiNzdyY2Af7irS0EWyIRoWbcpZWVlCA0NRWlpKUJCQlxdnJZjw1xXl4CIiNxFE8x+be/1m/1kiYiIyGO5ZfdrcgNVxequeP7hQLsMV5eGiIjIKAYyLd35XYB3ABDTQ395XZV6WPXwDoC8UcWcJOlPC29qwkOiRvZfKEFZtRKDOke5uihE1Eqwaaklq7yqHhfg8PeGz+1eoh4BU3cGXSHUg0E1nnzOlrEZPJBSkrAxrwhnih2YQZsAAL8eLcKuM8UoLGvZn5nS6np8vfscTl5x0txNDiiuqoPS2jm63Eh5bT3WHLyES6WeNWYJuR8GMi1JdYl6MjrNzMGmBgCrq2yYBFJ3+PMD3wCb3jSYILJWqcK+8yXYkFeEovKWcYFSShJyz13Dtao65J4rQe75Eny318REkI0INxlb4nJ5Lb7be8Hu96Ssph4/HSqweft6lYT/7TmPfedLTK5Tp9K/sColyW3Om6OUkoQf9l3EhZJq/LCveeewERDYc/YaTl9VB90nr1Tg022n8c3u8012fptqvz8fKkReYTmW72q+WZiNvZaNx4qw9cSVZiuDM1TXO3eU6rKaelytrLW8optiIGMlSRL47+ZT2Hv2mquLYtrRlUDxKWDfcvPr7dd5vkzn4q0ZuK5Af3j1pTvOYkNeEfadL8EXO89iwcZ87DtfAiEEBASEEPj5cAFyz1l3bs4WV+GTradxoUR9JyYg8MO+i/hx/0WbfjQPXSzF4q2nUFxpfJyaGqUKW/KvaL+gQqjLeryoHP/bfR4bj13GJ9tOG92+ul6FbSevorS6HtL116lZvmjzafyefxkAUFWnxJb8KyipNl4GSQgUltVAKUk4daUCPx0qwKGLpdog4NTVSsxffwwLfzthcPFvvJ+zxVWov76OgMDXe87hTHEllv1h+kJQU68yWbZFW07hSEEZvth51uC5E5crUFhWAwGBI5fK9IKd3HMlOHetChvyzA8oVlWnxP7zJVh14BLe25CPFXtdN3FdcWUtNuQVoaJWf5qIspp6lNXUY+fpYny58yxKq+tRXqseol663qFTQGDnqava2pfFW07r/egrJQmazp+VdUocvFCqfZ+MkYRAQVkNVI06jColCWeKKw1qV85fq8K6w4WoqVfh/LVqbDp+GSty1d/bgxfU45wUlNXg3+uPQyVZ9/0prqzFJ9tO49s95/H17nOorlehsk59boTO5z3/cgU+3nQK564Z3hRV1imxdMcZ7Wf58KUyfHN9X8Zofis0Sqocnwrg5JUKHL5UBkkIrDtciMOXynCssFz7Xuo6XlSOjzad1HstZTX1yD1Xgp2niw0+G/bQ/a2wpZZM9/fl4IVS1CpVyC8qx64zxQbr7r9Qgg83ncD2k1e1yzTHUkqSwesor63H7jPXUKNUoaymHkpJwtniKr3yLdpyCp9tP4PKOiVqlCpcLKn2qBsP5shY6cf9F/HyysMAgNOvj3ZxaUwwN5374R/UU8gnZgHlOlNEaIbp1p1f5Ox2vU3LavR/EOpVEjbkFRlcyA5fUtcSdI0NQWJEgHb5uWtV2Hz8CuJC/VBVr8KxwnIAwNe7z2HGiC6orlNpLxJ5BeUoLKtF+8gASEKgQ1QgSqvqERrgjbyCcgT6euGXw4UYlByFdUfUr2PdkUJMzDCcKPTj309CJQn8caYYmUkR2Hna8EdBXe6GQa/yiyoQG+qHX44U4vTVSuw4pf6xSAgPwO03tMPes9e0Pwzecjlyz5WgRqnCH2eKER/qj7SEMHRsE4i8gnKE+nvjmz3nDY53pEB9vLZh/vj++gWpRqnC+xvzce/ADgjx88bVylrkFZQjMSIAW09chUwGXCipRmJEAKKD/fR+4CQhUFJdhzB/H73jCAgs3HQCAHBP/yREBPhg/4USnCuuwuDkNkbPBQBcqajFj/vVQUdOzzj8dLhAvY9+SSipqjO4SJ8trsKvR4swLjVO9+D46PeTeutpmu7yCstxrbIOxwrLMbp3HCID9edKExDYcbIY1fUqDOvaBjLI9J4rqapHqL831hy8BLlMhpyeDcctra7H4q2nAAABPl7oGBWIgxcbahj3nS9BfKg/xqXGw0shw6Itp/SOrdk2LtQfl0qrMbxrNEL9vbH1+kVjdK847QVf470N6huAhPAA7UXy5JVKjEuNx9GCMhy8UIqcXnHw9ZJj9YEC7We9e2wIsjpEoKi8FskxQfj1aBEOXypDbIgfCq43zf2lb6L2MyQg0C684Xt1rLDcoGnr499PYnTvOIT4eePbPefRJzEciRH+yD1Xiv0XSjC5fxLCA3zw06FCXKuqw7UqdZD74fXPyehecdiYdxlhAd64I70dVl7/HPxvz3ncN6gDKmtV8POWI8zfB+uPFOFyhTpA3HT8sjaI2nbiCnrEh+L345cxsHMUCkpr0D4yAN/uuYDKOiXu6dce3gq5NmA0ZtuJKygqr0WfxHDEh/nBSy5HeU09JKGuIQ4L8MGmY5e17+3m/CuoqlPi0KWG93rtoQIM6hyFa5V16BIbjFUHLgEAvt17AY/dmAwAUKoaLtb/2XwSfRLCMbSL+rtRp5Jw8EIpOkcHIcTP22RZNcpr6/HfzerPT9/2EfjjTDH+nJGA+FD1vEVKScKyneeQGBGAIV0avn9Ltp5CSXU9kiIDtTVtf5wp1gZixZV16JsUgQAfBY4WlGt/d7efuortpxqCmUmZ7bEiV32Op/RPQliA+vfgqz/Oo7y2XnvzpSutXRgighp+N3afvoY9129Ib+4Ri26xwRACUMhlKK6qQ0lVHWqVEjq3CYLlM9J8OI6Mlf659ig+2Kj+srttILPjQ3VvI0Ddx7/kHLD3c/11Bs8ynCl5+DPqIGjru0Z3O3/9MbuK0yMuBJ3aBGkvisZM6Z+EJdtO27V/XTNGdMHec9fw2zH1l7V7bIg2YHCWv/RNxLI/DGsvGmsb6o8LVrT7T0hrq72zdpa/ZiYiOtgPAPDJttPaC1WAtwKje8fj693Ga2/G9I7HoQulOHW1Ej5ectQprbubHJ/aFt/vs/413N6nHf63Vz+4S08Mx+7rNZ19kyLwh07AmRwdjJt7xKC8VokL16qx/3wJLlfoV4EnRQYiItAHvduFYsnW01aV44aEcHSICjQoizM9OKSTNkDw9VKgVmm6OaBTmyCcuGw532ZAx0htUGWvMb3isPL6Rd2cBwZ3NAhGNWaM6GLydyHI18vm2o1gX3XgdKm0Gl1igvHOr8f1nnfG69b12IhkFJTWGG3WurFrNH5tdJM2dUAHbDp2Gdk9YnDmaiUCfLz0btaUkqQNaE0Z3DkKv+erm7CCfLwwPq0tVEJY9Ztir6kDOmiDc0d0iQnW3oBq/PXJDxAd4ufwvnXZe/1mIGOleT/n4Z1fGz6o/7knA9k93Gw0YmsCmUH/ADa/rb9s+DPA2R3AiV8NdikJYfCjQu5tTK94JEUFWPxhJXJHtgTSrnRDQjgOXiw12yTcks1X3uH0m3p7r99sWrJSm2D96u+/fboL6e3D8b+HB7ioRBbs/1p/ssbrKuuUWJd7AdV1Ktx2Q1v4eimAggPaIEYSAlcr6xAV6AOZTIa8gnKDfZB7W3nAdbkoRI7yhCAGgLYJhlyPyb5W+uVIETrJLqCf/DA0M6LuPnMNF0vcs+uguHrcoC1fJQTGvLIMp69WorC8Bh/8dkKd8HVkpXadDXlFWLrjDLadvAqVJIwmmxEREbkL1shY6Y70djhx8gMAQLkIwCGRBAAY8PqveOfOPhia3AahAd44XliOdUcKce/ADvDzVjR5uYQQ6lTI/V81NCtB3bVRN0fk9hvawddLjkjod61+b0M+0tqFITrED+eKq7Tb7DxdbDI5loiIWjdfGO8N6QrMkbGSEAL/fv5e7eNlyuEoQKTeOn0Sw7D3bAkAICLQB9/9fQAqa1VoHxkApUogNMBbszOgqhg13iGoVQGXy2vQuWIPai/sg0/mVMh8g9WrqeqB2grIAozPvjphwRbkniuBH2rxkNePeHhoJ2zJv4JzxdW4ZqLL7TURjHAZm4uIiMh+V0QoXnl1vlP3yRyZJiaTyfQep8pPIA0ncE60wSHRAQC0QQyg7jI39I2NBvvxRw0e9FI35ZyQ4vGjpM6xmeH1jXqFn/ZivvIOAMBdinWIkpXikJSEdVI6Iv2AeWOTMCC1O9YeKkTuOfXxZNebuj747YTF18EghoiIHBUlK7W8UjNhIGOtWv0AoLtc3WWuG87ikLKD1bvJljdMCdBJfhGdxAWUiUC9dRJkhRCQaT8oKfLT6CC7hABlLfZ+B7z4zQCcFPH2vhIiIqIWg4GMtS7tt7wOgBBUQgaBUgRpl8mgGY1VjohGNSJjFdsM9nG74neDZQGyhrEz+sjycVLEI0l2CePk27BKyrKqbERERC0NAxlrKS3PRyODhHu91gAAFignwBtK9JXnoY/8OKqFLz5V3eSUpp0EeRFSxGncpNgFwHgwRERE1BowkLGWZHmSrkA0BDuJskIMkB9CpEzdC8hfVqvNjXEGTRBDRETUmjGQsdbFPSaf0k3g1WAtCRERUdPjgHjWEgIZ7SOMPuXMmhYiIiKyHgMZG/RNMj6eCxEREbkGAxkb+Ho1/Ui9REREZD0GMjbq3CbI8kpERETULBjI2GhMbw5ER0RE5C4YyBAREZHHYiBDREREHouBDBEREXksBjJ2CPXzdnURiIiICAxkrBeVrP2vXCZzYUGIiIhIg4GMtWQNp0q4sBhERETUgIGMtXQCmQyO8EtEROQWGMhYS6c5KSE8wIUFISIiIg0GMnYI8OFUBURERO6AgYwdvBU8bURERO6AV2SrsacSERGRu2EgYy0ZTxUREZG74dXZWnIvV5eAiIiIGmEgYy0OgkdEROR2GMhYjYEMERGRu2EgQ0RERB6LgQwRERF5LAYy1mKODBERkdthIGOntmH+ri4CERFRq8dAxmoyM4+IiIjIFRjIWMsgcmEoQ0RE5GoMZOw0KDnK1UUgIiJq9RjIWE2/BibM39tF5SAiIiINBjJERETksRjIWIvdr4mIiNwOAxlrcfZrIiIit8Ors7XCk/Qeenvx1BEREbma212Nz507h2HDhqFHjx7o3bs3vv76a1cXSU3hq/+QTU1EREQu53aBjJeXF+bPn4/Dhw/j559/xowZM1BZWenqYgHBsQaLesaHuqAgREREpOHl6gI0FhcXh7i4OABAbGwsoqKiUFxcjMDAQNcWjDUwREREbsfmGplNmzZh7NixiI+Ph0wmw4oVKwzWWbBgAZKSkuDn54esrCzs3LnTrsLt3r0bKpUKCQkJdm1PRERELZvNgUxlZSVSU1OxYMECo88vX74cM2fOxJw5c7Bnzx6kpqZi5MiRKCoq0q6TlpaGnj17GvxdvHhRu05xcTHuuecefPTRR3a8rOaRlhDm6iIQERG1ajY3LeXk5CAnJ8fk8/PmzcP999+PqVOnAgAWLlyIVatWYdGiRXj66acBALm5uWaPUVtbiwkTJuDpp5/GgAEDLK5bW1urfVxWVmblK3FcVJCv5ZWIiIioyTg12beurg67d+9GdnZ2wwHkcmRnZ2Pbtm1W7UMIgSlTpuDGG2/E3XffbXH9uXPnIjQ0VPvHZigiIqLWw6mBzJUrV6BSqRATE6O3PCYmBgUFBVbtY8uWLVi+fDlWrFiBtLQ0pKWl4cCBAybXf+aZZ1BaWqr9O3funEOvgYiIiDyH2/VaGjRoECRJsnp9X19f+Pq6qIknqA2AY645NhERETm3RiYqKgoKhQKFhYV6ywsLCxEbazgOi8eL6OTqEhAREbVqTg1kfHx8kJ6ejvXr12uXSZKE9evXo3///s48lHvwcfHYNkRERK2czU1LFRUVyM/P1z4+deoUcnNzERERgcTERMycOROTJ09GRkYGMjMzMX/+fFRWVmp7MbUonEiSiIjIpWwOZHbt2oXhw4drH8+cORMAMHnyZCxZsgQTJ07E5cuXMXv2bBQUFCAtLQ1r1641SAAmIiIicpTNgcywYcMghDC7zvTp0zF9+nS7C+VJgn29UV5b7+piEBERtUpsG3HQjd2iXV0EIiKiVouBjIOkDkNdXQQiIqJWi4GMg+riMvCbKhW7pS6uLgoREVGr43YD4nmUNt3QzScQe0UyIIB0OQfHIyIiak4MZOyRfBMQlwYovCADoJDLoJLMJ0ATERGR87FpyS4yQMEYsDlcE8EuPX614AznRETujIGMLdp0UQcw0d1dXZJWIU9KwHeqgU7d5x9SV5vW/0x1k1OPT0REzsVAxhYptwGDZgI+AXqL7x2Y5JrytGALlBOwRspCJfydut9dNgYy1fBBnfB2ahnM+VJ5Y7MdyxWOS+1cXQQiamEYyNhCJgPkCoPFT43q5oLCtGz119O3BGRO22el8EMtbAtKBOT4UDUGNcLH6m3eVd6KL5QjbC0elihHohARJp8/LTX9xKv7JPMToX6kHIMDUge7979K6mf3tq6gEvyJJHJ3/JY6gZdCfRp/UvVFbaML3mUR5oIStRxSo4/ojyrDyUfLRQB2SobBZL7UFgBwVErEfOXt+Fg1GjATGDXet2Z7FRTIF22tLrMKChQh3Or1NWpgPlhaI2XavE9z/qcabLBsg9TH7DZV8MN6Kd2h4xYJ8+fmK+UwfKgc49AxiKhp7Zc6uroIWgxknOiIaI910g16yzZLPV1UmpbphGiL+co7sF3qAQAoFOH4ryoHW6We2CMl661bikC8q7wVa6W+UAcwhkGMblNTqQjS/v+CiMIvOu/lThubpACgRGd/zlBrIdCxtsbmnBSNr5VDcU7E4KQU74yiaZWLAMsrWXARUaiGH5YqR5h8Ta5OAm+NzkrR2KzqiZ9VGa4uCrmBSuHcZn9HMJBpQu8rx+OMaPrmgNZoh9QN36kG4VvVYGgClE1SKuYr79CuIyCDCgo0DmCOSO0BAB8qx+CglKRdXoxg1AoflIpAfK0ahho09FgqQyAuikijZflSeSOuiFCD5UtV2Ta9JnVZgc0q24Pf/6kG44KIsrheqQjE/6QhuIA2AIDfpN4G63yjGmLz8TUKRATeV463e3tdlxGuF0zq+lR1E/6rvMUpxzGnBI4Ho0elRHygHIeTUpwTSuQai5Sj8J00CLtENxwWSfiP8hYstaP5tDVpjqZgVyqG+9xMMJBpQnU25mOQ9QTkOCNiLdZSGPOT1BfzlXegGn4oQTA+V96Ej5RjIF3Ph1miGmlkKxm+Ug27Hjg1qBR+KESE0byRengh10LOCaC++K9VZWrzgmxpxnJUKYIMenKdF9EmgzZr2PO5l0zkolQgAO8qbzWogRGQoxwBFptuz0m2zYW2VZWi9/gH1QCbtjdmrZRp1+fUXldFiM3bWGruK0MQhM7logIBuGxH82lrssWO2vhfVMYDd3d0vBl/pyxhIOMkHaMCATg3OZWaxxWEogp+ANQ5OcLk10KGsyJGb4l0/f0+KDrgiNQea1T6eSwbpT4Wa0r+kLriqEjUPtbUzBjTeP8aNcIHZ4X6oi2EbZ9BzXbO9L2ZbvPGho6UGV2qpoLC5LOWkrdVNvzE/aTqi/2iod2/Rvig1EiNjK3n1xjdmkONI1KiU5ptjot2eF85HitMvAelItBg2Q4jOWbWyJU6a/9vLE9No6zRMXXHZ2JCdQN3qME3dlOxUmUsSd99rnX8BDnJiunOHe+kNbOmicRdFAp1LyMVFPhJ6os8nYBE4ydVX5yQ4vGVcpjBczuk7jgh9PNUytGQZ3KpUc1InkjEfOUd2KTqjW9UQ/CzKgPbpR64jHAUIgJLlSPwoWoMliqNN2tZG2irhGEwpclL0nVFhBq9gJ0ScTgqGZ4LzXPNxZbxti0lWwPARlUaLkL/PVEaOVd1wtiAmZbOvQyHRZLDn38hZKiDt8FnR+MPqSvWOSnPZaOUhneUt+FD5RhsNVEDYSwpVJ23prZVUteCOSNAtIctTZRLldk2Nf1qOgxYS/e77wqmbkAa/0a5GwYyThLix2YkZ/la5TkzipvK4dBVhkD8KA3ARRheoLZJPWDsAveBchxWqvphk8owhwUA9oguOC+icVgk6QUYlxGOGvjiMsKwXnWDwcVMMnKsEiOJs+ulPrgmgrFOlY75ytvxifJmbJcMB4IsEwF6F7BynXF/fjXRA2qn1A1rVZlYrByFI1Kiibs9fc5I7j0nRaPYwn50a4YaB32/qvogV3Q2WP6tajDW6zQJfKUcZvQzfE60saqc36kGWbWeKVdge9OSOQctdLeXIEf19RrNxo5J7Qw+B+8obzOoeXhHeRveU02wuWzOuOmxJXi4jDDsEtbWXgmskrLwudJwUM2mHjHcVFOtOX9IXc3eZKxTOdZbsSkxkCE35D5VluYcl9rpJQQ7Uy18kC/aQenAV/SA6IjlquE4pJPQbKxpqhwBWK4cjk+UN2uXlSAYn6hG4pDoAECGawiB7vtScb3HguZO7TvVIByR2mOHTrBjKldGghxHRSJKEYSfpEzkC8uD5K23ImC05EepPz5tlP90+Hrit4a5T17x9QBhm0odOB6QOmChciwuIgqHRBIAdc5U4xobjVzRCT+p+mKRMsdsOR1tnta8J3UmptKzJV/ngogyGZBao7jR5wYwHFJBs8xck6opBcL0uEu2sCZ4tDR+krGxowTkuIJQLFMO11te1US/G4B9OVLWOCSSsLdRz1B3wQmDnMzcwGk/qAZgnGJrM5amZbgiQhElK3V1MTzWRRGFFJwGAJMJmpdMXHxN+VyVjWhZiTa/5oyIbdL2/Sr44XdVLwxWHNBbXie8tNfJpcoRGKPYjs1SL4xWbAegDgo+Uo6BApI2sPpYORoBqEUZAlALH/SQnwEAg55nmrqZpcoRiJCV4/z1GpULaIP3leOvBwrqg0uQG8170d+fHEdEe5PPa86lLXk9xsm0x/tAOQ4Pe/2gfeaw1B75Ih6RKLdqTxdFpNHAw5lM5UdVCj8EymoMlgshg0ym3qbQQpKyRpkIRDn88bVqKAbJDyJDngcA2hq6MyIWq1T9tJ8bXeUiAMGyKosX8SKEmXyuwIbv1x4pGTfIj1u9fmNrVZm4U/Gr3dubJsNvUm+UC39chmEvTVdiIONkFxCFP6SuRqvC6+CNMhGIEFmlC0rmGYxVY69WZeEer59dUBrXc3WbuSk18DVIfLakKZI6N0ppCJZVY4+UjMsIx2KVYW1HVaNmj0r460198bFyNHxRj3IEIACGF87LCMflRhfMpuiReESbXyXDAuUEyCGhu+wshilyAajzF8Yrtti0z1r44AfVANwk3421Ul9tsHkFociVOiNNnu/EV2CbEhGEMFmFyfyL5arhuNdrjcE2P6syEC6rgBwSjokEeKlUuFmxy+yxFqtGXq/pkqFa52ZTd4iE46ItvlMNQrLsAnrKT2mXf6q6Gb6oQ4WZ72KelABLNck/qAZgtHw7fpYykCk/avC8prZ0k9QbEuTaYMtW1uR6GWNdM50Me0QXu/bflBjIOJ0MW6Reri6Ex9ogpRksK0YIPlXebHN1rLF8EGfIlTohTX5CrxnFfubLWANfLFVmo96OancNWxJem8ohKQmbjIxZ46gyBNo8Xk9jjQMb12n4LGi64uvWztibJH1SxONDVRwaf9Y2Sb0RJSt1qKu9Iz5T3QQ/1Jk892UIxDeqobhD8RsAdW+rJapRANS1jBqHRRJuhvlARrcn4j7RCbHSNZwUcY2as2Q4I2IRL7uqt60KcpNBTIXwx3eqQUbHVGnchHdSxOM91QQIyJGJhkDmU+XNKEWgTllk2CqlIAwVOCNiMEKxx+xrA9Q5MXKZhPOiDcoRgM1STwxR7Eeu1AkxshLENXpNuhYpcxAhK8NpN+gxZS/myDjRwrvSkRhh/g7ak3rkuELjdvL/3KPuXVGMEKvzUbZLPXBNBBuM9AsA3zxkOMWBOX2TDKuuN0p98K7yVlxppurVywhDiRsNPmWPEhHk8Fgq5rpoO4vu3aw7jAPlvNdsGDBLkOMb1VCTvY3ssUaVid9UqVatq4LCYgB53soEaVso4YVVUj+zzXzWEgCuIlQbKGm6mQshQxkMu7lr1tMd/6gYIQa/exLkWCn1xwHREfVGe8A1KBAReEd1G+Yr78A315PM94hkLFKOwkYjN4aNlSEQp4VhoOtJWCPjRKN6xgIQeOhz4xH0VRGMMpl7NhW4q8FdbA/8tks9sB2GXYUBICPJtuTA127thZve3mSw3J7ERHIF236cdfNBmqpGryXTDD8wFPucvu/qJkyQdZblqmHoILtkdBgGXRukNFTBVzvKuCOMD9ooQ5mRMZDWqTJwk4VmOGPcfXw0BjLN4CPlGHhDabKLIhmX3d35A7XZKiygaUZk3apKabaRMY+Jdugr8lgbaCNH5spyVoLscdEWN2Jvq37vvlMNQqb8qEfM8VQJfxwUhuPmNFYLH2ySrKu5Mlcnt1vqYpADZs4hkYR6lQJRslKjeTqeioFMM7Dlg9ZafaMagjKdCQfvzEzAKxN6QSlJLiwV4KNwbuurJtl7n+jUbMPWK+GFT1Q3w5OrjgHYlcdiT8PMV8ph6C0/id8dyHW7ihDkSQkOf/er4Yf3lBOgdFENoDt8Ys6IWJxReW7+hqOc/R4cE+rPpW6ejqdjjkwza9zmbWrAs9bmvIjWqwqdPSYFCrlzv8L/nWz7HV1ogDeeGGn7zNemLFGNxPvK8UaDmFEpsTj8krF5ntQiAx0JfJxzLnvE2TZGhWbU2zPXezidfn00Iux8HUdFAvZKyfhRZVuek60uIgprpUxUwh9edn8GZVgjZeE3M3fd1uaSKHW6eXsqa7tJE9mDgYzTNfzg/Dh9EE68Zn7460rW1pjVuEYkIcK+3iX7Zt+MEd3Ndxcen2a8G+i04Z3RPtL63KbTr4/G6ddHG31OgtxkEunc23ohwMd0Jem9g8wPyOUMi6f0Nfv86scGW1xH18eq0fhMeROKdMavaRdu/j1MiPDHg0MNq+cF5PhNSsUJG5rkrrlxkvRekazt+eaMXAl3tl7qg11SV3xmZJRbz+bZAWZLwUCmCfVqF2qxVsHYBG7UQCbTP39rHxuCacP1Z5R+584++HWW4ZDwDw7tiOdGd8f30wYiNMB48NA2rOGi+uAQ/f1+MKlhNNm5t7q+S/3DQy3PpG2t5Ogg7HzWcCTS4d0s5yWZWychwl8viKuFD67a2Lvr9ydvxNOjuqFbrP1ByFfKYdgrJTvcRV7WxNepbVIPfKEcgXWSa4d/LzWRD1RkYXZxSyqF+katBr7YLPWy+bNgLc3I0q3NJSeNbGyPR27sbHmlZsJAxsWU8MIHynFYoJzg6qK4FV8v4x/NQF8vPDGyG9bPGore7ULx4d3pGJcaj45tgrBv9s2YM7aht5JcJsPfBndEakKY0X21DfPH4yMbBncK8W+oDfnib1nXe6GppcSb/gG+rY/xGoIFf3V8WH1dcjNBcZeYINzVz3xPCQCICvLBi+NSsPT+LEQH+2HubYYBmiMteilxzrlQyWQyrH50MJ4bbTwQmXtbL3SLDdbOOt/YRUThNylVOx6L+5KhCOFNPnquJVcQitWqLL2JTY9J7XBMZ/qItyem4uCLI3HitVswPi3ebM3aSlU/7Jc6aqdusJZmPh9bE3vPiFj8JPXFGlUm1jaahqPxiM2WmBud3RWMzUy+RDkSa1SZyLe7w4Dj3frlTR3l24CBTDM7KRkOalULHw/4wW1e5i7aANCpTRB+mD4II1Mago3QAG9MHWi5+eV/D/fHwrvSseXpGzGmdzyGd22Dx2/ugnbhAZgztgfe/FMqBnSO0qsNCg3wxnt/NT7nzLyJaXjUyN3J6N7WD2DmJZchxF9da7TyEdsnDZwzNgVxoZab3YL9vDF5QBKig9V3yrf0Mizj3tk3I9xEDZYlzvxtk8tluKtfe+T0NEz0vDMzEWtnDEF0SNN2yb05xfEk02UP9EO2hWZNW10UkUZn3XbEMZGgN7Gpehwm9Rt6+vXRuLVPOwT5ekEhl+Hff+mDTU8MN7EnIF+0w6/SDTYHaIdEB7yrvBWHbQyANPJEIo426vq8VGVY82jOftERJ6WGZmZj3fA1Y7uY6032/BjjQ0CYY2wcsl1CP0fvv8pbUILg6128XRdM3GhF7W1zYSDjZAE+5n9cChCJT3Um56Pml94+Qlvb4q2QY/HUTEy/UT143tSBHXBHuvFJDMf0jjfIeYq5fiEd2Nn4D9r/HracmPp0TjccfHGkthky2M++oNaeHlah/t5YeFe6wbKObezreqwJZJKj7e+6rMvPW4EP7kpHxzb2NcGOsSGYBIDFU/Xzf143UmNlq34dI/HR3elIb9+QJ9S/o+FourrNnKZsVKXhgNQBX6mGYYFqvNF1pgxIMppjZM6UAUna//+k6osdUneL8wNZutmwlzPGaPrl+mzkq1T99Eb1tfb4P0gD8KFyDD5QjoOxYOFzVTa2qVKMjkSukWnjmFUAMNto8KN/fFunLbE1fcHaQRhN1XS7AgMZJxvUOQrjUuPN9nTRzKILcNAtQD0KpqcwlfOU1TES3zzU3yDvJL19hPai0rOt8R4/2d1j4Ofd8OMd5m+6anvnsyPwdI5hVXNydBDuzEpEz7YhmJGdbHGEaV1BvtYFTpaCdF2f3Gs4y7a7++/kDKTEN7xHUUG+CPYzrJkKs6O2Si6X6dVyfflAP4N1sjpG4OCLpnutAUCu6Iz1UjrUlxvjP98RgT54Jqc7tj9jvCZibGo8erfTb24ZnNwQiB8R7bFNSjFbDo03/9TQ8+r2G0zPYt44SOukE5iOTHFubRUAHBQd8a7yVhy3YmZ1U6rhZ9C7cEgX9UjDpQjCDtHd6UMo9LUj+LFko5SKI1KidtRfS3RrVT9SjsFC5Vjsfd69b74ZyDiZXC7DO3f2wbTh5hOh9krJOColGp2jo7X5o1HV6T9vd05irWiGSYYe0EkQzkiK0DbZ6Jp1U1d8dHc6lv7N8OK16Ynh6Nyo9iI0wBvjUtVV240D4uhgPzw0tBP2zb4Zx17JwY7/G4FfZg5FdIgfgny9sPKRwZiR3QU//2OIQ6+rp84FfXL/9ujdLhRf3m9Y/hu7RWPD48MMlseH+etd5HQ9N1p916lby6KZzdjZHNlr42aylPgQLP1blkESsubipjG6Vxz+mmU5X8mYIF8vvD3Rum7ZlgT4Gg88B3aKxN39nJMYe0d6O5x+fTSOvZKDt/5svNyfNgpq+ySG4QOdWsC0hHDc1qet05vfrK3ZMdXD0JjFU/pi5/9Z31TVuLbTElOdEmylWztbA1/8JGVaNd3D/Ilpeo+r4Ica+CLYzwv9OrousdgSBjIu8puUirVSJoxVW5a18p5ME/vadxFobh3bBOLegUkW1/PxkuPmlFiE+hv+SCWa6Nb9zp19kP9qDoZ2Mf7jExrgDR8vOWJC/AwCIUDdJLN2xmC8PEF/Hh1j62YkhSM62Ffvh+qJUd0wfXhnrH50MF4c3xM/TB9ktCpZBqBDVCB8ridnD0luKK+pJrrMDhE4+vIorJ85FP+dnIGtT99odD1dmsDOZjqRzKu39jT4obbFnZmJGNg5CpGBDXk5g5OjMH9iGpb+LUu77MlRXfHXTMPP8MPD1Dc3E0x089fI6Wnf5JAN26ubTZ2VjNm4uc0YHxPJ+Y/c2Nkg0Pvu7wPRJUY/GJw3MQ3/sWOcJ1O1nLYylTTemEIuQ3SI8SEzjO1jVM9Yo0NwGPseutpDQzthgomOCzKZDG/c4ZwAuykwkGlGUUHWJSbmSs7rZlvrZhn4LUm32GCD7uHO5OXgqMLdYkNwd7/2esGMsV5Kft4KbH36Rr0alyBfLzw+sit6xBu/UGiay2bdrK4x2vTEcHx4dzr+nJFgVdn8vBWQyWQY0T0G8Vbkhkwb3lkvx8QYU4P1jUqJRWZSBO7sm4gJfdrithsafqyXNL5IG6nCiQ9VX7g0QeWcsT0wqHMUPrw7HZ/dl4WIQB8M7ByFp0Z1wz9v74X2kcYviuntw7H/hZvxtgPBlDWSrwcJQb5eRs+JLRfRh4Z2wvCu9id1OntQy8aM5RrZY5EVYyMZa9LVtWbGYKPLFXIZ9s1pvqaZ7O4xEHbURVr6KUuICMD/HjY2r5PrMZBpRgv+2sfu3iDmGOsu+KOqP/6jvAVHGmXw75dsSwJsDpa6O7403rr2ejLOVycgMhVMeynkNgVlz+R0x/FXc7SBTmyoH0amxDZZAqi3Qo4RRube0r2zX3JvX9zVLxFrHmu4oAgILLw7HV891F9btnl/TsPJ127B6ddHY1jXaNzUIwZtw/xNJmxveGIYdj2XjYTreUfRIX74/G9Zej3mAODhYZ0s1iaG+HmbPM/3Xu9x5+etwG192uLmHjEItCEvyZjVj+lfXN/7ax9kJEUYDA7ZHM2wppiK10eZ6DHWJaYhEBufZl3348n92+PJUV3x+5P6Pa1m3aQefiEpKhDrTDTHPnJjZ3SPC8EkC82F5pLtQ/29ERWk/p2z9DUzCK5t9KyJIQucIb19OP47OQO/zHSs6drZGMg0M18vyz9MVfBDiQjSm77d1oG9Toi2qDCS3f6rZLwLsascl9phv84ka/+6w3DKhklZ7XFnZiLeMPKcK5kbW8ZZOkcHwc9bblWPFpOa6KbY28YaozszrautMUVm5IU8MbIr7hvUASumDUR0sB9emdAL3a2YRkE34Pro7nRsenK4XsK1Ll8vhdW1qY7o2bbh8zRvYho+uicDT9/S8L03N32FOWseG4xbesXil5lDMKa3ulkrItAHH9/j2kkY/z6sEzpHB+FOI81wgLp5tbE7MxOwaEpf/PyPIVj96GD0bBtqEJwY8+L4nvj7sM5IiAjQy0F6ZESy9v/JMcE49OJIPDxMv0b8sRHJWPPYYKOJ34D6XM77c6rFG4HP/5aFoV3a4PtpA40+/8N09fJhXaPx0d32D5AY4uel16xo6d5CU9N5+w3WBYUjusegc7R75XZy8JJm5udt+cdfAPhEdTOCUY17vdYAaBghEwCuihBEysqaqojNapWkn0BqrGlCIZcZbRKxpHHPDGdZ89hg/HbsMqZakR/jKD9vBfbNuRkKB5qw3KFP2BMju1pMgLdHsJ+32fE6rKlpkMlkUGhOkjucLBPMTV9hTve4ELw/yfDCmN09Go/c2BldHRhB2RFPjuqGJ0eZbq7x8ZJj93PZSH/lFwDqqS3m3mZ4M5NgQw89ABif2hZXK+qQYaSHUKCvl00fgbhQP2x9+kajQUxcmH4uTbfYEKO9+U7NvcVg+5t6xOC50d3Rq20o7l6002I5/pTeDl/vPo//u6UbIoN88em9mZj2xV68ND4FH/9+EnvPlpjc9qsH+6Osuh7hDs3l5lqskWlGyTHBVmfmC8hNds0uFvp3nOaGNxdG9rFLct4kiO7ol5lD8PbEVKMDqTlD97gQPDS0k1W1a87g66VwOF+GrNNGp+YlxM7xfDyFTCbDrJu7YkzveCeM86q26tFBWGaka7m9IpugJkwuV4/4nWZiHJTGMYmlc6MbhGgGiRvdO85sLZ7mOhAd7Gs0CJJdH5U8q2OkxcBqfFo83vhTKk6/PlrbizKrYyT+eHaE0QEvG1PIZRaDGDeO7wGwRqZZ5M6+CVV1KkQE+pi9IB2W2iNOVowTwvoeGu8pJ0BlYzy6WeqFYhGMmxW7bNrO2ZoqoOocHex2VZ/GmOrV42ztwm27Y21JbM390L2oNGUit7XaBLn2LtnWpNGmaG7tEhOEY4UV2mYxd9L4E/LBXTfg6KVy9Gpr/jzMyE5GcnSQ3vg99ujUJhD/vN14k7vm86tbxs1PDcegf25w6JjuiIFMMwgL8EGYFdeSn6W+UMf/hj+gJ0Q8bsReAPp3CEp4QQbJ5jLVufitn6+8w2BZS78D1vXl/f3Qv5NzelxY0q9jBJ4f00MvSbK1sKf3xg2JYdhztgR/ciDQjA52Tk3CzT1i8bdBHZCWGOaU/Xmi5Q/0x7aTV50+zkxT8PVSWDXirZ+3Ardb+fmSyWCyWujGbtEmc7s0dDdtFx6AlY8Mwoljh3Bq/Sarju8JWs+Vw01YvskzvoJSZ3AnW4aodmFnBJtsfmo4Ijy4jdZac8b2wLHCimYdXEomk+G+QZbnoGpKXk7ozTSwc/MEfp/dl4UDF0odGmU1OsQPS6b2tXrUZFPkchmes2POHlsJV3ZbsiA80MeqJhKyTs+2oai97I9Tri6IE7Hh3cXeMjH6KQDU6Ax/XQ8vvK8cjw+U4wwmmDSWB+Np2oUH2J3M6EmmDuyAubf1cotmi+bwyI2d0S02GJOcMJJs73ZhWPnIIOx+LtsJJTMt0NcL/TpGOjwGyrCu0UYTSjXWPGZ83JGWSJMYP6yr5dFlXc1Y7zhyby3/yuFmGn9FvBSmvzRKeGGJUt3lUoIcdSbjThkWKseis+wCshV7nFNQIieYdXNX7aB5ztDTQu6BRmyIHwrKarSTg7qj7nEh+Pqh/pixLBdzxjZ9rYsr3TeoA7I6RKJLbNM0b8pkrhkLp7XckLj7y2Qg42Ido8x/sUusnIupBr6ohPmxRtRT07v5J5LICX6aMQSHL5W59fwwgHqSwC1WTNHQ1PokqscSUchlUEkNEYHdU0Ncp8kXkclk6GXFcAhyGSAJwN9C3kdjO54Zgf3nS/G3T13bgaEpeMnlgEp/WZ/EMOw9W2J1nk1Lx0CmmcU0mqdDIZch/9UcyGUydPy/1U167B8k9xxemsjZQgO8my2ZuiVoE+yLnf83AoG+XkiZ8xMA4PXbetndC2nD48OQV1COYSbmCjPlu78PxOtrjto8Om10iB+ye/hpB8cb/K+GnjmP39zFpn01HlDR1elDi6f2xZb/LNM+Htg5Ep9MzURpdX2TdE/3RMyRaWZ3ZiYajGTppZA32dDu1ubPnJZicVhyzoy4RNS0pg/vrB2zxFmiQ/wQqJOcnNnB/tqsDlGBGNUz1uaml9SEMHz5QD+rmxAbS4gI0BsgL9TfG9NvTDazhaFbesXi5Qk9EeCjwPCubYxOiJl5PffJ2rnFHNE46fyze7PgpZA7GMS4b3K3PVgj08x8vOSYe1svfLnzbLMcz9Q8RtVC/0vwu9QLVxGKZNkFeMuUzVE0IrLRl/f3w/lrVfjT9Qvo/Oecf4yVjwzC5YpadGzjud31lz/QD3PXHMUrjWZ/t4ZMJsPd/drjrqxEk4HY4ql9kXuuBFkOBHv2kMlkNt/0ZnWINDuyrzkp8SEI9Xf+/IDOxkDGxWJDjU8J7yx7RWfESNcMBtm7gCjt/E3nRRSuQn0HJGthkTpRS6JuLmvaJjN7a0PcSVbHSKwwMaeRtczVJgX6epmcZNTdzMhORnSwr101eD9OHwSZzP2TmhnIuMjP/xiiHe3XVnXC+rdNCS+slPobeUaGbZJ7zCo9bXgnyysREZHN/LwVuNfOcaSaKuXB2RjIuEiXGNO9kdoE++Jyea3J5/eLjkiUinBScJAoIiJq3dw22beqqgrt27fH448/7uqiNDtLo7Aq4YUV0iDsF5ZrMhJtnBl2m9Syx7MgImr1WlgGgdsGMq+++ir69XPeLKqeRGFje2SwkTmKVj4yCIdeHGkwINgQC90hd4suWKps2pFTG2sNI/oSETnM1X3B3ZRbBjLHjx/H0aNHkZOT4+qiuERkkI/BHC2Nu2xb0rNtqF5XSo1Ppva1sKUMlxFm07FssUXVE58rb9I+HtApElMGJDXZ8YiIqGWzOZDZtGkTxo4di/j4eMhkMqxYscJgnQULFiApKQl+fn7IysrCzp07bTrG448/jrlz59patBZDIZdh9/PZ2sGdAKBHfMMgTcEOTkTnSntEMq6goVfEF/f3MxpwERERWcPmQKayshKpqalYsGCB0eeXL1+OmTNnYs6cOdizZw9SU1MxcuRIFBUVaddJS0tDz549Df4uXryI77//Hl26dEGXLraNxtiS+Cjk8PVSwFth/O0Z3EW/29/bf04zuS9js9qO7m05SXiFyrGui0RERM3B5lvhnJwcs00+8+bNw/3334+pU6cCABYuXIhVq1Zh0aJFePrppwEAubm5Jrffvn07li1bhq+//hoVFRWor69HSEgIZs+ebXT92tpa1NY29PApKyuz9SW5jUdu7Iw9Z68hu0eM2fV0Z2c99koObO0h9+5f+uCGxHC8vPKwyXVOi6aZbE93pOGM9uFNcgwiImo9nFqnX1dXh927d+OZZ57RLpPL5cjOzsa2bdus2sfcuXO1zUpLlizBwYMHTQYxmvVffPFFxwruJszNEmxqzhIfLzmUKsmm48jlMrQNszQQn/PHD/hV1QfS9UrA/S/cjCAm+RIRkYOcmux75coVqFQqxMTo1yjExMSgoKDAmYfSeuaZZ1BaWqr9O3fuXJMcx9VC/BqGiY5vFISYG3XR1HPWJL+vVmVZVzgr6XYXD/Hz9pjBloiIyH259S3xlClTLK7j6+sLX9+WOQNoWEBD8OLvo8Afz2ajXiXhq136wZpCLsNL41Pwx65KoNB5xz8mEpAjdkImY5c/IiJyT04NZKKioqBQKFBYqH81LSwsRGxs0+RctGR+3gr8OmsoZDIZfLzkaBNsOmC7p38SOisKsPMH8/sUArBlmBoBGedfIiJqQVraL7pTm5Z8fHyQnp6O9evXa5dJkoT169ejf39j8/2QJR3bBKFDVKBT9pXdPcbm5hyVew41REREBMCOGpmKigrk5+drH586dQq5ubmIiIhAYmIiZs6cicmTJyMjIwOZmZmYP38+Kisrtb2YyHX+MznD5m12SV3RX3GoCUpDRETuRqApuno0LZsDmV27dmH48IaB2mbOnAkAmDx5MpYsWYKJEyfi8uXLmD17NgoKCpCWloa1a9caJACTe0mMCECwnxcOXdTvvl4N22fnJiIi53NWk5C5dAFPTCWwOZAZNmyY0UHWdE2fPh3Tp0+3u1DkPBGBxgORoEbzM7331z7o3S4MXZ9bg1qlbd25TTkutUOy/LxT9kVERGSMW/daIsdNGZCEgxdKcVOjQfYGdY7CnZmJqKlXYVjXNujdLszo9sKBSkbPi+uJiMjTMJDxQGH+3pZXus7PW4H3/nqDwXKZTIa5t/WyuP0JEY8R2GNT+YiIiJoLAxkPdGdWInaduYZhXaOb/Fj1TvqInJGYI0VERM7HQMYD+XoZr2VxhtG94vDt3gvax5KD+etfKYeho/wStkvdHS0aERGRAQ4SQnpentATT4xsmPNJBYVD+7uIKGyWekHJmJmIyC1YM0WNJ2EgQ3oCfb0wbXjnJtt/WkIY3p/UNLVJRETU+vA2mZrVVw/2h48X42ciInIOXlHIqBfG9rBruwIRYfZ5wU7ZRETkRAxkyKiJfRPt2u4PqavllYiIiJyEgQwZ5e9jX5LvedFG+//Gg+mN7h0HXy/HkoeJiIh0MZAhk8anxdu8TS18sFnVExXCH1uknnrPLWiiLuNERNR6MZAhk976U6pd2+0S3fAf1S0oQ6CTS0RERKSPgQyZ5KWQw1th74B4njYRPBEReSIGMuQ0P6n6uroIRERkQUvrPcpAhswam2p9nswR0b4JS0JERGSIgUwL0hSNOentw5tgr0RE5DqskSGySvvIAFcXgYiIWjgGMmS3CyLK7PM94kKaqSRERNRaMZBpQWoDYpy+z95tw4wu/0Y1BHWCU3UREZFr8UrUgkheAfhYORr18MIMJ+2zc3QQ1l//f77UFlukFFyDuqalh+yM2W1l7IFNRERNjDUyLUwl/FEH7ybZ92HRXhvEAMDvUi+L27wyoSe6x4Vg5/+NaJIyERFR68YaGTLLz7sh1m08d1I1/HBISkKK/LTJ7e/q1x539WO3bCIiahqskSGzZBbahy6aSfiVcXRfIiJqYqyRIYccEu0hqWS4JCJcXRQiIrKCaFnDyDCQIUfJOKIvERG5DJuWyKk+ujvd1UUgIqJWhIEMOVUiR/MlIqJmxECGnKpbbIh2aoIxveNcXBoiImrpmCNDTrfykUE4ebkSvduFurooRETUwjGQIacL9vNGakKYq4tBREStAJuWyGkGdo50dRGIiKiVYSBDTvPZvVmuLgIREbUyDGTIaeRyjuRLROT2WtiAeAxkiIiIyGMxkCEiIiKPxUCG7HJXv0QM79rG1cUgIqJWjt2vWxAvedPHpS+PT0GP+BD0bheGBz7d1eTHIyIiMoeBTAsyoFMk+neMRLe44CbZ/0vjUzC4X5L28YNDO2FD3uUmORYREZE1GMi0IF4KOb58oF+zHa9fx0hkd4/BL0cKm+2YREREupgjQw7p2CbQ1UUgIqJWjDUy5JBpwzsjr6AcE/rEu7ooRETUCjGQIYeE+nvjk3szXV0MIiKykmhhI+KxaYmIiIg8FgMZIiIi8lgMZMhqnEmJiIjcDQMZIiIi8lgMZIiIiMhjMZAhIiIij8VAhoiIiDwWAxkiIiLyWAxkiIiIWhPBAfGa3KlTpzB8+HD06NEDvXr1QmVlpauLRERE1CK0rDDGTacomDJlCl555RUMHjwYxcXF8PX1dXWRiIiIyA25XSBz6NAheHt7Y/DgwQCAiIgIF5eIGnBIPCIici82Ny1t2rQJY8eORXx8PGQyGVasWGGwzoIFC5CUlAQ/Pz9kZWVh586dVu//+PHjCAoKwtixY3HDDTfgtddes7WI1ERkMgYyRETkXmyukamsrERqairuvfde3HbbbQbPL1++HDNnzsTChQuRlZWF+fPnY+TIkcjLy0N0dDQAIC0tDUql0mDbn3/+GUqlEr///jtyc3MRHR2NUaNGoW/fvrjpppvseHlERETUktkcyOTk5CAnJ8fk8/PmzcP999+PqVOnAgAWLlyIVatWYdGiRXj66acBALm5uSa3b9u2LTIyMpCQkAAAuOWWW5Cbm2sykKmtrUVtba32cVlZma0viYiIiDyUU3st1dXVYffu3cjOzm44gFyO7OxsbNu2zap99O3bF0VFRbh27RokScKmTZvQvXt3k+vPnTsXoaGh2j9NAEREREQtn1MDmStXrkClUiEmJkZveUxMDAoKCqzah5eXF1577TUMGTIEvXv3RnJyMsaMGWNy/WeeeQalpaXav3Pnzjn0GoiIiMhzuF2vJcBy85UuX19fds8mIiJqpZxaIxMVFQWFQoHCwkK95YWFhYiNjXXmoYiIiMgeLWxEPKcGMj4+PkhPT8f69eu1yyRJwvr169G/f39nHoqIiIjI9qaliooK5Ofnax+fOnUKubm5iIiIQGJiImbOnInJkycjIyMDmZmZmD9/PiorK7W9mIiIiIicxeZAZteuXRg+fLj28cyZMwEAkydPxpIlSzBx4kRcvnwZs2fPRkFBAdLS0rB27VqDBGAiIiIiR9kcyAwbNgzCwsyZ06dPx/Tp0+0uFBEREZE13HL2ayIiIiJrMJAhIiIij8VAhoiIqFVpWf2vGcgQERGRx2IgQ0RE1KqwRoaIiIjILTCQISIiIo/FQIaIiIg8FgMZIiIi8lgMZMhqMpmrS0BERKSPgQwRERF5LAYyRERE5LEYyBAREZHHYiBDRETUioiWNR4eAxkiIiLyXAxkiIiIyGMxkCEiIiKPxUCGiIiIPBYDGSIiIvJYDGTIahzZl4ioJWhZ3ZYYyJANGMkQEZF7YSBDREREHouBDBEREXksBjJEREStCEf2JSIiInITDGSIiIjIYzGQISIiIo/FQIaIiIg8FgMZIiIi8lgMZMhqMg6IR0REboaBDBEREXksBjJERETksRjIEBERtSItbDw8BjJERETkuRjIEBERkcdiIENEREQei4EMERFRKyJrYVkyDGSIiIjIYzGQISIiIo/FQIasx4F9iYjIzTCQISIiIo/FQIaIiKgVEWZyfQ9IHQAAJ6T4ZiqN47xcXQAiIiJyDxulNJwQ8Tgv2ri6KFZjIENEREQAABUUOC3iXF0Mm7BpiYiIyAOoBC/ZxvCsEBERubHlyuG4JCLxlWqYU/an8vJ3yn7cBZuWiIiI3NglRGK5arjT9lfjH4etqhSUIAgznLZX12EgQ0RE1JrIZNgpuru6FE7DpiUiIiLyWAxkiIiIyGMxkCGrcYYCIiLP17LmvnbTQObtt99GSkoKevTogUcffRTC3DCE1OTypARcEaGoDmzn6qIQERHpcbtk38uXL+O9997DoUOH4O3tjSFDhmD79u3o37+/q4vWaq2RsgAIZMsVri4KERGRHrcLZABAqVSipqYGAFBfX4/o6GgXl4jYsERERO7I5qalTZs2YezYsYiPj4dMJsOKFSsM1lmwYAGSkpLg5+eHrKws7Ny50+r9t2nTBo8//jgSExMRHx+P7OxsdOrUydZiEhERUStgcyBTWVmJ1NRULFiwwOjzy5cvx8yZMzFnzhzs2bMHqampGDlyJIqKirTrpKWloWfPngZ/Fy9exLVr17By5UqcPn0aFy5cwNatW7Fp0yb7XyERERG1WDY3LeXk5CAnJ8fk8/PmzcP999+PqVOnAgAWLlyIVatWYdGiRXj66acBALm5uSa3//rrr9G5c2dEREQAAEaPHo3t27djyJAhRtevra1FbW2t9nFZWZmtL4mIiIg8lFN7LdXV1WH37t3Izs5uOIBcjuzsbGzbts2qfSQkJGDr1q2oqamBSqXCxo0b0bVrV5Prz507F6Ghodq/hIQEh18HEREReQanBjJXrlyBSqVCTEyM3vKYmBgUFBRYtY9+/frhlltuQZ8+fdC7d2906tQJ48aNM7n+M888g9LSUu3fuXPnHHoNRERE5DncstfSq6++ildffdWqdX19feHr69vEJSIiIiJ35NQamaioKCgUChQWFuotLywsRGxsrDMPRS4gk7ELNhGRp2tpY8w6NZDx8fFBeno61q9fr10mSRLWr1/PAe2IiIjI6WxuWqqoqEB+fr728alTp5Cbm4uIiAgkJiZi5syZmDx5MjIyMpCZmYn58+ejsrJS24uJiIiIyFlsDmR27dqF4cOHax/PnDkTADB58mQsWbIEEydOxOXLlzF79mwUFBQgLS0Na9euNUgAJiIiInKUzYHMsGHDLE7iOH36dEyfPt3uQjUHlUqF+vp6VxfDI7QNVs+xJFPVa6eOcGfe3t5QKDgvFBFRa+CWvZaakhACBQUFKCkpcXVRPMYLw9VzXQXXF+PUqVIXl8Y6YWFhiI2NZYIyEZENvrg/CzOW5eLVW3u5uihWa3WBjCaIiY6ORkBAAC90VqjzV4+W3C7cH4G+3i4ujXlCCFRVVWmnxIiLi3NxiYiIPMeATlHY+Wy25RXdSKsKZFQqlTaIiYyMdHVxPIbMS92c5OPrBz8/9w5kAMDf3x8AUFRUhOjoaDYzERG1YE7tfu3uNDkxAQEBLi4JNTXNe8w8KCLydD3bhgAAbkgMc21B3FSrqpHRYHOSffy8Padmg+8xEbUUi6b0xTe7z+NP6c6ZS7BzdJBT9uMuWmUg44mGDRuGtLQ0zJ8/v9mP3SMuBJIAvBWtqgKPyOOUC9Y2t0TRwX74+7DOTttf5+ggLP1bFtoEt4zpfRjIkEVeDGCI3N5HyjGohTeed3VByCMM7Bzl6iI4DQMZIqIWoAp+ri4CkUvwVtsDXbt2Dffccw/Cw8MREBCAnJwcHD9+XPv8mTNnMHbsWISHhyMwMBApKSlYvXq1dttJkyahTZs28Pf3R3JyMhYvXuyql0JEDtgndQIA7JGSXVwSItdp9TUyQghU16ua/bj+3gq7E1KnTJmC48eP44cffkBISAieeuop3HLLLTh8+DC8vb0xbdo01NXVYdOmTQgMDMThw4cRFKRO7nr++edx+PBhrFmzBlFRUcjPz0d1dbUzXxoRNZONUioOSkm4glBXF4XIZVp9IFNdr0KP2T81+3EPvzQSAT62n35NALNlyxYMGDAAALB06VIkJCRgxYoV+NOf/oSzZ8/i9ttvR69e6pEZO3bsqN3+7Nmz6NOnDzIyMgAASUlJjr8YInIJATkuI9zVxSByKTYteZgjR47Ay8sLWVlZ2mWRkZHo2rUrjhw5AgB49NFH8corr2DgwIGYM2cO9u/fr1334YcfxrJly5CWloYnn3wSW7dubfbXQERE5CytvkbG31uBwy+NdMlxm8rf/vY3jBw5EqtWrcLPP/+MuXPn4q233sIjjzyCnJwcnDlzBqtXr8a6deswYsQITJs2DW+++WaTlYeIiKiptPoaGZlMhgAfr2b/szc/pnv37lAqldixY4d22dWrV5GXl4cePXpolyUkJOChhx7Ct99+i1mzZuHjjz/WPtemTRtMnjwZn3/+OebPn4+PPvrI/hNIRETkQq2+RsbTJCcnY/z48bj//vvx4YcfIjg4GE8//TTatm2L8ePHAwBmzJiBnJwcdOnSBdeuXcOGDRvQvXt3AMDs2bORnp6OlJQU1NbWYuXKldrniIiIPE2rr5HxRIsXL0Z6ejrGjBmD/v37QwiB1atXw9tbPaGjSqXCtGnT0L17d4waNQpdunTB+++/DwDw8fHBM888g969e2PIkCFQKBRYtmyZK18OEdarbgAAbFSlubYgRORxWCPjITZu3Kj9f3h4OD799FOT67777rsmn3vuuefw3HPPObNoRA47IDoiT5mAOrj/7OpE5F5YI0NEboFBDBHZg4EMEREReSwGMkREROSxGMgQERGRx2IgQ0RERB6LgQwRERF5LAYyRERE5LEYyBAREZHHYiBDREREHouBDBn1wgsvIC0tzdXFICIiMouBDBFRC5HePtzVRSBqdpxrqQWrq6uDj4+Pq4thk/r6eu3kl0RkvUMvjoS/t8LVxSBqdqyR8RDl5eWYNGkSAgMDERcXh7fffhvDhg3DjBkztOskJSXh5Zdfxj333IOQkBA88MADAICnnnoKXbp0QUBAADp27Ijnn38e9fX1evt//fXXERMTg+DgYNx3332oqakxW56NGzdCJpNh/fr1yMjIQEBAAAYMGIC8vDy99T744AN06tQJPj4+6Nq1Kz777DO952UyGT744AOMGzcOgYGBePXVV7XNWosWLUJiYiKCgoLw97//HSqVCv/6178QGxuL6OhovPrqqw6cUaKWJdDXC3K5zNXFIGp2DGSEAJR1zf8nhE3FnDlzJrZs2YIffvgB69atw++//449e/YYrPfmm28iNTUVe/fuxfPPPw8ACA4OxpIlS3D48GH8+9//xscff4y3335bu81XX32FF154Aa+99hp27dqFuLg4vP/++1aV69lnn8Vbb72FXbt2wcvLC/fee6/2ue+++w6PPfYYZs2ahYMHD+LBBx/E1KlTsWHDBr19vPDCC7j11ltx4MAB7fYnTpzAmjVrsHbtWnz55Zf473//i9GjR+P8+fP47bff8M9//hPPPfccduzYYdN5JGpJJmYkAADu6d/exSUhch2ZEDZeUd1cWVkZQkNDUVpaipCQEL3nampqcOrUKXTo0AF+fn7qhco64Pe3mr+gg2cBXtY1+5SXlyMyMhJffPEF7rjjDgBAaWkp4uPjcf/992P+/PkA1DUyffr0wXfffWd2f2+++SaWLVuGXbt2AQAGDBiAPn36YMGCBdp1+vXrh5qaGuTm5hrdx8aNGzF8+HD88ssvGDFiBABg9erVGD16NKqrq+Hn54eBAwciJSUFH330kXa7P//5z6isrMSqVasAqGtkZsyYoRdYvfDCC3jjjTdQUFCA4OBgAMCoUaOQl5eHEydOQC5Xx9/dunXDlClT8PTTTxuUz+h7TW4r6elV2v+ffn20C0viWepVEvafL0FquzB4KXhfSp7N3PXbHH7yPcDJkydRX1+PzMxM7bLQ0FB07drVYN2MjAyDZcuXL8fAgQMRGxuLoKAgPPfcczh79qz2+SNHjiArK0tvm/79+1tVtt69e2v/HxcXBwAoKirS7nfgwIF66w8cOBBHjhyxWOakpCRtEAMAMTEx6NGjhzaI0SzTHIuoNfJWyJHePoJBDLVqTPZVeKtrR1xx3CYQGBio93jbtm2YNGkSXnzxRYwcORKhoaFYtmwZ3nrLObVQuom5Mpm6fV6SJJv20bjMjfer2bexZbYei4iIWhaG8TKZuomnuf9k1ifldezYEd7e3vjjjz+0y0pLS3Hs2DGL227duhXt27fHs88+i4yMDCQnJ+PMmTN663Tv3t0g12T79u1Wl8+U7t27Y8uWLXrLtmzZgh49eji8byIiIoA1Mh4hODgYkydPxhNPPIGIiAhER0djzpw5kMvl2loQU5KTk3H27FksW7YMffv2xapVqwxyaB577DFMmTIFGRkZGDhwIJYuXYpDhw6hY8eODpX7iSeewJ///Gf06dMH2dnZ+PHHH/Htt9/il19+cWi/REREGqyR8RDz5s1D//79MWbMGGRnZ2PgwIHo3r27xUTWcePG4R//+AemT5+OtLQ0bN26VdubSWPixIl4/vnn8eSTTyI9PR1nzpzBww8/7HCZJ0yYgH//+9948803kZKSgg8//BCLFy/GsGHDHN43tSxf3t8PiREB+Oy+TMsrExHpYK8lD1VZWYm2bdvirbfewn333efq4ridlvReExG1Bvb2WmLTkofYu3cvjh49iszMTJSWluKll14CAIwfP97FJSMiInIdBjIe5M0330ReXh58fHyQnp6O33//HVFRUa4uFhERkcswkPEQffr0we7du11dDCIiIrfCZF8iIiLyWAxkiIiIyGO1ykCmhXXUIiP4HhMRtQ6tKpDRDHFfVVXl4pJQU9O8x42nNSAiopalVSX7KhQKhIWFaScaDAgIsDgyLnkWIQSqqqpQVFSEsLAwKBQKVxeJiIiaUKsKZAAgNjYWADhrcgsXFhamfa+JiKjlanWBjEwmQ1xcHKKjo1FfX+/q4lAT8Pb2Zk0MEVEr0eoCGQ2FQsGLHRERkYdrVcm+RERE1LIwkCEiIiKPxUCGiIiIPFaLy5HRDIRWVlbm4pIQERGRtTTXbVsHNG1xgUx5eTkAICEhwcUlISIiIluVl5cjNDTU6vVlooWN5S5JEi5evIjg4GCnD3ZXVlaGhIQEnDt3DiEhIU7dNzXgeW4ePM/Ng+e5efA8N5+mOtdCCJSXlyM+Ph5yufWZLy2uRkYul6Ndu3ZNeoyQkBB+UZoBz3Pz4HluHjzPzYPnufk0xbm2pSZGg8m+RERE5LEYyBAREZHHYiBjA19fX8yZMwe+vr6uLkqLxvPcPHiemwfPc/PgeW4+7nauW1yyLxEREbUerJEhIiIij8VAhoiIiDwWAxkiIiLyWAxkiIiIyGMxkLHSggULkJSUBD8/P2RlZWHnzp2uLpLbmDt3Lvr27Yvg4GBER0djwoQJyMvL01unpqYG06ZNQ2RkJIKCgnD77bejsLBQb52zZ89i9OjRCAgIQHR0NJ544gkolUq9dTZu3IgbbrgBvr6+6Ny5M5YsWWJQntbyXr3++uuQyWSYMWOGdhnPs3NcuHABd911FyIjI+Hv749evXph165d2ueFEJg9ezbi4uLg7++P7OxsHD9+XG8fxcXFmDRpEkJCQhAWFob77rsPFRUVeuvs378fgwcPhp+fHxISEvCvf/3LoCxff/01unXrBj8/P/Tq1QurV69umhftAiqVCs8//zw6dOgAf39/dOrUCS+//LLeXDs817bbtGkTxo4di/j4eMhkMqxYsULveXc6p9aUxSJBFi1btkz4+PiIRYsWiUOHDon7779fhIWFicLCQlcXzS2MHDlSLF68WBw8eFDk5uaKW265RSQmJoqKigrtOg899JBISEgQ69evF7t27RL9+vUTAwYM0D6vVCpFz549RXZ2tti7d69YvXq1iIqKEs8884x2nZMnT4qAgAAxc+ZMcfjwYfHuu+8KhUIh1q5dq12ntbxXO3fuFElJSaJ3797iscce0y7neXZccXGxaN++vZgyZYrYsWOHOHnypPjpp59Efn6+dp3XX39dhIaGihUrVoh9+/aJcePGiQ4dOojq6mrtOqNGjRKpqali+/bt4vfffxedO3cWd955p/b50tJSERMTIyZNmiQOHjwovvzyS+Hv7y8+/PBD7TpbtmwRCoVC/Otf/xKHDx8Wzz33nPD29hYHDhxonpPRxF599VURGRkpVq5cKU6dOiW+/vprERQUJP79739r1+G5tt3q1avFs88+K7799lsBQHz33Xd6z7vTObWmLJYwkLFCZmammDZtmvaxSqUS8fHxYu7cuS4slfsqKioSAMRvv/0mhBCipKREeHt7i6+//lq7zpEjRwQAsW3bNiGE+osnl8tFQUGBdp0PPvhAhISEiNraWiGEEE8++aRISUnRO9bEiRPFyJEjtY9bw3tVXl4ukpOTxbp168TQoUO1gQzPs3M89dRTYtCgQSaflyRJxMbGijfeeEO7rKSkRPj6+oovv/xSCCHE4cOHBQDxxx9/aNdZs2aNkMlk4sKFC0IIId5//30RHh6uPe+aY3ft2lX7+M9//rMYPXq03vGzsrLEgw8+6NiLdBOjR48W9957r96y2267TUyaNEkIwXPtDI0DGXc6p9aUxRpsWrKgrq4Ou3fvRnZ2tnaZXC5HdnY2tm3b5sKSua/S0lIAQEREBABg9+7dqK+v1zuH3bp1Q2JiovYcbtu2Db169UJMTIx2nZEjR6KsrAyHDh3SrqO7D806mn20lvdq2rRpGD16tMG54Hl2jh9++AEZGRn405/+hOjoaPTp0wcff/yx9vlTp06hoKBA7/WHhoYiKytL7zyHhYUhIyNDu052djbkcjl27NihXWfIkCHw8fHRrjNy5Ejk5eXh2rVr2nXMvReebsCAAVi/fj2OHTsGANi3bx82b96MnJwcADzXTcGdzqk1ZbEGAxkLrly5ApVKpffDDwAxMTEoKChwUanclyRJmDFjBgYOHIiePXsCAAoKCuDj44OwsDC9dXXPYUFBgdFzrHnO3DplZWWorq5uFe/VsmXLsGfPHsydO9fgOZ5n5zh58iQ++OADJCcn46effsLDDz+MRx99FJ988gmAhvNk7vUXFBQgOjpa73kvLy9EREQ45b1oCecZAJ5++mn85S9/Qbdu3eDt7Y0+ffpgxowZmDRpEgCe66bgTufUmrJYo8XNfk2uNW3aNBw8eBCbN292dVFanHPnzuGxxx7DunXr4Ofn5+ritFiSJCEjIwOvvfYaAKBPnz44ePAgFi5ciMmTJ7u4dC3LV199haVLl+KLL75ASkoKcnNzMWPGDMTHx/Nck9VYI2NBVFQUFAqFQc+PwsJCxMbGuqhU7mn69OlYuXIlNmzYgHbt2mmXx8bGoq6uDiUlJXrr657D2NhYo+dY85y5dUJCQuDv79/i36vdu3ejqKgIN9xwA7y8vODl5YXffvsN77zzDry8vBATE8Pz7ARxcXHo0aOH3rLu3bvj7NmzABrOk7nXHxsbi6KiIr3nlUoliouLnfJetITzDABPPPGEtlamV69euPvuu/GPf/xDW+PIc+187nROrSmLNRjIWODj44P09HSsX79eu0ySJKxfvx79+/d3YcnchxAC06dPx3fffYdff/0VHTp00Hs+PT0d3t7eeucwLy8PZ8+e1Z7D/v3748CBA3pfnnXr1iEkJER7Uenfv7/ePjTraPbR0t+rESNG4MCBA8jNzdX+ZWRkYNKkSdr/8zw7buDAgQbDBxw7dgzt27cHAHTo0AGxsbF6r7+srAw7duzQO88lJSXYvXu3dp1ff/0VkiQhKytLu86mTZtQX1+vXWfdunXo2rUrwsPDteuYey88XVVVFeRy/cuQQqGAJEkAeK6bgjudU2vKYhWr04JbsWXLlglfX1+xZMkScfjwYfHAAw+IsLAwvZ4frdnDDz8sQkNDxcaNG8WlS5e0f1VVVdp1HnroIZGYmCh+/fVXsWvXLtG/f3/Rv39/7fOabsE333yzyM3NFWvXrhVt2rQx2i34iSeeEEeOHBELFiww2i24Nb1Xur2WhOB5doadO3cKLy8v8eqrr4rjx4+LpUuXioCAAPH5559r13n99ddFWFiY+P7778X+/fvF+PHjjXZf7dOnj9ixY4fYvHmzSE5O1uu+WlJSImJiYsTdd98tDh48KJYtWyYCAgIMuq96eXmJN998Uxw5ckTMmTPHY7sEGzN58mTRtm1bbffrb7/9VkRFRYknn3xSuw7Pte3Ky8vF3r17xd69ewUAMW/ePLF3715x5swZIYR7nVNrymIJAxkrvfvuuyIxMVH4+PiIzMxMsX37dlcXyW0AMPq3ePFi7TrV1dXi73//uwgPDxcBAQHi1ltvFZcuXdLbz+nTp0VOTo7w9/cXUVFRYtasWaK+vl5vnQ0bNoi0tDTh4+MjOnbsqHcMjdb0XjUOZHienePHH38UPXv2FL6+vqJbt27io48+0ntekiTx/PPPi5iYGOHr6ytGjBgh8vLy9Na5evWquPPOO0VQUJAICQkRU6dOFeXl5Xrr7Nu3TwwaNEj4+vqKtm3bitdff92gLF999ZXo0qWL8PHxESkpKWLVqlXOf8EuUlZWJh577DGRmJgo/Pz8RMeOHcWzzz6r16WX59p2GzZsMPqbPHnyZCGEe51Ta8piiUwInSEUiYiIiDwIc2SIiIjIYzGQISIiIo/FQIaIiIg8FgMZIiIi8lgMZIiIiMhjMZAhIiIij8VAhoiIiDwWAxkicsiwYcMwY8YMVxdDj0wmw4oVK1xdDCJqBhwQj4gcUlxcDG9vbwQHByMpKQkzZsxotsDmhRdewIoVK5Cbm6u3vKCgAOHh4fD19W2WchCR63i5ugBE5NkiIiKcvs+6ujr4+PjYvX1Lm7GYiExj0xIROUTTtDRs2DCcOXMG//jHPyCTySCTybTrbN68GYMHD4a/vz8SEhLw6KOPorKyUvt8UlISXn75Zdxzzz0ICQnBAw88AAB46qmn0KVLFwQEBKBjx454/vnntbPtLlmyBC+++CL27dunPd6SJUsAGDYtHThwADfeeCP8/f0RGRmJBx54ABUVFdrnp0yZggkTJuDNN99EXFwcIiMjMW3aNL2ZfYnIPTGQISKn+Pbbb9GuXTu89NJLuHTpEi5dugQAOHHiBEaNGoXbb78d+/fvx/Lly7F582ZMnz5db/s333wTqamp2Lt3L55//nkAQHBwMJYsWYLDhw/j3//+Nz7++GO8/fbbAICJEydi1qxZSElJ0R5v4sSJBuWqrKzEyJEjER4ejj/++ANff/01fvnlF4Pjb9iwASdOnMCGDRvwySefYMmSJdrAiIjcF5uWiMgpIiIioFAoEBwcrNe0M3fuXEyaNEmbN5OcnIx33nkHQ4cOxQcffAA/Pz8AwI033ohZs2bp7fO5557T/j8pKQmPP/44li1bhieffBL+/v4ICgqCl5eX2aakL774AjU1Nfj0008RGBgIAHjvvfcwduxY/POf/0RMTAwAIDw8HO+99x4UCgW6deuG0aNHY/369bj//vudcn6IqGkwkCGiJrVv3z7s378fS5cu1S4TQkCSJJw6dQrdu3cHAGRkZBhsu3z5crzzzjs4ceIEKioqoFQqERISYtPxjxw5gtTUVG0QAwADBw6EJEnIy8vTBjIpKSlQKBTadeLi4nDgwAGbjkVEzY+BDBE1qYqKCjz44IN49NFHDZ5LTEzU/l830ACAbdu2YdKkSXjxxRcxcuRIhIaGYtmyZXjrrbeapJze3t56j2UyGSRJapJjEZHzMJAhIqfx8fGBSqXSW3bDDTfg8OHD6Ny5s0372rp1K9q3b49nn31Wu+zMmTMWj9dY9+7dsWTJElRWVmqDpS1btkAul6Nr1642lYmI3A+TfYnIaZKSkrBp0yZcuHABV65cAaDuebR161ZMnz4dubm5OH78OL7//nuDZNvGkpOTcfbsWSxbtgwnTpzAO++8g++++87geKdOnUJubi6uXLmC2tpag/1MmjQJfn5+mDx5Mg4ePIgNGzbgkUcewd13361tViIiz8VAhoic5qWXXsLp06fRqVMntGnTBgDQu3dv/Pbbbzh27BgGDx6MPn36YPbs2YiPjze7r3HjxuEf//gHpk+fjrS0NGzdulXbm0nj9ttvx6hRozB8+HC0adMGX375pcF+AgIC8NNPP6G4uBh9+/bFHXfcgREjRuC9995z3gsnIpfhyL5ERETksVgjQ0RERB6LgQwRERF5LAYyRERE5LEYyBAREZHHYiBDREREHouBDBEREXksBjJERETksRjIEBERkcdiIENEREQei4EMEREReSwGMkREROSxGMgQERGRx/p/xB3BhEzL3xcAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Increasing the max grad norm to 5"
      ],
      "metadata": {
        "id": "d7XSRVu6ilL1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "parity_net = ParityNet(hidden_dim=3)\n",
        "if CUDA:\n",
        "    parity_net.cuda()\n",
        "parity_trainer = Trainer(parity_net)\n",
        "parity_trainer.lrate = 1e-2\n",
        "losses = []\n",
        "# When set to True the net recieves an error signal after each step\n",
        "# When set to False the net recieves an error signal only once at the end\n",
        "parity_trainer.full_supervision = True\n",
        "# Gradient clipping\n",
        "parity_trainer.max_grad_norm = 5.0\n",
        "# This enables \"curriculum learning\" - we gradually train on\n",
        "# longer and longer sequences\n",
        "#\n",
        "learning_curriculum = True\n",
        "train_and_eval_parity(parity_trainer, learning_curriculum=learning_curriculum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "xPdgc7Z-QvwF",
        "outputId": "6e2be0bd-df57-4115-cdd6-4f5ca99d45fb"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 {'loss': 0.2545917332172394, 'grad_norm': 0.05218580365180969}\n",
            "500 {'loss': 0.2659689784049988, 'grad_norm': 0.04535806551575661}\n",
            "1000 {'loss': 0.2340136021375656, 'grad_norm': 0.0145043870434165}\n",
            "1500 {'loss': 0.11919023841619492, 'grad_norm': 0.09391631186008453}\n",
            "2000 {'loss': 0.22799614071846008, 'grad_norm': 0.026611147448420525}\n",
            "2500 {'loss': 0.23899206519126892, 'grad_norm': 0.03234787657856941}\n",
            "3000 {'loss': 0.12447245419025421, 'grad_norm': 0.08664464205503464}\n",
            "3500 {'loss': 0.24948275089263916, 'grad_norm': 0.022166233509778976}\n",
            "4000 {'loss': 0.18253307044506073, 'grad_norm': 0.049819935113191605}\n",
            "4500 {'loss': 0.28398630023002625, 'grad_norm': 0.07230512797832489}\n",
            "5000 {'loss': 0.2205696702003479, 'grad_norm': 0.056740596890449524}\n",
            "5500 {'loss': 0.19731760025024414, 'grad_norm': 0.024290546774864197}\n",
            "6000 {'loss': 0.23925533890724182, 'grad_norm': 0.017101306468248367}\n",
            "6500 {'loss': 0.20146656036376953, 'grad_norm': 0.06294794380664825}\n",
            "7000 {'loss': 0.20748290419578552, 'grad_norm': 0.06589438021183014}\n",
            "7500 {'loss': 0.14386191964149475, 'grad_norm': 0.04396682232618332}\n",
            "8000 {'loss': 0.19114479422569275, 'grad_norm': 0.02822980284690857}\n",
            "8500 {'loss': 0.16149714589118958, 'grad_norm': 0.03755529224872589}\n",
            "9000 {'loss': 0.15400321781635284, 'grad_norm': 0.01946147345006466}\n",
            "9500 {'loss': 0.1816931664943695, 'grad_norm': 0.007485891692340374}\n",
            "10000 {'loss': 0.12367160618305206, 'grad_norm': 0.04346799477934837}\n",
            "10500 {'loss': 0.025176193565130234, 'grad_norm': 0.015229644253849983}\n",
            "11000 {'loss': 0.016934646293520927, 'grad_norm': 0.03048725426197052}\n",
            "11500 {'loss': 0.15361081063747406, 'grad_norm': 0.06786905974149704}\n",
            "12000 {'loss': 0.16146379709243774, 'grad_norm': 0.0596698597073555}\n",
            "12500 {'loss': 0.04648799076676369, 'grad_norm': 0.03965575620532036}\n",
            "13000 {'loss': 0.06442087143659592, 'grad_norm': 0.025224830955266953}\n",
            "13500 {'loss': 0.14568594098091125, 'grad_norm': 0.061859529465436935}\n",
            "14000 {'loss': 0.16091136634349823, 'grad_norm': 0.03766648471355438}\n",
            "14500 {'loss': 0.03415908291935921, 'grad_norm': 0.027516575530171394}\n",
            "15000 {'loss': 0.07813374698162079, 'grad_norm': 0.013527588918805122}\n",
            "15500 {'loss': 0.006075359880924225, 'grad_norm': 0.012824587523937225}\n",
            "16000 {'loss': 0.06728105247020721, 'grad_norm': 0.08413530141115189}\n",
            "16500 {'loss': 0.000704214267898351, 'grad_norm': 0.0023081982508301735}\n",
            "17000 {'loss': 0.15310534834861755, 'grad_norm': 0.04933927580714226}\n",
            "17500 {'loss': 0.09421893954277039, 'grad_norm': 0.04827365651726723}\n",
            "18000 {'loss': 0.012344352900981903, 'grad_norm': 0.031940657645463943}\n",
            "18500 {'loss': 0.09861025959253311, 'grad_norm': 0.048180777579545975}\n",
            "19000 {'loss': 0.0973484143614769, 'grad_norm': 0.030415376648306847}\n",
            "19500 {'loss': 0.0881095826625824, 'grad_norm': 0.05537845566868782}\n",
            "20000 {'loss': 0.09105832874774933, 'grad_norm': 0.03786524757742882}\n",
            "20500 {'loss': 0.11920170485973358, 'grad_norm': 0.06738271564245224}\n",
            "21000 {'loss': 0.08642934262752533, 'grad_norm': 0.02604234404861927}\n",
            "21500 {'loss': 0.16129353642463684, 'grad_norm': 0.04250776395201683}\n",
            "22000 {'loss': 0.1858445107936859, 'grad_norm': 0.09416525810956955}\n",
            "22500 {'loss': 0.18663813173770905, 'grad_norm': 0.11190220713615417}\n",
            "23000 {'loss': 0.03453581780195236, 'grad_norm': 0.02619609609246254}\n",
            "23500 {'loss': 0.00030356962815858424, 'grad_norm': 0.0008060255786404014}\n",
            "24000 {'loss': 0.09526661783456802, 'grad_norm': 0.03338882699608803}\n",
            "24500 {'loss': 0.10723257064819336, 'grad_norm': 0.10587434470653534}\n",
            "25000 {'loss': 0.016172591596841812, 'grad_norm': 0.04259917512536049}\n",
            "25500 {'loss': 0.07326467335224152, 'grad_norm': 0.019738953560590744}\n",
            "26000 {'loss': 0.0688750371336937, 'grad_norm': 0.052264392375946045}\n",
            "26500 {'loss': 0.004477481357753277, 'grad_norm': 0.00994746945798397}\n",
            "27000 {'loss': 0.05262363702058792, 'grad_norm': 0.060389675199985504}\n",
            "27500 {'loss': 0.012019358575344086, 'grad_norm': 0.03211444988846779}\n",
            "28000 {'loss': 0.0002664382918737829, 'grad_norm': 0.0009059371659532189}\n",
            "28500 {'loss': 0.08944878727197647, 'grad_norm': 0.028446216136217117}\n",
            "29000 {'loss': 0.128733828663826, 'grad_norm': 0.026507588103413582}\n",
            "29500 {'loss': 0.027846403419971466, 'grad_norm': 0.006104046478867531}\n",
            "30000 {'loss': 0.08140556514263153, 'grad_norm': 0.035797130316495895}\n",
            "30500 {'loss': 0.005170698743313551, 'grad_norm': 0.011985493823885918}\n",
            "31000 {'loss': 0.20060321688652039, 'grad_norm': 0.23321251571178436}\n",
            "31500 {'loss': 0.1291414052248001, 'grad_norm': 0.017481032758951187}\n",
            "32000 {'loss': 0.17273934185504913, 'grad_norm': 0.0429399274289608}\n",
            "32500 {'loss': 0.0828070342540741, 'grad_norm': 0.021185530349612236}\n",
            "33000 {'loss': 0.17606709897518158, 'grad_norm': 0.14978283643722534}\n",
            "33500 {'loss': 0.17109829187393188, 'grad_norm': 0.12215515971183777}\n",
            "34000 {'loss': 0.02578519470989704, 'grad_norm': 0.0030070680659264326}\n",
            "34500 {'loss': 0.00021065259352326393, 'grad_norm': 0.0006306985742412508}\n",
            "35000 {'loss': 0.10765598714351654, 'grad_norm': 0.02204679697751999}\n",
            "35500 {'loss': 0.2505071759223938, 'grad_norm': 0.1792214959859848}\n",
            "36000 {'loss': 0.16837210953235626, 'grad_norm': 0.07385420054197311}\n",
            "36500 {'loss': 0.0002202909963671118, 'grad_norm': 0.0007725221221335232}\n",
            "37000 {'loss': 0.00021165637008380145, 'grad_norm': 0.0006411413196474314}\n",
            "37500 {'loss': 0.19374646246433258, 'grad_norm': 0.14831191301345825}\n",
            "38000 {'loss': 0.0044195749796926975, 'grad_norm': 0.011040915735065937}\n",
            "38500 {'loss': 0.057131577283144, 'grad_norm': 0.01850234903395176}\n",
            "39000 {'loss': 0.11038003116846085, 'grad_norm': 0.10676904022693634}\n",
            "39500 {'loss': 0.07386086881160736, 'grad_norm': 0.031486742198467255}\n",
            "40000 {'loss': 0.00018449632625561208, 'grad_norm': 0.0005543621955439448}\n",
            "40500 {'loss': 0.04355558753013611, 'grad_norm': 0.01788550801575184}\n",
            "41000 {'loss': 0.05452984943985939, 'grad_norm': 0.019441969692707062}\n",
            "41500 {'loss': 0.09192517399787903, 'grad_norm': 0.02734958939254284}\n",
            "42000 {'loss': 0.14217320084571838, 'grad_norm': 0.03220351040363312}\n",
            "42500 {'loss': 0.13466817140579224, 'grad_norm': 0.0398733913898468}\n",
            "43000 {'loss': 0.00026008940767496824, 'grad_norm': 0.000805665913503617}\n",
            "43500 {'loss': 0.1887255311012268, 'grad_norm': 0.30593156814575195}\n",
            "44000 {'loss': 0.09474150836467743, 'grad_norm': 0.062439270317554474}\n",
            "44500 {'loss': 0.20759937167167664, 'grad_norm': 0.15821707248687744}\n",
            "45000 {'loss': 0.0430496521294117, 'grad_norm': 0.052100203931331635}\n",
            "45500 {'loss': 0.016866663470864296, 'grad_norm': 0.04714859649538994}\n",
            "46000 {'loss': 0.15726050734519958, 'grad_norm': 0.05312905088067055}\n",
            "46500 {'loss': 0.00020465627312660217, 'grad_norm': 0.0007253444637171924}\n",
            "47000 {'loss': 0.13449949026107788, 'grad_norm': 0.04956696555018425}\n",
            "47500 {'loss': 0.04816807806491852, 'grad_norm': 0.0038071023300290108}\n",
            "48000 {'loss': 0.003932718187570572, 'grad_norm': 0.008568767458200455}\n",
            "48500 {'loss': 0.062073420733213425, 'grad_norm': 0.039222601801157}\n",
            "49000 {'loss': 0.09521770477294922, 'grad_norm': 0.08625785261392593}\n",
            "49500 {'loss': 0.09776852279901505, 'grad_norm': 0.11131924390792847}\n",
            "50000 {'loss': 0.005521283484995365, 'grad_norm': 0.006068216171115637}\n",
            "50500 {'loss': 0.0016706640599295497, 'grad_norm': 0.0013552310410887003}\n",
            "51000 {'loss': 0.0017742295749485493, 'grad_norm': 0.0016372146783396602}\n",
            "51500 {'loss': 0.0008219486335292459, 'grad_norm': 0.0006049732910469174}\n",
            "52000 {'loss': 0.0007750184158794582, 'grad_norm': 0.0009877148550003767}\n",
            "52500 {'loss': 0.0010652600321918726, 'grad_norm': 0.0008015627390705049}\n",
            "53000 {'loss': 0.001107390969991684, 'grad_norm': 0.0007592033944092691}\n",
            "53500 {'loss': 0.0009291338501498103, 'grad_norm': 0.0006326064467430115}\n",
            "54000 {'loss': 0.0009602904901839793, 'grad_norm': 0.0006604270893149078}\n",
            "54500 {'loss': 0.0008520570117980242, 'grad_norm': 0.0008699255995452404}\n",
            "55000 {'loss': 0.0007442834903486073, 'grad_norm': 0.0005548871704377234}\n",
            "55500 {'loss': 0.0002496427914593369, 'grad_norm': 0.000261411041719839}\n",
            "56000 {'loss': 0.0006707631982862949, 'grad_norm': 0.0005486214067786932}\n",
            "56500 {'loss': 0.000526541261933744, 'grad_norm': 0.0004683634906541556}\n",
            "57000 {'loss': 0.0005677386652678251, 'grad_norm': 0.0004732661764137447}\n",
            "57500 {'loss': 0.00011096072557847947, 'grad_norm': 0.00038032486918382347}\n",
            "58000 {'loss': 0.0004392679547891021, 'grad_norm': 0.0004114901530556381}\n",
            "58500 {'loss': 0.00047952955355867743, 'grad_norm': 0.0003226937842555344}\n",
            "59000 {'loss': 0.00046674677287228405, 'grad_norm': 0.00031723457504995167}\n",
            "59500 {'loss': 0.0002846800780389458, 'grad_norm': 0.00025699520483613014}\n",
            "60000 {'loss': 0.00013684695295523852, 'grad_norm': 0.00027454050723463297}\n",
            "60077 Increasing seq length to:  20\n",
            "60500 {'loss': 0.00012806984886992723, 'grad_norm': 0.000457643938716501}\n",
            "61000 {'loss': 0.00040476644062437117, 'grad_norm': 0.0002744756930042058}\n",
            "61500 {'loss': 0.00041350233368575573, 'grad_norm': 0.0003250509616918862}\n",
            "62000 {'loss': 0.00042486359598115087, 'grad_norm': 0.0003408112970646471}\n",
            "62500 {'loss': 0.0003906837373506278, 'grad_norm': 0.0002986321924254298}\n",
            "63000 {'loss': 0.000351288472302258, 'grad_norm': 0.00023730748216621578}\n",
            "63500 {'loss': 0.00037772938958369195, 'grad_norm': 0.0002583409659564495}\n",
            "64000 {'loss': 0.00019073383009526879, 'grad_norm': 0.0002401440724497661}\n",
            "64500 {'loss': 0.0002838760847225785, 'grad_norm': 0.0001890901185106486}\n",
            "65000 {'loss': 0.00032254820689558983, 'grad_norm': 0.0002529036137275398}\n",
            "65500 {'loss': 0.00026975912624038756, 'grad_norm': 0.0002137935080099851}\n",
            "66000 {'loss': 0.0002177435380872339, 'grad_norm': 0.000160102266818285}\n",
            "66500 {'loss': 0.00023937180230859667, 'grad_norm': 0.00019233519560657442}\n",
            "67000 {'loss': 0.00025159958750009537, 'grad_norm': 0.00017363978258799762}\n",
            "67044 Increasing seq length to:  30\n",
            "67500 {'loss': 0.00017422225209884346, 'grad_norm': 0.0001403683127136901}\n",
            "67902 Increasing seq length to:  40\n",
            "68000 {'loss': 0.0002747270918916911, 'grad_norm': 0.00018636438471730798}\n",
            "68500 {'loss': 0.00025760376593098044, 'grad_norm': 0.00017161226423922926}\n",
            "69000 {'loss': 0.00022038770839571953, 'grad_norm': 0.0001444931112928316}\n",
            "69500 {'loss': 0.0002443701378069818, 'grad_norm': 0.00017812610894907266}\n",
            "70000 {'loss': 0.0002194000408053398, 'grad_norm': 0.00015673739835619926}\n",
            "70500 {'loss': 7.809415546944365e-05, 'grad_norm': 0.00016838636656757444}\n",
            "71000 {'loss': 0.0002122108417097479, 'grad_norm': 0.00014445913257077336}\n",
            "71500 {'loss': 0.00022322229051496834, 'grad_norm': 0.00014799609198234975}\n",
            "72000 {'loss': 0.00021689569985028356, 'grad_norm': 0.00014268103404901922}\n",
            "72500 {'loss': 5.1264651119709015e-05, 'grad_norm': 0.00016377304564230144}\n",
            "73000 {'loss': 0.00019872722623404115, 'grad_norm': 0.00013044188381172717}\n",
            "73500 {'loss': 0.00016777559358160943, 'grad_norm': 0.00011024979903595522}\n",
            "74000 {'loss': 0.00017930635658558458, 'grad_norm': 0.00013436978042591363}\n",
            "74500 {'loss': 0.0001869712141342461, 'grad_norm': 0.00012423290172591805}\n",
            "75000 {'loss': 0.00015631670248694718, 'grad_norm': 0.00010917531471932307}\n",
            "75500 {'loss': 0.0001751367381075397, 'grad_norm': 0.00011459035886218771}\n",
            "76000 {'loss': 0.00016079454508144408, 'grad_norm': 0.00010686284076655284}\n",
            "76500 {'loss': 0.00018154548888560385, 'grad_norm': 0.00014944256690796465}\n",
            "77000 {'loss': 0.00015900362632237375, 'grad_norm': 0.000112833411549218}\n",
            "77500 {'loss': 0.0001681222056504339, 'grad_norm': 0.00011230705422349274}\n",
            "78000 {'loss': 0.00016342298476956785, 'grad_norm': 0.00010859798203455284}\n",
            "78500 {'loss': 0.00010170436144107953, 'grad_norm': 8.476608491037041e-05}\n",
            "79000 {'loss': 0.00016108019917737693, 'grad_norm': 0.00010644169378792867}\n",
            "79500 {'loss': 0.00014262546028476208, 'grad_norm': 9.409752965439111e-05}\n",
            "80000 {'loss': 0.00012907276686746627, 'grad_norm': 8.406860433751717e-05}\n",
            "80500 {'loss': 0.00014726367953699082, 'grad_norm': 9.80380063992925e-05}\n",
            "81000 {'loss': 0.0001438971667084843, 'grad_norm': 9.442581358598545e-05}\n",
            "81090 Increasing seq length to:  50\n",
            "81500 {'loss': 0.00015094949048943818, 'grad_norm': 0.00011098929826403037}\n",
            "82000 {'loss': 7.56180306780152e-05, 'grad_norm': 5.677562512573786e-05}\n",
            "82500 {'loss': 0.00013685533485841006, 'grad_norm': 9.327665611635894e-05}\n",
            "83000 {'loss': 0.0001351050304947421, 'grad_norm': 9.128235979005694e-05}\n",
            "83500 {'loss': 0.00012734488700516522, 'grad_norm': 8.629803051007912e-05}\n",
            "83657 Increasing seq length to:  60\n",
            "84000 {'loss': 0.00013250102347228676, 'grad_norm': 8.734026050660759e-05}\n",
            "84500 {'loss': 5.281373887555674e-05, 'grad_norm': 0.00018254228052683175}\n",
            "85000 {'loss': 0.00011718539462890476, 'grad_norm': 9.543393389321864e-05}\n",
            "85500 {'loss': 0.0001055187385645695, 'grad_norm': 6.948706140974537e-05}\n",
            "86000 {'loss': 0.00012476119445636868, 'grad_norm': 8.343195804627612e-05}\n",
            "86500 {'loss': 0.00010588082659523934, 'grad_norm': 9.81221382971853e-05}\n",
            "87000 {'loss': 0.00010435208969283849, 'grad_norm': 7.458720210706815e-05}\n",
            "87157 Increasing seq length to:  70\n",
            "87500 {'loss': 0.00011695642751874402, 'grad_norm': 8.609430369688198e-05}\n",
            "88000 {'loss': 0.00011298962635919452, 'grad_norm': 7.606759754708037e-05}\n",
            "88500 {'loss': 0.00011605264444369823, 'grad_norm': 7.55096334614791e-05}\n",
            "89000 {'loss': 0.00011731202539522201, 'grad_norm': 7.681040005991235e-05}\n",
            "89053 Increasing seq length to:  80\n",
            "89474 Increasing seq length to:  90\n",
            "89500 {'loss': 0.00011463448026916012, 'grad_norm': 7.467038813047111e-05}\n",
            "89656 Increasing seq length to:  100\n",
            "        X:  [1. 1. 0. 1. 0. 0. 0. 1. 1. 1.]\n",
            "predicted:  [1. 0. 0. 1. 1. 1. 1. 0. 1. 0.]\n",
            "   target:  [1. 0. 0. 1. 1. 1. 1. 0. 1. 0.]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Without supervision\n"
      ],
      "metadata": {
        "id": "CUm_Y5wNia41"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "parity_net = ParityNet(hidden_dim=3)\n",
        "if CUDA:\n",
        "    parity_net.cuda()\n",
        "parity_trainer = Trainer(parity_net)\n",
        "parity_trainer.lrate = 1e-2\n",
        "losses = []\n",
        "# When set to True the net recieves an error signal after each step\n",
        "# When set to False the net recieves an error signal only once at the end\n",
        "parity_trainer.full_supervision = False\n",
        "# Gradient clipping\n",
        "parity_trainer.max_grad_norm = 1.0\n",
        "# This enables \"curriculum learning\" - we gradually train on\n",
        "# longer and longer sequences\n",
        "#\n",
        "learning_curriculum = True\n",
        "train_and_eval_parity(parity_trainer, learning_curriculum=learning_curriculum)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "BMZF-yz6iZrl",
        "outputId": "2468ee9e-1009-4dd8-d166-7f4c07406310"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 {'loss': 0.2547242343425751, 'grad_norm': 0.13269034028053284}\n",
            "500 {'loss': 0.22809302806854248, 'grad_norm': 0.072639599442482}\n",
            "1000 {'loss': 0.2569836378097534, 'grad_norm': 0.18050721287727356}\n",
            "1500 {'loss': 0.2613374888896942, 'grad_norm': 0.08353307098150253}\n",
            "2000 {'loss': 0.25712117552757263, 'grad_norm': 0.0811237022280693}\n",
            "2500 {'loss': 0.25780218839645386, 'grad_norm': 0.033301062881946564}\n",
            "3000 {'loss': 0.2246505469083786, 'grad_norm': 0.1965578943490982}\n",
            "3500 {'loss': 0.24679481983184814, 'grad_norm': 0.26270169019699097}\n",
            "4000 {'loss': 0.2259354591369629, 'grad_norm': 0.32567980885505676}\n",
            "4500 {'loss': 0.231822207570076, 'grad_norm': 0.030176203697919846}\n",
            "5000 {'loss': 0.006867943797260523, 'grad_norm': 0.01002766378223896}\n",
            "5500 {'loss': 0.004099911544471979, 'grad_norm': 0.005846798419952393}\n",
            "6000 {'loss': 0.28067275881767273, 'grad_norm': 0.2086915224790573}\n",
            "6500 {'loss': 0.18188241124153137, 'grad_norm': 0.08261780440807343}\n",
            "7000 {'loss': 0.25442957878112793, 'grad_norm': 0.2760899066925049}\n",
            "7500 {'loss': 0.22774021327495575, 'grad_norm': 0.11063964664936066}\n",
            "8000 {'loss': 0.2721294164657593, 'grad_norm': 0.07494676858186722}\n",
            "8500 {'loss': 0.2663842737674713, 'grad_norm': 0.3623770773410797}\n",
            "9000 {'loss': 0.2554793953895569, 'grad_norm': 0.1886991262435913}\n",
            "9500 {'loss': 0.00141717994119972, 'grad_norm': 0.0025650369934737682}\n",
            "10000 {'loss': 0.0017197240376845002, 'grad_norm': 0.0032277796417474747}\n",
            "10500 {'loss': 0.24463272094726562, 'grad_norm': 0.3641596734523773}\n",
            "11000 {'loss': 0.18791954219341278, 'grad_norm': 0.17878052592277527}\n",
            "11500 {'loss': 0.23065149784088135, 'grad_norm': 0.07049451023340225}\n",
            "12000 {'loss': 0.22139163315296173, 'grad_norm': 0.11701439321041107}\n",
            "12500 {'loss': 0.10397132486104965, 'grad_norm': 0.09848561137914658}\n",
            "13000 {'loss': 0.3185012936592102, 'grad_norm': 0.17565815150737762}\n",
            "13500 {'loss': 0.26500123739242554, 'grad_norm': 0.23221027851104736}\n",
            "14000 {'loss': 0.0008790517458692193, 'grad_norm': 0.0016614915803074837}\n",
            "14500 {'loss': 0.1497783213853836, 'grad_norm': 0.14090998470783234}\n",
            "15000 {'loss': 0.29648131132125854, 'grad_norm': 0.2673473656177521}\n",
            "15500 {'loss': 0.25601691007614136, 'grad_norm': 0.21040649712085724}\n",
            "16000 {'loss': 0.24603863060474396, 'grad_norm': 0.03060876950621605}\n",
            "16500 {'loss': 0.1779109537601471, 'grad_norm': 0.12707960605621338}\n",
            "17000 {'loss': 0.00035313895205035806, 'grad_norm': 0.0007028895779512823}\n",
            "17500 {'loss': 0.24343399703502655, 'grad_norm': 0.0671444982290268}\n",
            "18000 {'loss': 0.2879270911216736, 'grad_norm': 0.2750418186187744}\n",
            "18500 {'loss': 0.2416393756866455, 'grad_norm': 0.1287701278924942}\n",
            "19000 {'loss': 0.24566933512687683, 'grad_norm': 0.19861803948879242}\n",
            "19500 {'loss': 0.0009136531734839082, 'grad_norm': 0.0018313153414055705}\n",
            "20000 {'loss': 0.11167643219232559, 'grad_norm': 0.1322576254606247}\n",
            "20500 {'loss': 0.2552708685398102, 'grad_norm': 0.17272664606571198}\n",
            "21000 {'loss': 0.11154767125844955, 'grad_norm': 0.13482488691806793}\n",
            "21500 {'loss': 0.25427258014678955, 'grad_norm': 0.2775046229362488}\n",
            "22000 {'loss': 0.246543288230896, 'grad_norm': 0.04097025468945503}\n",
            "22500 {'loss': 0.028712023049592972, 'grad_norm': 0.06116577237844467}\n",
            "23000 {'loss': 0.2569926083087921, 'grad_norm': 0.14443378150463104}\n",
            "23500 {'loss': 0.20830026268959045, 'grad_norm': 0.045768193900585175}\n",
            "24000 {'loss': 0.11773766577243805, 'grad_norm': 0.1586160957813263}\n",
            "24500 {'loss': 0.18682709336280823, 'grad_norm': 0.0938873291015625}\n",
            "25000 {'loss': 0.0017643555765971541, 'grad_norm': 0.0034603967797011137}\n",
            "25500 {'loss': 0.22647669911384583, 'grad_norm': 0.23374316096305847}\n",
            "26000 {'loss': 0.2411280870437622, 'grad_norm': 0.15253236889839172}\n",
            "26500 {'loss': 0.16606467962265015, 'grad_norm': 0.07826516032218933}\n",
            "27000 {'loss': 0.26945313811302185, 'grad_norm': 0.1769677698612213}\n",
            "27500 {'loss': 0.0012334143975749612, 'grad_norm': 0.002389435190707445}\n",
            "28000 {'loss': 0.18257352709770203, 'grad_norm': 0.10223688930273056}\n",
            "28500 {'loss': 0.0008528673788532615, 'grad_norm': 0.0014521956909447908}\n",
            "29000 {'loss': 0.23328010737895966, 'grad_norm': 0.09325361996889114}\n",
            "29500 {'loss': 0.20494942367076874, 'grad_norm': 0.11965347081422806}\n",
            "30000 {'loss': 0.001059612724930048, 'grad_norm': 0.004753774031996727}\n",
            "30500 {'loss': 0.03890553489327431, 'grad_norm': 0.06369270384311676}\n",
            "31000 {'loss': 0.12318591773509979, 'grad_norm': 0.09105180203914642}\n",
            "31500 {'loss': 0.17122161388397217, 'grad_norm': 0.07051602751016617}\n",
            "32000 {'loss': 0.1556433141231537, 'grad_norm': 0.17128156125545502}\n",
            "32500 {'loss': 0.14604215323925018, 'grad_norm': 0.1367224007844925}\n",
            "33000 {'loss': 0.2840338349342346, 'grad_norm': 0.14311762154102325}\n",
            "33500 {'loss': 0.060652684420347214, 'grad_norm': 0.036515116691589355}\n",
            "34000 {'loss': 0.2810959815979004, 'grad_norm': 0.26995551586151123}\n",
            "34500 {'loss': 0.1603507250547409, 'grad_norm': 0.10033230483531952}\n",
            "35000 {'loss': 0.03795190528035164, 'grad_norm': 0.08727526664733887}\n",
            "35500 {'loss': 0.3846472501754761, 'grad_norm': 0.06952458620071411}\n",
            "36000 {'loss': 0.14948293566703796, 'grad_norm': 0.11037518829107285}\n",
            "36500 {'loss': 0.023168392479419708, 'grad_norm': 0.06002425029873848}\n",
            "37000 {'loss': 0.12593896687030792, 'grad_norm': 0.03920945152640343}\n",
            "37500 {'loss': 0.1692773699760437, 'grad_norm': 0.07543867081403732}\n",
            "38000 {'loss': 0.028648506850004196, 'grad_norm': 0.047253984957933426}\n",
            "38500 {'loss': 0.04488358646631241, 'grad_norm': 0.05038191005587578}\n",
            "39000 {'loss': 0.30349230766296387, 'grad_norm': 0.08512590825557709}\n",
            "39500 {'loss': 0.00582458171993494, 'grad_norm': 0.04211493209004402}\n",
            "40000 {'loss': 0.08903931081295013, 'grad_norm': 0.11969710141420364}\n",
            "40500 {'loss': 0.160735085606575, 'grad_norm': 0.146748349070549}\n",
            "41000 {'loss': 0.22031910717487335, 'grad_norm': 0.1658918410539627}\n",
            "41500 {'loss': 0.06256209313869476, 'grad_norm': 0.19457398355007172}\n",
            "42000 {'loss': 0.09731066972017288, 'grad_norm': 0.04054637625813484}\n",
            "42500 {'loss': 0.20442596077919006, 'grad_norm': 0.16646724939346313}\n",
            "43000 {'loss': 0.3030446171760559, 'grad_norm': 0.10992810875177383}\n",
            "43500 {'loss': 0.22284798324108124, 'grad_norm': 0.0789220854640007}\n",
            "44000 {'loss': 0.1808871328830719, 'grad_norm': 0.09449415653944016}\n",
            "44500 {'loss': 0.013988660648465157, 'grad_norm': 0.03345124050974846}\n",
            "45000 {'loss': 0.1889108419418335, 'grad_norm': 0.16625411808490753}\n",
            "45500 {'loss': 0.03214888274669647, 'grad_norm': 0.058204054832458496}\n",
            "46000 {'loss': 0.1252509504556656, 'grad_norm': 0.15474526584148407}\n",
            "46500 {'loss': 0.3756672739982605, 'grad_norm': 0.1255902498960495}\n",
            "47000 {'loss': 0.09133864939212799, 'grad_norm': 0.05747934803366661}\n",
            "47500 {'loss': 0.10044901072978973, 'grad_norm': 0.16913679242134094}\n",
            "48000 {'loss': 0.0017352455761283636, 'grad_norm': 0.008380826562643051}\n",
            "48500 {'loss': 0.09871148318052292, 'grad_norm': 0.0894416943192482}\n",
            "49000 {'loss': 0.04756177216768265, 'grad_norm': 0.09989278763532639}\n",
            "49500 {'loss': 0.29831239581108093, 'grad_norm': 0.18881987035274506}\n",
            "50000 {'loss': 0.009447146207094193, 'grad_norm': 0.02040870487689972}\n",
            "50500 {'loss': 0.026695970445871353, 'grad_norm': 0.05037357658147812}\n",
            "51000 {'loss': 0.02692052721977234, 'grad_norm': 0.03771432489156723}\n",
            "51500 {'loss': 0.004909351002424955, 'grad_norm': 0.02231573313474655}\n",
            "52000 {'loss': 0.002516458509489894, 'grad_norm': 0.011496675200760365}\n",
            "52500 {'loss': 0.03843209147453308, 'grad_norm': 0.11054723709821701}\n",
            "53000 {'loss': 0.1027410626411438, 'grad_norm': 0.09671730548143387}\n",
            "53500 {'loss': 0.003651876701042056, 'grad_norm': 0.03194897621870041}\n",
            "54000 {'loss': 0.007505564950406551, 'grad_norm': 0.022297844290733337}\n",
            "54500 {'loss': 0.09967567026615143, 'grad_norm': 0.05148666352033615}\n",
            "55000 {'loss': 0.15412665903568268, 'grad_norm': 0.1618407666683197}\n",
            "55500 {'loss': 0.03853769972920418, 'grad_norm': 0.08662360161542892}\n",
            "56000 {'loss': 0.2001451998949051, 'grad_norm': 0.06641025841236115}\n",
            "56500 {'loss': 0.010759672150015831, 'grad_norm': 0.024071577936410904}\n",
            "57000 {'loss': 0.3396744132041931, 'grad_norm': 0.2487492710351944}\n",
            "57500 {'loss': 0.00112463952973485, 'grad_norm': 0.005128717515617609}\n",
            "58000 {'loss': 0.03284471109509468, 'grad_norm': 0.0984492227435112}\n",
            "58500 {'loss': 0.1907632052898407, 'grad_norm': 0.2056465595960617}\n",
            "59000 {'loss': 0.01583697274327278, 'grad_norm': 0.04131259396672249}\n",
            "59500 {'loss': 0.07984254509210587, 'grad_norm': 0.04783385246992111}\n",
            "60000 {'loss': 0.28297990560531616, 'grad_norm': 0.06957817077636719}\n",
            "60500 {'loss': 0.24219703674316406, 'grad_norm': 0.16973650455474854}\n",
            "61000 {'loss': 0.09331308305263519, 'grad_norm': 0.026336094364523888}\n",
            "61500 {'loss': 0.024450073018670082, 'grad_norm': 0.039025239646434784}\n",
            "62000 {'loss': 0.023172538727521896, 'grad_norm': 0.05918862298130989}\n",
            "62500 {'loss': 0.0017498660599812865, 'grad_norm': 0.007842537946999073}\n",
            "63000 {'loss': 0.1885971575975418, 'grad_norm': 0.04782337695360184}\n",
            "63500 {'loss': 0.0013057825854048133, 'grad_norm': 0.005726194940507412}\n",
            "64000 {'loss': 0.07620199769735336, 'grad_norm': 0.032460976392030716}\n",
            "64500 {'loss': 0.002889733063057065, 'grad_norm': 0.012585246935486794}\n",
            "65000 {'loss': 0.1029277816414833, 'grad_norm': 0.08276893943548203}\n",
            "65500 {'loss': 0.0022033201530575752, 'grad_norm': 0.009805786423385143}\n",
            "66000 {'loss': 0.14331436157226562, 'grad_norm': 0.09789034724235535}\n",
            "66500 {'loss': 0.08958248049020767, 'grad_norm': 0.05189071223139763}\n",
            "67000 {'loss': 0.2073850929737091, 'grad_norm': 0.14893098175525665}\n",
            "67500 {'loss': 0.27644991874694824, 'grad_norm': 0.1281304508447647}\n",
            "68000 {'loss': 0.1701042354106903, 'grad_norm': 0.18650300800800323}\n",
            "68500 {'loss': 0.003271267516538501, 'grad_norm': 0.026582391932606697}\n",
            "69000 {'loss': 0.1613592803478241, 'grad_norm': 0.1220947653055191}\n",
            "69500 {'loss': 0.06940530240535736, 'grad_norm': 0.19474348425865173}\n",
            "70000 {'loss': 0.04314045608043671, 'grad_norm': 0.09983433037996292}\n",
            "70500 {'loss': 0.003755078883841634, 'grad_norm': 0.033865515142679214}\n",
            "71000 {'loss': 0.1718555986881256, 'grad_norm': 0.14320863783359528}\n",
            "71500 {'loss': 0.14485427737236023, 'grad_norm': 0.05712779611349106}\n",
            "72000 {'loss': 0.20101073384284973, 'grad_norm': 0.10826163738965988}\n",
            "72500 {'loss': 0.09412631392478943, 'grad_norm': 0.08934998512268066}\n",
            "73000 {'loss': 0.21179434657096863, 'grad_norm': 0.16665692627429962}\n",
            "73500 {'loss': 0.25404447317123413, 'grad_norm': 0.1728818416595459}\n",
            "74000 {'loss': 0.1131545677781105, 'grad_norm': 0.17972703278064728}\n",
            "74500 {'loss': 0.005222075618803501, 'grad_norm': 0.022399792447686195}\n",
            "75000 {'loss': 0.008681242354214191, 'grad_norm': 0.029883988201618195}\n",
            "75500 {'loss': 0.1014629378914833, 'grad_norm': 0.073153555393219}\n",
            "76000 {'loss': 0.34294718503952026, 'grad_norm': 0.20807239413261414}\n",
            "76500 {'loss': 0.03667565435171127, 'grad_norm': 0.08492469042539597}\n",
            "77000 {'loss': 0.0035934350453317165, 'grad_norm': 0.015485197305679321}\n",
            "77500 {'loss': 0.4044535160064697, 'grad_norm': 0.14648465812206268}\n",
            "78000 {'loss': 0.18178851902484894, 'grad_norm': 0.16103899478912354}\n",
            "78500 {'loss': 0.1526373326778412, 'grad_norm': 0.07385370880365372}\n",
            "79000 {'loss': 0.02749558910727501, 'grad_norm': 0.06369354575872421}\n",
            "79500 {'loss': 0.018016835674643517, 'grad_norm': 0.0490155927836895}\n",
            "80000 {'loss': 0.025458866730332375, 'grad_norm': 0.09179547429084778}\n",
            "80500 {'loss': 0.2909431457519531, 'grad_norm': 0.23452426493167877}\n",
            "81000 {'loss': 0.008826232515275478, 'grad_norm': 0.020148104056715965}\n",
            "81500 {'loss': 0.02984706498682499, 'grad_norm': 0.059519343078136444}\n",
            "82000 {'loss': 0.14057713747024536, 'grad_norm': 0.15536315739154816}\n",
            "82500 {'loss': 0.2589840590953827, 'grad_norm': 0.23101221024990082}\n",
            "83000 {'loss': 0.25477761030197144, 'grad_norm': 0.1392333060503006}\n",
            "83500 {'loss': 0.04580410569906235, 'grad_norm': 0.09969688951969147}\n",
            "84000 {'loss': 0.19519251585006714, 'grad_norm': 0.19616027176380157}\n",
            "84500 {'loss': 0.018310513347387314, 'grad_norm': 0.05209716781973839}\n",
            "85000 {'loss': 0.24912938475608826, 'grad_norm': 0.339968740940094}\n",
            "85500 {'loss': 0.08751804381608963, 'grad_norm': 0.0666811391711235}\n",
            "86000 {'loss': 0.21138975024223328, 'grad_norm': 0.04925113543868065}\n",
            "86500 {'loss': 0.014531801454722881, 'grad_norm': 0.038056012243032455}\n",
            "87000 {'loss': 0.1304911971092224, 'grad_norm': 0.08692009747028351}\n",
            "87500 {'loss': 0.2020958960056305, 'grad_norm': 0.10352152585983276}\n",
            "88000 {'loss': 0.2158668041229248, 'grad_norm': 0.12361741811037064}\n",
            "88500 {'loss': 0.17355625331401825, 'grad_norm': 0.07379171252250671}\n",
            "89000 {'loss': 0.035255201160907745, 'grad_norm': 0.05747341364622116}\n",
            "89500 {'loss': 0.0022500306367874146, 'grad_norm': 0.020793577656149864}\n",
            "90000 {'loss': 0.16611060500144958, 'grad_norm': 0.09490311145782471}\n",
            "90500 {'loss': 0.01715594157576561, 'grad_norm': 0.05099445581436157}\n",
            "91000 {'loss': 0.030000368133187294, 'grad_norm': 0.04850245639681816}\n",
            "91500 {'loss': 0.28130751848220825, 'grad_norm': 0.12049326300621033}\n",
            "92000 {'loss': 0.044272858649492264, 'grad_norm': 0.09402698278427124}\n",
            "92500 {'loss': 0.1447993814945221, 'grad_norm': 0.13551871478557587}\n",
            "93000 {'loss': 0.19227497279644012, 'grad_norm': 0.1803196668624878}\n",
            "93500 {'loss': 0.00014755224401596934, 'grad_norm': 0.0007046653190627694}\n",
            "94000 {'loss': 0.06099291890859604, 'grad_norm': 0.20962946116924286}\n",
            "94500 {'loss': 0.006499134935438633, 'grad_norm': 0.017702341079711914}\n",
            "95000 {'loss': 0.12541793286800385, 'grad_norm': 0.11271648854017258}\n",
            "95500 {'loss': 0.20557698607444763, 'grad_norm': 0.10175596922636032}\n",
            "96000 {'loss': 0.22363297641277313, 'grad_norm': 0.26417276263237}\n",
            "96500 {'loss': 0.3284921944141388, 'grad_norm': 0.11512219905853271}\n",
            "97000 {'loss': 0.00014499042299576104, 'grad_norm': 0.0007554813055321574}\n",
            "97500 {'loss': 0.1320389360189438, 'grad_norm': 0.05042348802089691}\n",
            "98000 {'loss': 3.069015292567201e-05, 'grad_norm': 0.00016494796727783978}\n",
            "98500 {'loss': 0.1477804332971573, 'grad_norm': 0.1502249836921692}\n",
            "99000 {'loss': 7.636630471097305e-05, 'grad_norm': 0.00044129916932433844}\n",
            "99276 Increasing seq length to:  20\n",
            "99500 {'loss': 0.17861708998680115, 'grad_norm': 0.12499383091926575}\n",
            "99785 Increasing seq length to:  30\n",
            "        X:  [1. 1. 1. 1. 1. 0. 0. 0. 1. 1.]\n",
            "predicted:  [1. 0. 1. 0. 1. 1. 1. 1. 0. 1.]\n",
            "   target:  [1. 0. 1. 0. 1. 1. 1. 1. 0. 1.]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Increasing the sequence length"
      ],
      "metadata": {
        "id": "meUrNeyii1PD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def train_and_eval_parity(parity_trainer, patience_max=3, max_iters=100000, learning_curriculum=True, stop_loss=1e-4):\n",
        "    max_seq_len = 100\n",
        "    seq_len = max_seq_len\n",
        "    if learning_curriculum:\n",
        "        seq_len = 10\n",
        "    patience = patience_max\n",
        "    for i in range(max_iters):\n",
        "        Xp, Yp = gen_parity_examples(np.random.randint(1, seq_len), 10)\n",
        "        ret = parity_trainer.train_step(Xp, Yp)\n",
        "        losses.append(dict(iter=i, **ret))\n",
        "        if ret['loss'] < stop_loss:\n",
        "            patience -= 1\n",
        "            if patience == 0:\n",
        "                seq_len += 20 # increase the sequence length\n",
        "                if seq_len > max_seq_len:\n",
        "                    break\n",
        "                else:\n",
        "                    patience = patience_max\n",
        "                print(i, \"Increasing seq length to: \", seq_len)\n",
        "        else:\n",
        "            patience = patience_max\n",
        "        if i % 500 == 0:\n",
        "            print(i, ret)\n",
        "    losses_df = pd.DataFrame(losses)\n",
        "    plt.semilogy(losses_df['iter'], losses_df['loss'], label='loss')\n",
        "    plt.semilogy(losses_df['iter'], losses_df['grad_norm'], label='grad norm', alpha=0.5)\n",
        "    plt.legend(loc='lower left')\n",
        "    plt.title('Training loss')\n",
        "    plt.xlabel('iteration')\n",
        "\n",
        "    Xp,Yp = gen_parity_examples(10, 1)\n",
        "    model = parity_trainer.network.eval()\n",
        "    predictions = model(np_to_tensor(Xp)).detach().cpu().numpy().squeeze()\n",
        "    print('        X: ', Xp.squeeze())\n",
        "    print('predicted: ', np.round(predictions))\n",
        "    print('   target: ', Yp.squeeze())"
      ],
      "metadata": {
        "id": "mhIHr-jRRlIO"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parity_net = ParityNet(hidden_dim=3)\n",
        "if CUDA:\n",
        "    parity_net.cuda()\n",
        "parity_trainer = Trainer(parity_net)\n",
        "parity_trainer.lrate = 1e-2\n",
        "losses = []\n",
        "# When set to True the net recieves an error signal after each step\n",
        "# When set to False the net recieves an error signal only once at the end\n",
        "parity_trainer.full_supervision = True\n",
        "# Gradient clipping\n",
        "parity_trainer.max_grad_norm = 1.0\n",
        "# This enables \"curriculum learning\" - we gradually train on\n",
        "# longer and longer sequences\n",
        "#\n",
        "learning_curriculum = True\n",
        "train_and_eval_parity(parity_trainer, learning_curriculum=learning_curriculum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "U6etkHzARvRm",
        "outputId": "9ce11c2a-fa62-4adb-b5e9-59d560492460"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 {'loss': 0.30493706464767456, 'grad_norm': 0.18126817047595978}\n",
            "500 {'loss': 0.205227792263031, 'grad_norm': 0.04830726981163025}\n",
            "1000 {'loss': 0.25863224267959595, 'grad_norm': 0.0360579676926136}\n",
            "1500 {'loss': 0.23010887205600739, 'grad_norm': 0.05130104348063469}\n",
            "2000 {'loss': 0.1789846271276474, 'grad_norm': 0.01982135884463787}\n",
            "2500 {'loss': 0.19447462260723114, 'grad_norm': 0.043901026248931885}\n",
            "3000 {'loss': 0.23475010693073273, 'grad_norm': 0.09023164212703705}\n",
            "3500 {'loss': 0.1327008306980133, 'grad_norm': 0.012913310900330544}\n",
            "4000 {'loss': 0.03591196611523628, 'grad_norm': 0.080526202917099}\n",
            "4500 {'loss': 0.22133581340312958, 'grad_norm': 0.020599691197276115}\n",
            "5000 {'loss': 0.22440893948078156, 'grad_norm': 0.04433638975024223}\n",
            "5500 {'loss': 0.05637267976999283, 'grad_norm': 0.1215956062078476}\n",
            "6000 {'loss': 0.06844598799943924, 'grad_norm': 0.04761160910129547}\n",
            "6500 {'loss': 0.21411927044391632, 'grad_norm': 0.04942672327160835}\n",
            "7000 {'loss': 0.21375344693660736, 'grad_norm': 0.05324365943670273}\n",
            "7500 {'loss': 0.24077454209327698, 'grad_norm': 0.11490771174430847}\n",
            "8000 {'loss': 0.2284747213125229, 'grad_norm': 0.0485771968960762}\n",
            "8500 {'loss': 0.09245594590902328, 'grad_norm': 0.05486937612295151}\n",
            "9000 {'loss': 0.022250134497880936, 'grad_norm': 0.05107966810464859}\n",
            "9500 {'loss': 0.03693907707929611, 'grad_norm': 0.08286648988723755}\n",
            "10000 {'loss': 0.042505573481321335, 'grad_norm': 0.09167946875095367}\n",
            "10500 {'loss': 0.23826073110103607, 'grad_norm': 0.018076276406645775}\n",
            "11000 {'loss': 0.2304375171661377, 'grad_norm': 0.06774259358644485}\n",
            "11500 {'loss': 0.16589081287384033, 'grad_norm': 0.03162539005279541}\n",
            "12000 {'loss': 0.15391980111598969, 'grad_norm': 0.041316669434309006}\n",
            "12500 {'loss': 0.17601783573627472, 'grad_norm': 0.022633874788880348}\n",
            "13000 {'loss': 0.17893165349960327, 'grad_norm': 0.029378604143857956}\n",
            "13500 {'loss': 0.1482907235622406, 'grad_norm': 0.04924301430583}\n",
            "14000 {'loss': 0.20979094505310059, 'grad_norm': 0.036630768328905106}\n",
            "14500 {'loss': 0.07239361852407455, 'grad_norm': 0.15527018904685974}\n",
            "15000 {'loss': 0.1429612785577774, 'grad_norm': 0.022941455245018005}\n",
            "15500 {'loss': 0.22469432651996613, 'grad_norm': 0.03778475150465965}\n",
            "16000 {'loss': 0.20542389154434204, 'grad_norm': 0.039229463785886765}\n",
            "16500 {'loss': 0.19226554036140442, 'grad_norm': 0.01977236196398735}\n",
            "17000 {'loss': 0.15475745499134064, 'grad_norm': 0.055477552115917206}\n",
            "17500 {'loss': 0.14035984873771667, 'grad_norm': 0.012672221288084984}\n",
            "18000 {'loss': 0.24510373175144196, 'grad_norm': 0.07929982990026474}\n",
            "18500 {'loss': 0.12040243297815323, 'grad_norm': 0.04094604030251503}\n",
            "19000 {'loss': 0.20254752039909363, 'grad_norm': 0.04295498505234718}\n",
            "19500 {'loss': 0.2225581258535385, 'grad_norm': 0.051424115896224976}\n",
            "20000 {'loss': 0.22305333614349365, 'grad_norm': 0.054093118757009506}\n",
            "20500 {'loss': 0.17320604622364044, 'grad_norm': 0.0023348494432866573}\n",
            "21000 {'loss': 0.21343207359313965, 'grad_norm': 0.036164138466119766}\n",
            "21500 {'loss': 0.15975898504257202, 'grad_norm': 0.03821050748229027}\n",
            "22000 {'loss': 0.09764345735311508, 'grad_norm': 0.0641150027513504}\n",
            "22500 {'loss': 0.08264319598674774, 'grad_norm': 0.10487909615039825}\n",
            "23000 {'loss': 0.22937646508216858, 'grad_norm': 0.0790705755352974}\n",
            "23500 {'loss': 0.1903609186410904, 'grad_norm': 0.014481702819466591}\n",
            "24000 {'loss': 0.19921989738941193, 'grad_norm': 0.01366361789405346}\n",
            "24500 {'loss': 0.12567509710788727, 'grad_norm': 0.08220118284225464}\n",
            "25000 {'loss': 0.2360529601573944, 'grad_norm': 0.057584550231695175}\n",
            "25500 {'loss': 0.21688628196716309, 'grad_norm': 0.027049675583839417}\n",
            "26000 {'loss': 0.18265384435653687, 'grad_norm': 0.019934173673391342}\n",
            "26500 {'loss': 0.13513123989105225, 'grad_norm': 0.09015905112028122}\n",
            "27000 {'loss': 0.15626078844070435, 'grad_norm': 0.0199515912681818}\n",
            "27500 {'loss': 0.20967143774032593, 'grad_norm': 0.05252423509955406}\n",
            "28000 {'loss': 0.23385366797447205, 'grad_norm': 0.10667044669389725}\n",
            "28500 {'loss': 0.22058908641338348, 'grad_norm': 0.03818727284669876}\n",
            "29000 {'loss': 0.075192891061306, 'grad_norm': 0.1594371795654297}\n",
            "29500 {'loss': 0.21053212881088257, 'grad_norm': 0.0897660106420517}\n",
            "30000 {'loss': 0.18408742547035217, 'grad_norm': 0.013351134024560452}\n",
            "30500 {'loss': 0.11607742309570312, 'grad_norm': 0.11143644899129868}\n",
            "31000 {'loss': 0.147320955991745, 'grad_norm': 0.052645619958639145}\n",
            "31500 {'loss': 0.20567624270915985, 'grad_norm': 0.04851070046424866}\n",
            "32000 {'loss': 0.16185058653354645, 'grad_norm': 0.046067897230386734}\n",
            "32500 {'loss': 0.2576918303966522, 'grad_norm': 0.14987041056156158}\n",
            "33000 {'loss': 0.18818680942058563, 'grad_norm': 0.060411032289266586}\n",
            "33500 {'loss': 0.0918133482336998, 'grad_norm': 0.21027620136737823}\n",
            "34000 {'loss': 0.189102903008461, 'grad_norm': 0.0602806955575943}\n",
            "34500 {'loss': 0.20010223984718323, 'grad_norm': 0.022691035643219948}\n",
            "35000 {'loss': 0.20021255314350128, 'grad_norm': 0.10348884016275406}\n",
            "35500 {'loss': 0.12074092775583267, 'grad_norm': 0.02274279110133648}\n",
            "36000 {'loss': 0.20288413763046265, 'grad_norm': 0.041787274181842804}\n",
            "36500 {'loss': 0.19575239717960358, 'grad_norm': 0.07116744667291641}\n",
            "37000 {'loss': 0.15592044591903687, 'grad_norm': 0.0668988972902298}\n",
            "37500 {'loss': 0.1730366051197052, 'grad_norm': 0.058112289756536484}\n",
            "38000 {'loss': 0.21073593199253082, 'grad_norm': 0.06846316903829575}\n",
            "38500 {'loss': 0.18742935359477997, 'grad_norm': 0.10708408057689667}\n",
            "39000 {'loss': 0.21069972217082977, 'grad_norm': 0.07375933229923248}\n",
            "39500 {'loss': 0.1635211855173111, 'grad_norm': 0.042485639452934265}\n",
            "40000 {'loss': 0.14344781637191772, 'grad_norm': 0.013621010817587376}\n",
            "40500 {'loss': 0.18523359298706055, 'grad_norm': 0.025183074176311493}\n",
            "41000 {'loss': 0.06862076371908188, 'grad_norm': 0.15726076066493988}\n",
            "41500 {'loss': 0.22342707216739655, 'grad_norm': 0.09220553189516068}\n",
            "42000 {'loss': 0.2417210042476654, 'grad_norm': 0.05426207184791565}\n",
            "42500 {'loss': 0.10843095928430557, 'grad_norm': 0.07771658897399902}\n",
            "43000 {'loss': 0.09642358869314194, 'grad_norm': 0.15083375573158264}\n",
            "43500 {'loss': 0.053295500576496124, 'grad_norm': 0.11971689760684967}\n",
            "44000 {'loss': 0.16806431114673615, 'grad_norm': 0.05681060627102852}\n",
            "44500 {'loss': 0.2296665757894516, 'grad_norm': 0.04283580929040909}\n",
            "45000 {'loss': 0.17995508015155792, 'grad_norm': 0.07076689600944519}\n",
            "45500 {'loss': 0.07081174850463867, 'grad_norm': 0.1528850793838501}\n",
            "46000 {'loss': 0.21516558527946472, 'grad_norm': 0.03092753328382969}\n",
            "46500 {'loss': 0.21455711126327515, 'grad_norm': 0.04424864053726196}\n",
            "47000 {'loss': 0.24077510833740234, 'grad_norm': 0.07239139080047607}\n",
            "47500 {'loss': 0.05855166167020798, 'grad_norm': 0.13332213461399078}\n",
            "48000 {'loss': 0.1825263649225235, 'grad_norm': 0.01099720411002636}\n",
            "48500 {'loss': 0.1984865516424179, 'grad_norm': 0.015970250591635704}\n",
            "49000 {'loss': 0.16443605720996857, 'grad_norm': 0.03481708839535713}\n",
            "49500 {'loss': 0.19493259489536285, 'grad_norm': 0.029425274580717087}\n",
            "50000 {'loss': 0.18516360223293304, 'grad_norm': 0.0181049183011055}\n",
            "50500 {'loss': 0.15529616177082062, 'grad_norm': 0.048279400914907455}\n",
            "51000 {'loss': 0.22252565622329712, 'grad_norm': 0.051237620413303375}\n",
            "51500 {'loss': 0.1359902322292328, 'grad_norm': 0.08646470308303833}\n",
            "52000 {'loss': 0.21354073286056519, 'grad_norm': 0.049413274973630905}\n",
            "52500 {'loss': 0.21473033726215363, 'grad_norm': 0.040796272456645966}\n",
            "53000 {'loss': 0.1327151209115982, 'grad_norm': 0.06502971798181534}\n",
            "53500 {'loss': 0.21122384071350098, 'grad_norm': 0.04269366338849068}\n",
            "54000 {'loss': 0.05757351592183113, 'grad_norm': 0.1375282257795334}\n",
            "54500 {'loss': 0.189052015542984, 'grad_norm': 0.05843757092952728}\n",
            "55000 {'loss': 0.09768831729888916, 'grad_norm': 0.14464356005191803}\n",
            "55500 {'loss': 0.21642012894153595, 'grad_norm': 0.04757678508758545}\n",
            "56000 {'loss': 0.07289128005504608, 'grad_norm': 0.1643829643726349}\n",
            "56500 {'loss': 0.06728596240282059, 'grad_norm': 0.010515552945435047}\n",
            "57000 {'loss': 0.18656392395496368, 'grad_norm': 0.017901688814163208}\n",
            "57500 {'loss': 0.13328346610069275, 'grad_norm': 0.010181475430727005}\n",
            "58000 {'loss': 0.22863884270191193, 'grad_norm': 0.12129295617341995}\n",
            "58500 {'loss': 0.20188595354557037, 'grad_norm': 0.10584604740142822}\n",
            "59000 {'loss': 0.21715952455997467, 'grad_norm': 0.08576752245426178}\n",
            "59500 {'loss': 0.1389652043581009, 'grad_norm': 0.08324575424194336}\n",
            "60000 {'loss': 0.16245374083518982, 'grad_norm': 0.028699956834316254}\n",
            "60500 {'loss': 0.15681737661361694, 'grad_norm': 0.014136255718767643}\n",
            "61000 {'loss': 0.06498256325721741, 'grad_norm': 0.14382314682006836}\n",
            "61500 {'loss': 0.1799294501543045, 'grad_norm': 0.06352091580629349}\n",
            "62000 {'loss': 0.03249696269631386, 'grad_norm': 0.07529839128255844}\n",
            "62500 {'loss': 0.07415808737277985, 'grad_norm': 0.1664600521326065}\n",
            "63000 {'loss': 0.2139059454202652, 'grad_norm': 0.02118377946317196}\n",
            "63500 {'loss': 0.13920554518699646, 'grad_norm': 0.03409361466765404}\n",
            "64000 {'loss': 0.2160874605178833, 'grad_norm': 0.04052076116204262}\n",
            "64500 {'loss': 0.21313932538032532, 'grad_norm': 0.056441523134708405}\n",
            "65000 {'loss': 0.1760435551404953, 'grad_norm': 0.04531979188323021}\n",
            "65500 {'loss': 0.02337963692843914, 'grad_norm': 0.053088508546352386}\n",
            "66000 {'loss': 0.22410042583942413, 'grad_norm': 0.029362162575125694}\n",
            "66500 {'loss': 0.06883228570222855, 'grad_norm': 0.14988097548484802}\n",
            "67000 {'loss': 0.1849687248468399, 'grad_norm': 0.025991596281528473}\n",
            "67500 {'loss': 0.20525655150413513, 'grad_norm': 0.042927343398332596}\n",
            "68000 {'loss': 0.09894991666078568, 'grad_norm': 0.03202342987060547}\n",
            "68500 {'loss': 0.17824408411979675, 'grad_norm': 0.06431027501821518}\n",
            "69000 {'loss': 0.12565521895885468, 'grad_norm': 0.0341486819088459}\n",
            "69500 {'loss': 0.1235201358795166, 'grad_norm': 0.036595944315195084}\n",
            "70000 {'loss': 0.0465523786842823, 'grad_norm': 0.10609157383441925}\n",
            "70500 {'loss': 0.22600610554218292, 'grad_norm': 0.04101378470659256}\n",
            "71000 {'loss': 0.23129360377788544, 'grad_norm': 0.10198450088500977}\n",
            "71500 {'loss': 0.2080589085817337, 'grad_norm': 0.04147199168801308}\n",
            "72000 {'loss': 0.16636323928833008, 'grad_norm': 0.13589099049568176}\n",
            "72500 {'loss': 0.23192153871059418, 'grad_norm': 0.04839695245027542}\n",
            "73000 {'loss': 0.1984550952911377, 'grad_norm': 0.06335970014333725}\n",
            "73500 {'loss': 0.20926450192928314, 'grad_norm': 0.01968987099826336}\n",
            "74000 {'loss': 0.19582729041576385, 'grad_norm': 0.04294215515255928}\n",
            "74500 {'loss': 0.1812599003314972, 'grad_norm': 0.01588955894112587}\n",
            "75000 {'loss': 0.1674892008304596, 'grad_norm': 0.045497529208660126}\n",
            "75500 {'loss': 0.23824842274188995, 'grad_norm': 0.09571164846420288}\n",
            "76000 {'loss': 0.17030665278434753, 'grad_norm': 0.026313813403248787}\n",
            "76500 {'loss': 0.14304563403129578, 'grad_norm': 0.12067355960607529}\n",
            "77000 {'loss': 0.12300380319356918, 'grad_norm': 0.050994910299777985}\n",
            "77500 {'loss': 0.1415468156337738, 'grad_norm': 0.0334874726831913}\n",
            "78000 {'loss': 0.21861380338668823, 'grad_norm': 0.04357321187853813}\n",
            "78500 {'loss': 0.25979340076446533, 'grad_norm': 0.09576670825481415}\n",
            "79000 {'loss': 0.11271203309297562, 'grad_norm': 0.054740309715270996}\n",
            "79500 {'loss': 0.2489597052335739, 'grad_norm': 0.08638583868741989}\n",
            "80000 {'loss': 0.16766628623008728, 'grad_norm': 0.04169347882270813}\n",
            "80500 {'loss': 0.1778837889432907, 'grad_norm': 0.03821566328406334}\n",
            "81000 {'loss': 0.17793598771095276, 'grad_norm': 0.036513954401016235}\n",
            "81500 {'loss': 0.06584091484546661, 'grad_norm': 0.15246257185935974}\n",
            "82000 {'loss': 0.2246299684047699, 'grad_norm': 0.07251323014497757}\n",
            "82500 {'loss': 0.20939619839191437, 'grad_norm': 0.05382891744375229}\n",
            "83000 {'loss': 0.2251620888710022, 'grad_norm': 0.03327284753322601}\n",
            "83500 {'loss': 0.2078021764755249, 'grad_norm': 0.025396138429641724}\n",
            "84000 {'loss': 0.1248960942029953, 'grad_norm': 0.12417703121900558}\n",
            "84500 {'loss': 0.11290685832500458, 'grad_norm': 0.098963662981987}\n",
            "85000 {'loss': 0.2473006695508957, 'grad_norm': 0.0920124277472496}\n",
            "85500 {'loss': 0.2347712516784668, 'grad_norm': 0.05138926953077316}\n",
            "86000 {'loss': 0.19044099748134613, 'grad_norm': 0.02044396661221981}\n",
            "86500 {'loss': 0.22635093331336975, 'grad_norm': 0.0710422545671463}\n",
            "87000 {'loss': 0.18069903552532196, 'grad_norm': 0.027168098837137222}\n",
            "87500 {'loss': 0.21884135901927948, 'grad_norm': 0.0575902983546257}\n",
            "88000 {'loss': 0.1529109627008438, 'grad_norm': 0.014337699860334396}\n",
            "88500 {'loss': 0.10655196756124496, 'grad_norm': 0.15344159305095673}\n",
            "89000 {'loss': 0.23250141739845276, 'grad_norm': 0.07884202897548676}\n",
            "89500 {'loss': 0.21905358135700226, 'grad_norm': 0.07109026610851288}\n",
            "90000 {'loss': 0.2231425642967224, 'grad_norm': 0.054584816098213196}\n",
            "90500 {'loss': 0.21742793917655945, 'grad_norm': 0.030987204983830452}\n",
            "91000 {'loss': 0.06667093187570572, 'grad_norm': 0.15391401946544647}\n",
            "91500 {'loss': 0.08636520057916641, 'grad_norm': 0.19405901432037354}\n",
            "92000 {'loss': 0.21569345891475677, 'grad_norm': 0.039471372961997986}\n",
            "92500 {'loss': 0.2121042013168335, 'grad_norm': 0.02215389721095562}\n",
            "93000 {'loss': 0.13714951276779175, 'grad_norm': 0.01077265851199627}\n",
            "93500 {'loss': 0.1515756994485855, 'grad_norm': 0.08087358623743057}\n",
            "94000 {'loss': 0.19242046773433685, 'grad_norm': 0.04775528982281685}\n",
            "94500 {'loss': 0.21031418442726135, 'grad_norm': 0.0410185307264328}\n",
            "95000 {'loss': 0.1742338240146637, 'grad_norm': 0.01087263785302639}\n",
            "95500 {'loss': 0.20985519886016846, 'grad_norm': 0.025724422186613083}\n",
            "96000 {'loss': 0.04188741371035576, 'grad_norm': 0.09806890040636063}\n",
            "96500 {'loss': 0.26649460196495056, 'grad_norm': 0.11755368858575821}\n",
            "97000 {'loss': 0.06993237882852554, 'grad_norm': 0.15950986742973328}\n",
            "97500 {'loss': 0.051285408437252045, 'grad_norm': 0.12071313709020615}\n",
            "98000 {'loss': 0.21260853111743927, 'grad_norm': 0.07659295946359634}\n",
            "98500 {'loss': 0.2484264075756073, 'grad_norm': 0.05564733222126961}\n",
            "99000 {'loss': 0.15619255602359772, 'grad_norm': 0.024851791560649872}\n",
            "99500 {'loss': 0.19185017049312592, 'grad_norm': 0.057563912123441696}\n",
            "        X:  [1. 1. 0. 0. 1. 1. 0. 0. 1. 0.]\n",
            "predicted:  [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
            "   target:  [1. 0. 0. 0. 1. 0. 0. 0. 1. 1.]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YSMOan7qqreQ"
      },
      "source": [
        "## LSTM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "DKefgIqAqvPz"
      },
      "outputs": [],
      "source": [
        "class LSTMCell(nn.Module):\n",
        "    def __init__(self, in_dim, hidden_dim, **kwargs):\n",
        "        super(LSTMCell, self).__init__(**kwargs)\n",
        "        self.in_to_gates = nn.Linear(in_dim, hidden_dim * 4, bias=True)\n",
        "        self.hidden_to_gates = nn.Linear(hidden_dim, hidden_dim * 4, bias=False)\n",
        "\n",
        "\n",
        "    def forward(self, input, hidden):\n",
        "        hx, cx = hidden\n",
        "        gates = self.in_to_gates(input) + self.hidden_to_gates(hx)\n",
        "\n",
        "        ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)\n",
        "        #\n",
        "        # TODO TASK 3ingate = torch.sigmoid(ingate)\n",
        "        #\n",
        "        # Implement the LSTM equations\n",
        "        #\n",
        "        #my task\n",
        "         # Apply sigmoid activation to the input, forget, and output gates\n",
        "        ingate = torch.sigmoid(ingate)\n",
        "        forgetgate = torch.sigmoid(forgetgate)\n",
        "        # Apply tanh activation to the cell gate\n",
        "        cellgate = torch.tanh(cellgate)\n",
        "        outgate = torch.sigmoid(outgate)\n",
        "        # Calculate the new cell state. It is a combination of the old cell state (cx) modulated by the forget gate\n",
        "        # and the new candidate values (cellgate) modulated by the input gate\n",
        "        cy = (forgetgate * cx) + (ingate * cellgate)\n",
        "        # Calculate the new hidden state (hy). It is the output gate modulating the tanh of the cell state\n",
        "        hy = outgate * torch.tanh(cy)\n",
        "\n",
        "        return hy, cy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 709
        },
        "id": "Ay3bGMHjntI4",
        "outputId": "ef98104b-b75b-48f2-9fc5-68385de30a73"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 {'loss': 0.25577056407928467, 'grad_norm': 0.02134794555604458}\n",
            "500 {'loss': 0.23935498297214508, 'grad_norm': 0.02289954014122486}\n",
            "1000 {'loss': 0.0010495868045836687, 'grad_norm': 0.0018474876414984465}\n",
            "1500 {'loss': 0.00035189493792131543, 'grad_norm': 0.0006003460730426013}\n",
            "2000 {'loss': 0.00021912006195634604, 'grad_norm': 0.0003151722776237875}\n",
            "2009 Increasing seq length to:  30\n",
            "2500 {'loss': 0.0001335903798462823, 'grad_norm': 0.00019475299632176757}\n",
            "2586 Increasing seq length to:  50\n",
            "2678 Increasing seq length to:  70\n",
            "2754 Increasing seq length to:  90\n",
            "        X:  [1. 1. 0. 1. 1. 0. 1. 1. 1. 0.]\n",
            "predicted:  [1. 0. 0. 1. 0. 0. 1. 0. 1. 1.]\n",
            "   target:  [1. 0. 0. 1. 0. 0. 1. 0. 1. 1.]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "parity_net = ParityNet(hidden_dim=3, use_lstm=True)\n",
        "if CUDA:\n",
        "    parity_net.cuda()\n",
        "parity_trainer = Trainer(parity_net)\n",
        "losses = []\n",
        "train_and_eval_parity(parity_trainer, learning_curriculum=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pMPnwZJMxhav"
      },
      "source": [
        "# Problem 2. GPT\n",
        "\n",
        "Now we will implement the GPT architecture. GPT stands for _Generative Pre-trained Transformer_. GPT is a model trained to generate sequences, one token (character, word, or else) at a time, pretty similar to the RNN from slide 25 in our lecture. GPT is the architecture behind the immensely famous [ChatGPT](https://chat.openai.com/) and many other state-of-the-art AIs.\n",
        "\n",
        "GPT training examples look like this (image taken from [GPT-3 Illustrated](https://jalammar.github.io/how-gpt3-works-visualizations-animations/)):\n",
        "\n",
        "![image.png](attachment:image.png)\n",
        "\n",
        "So, in the example above, the input sequence would be `Second law of robotics: A robot must obey the orders given it by human`, and the target sequence would be `law of robotics: A robot must obey the orders given it by human beings`. In short words, GPT is a transformer trained to do next-token prediction. This is termed _auto-regressive modeling_.\n",
        "\n",
        "Aside of the main transformer elements we saw in the lecture there are two extra things we need to take care of to implement GPT. First, a definition:\n",
        "\n",
        "**Embedding**: a real valued vector of dimension $d$ (usually high-dimensional) representing something. E.g. neural nets can process numbers, but not words, so in order to get them to process text we assign an embedding to each word.\n",
        "\n",
        "Now, two extra elements we need to implement:\n",
        "\n",
        "1. **Positional encoding**:\n",
        "    \n",
        "    Notice how none of the operations in the transformer cares about the position of the elements in the sequence. The only operation by which elements of the sequence interact with each other is self-attention, but self-attention is just a weighted average of the sequence elements. In a weighted average if you change the order of the elements the result is still the same.\n",
        "    \n",
        "    Sequences however have an order. For instance, if we switch `robot` and `human` in the example above, yielding as input `Second law of robotics: A human must obey the orders given it by robot beings`, the meaning of the sentence has totally changed, but the output of the transformer would be the same as with the original!\n",
        "    \n",
        "    To fix this we need to somehow inject information about the position. The way we do it is by adding to each embedding representing an input word another embedding to represent the position of such word. Consider $E$ a function that assigns embeddings to words, and $P$ a function that assigns embeddings to positions. Then, in our example, the input to the transformer would be:\n",
        "    \n",
        "    $$\n",
        "    E(Second) + P(0), E(law) + P(1), E(of) + P(2), \\dots, E(human) + P(14)\n",
        "    $$\n",
        "    \n",
        "    The simplest way to implement positional encoding is using learned embeddings: we assume that we will process sequences of at most $T$ elements, and initialize randomly $T$ positional embeddings. During training, the model learns to modify our randomly initialize embeddings to better represent position. There are however many [methods for positional encodings](https://kazemnejad.com/blog/transformer_architecture_positional_encoding/). This is actually a fairly active research area. Currently, the most popular (advanced) positional encoding method is [RoPE](https://blog.eleuther.ai/rotary-embeddings/).\n",
        "\n",
        "\n",
        "\n",
        "2. **Causal self-attention**:\n",
        "\n",
        "    In self-attention, each embedding attends to itself and all of the other elements in the sequence. Therefore each token gets to see all of the other tokens in the sequence. This is a problem in GPT, where the task is next-token prediction. If a token gets to see all of the other tokens in the sequence, including the next token, then it can trivially solve the task by just copying the value of the next token to the output!\n",
        "    \n",
        "    We need to modify attention so that each token is only allowed to attend to itself and the previous tokens in the sequence:\n",
        "    \n",
        "    ![image-2.png](attachment:image-2.png)\n",
        "    \n",
        "    We do so by applying a mask to the attention matrix:\n",
        "    \n",
        "    ![image-3.png](attachment:image-3.png)\n",
        "    \n",
        "    ![image-4.png](attachment:image-4.png)\n",
        "    \n",
        "    ![image-5.png](attachment:image-5.png)\n",
        "    \n",
        "\n",
        "So, in summary, in GPT:\n",
        "\n",
        "1. We convert each input token in the sequence to an embedding and add to it a positional embedding.\n",
        "2. We pass the encoded inputs through $N$ transformer blocks, which are just as the ones we described in class, except that we use causal self-attention instead of vanilla self-attention.\n",
        "3. We use the output of the last transformer block as the input to a Softmax classifier that predicts the next-token in the sequence.\n",
        "\n",
        "In the tasks below you will implement and use the GPT architecture.\n",
        "\n",
        "\n",
        "**Tasks**:\n",
        "1. **(3.5 pt)** Implement a transformer decoder block:\n",
        "\n",
        "    1.1 **(2 pt)** Implement the forward pass of `MultiheadAttention`. You should implement the projection of the input embeddings to queries, keys and values (using `c_attn`), the computation of the causal attention matrix, and the output projection (using `c_proj`).\n",
        "    \n",
        "    _Note_: notice that we intend to do the query, key, and value projections in a single batched operation, therefore the `3 * n_embd` as output in `c_attn`. This is a more efficient implementation than doing separate linear projections for query, key, and value. However, you can use separate projection matrices if it is easier for you.\n",
        "    \n",
        "    _Note_: for the causal attention matrix you can use [masked_fill](https://pytorch.org/docs/stable/generated/torch.Tensor.masked_fill_.html#torch.Tensor.masked_fill_) in order to apply the mask.\n",
        "    \n",
        "    1.2. **(0.5 pt)** Implement the forward pass of the attention block in `Block`. Use the following transformer block as guide of the operations you should implement:\n",
        "    \n",
        "    <div>\n",
        "        <img src=\"attachment:image-6.png\" width=\"200\"/>\n",
        "    </div>     \n",
        "    \n",
        "    Where `Norm` corresponds to layer normalization, i.e. `ln_1` and `ln_2` in our implementation.\n",
        "    \n",
        "    1.3. **(1 pt)** Implement the forward pass of the transformer in `GPT`. In here you should implement the operations that apply the token embedding `wte` and position embedding `wpe` to the inputs, as well as the stack of transformer blocks `h`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KkD_OM8yMZvo"
      },
      "source": [
        "2. **(7.0 pt max)** Train a GPT to learn to generate Harry Potter text based on the first four books:\n",
        "\n",
        "    2.1 **(0.5 pt)** As we mentioned, neural nets need to assign vectors to words/characters in order to process them. Normally for that we use the [nn.Embedding](https://pytorch.org/docs/stable/generated/torch.nn.Embedding.html) module, as in the `__init__` method from `GPT`. It assigns vectors to integer numbers, which themselves can correspond to discrete symbols, like our characters or words. For this exercise you have to encode our text as integer numbers (we call this process tokenization). We will start with the simplest tokenization: encode each character as an integer. You will need to create two dictionaries: `stoi` (string to integer) and `itos` (integer to string) that map text to integers and integers to text, respectively.\n",
        "    \n",
        "    2.2 **(0.5 pt)** Define the targets `y` in the `get_batch` function so that the model does next token prediction.\n",
        "    \n",
        "    2.3 **(4.5 pt max)** Implement the code to generate data in the function `generate` of `GPT`. Here you just need to feed back the predicted next tokens that the model outputs as input for the next time step (**0.5 pt**). You can also implement [top-k sampling](https://huggingface.co/blog/how-to-generate) for an extra **1 pt**, and/or [Key-Value caching](https://huggingface.co/blog/optimize-llm) to accelerate inference for extra **3 pt**.\n",
        "    \n",
        "    2.4 **(1.5 pt)** Improve the tokenization.\n",
        "    \n",
        "    Using character tokenization is a simple first approach, but is rarely used in practice because it results in too long sequences (remember that the computational complexity of transformers grows quadratically with the sequence length). As an alternative we could split the text by whitespaces (e.g. the sentence _\"said Dumbledore, smiling\"_ becomes `[\"said\", \"Dumbledore,\", \"smiling\"]`), and then encode each unique word in the text as an integer. This is termed word tokenization, and although it solves our issue with length, it comes with its own problems. For instance, how do we deal with a word that was not in the training set? We could assign an special token for unknown words, but there is a better alternative: subword tokenization.\n",
        "    \n",
        "    Subword tokenization divides words into smaller, meaningful units, from which other words can be formed. Consider the word \"_chatGPT_\", and imagine you are using a word-level tokenizer that doesn't recognize the term because it's not present in its vocabulary. In such a case, the entire term will be treated as an out-of-vocabulary (OOV) word, and the model may struggle to understand or generate meaningful predictions for it. A subword tokenizer, instead of treating the entire term as a single token, it would would break it down into smaller, more meaningful subword units. For instance, it might tokenize \"_chatGPT_\" into `chat` and `GPT`. This would enable the model to leverage its already acquired knowledge of `chat` and `GPT` to infer that likely \"_chatGPT_\" is a `GPT` with which you can `chat`.\n",
        "    \n",
        "    Implement subword tokenization. You can use [SentencePiece](https://github.com/google/sentencepiece) or any other subword tokenizer of your chosing. Repeat training. Do you see any improvement?."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sJQDgRcHMZvo"
      },
      "source": [
        "3. **(2.5 pt máx)** Evaluate the English skills of your Harry Potter GPT.\n",
        "    \n",
        "    If you have successfully trained your GPT, you should have now a neural network that generates (vaguely) Harry Potter related text. How good of an English it learned from it? In this task we will assess it by calculating how well our model can tell apart proper and wrong English. We will test it in two problems:\n",
        "    \n",
        "    * Spelling test: we will present our model with pairs of `[word, non-word]`, e.g. `[observation, odservation]`. We will check on average how often our model assigns higher probablity to the properlly spelled word.\n",
        "    * Grammar test: we will present our model with pairs of `[sentence, non-sentence]`, e.g. `[Hermione is listening to herself, Hermione is listening to itself]`. We will check on average how often our model assigns higher probablity to the properlly spelled sentence.\n",
        "    \n",
        "    In this exercise your task is to implement the function that will calculate the score of the model (**2 pt**). Remember from the lecture that we define the probability of a sentence of length $T$ composed of tokens $x_1, x_2, \\dots, x_T$ as:\n",
        "    \n",
        "    $$\n",
        "    p(x_1, x_2, \\dots, x_T) = p(x_1)p(x_2 | x_1)p(x_3 | x_1, x_2) \\dots p(x_T | x_1, x_2, \\dots, x_{T-1})\n",
        "    $$\n",
        "    \n",
        "   , and that our model's inputs and outputs look like this:\n",
        "   \n",
        "   <div>\n",
        "        <img src=\"attachment:image.png\" width=\"500\"/>\n",
        "    </div>\n",
        "    \n",
        "    _Hint: think of the equation for the cross entropy loss with which our model is trained, it should give you an easy answer_.\n",
        "    \n",
        "    For extra **0.5 pt**, and if you did task 2.4, check if a model trained on subwords does better on the grammar test."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class MultiheadAttention(nn.Module):\n",
        "\n",
        "    def __init__(self, n_embd, n_head, block_size, dropout):\n",
        "        super().__init__()\n",
        "        assert n_embd % n_head == 0, \"The embedding dimension bust be divisible by the number of heads\"\n",
        "        self.n_head = n_head\n",
        "        self.n_embd = n_embd\n",
        "        # key, query, value projections for all heads, but in a batch\n",
        "        self.c_attn = nn.Linear(n_embd, 3 * n_embd, bias=False)\n",
        "        # output projection\n",
        "        self.c_proj = nn.Linear(n_embd, n_embd, bias=False)\n",
        "        # regularization\n",
        "        self.attn_dropout = nn.Dropout(dropout)\n",
        "        self.resid_dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd)\n",
        "        # calculate query, key, values for all heads in batch and move head forward to be the batch dim\n",
        "\n",
        "        q, k, v = self.c_attn(x).split(self.n_embd, dim=2)\n",
        "        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
        "        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
        "        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
        "        #\n",
        "        # TODO TASK 1.1\n",
        "        #\n",
        "        # Implement the forward pass of MultiheadAttention\n",
        "        #-----------------------------------@@@----------------------------------\n",
        "        # Compute the attention scores\n",
        "        att = torch.matmul(q, k.transpose(-2, -1)) # (B, nh, T, T)\n",
        "        # Create a mask for the triangular part of the matrix (to handle sequences of variable length)\n",
        "        mask = torch.tril(torch.ones((T, T), device=x.device)).unsqueeze(0).unsqueeze(0) # (1, 1, T, T)\n",
        "        # Apply the mask to the attention scores\n",
        "        masked_att = att.masked_fill(mask == 0, float('-inf')) # (B, nh, T, T)\n",
        "        # Apply softmax to the masked attention scores\n",
        "        scores = torch.softmax(masked_att, dim=-1)\n",
        "        # Apply dropout for regularization\n",
        "        scores = self.attn_dropout(scores)\n",
        "\n",
        "\n",
        "        # Compute attention output\n",
        "        y = torch.matmul(scores, v) # (B, nh, T, hs) hs = C / nh\n",
        "        y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side\n",
        "        # output projection\n",
        "        y = self.c_proj(y)\n",
        "        y = self.resid_dropout(y)\n",
        "        return y"
      ],
      "metadata": {
        "id": "FRJ7OSAyjvnj"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### code to test MultiheadAttention"
      ],
      "metadata": {
        "id": "Gpvy4E8go3nf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "n_embd = 64\n",
        "n_head = 8\n",
        "block_size = 128\n",
        "dropout = 0.1\n",
        "multihead = MultiheadAttention(n_embd, n_head, block_size, dropout)\n",
        "B,T =2 , 10\n",
        "x = torch.randn(B,T,n_embd)\n",
        "y = multihead(x)\n",
        "print(f'expected output shape: {B,T,n_embd}')\n",
        "print(f'actual output shape: {y.shape}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P4xyLEGskJFs",
        "outputId": "97647619-6d46-48de-ef07-cd870b3f0329"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "expected output shape: (2, 10, 64)\n",
            "actual output shape: torch.Size([2, 10, 64])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class MLP(nn.Module):\n",
        "\n",
        "    def __init__(self, n_embd, dropout):\n",
        "        super().__init__()\n",
        "        self.c_fc    = nn.Linear(n_embd, 4 * n_embd, bias=False)\n",
        "        self.gelu    = nn.GELU()\n",
        "        self.c_proj  = nn.Linear(4 * n_embd, n_embd, bias=False)\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.c_fc(x)\n",
        "        x = self.gelu(x)\n",
        "        x = self.c_proj(x)\n",
        "        x = self.dropout(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "LuMW9igznh-T"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Block(nn.Module):\n",
        "\n",
        "    def __init__(self, n_embd, n_head, block_size, dropout):\n",
        "        super().__init__()\n",
        "        self.ln_1 = nn.LayerNorm(n_embd)\n",
        "        self.attn = MultiheadAttention(n_embd, n_head, block_size, dropout)\n",
        "        self.ln_2 = nn.LayerNorm(n_embd)\n",
        "        self.mlp = MLP(n_embd, dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        #\n",
        "        # TODO TASK 1.2\n",
        "        #\n",
        "        # Implement the forward pass of the attention block\n",
        "        #\n",
        "        # Apply the first layer normalization\n",
        "        x_norm = self.ln_1(x)\n",
        "        # Compute the attention output\n",
        "        x_attn = self.attn(x_norm)\n",
        "        # Add a residual connection (skip connection)\n",
        "        x = x + x_attn # residual\n",
        "        # Apply the second layer normalization\n",
        "        x_norm = self.ln_2(x)\n",
        "        # Pass the output through the MLP\n",
        "        x_mlp = self.mlp(x_norm)\n",
        "        x = x + x_mlp # # Add another residual connection\n",
        "        return x"
      ],
      "metadata": {
        "id": "2_jObNa0nrj5"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "z7RPO8SfMZvo"
      },
      "outputs": [],
      "source": [
        "class GPT(nn.Module):\n",
        "\n",
        "    def __init__(self, n_layer, n_embd, n_head, block_size, vocab_size, dropout):\n",
        "        super().__init__()\n",
        "        self.block_size = block_size\n",
        "        self.transformer = nn.ModuleDict(dict(\n",
        "            wte = nn.Embedding(vocab_size, n_embd),\n",
        "            wpe = nn.Embedding(block_size, n_embd),\n",
        "            drop = nn.Dropout(dropout),\n",
        "            h = nn.ModuleList([Block(n_embd, n_head, block_size, dropout) for _ in range(n_layer)]),\n",
        "            ln_f = nn.LayerNorm(n_embd),\n",
        "        ))\n",
        "        self.lm_head = nn.Linear(n_embd, vocab_size, bias=False)\n",
        "        # init all weights\n",
        "        self.apply(self._init_weights)\n",
        "\n",
        "    def _init_weights(self, module):\n",
        "        if isinstance(module, nn.Linear) or isinstance(module, nn.LayerNorm):\n",
        "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
        "            if module.bias is not None:\n",
        "                torch.nn.init.zeros_(module.bias)\n",
        "        elif isinstance(module, nn.Embedding):\n",
        "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
        "\n",
        "    def forward(self, idx, targets=None):\n",
        "        device = idx.device\n",
        "        b, t = idx.size()\n",
        "        assert t <= self.block_size, f\"Cannot forward sequence of length {t}, block size is only {self.block_size}\"\n",
        "\n",
        "        #\n",
        "        # TODO TASK 1.3 (done)\n",
        "        #\n",
        "        # Implement the forward pass of the transformer\n",
        "        #\n",
        "        # my task 1.3--------------------------------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@@@@\n",
        "        tok_emb = self.transformer.wte(idx)  # token embeddings of shape (b, t, n_embd)\n",
        "        pos = torch.arange(t, device=device) # position ids of shape (t,)\n",
        "        pos_emb = self.transformer.wpe(pos) # position embeddings of shape (t, n_embd)\n",
        "        x = self.transformer.drop(tok_emb + pos_emb) # combine token and position embeddings\n",
        "        for block in self.transformer.h:\n",
        "            x = block(x)\n",
        "        x = self.transformer.ln_f(x)\n",
        "        #---------------------------------------------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@@@\n",
        "        if targets is not None:\n",
        "            # if we are given some desired targets also calculate the loss\n",
        "            logits = self.lm_head(x)\n",
        "            #loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1).squeeze())\n",
        "            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1)\n",
        "        else:\n",
        "            # inference-time mini-optimization: only forward the lm_head on the very last position\n",
        "            logits = self.lm_head(x[:, [-1], :]) # note: using list [-1] to preserve the time dim\n",
        "            loss = None\n",
        "\n",
        "        return logits, loss\n",
        "\n",
        "    @torch.no_grad()\n",
        "    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):\n",
        "        \"\"\"\n",
        "        Take a conditioning sequence of indices idx (LongTensor of shape (b,t)) and complete\n",
        "        the sequence max_new_tokens times, feeding the predictions back into the model each time.\n",
        "        Most likely you'll want to make sure to be in model.eval() mode of operation for this.\n",
        "        \"\"\"\n",
        "        for _ in range(max_new_tokens):\n",
        "            # if the sequence context is growing too long we must crop it at block_size\n",
        "            idx_cond = idx if idx.size(1) <= self.block_size else idx[:, -self.block_size:]\n",
        "            # forward the model to get the logits for the index in the sequence\n",
        "            logits, _ = self(idx_cond)\n",
        "            # pluck the logits at the final step and scale by desired temperature\n",
        "            logits = logits[:, -1, :] / temperature\n",
        "            # optionally crop the logits to only the top k options\n",
        "            if top_k is not None:\n",
        "                #\n",
        "                # TODO TASK 2.3  (done)\n",
        "                #\n",
        "                # Implement top k sampling\n",
        "                #\n",
        "                # my task 2.3--------------------------------------------------------------------------------@@@@@@@@@@@@@@@@\n",
        "                # Implement top-k sampling\n",
        "                values , indices = torch.topk(logits, top_k)\n",
        "                logits = torch.full_like(logits, float('-inf')) # fill with -inf\n",
        "                logits.scatter_(1, indices, values) # get top-k logits\n",
        "                #---------------------------------------------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@@@\n",
        "                pass # ?\n",
        "            # apply softmax to convert logits to (normalized) probabilities\n",
        "            probs = F.softmax(logits, dim=-1)\n",
        "            # sample from the distribution\n",
        "            idx_next = torch.multinomial(probs, num_samples=1)\n",
        "            # append sampled index to the running sequence and continue\n",
        "            idx = torch.cat([idx, idx_next], dim=1) #  -------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@\n",
        "\n",
        "        return idx"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n_layer = 4     # Number of transformer blocks\n",
        "n_embd = 64     # Embedding dimension\n",
        "n_head = 8      # Number of attention heads\n",
        "block_size = 128 # Maximum sequence length the model can handle\n",
        "vocab_size = 1000 # Size of the vocabulary\n",
        "dropout = 0.1   # Dropout rate\n",
        "\n",
        "gpt_model = GPT(n_layer, n_embd, n_head, block_size, vocab_size, dropout)\n",
        "\n",
        "B, T = 2, 10  # Batch size and sequence length for test\n",
        "idx = torch.randint(0, vocab_size, (B, T))\n",
        "\n",
        "logits, loss = gpt_model(idx)\n",
        "print('expected logits shape: ', (B, 1, vocab_size))\n",
        "print(\"Logits shape:\", logits.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DJ8cg5zOzWlF",
        "outputId": "d9e3f002-f6ed-450f-8a55-af78f3f35d98"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "expected logits shape:  (2, 1, 1000)\n",
            "Logits shape: torch.Size([2, 1, 1000])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Because there is no target labels, the `loss` will be `None`. Then logits only computed for the last token."
      ],
      "metadata": {
        "id": "jpRjeVlDzceE"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5yUezDv4MZvp"
      },
      "source": [
        "First we load our data containing the first four Harry Potter books:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "jpSnfRhjMZvp",
        "outputId": "0327220a-0f9c-476a-b758-df345c6c94b7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "length of dataset in characters: 2,652,656\n"
          ]
        }
      ],
      "source": [
        "data = \"\"\n",
        "for i in range(4):\n",
        "    input_file_path = f\"hp{i + 1}.txt\"\n",
        "    with open(input_file_path, 'r', encoding='latin-1') as f:\n",
        "        book = f.read()\n",
        "    data += book + \"\\n\"\n",
        "print(f\"length of dataset in characters: {len(data):,}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GkfY2n7IMZvp"
      },
      "source": [
        "Here the first few lines of the text:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "8n-wVbTqMZvp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f2fc49f-4b27-4ff2-b39a-6e4ffa50ff14"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Harry Potter and the Sorcerer's Stone\n",
            "\n",
            "\n",
            "CHAPTER ONE\n",
            "\n",
            "THE BOY WHO LIVED\n",
            "\n",
            "Mr. and Mrs. Dursley, of number four, Privet Drive, were proud to say\n",
            "that they were perfectly normal, thank you very much. They were the last\n",
            "people you'd expect to be involved in anything strange or mysterious,\n",
            "because they just didn't hold with such nonsense.\n",
            "\n",
            "Mr. Dursley was the director of a firm called Grunnings, which made\n",
            "drills. He was a big, beefy man with hardly any neck, although he did\n",
            "have a very large mustache\n"
          ]
        }
      ],
      "source": [
        "print(data[:500])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2JJvB6OZMZvp"
      },
      "source": [
        "We compute the vocabulary size, i.e. the number of unique tokens in our data. We are working at the character level, so we will count the number of unique characters:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "6f2z1gWTMZvp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4190cefa-e080-4fce-c485-aacebc9e837f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "all the unique characters: \t\n",
            " !\"$%&'()*,-./0123456789:;=?ABCDEFGHIJKLMNOPQRSTUVWXYZ\\]^_`abcdefghijklmnopqrstuvwxyz}~ü\n",
            "vocab size: 91\n"
          ]
        }
      ],
      "source": [
        "# get all the unique characters that occur in this text\n",
        "chars = sorted(list(set(data)))\n",
        "vocab_size = len(chars)\n",
        "print(\"all the unique characters:\", ''.join(chars))\n",
        "print(f\"vocab size: {vocab_size:,}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rON6oZhGMZvp"
      },
      "source": [
        "Here you will integer encode the data. Define the two `dict` `stoi` and `itos` as described in the task 2.1. Afterwards we will split our data into train (first 90% of tokens) and validation (last 10% of tokens) sets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "tnVLmkG0MZvq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0de32d91-0d66-472c-9e95-22c3afb8b097"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train has 2,387,390 tokens\n",
            "val has 265,266 tokens\n"
          ]
        }
      ],
      "source": [
        "# TODO TASK 2.1\n",
        "#\n",
        "# create a mapping from characters to integers (stoi) and from integers to characters (itos)\n",
        "#\n",
        "# my task 2.1 ------------------------- -------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@@\n",
        "stoi ={char: i for i, char in enumerate(chars)}# Create mappings {char: i for i, char in enumerate(chars)} creates a dictionary (stoi) mapping characters to their indices. (this gives indices )\n",
        "itos = {i: char for i, char in enumerate(chars)} # Create mappings {i: char for i, char in enumerate(chars)} creates a dictionary (itos) mapping indices to their corresponding characters.(this gives characters)\n",
        "#---------------------------------------------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@@@\n",
        "def encode(s):\n",
        "    return [stoi[c] for c in s] # encoder: take a string, output a list of integers\n",
        "def decode(l):\n",
        "    return ''.join([itos[i] for i in l]) # decoder: take a list of integers, output a string\n",
        "\n",
        "# create the train and test splits\n",
        "n = len(data)\n",
        "train_data = data[:int(n*0.9)]\n",
        "val_data = data[int(n*0.9):]\n",
        "\n",
        "# encode both to integers\n",
        "train_ids = encode(train_data)\n",
        "val_ids = encode(val_data)\n",
        "train_data = np.array(train_ids, dtype=np.uint16)\n",
        "val_data = np.array(val_ids, dtype=np.uint16)\n",
        "print(f\"train has {len(train_ids):,} tokens\")\n",
        "print(f\"val has {len(val_ids):,} tokens\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WwXhBHOUMZvq"
      },
      "source": [
        "Here we define some variables regarding training and the model. You can play with them, however it all should work with these default values:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "LodikX3QMZvq"
      },
      "outputs": [],
      "source": [
        "CUDA = True\n",
        "device = \"cuda\" if CUDA else \"cpu\"\n",
        "# data\n",
        "batch_size = 32\n",
        "block_size = 256\n",
        "# model\n",
        "n_layer = 6\n",
        "n_head = 6\n",
        "n_embd = 384\n",
        "dropout = 0.2\n",
        "# adamw optimizer\n",
        "learning_rate = 1e-3 # max learning rate\n",
        "max_iters = 10000 # total number of training iterations\n",
        "grad_clip = 1.0 # clip gradients at this value, or disable if == 0.0\n",
        "# learning rate decay settings\n",
        "warmup_iters = 1000 # how many steps to warm up for\n",
        "lr_decay_iters = max_iters\n",
        "min_lr = 1e-4\n",
        "# logging\n",
        "eval_interval = 100\n",
        "eval_iters = 10\n",
        "log_interval = 10\n",
        "# generation\n",
        "max_new_tokens = 100\n",
        "temperature = 0.8\n",
        "top_k = None"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8IRKV9sMZvq"
      },
      "source": [
        "We define the function that will sample training batches. Here you should define `y` so that the model is trained for next-token prediction:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "s8QAQ31tMZvq"
      },
      "outputs": [],
      "source": [
        "def get_batch(split):\n",
        "    data = train_data if split == 'train' else val_data\n",
        "    ix = torch.randint(len(data) - block_size, (batch_size,))\n",
        "    x = torch.stack([torch.from_numpy((data[i:i+block_size]).astype(np.int64)) for i in ix])\n",
        "    # TODO TASK 2.2\n",
        "    #\n",
        "    # Define the targets that would implement next-token prediction\n",
        "    #\n",
        "    #my task 2.2 ------------------------- -------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@@\n",
        "    y = torch.stack([torch.from_numpy((data[i+1:i+1+block_size]).astype(np.int64)) for i in ix]) # Constructs target sequences by shifting the input sequences by one position. This is for next-token prediction.\n",
        "    #---------------------------------------------------------------------------------------------@@@@@@@@@@@@@@@@@@@@@@@\n",
        "    # transfer to GPU (non_blocking=True for faster operations)\n",
        "    \"\"\" Construct target sequences for training. The targets are shifted by one position\n",
        "     compared to the inputs, which is the standard approach for next-token prediction\n",
        "     This means each target sequence is a shifted version of its corresponding input sequence\"\"\"\n",
        "    if device == 'cuda':\n",
        "        # pin arrays x,y, which allows us to move them to GPU asynchronously (non_blocking=True)\n",
        "        x, y = x.pin_memory().to(device, non_blocking=True), y.pin_memory().to(device, non_blocking=True)\n",
        "    else:\n",
        "        # If not using CUDA, simply transfer the data to the device\n",
        "        x, y = x.to(device), y.to(device)\n",
        "    # Return the batch of input sequences (x) and their corresponding target sequences (y)\n",
        "    return x, y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ggBEe7zMZvq"
      },
      "source": [
        "This function implements a learning rate schedule with a [warm-up phase and a cosine learning rate decay](https://residentmario.github.io/pytorch-training-performance-guide/lr-sched-and-optim.html#cosine-annealed-warm-restart). This turns out to be necessary to train transformer models."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "UeLA-ZjMMZvr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 256
        },
        "outputId": "d46575c5-7b43-4297-cce4-c5fa32a3be95"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x200 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# learning rate decay scheduler (cosine with warmup)\n",
        "def get_lr(it):\n",
        "    # 1) linear warmup for warmup_iters steps\n",
        "    if it < warmup_iters:\n",
        "        return learning_rate * it / warmup_iters\n",
        "    # 2) if it > lr_decay_iters, return min learning rate\n",
        "    if it > lr_decay_iters:\n",
        "        return min_lr\n",
        "    # 3) in between, use cosine decay down to min learning rate\n",
        "    decay_ratio = (it - warmup_iters) / (lr_decay_iters - warmup_iters)\n",
        "    assert 0 <= decay_ratio <= 1\n",
        "    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff ranges 0..1\n",
        "    return min_lr + coeff * (learning_rate - min_lr)\n",
        "\n",
        "lr_seq = [get_lr(i) for i in range(max_iters)]\n",
        "plt.figure(figsize=(4, 2))\n",
        "plt.plot(lr_seq)\n",
        "plt.title('Cosine learning rate schedule with warmup')\n",
        "plt.xlabel('Iteration')\n",
        "plt.ylabel('Learning rate')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pagXphF6MZvr"
      },
      "source": [
        "For more details you can read [this post](https://www.borealisai.com/research-blogs/tutorial-17-transformers-iii-training/#Why_are_these_tricks_required)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hcxe7BlnMZvr"
      },
      "source": [
        "Here we define our model, optimizer, and run our training:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "ovwkh7SaMZvr",
        "outputId": "663ae5ea-5eb6-4aa3-d9e0-75fa70476fcf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "step 0: train loss 4.5117, val loss 4.5117\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " pNvmQL}E 6mseüBOlB7\"\t.dldI1 ny8bsHl!_ $KCL6e`tsHXQm*qHV:~?aL)pjbSXJvj\"y`rH1\\)r)i15\\z`f/39a)63b?O$!m\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 0: loss 4.5115, time 3985.91ms\n",
            "iter 10: loss 4.5108, time 186.74ms\n",
            "iter 20: loss 4.5078, time 187.85ms\n",
            "iter 30: loss 4.5019, time 187.54ms\n",
            "iter 40: loss 4.4892, time 185.47ms\n",
            "iter 50: loss 4.4707, time 186.55ms\n",
            "iter 60: loss 4.4551, time 187.50ms\n",
            "iter 70: loss 4.4389, time 188.34ms\n",
            "iter 80: loss 4.4185, time 188.64ms\n",
            "iter 90: loss 4.3937, time 187.94ms\n",
            "step 100: train loss 4.3586, val loss 4.3534\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " H]qm2Wm%!nou}~)kF,ghnvWDsEQEEX/aE /g&^s],(XB/a/*c.1gl275e1PHzff2qoarwb,zOuFu\"Eel5yR.'i_he=W(l3'1nHv\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 100: loss 4.3628, time 2346.26ms\n",
            "iter 110: loss 4.3173, time 187.76ms\n",
            "iter 120: loss 4.2722, time 188.20ms\n",
            "iter 130: loss 4.1978, time 190.88ms\n",
            "iter 140: loss 4.1338, time 190.73ms\n",
            "iter 150: loss 4.0375, time 190.64ms\n",
            "iter 160: loss 3.9347, time 192.43ms\n",
            "iter 170: loss 3.8273, time 192.87ms\n",
            "iter 180: loss 3.7268, time 192.05ms\n",
            "iter 190: loss 3.6082, time 192.75ms\n",
            "step 200: train loss 3.5092, val loss 3.4773\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " teos&\n",
            "e7n _ühH$saaoFLUMn\"e}alros5ru}ptt(sa Zter clwt,d,lnS\n",
            "kloid]gste2ihnPwxn9mw E\n",
            "$4oeyao\"^b^trn8h\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 200: loss 3.5067, time 2222.14ms\n",
            "iter 210: loss 3.3981, time 193.55ms\n",
            "iter 220: loss 3.3305, time 194.69ms\n",
            "iter 230: loss 3.2516, time 193.90ms\n",
            "iter 240: loss 3.1967, time 193.96ms\n",
            "iter 250: loss 3.1476, time 192.71ms\n",
            "iter 260: loss 3.1046, time 195.88ms\n",
            "iter 270: loss 3.0136, time 198.26ms\n",
            "iter 280: loss 2.9940, time 196.24ms\n",
            "iter 290: loss 2.9882, time 196.46ms\n",
            "step 300: train loss 2.9226, val loss 2.8888\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " bol ,ne t 6 tok, angr amoe tot :  ar rlhocok posernns,se ..\n",
            "sHeii,le ore, bil ras teehre nmi mte lhe\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 300: loss 2.9118, time 2241.84ms\n",
            "iter 310: loss 2.9232, time 196.09ms\n",
            "iter 320: loss 2.8616, time 198.36ms\n",
            "iter 330: loss 2.8088, time 199.53ms\n",
            "iter 340: loss 2.7605, time 200.61ms\n",
            "iter 350: loss 2.7654, time 201.54ms\n",
            "iter 360: loss 2.7288, time 198.99ms\n",
            "iter 370: loss 2.7103, time 200.46ms\n",
            "iter 380: loss 2.7444, time 200.33ms\n",
            "iter 390: loss 2.7167, time 201.01ms\n",
            "step 400: train loss 2.6516, val loss 2.6192\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " 5\" isert't arind.Won Htend t tsand me wourthoupnn, e tod ilr thangheradhout atike pe he idid amo Ani\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 400: loss 2.6437, time 2440.22ms\n",
            "iter 410: loss 2.6075, time 201.81ms\n",
            "iter 420: loss 2.6200, time 201.44ms\n",
            "iter 430: loss 2.6215, time 203.38ms\n",
            "iter 440: loss 2.5910, time 202.92ms\n",
            "iter 450: loss 2.5927, time 206.58ms\n",
            "iter 460: loss 2.5625, time 203.80ms\n",
            "iter 470: loss 2.5730, time 208.26ms\n",
            "iter 480: loss 2.5811, time 206.38ms\n",
            "iter 490: loss 2.5813, time 206.59ms\n",
            "step 500: train loss 2.5573, val loss 2.5195\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " be Weast Rearplwes acom ofois ckamasoag ad I,\n",
            "Sllly n torfege s, ary llllyoutheed thastas eded he an\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 500: loss 2.5359, time 2326.34ms\n",
            "iter 510: loss 2.5619, time 203.26ms\n",
            "iter 520: loss 2.5707, time 203.99ms\n",
            "iter 530: loss 2.5507, time 202.50ms\n",
            "iter 540: loss 2.5345, time 202.68ms\n",
            "iter 550: loss 2.5515, time 204.23ms\n",
            "iter 560: loss 2.5462, time 205.11ms\n",
            "iter 570: loss 2.5282, time 202.98ms\n",
            "iter 580: loss 2.5211, time 202.63ms\n",
            "iter 590: loss 2.5407, time 201.80ms\n",
            "step 600: train loss 2.5005, val loss 2.4621\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " oth thof tking Had tharidond d te outhare tonoun.\n",
            "\"\n",
            "\n",
            "\n",
            "\"Handd iby meathar, corthoreckermoond ing bloo\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 600: loss 2.5346, time 2360.21ms\n",
            "iter 610: loss 2.5226, time 200.82ms\n",
            "iter 620: loss 2.4816, time 201.04ms\n",
            "iter 630: loss 2.4873, time 200.50ms\n",
            "iter 640: loss 2.4821, time 201.76ms\n",
            "iter 650: loss 2.5009, time 200.03ms\n",
            "iter 660: loss 2.5361, time 200.81ms\n",
            "iter 670: loss 2.4881, time 201.61ms\n",
            "iter 680: loss 2.4998, time 200.51ms\n",
            "iter 690: loss 2.5026, time 199.97ms\n",
            "step 700: train loss 2.4758, val loss 2.4347\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " s lisis ooy withe fotin sthe f teathar we sh ponar.  whathe woy be ate athec!\"\tThint wa d d caleras \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 700: loss 2.4867, time 2294.07ms\n",
            "iter 710: loss 2.4943, time 199.84ms\n",
            "iter 720: loss 2.4870, time 201.14ms\n",
            "iter 730: loss 2.4498, time 200.68ms\n",
            "iter 740: loss 2.4430, time 200.87ms\n",
            "iter 750: loss 2.4711, time 201.91ms\n",
            "iter 760: loss 2.4846, time 202.20ms\n",
            "iter 770: loss 2.4748, time 202.36ms\n",
            "iter 780: loss 2.4748, time 203.14ms\n",
            "iter 790: loss 2.4622, time 204.85ms\n",
            "step 800: train loss 2.4250, val loss 2.3929\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " eroe weas ghin lowe chet had than tong san f thand anoy ud the ffrad tof wha tho icor we s\n",
            "s pithad \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 800: loss 2.4267, time 2287.30ms\n",
            "iter 810: loss 2.4540, time 201.42ms\n",
            "iter 820: loss 2.4548, time 202.76ms\n",
            "iter 830: loss 2.4286, time 201.99ms\n",
            "iter 840: loss 2.4277, time 203.03ms\n",
            "iter 850: loss 2.4283, time 202.84ms\n",
            "iter 860: loss 2.4216, time 202.40ms\n",
            "iter 870: loss 2.4240, time 203.81ms\n",
            "iter 880: loss 2.3861, time 204.20ms\n",
            "iter 890: loss 2.4021, time 202.02ms\n",
            "step 900: train loss 2.3441, val loss 2.3191\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " \"O Thepernd tom there Feded danly  brind ait.\n",
            "\n",
            "\"NErdnowel ju Led arofu tend me iryoven the hind to s\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 900: loss 2.3868, time 2304.27ms\n",
            "iter 910: loss 2.3821, time 203.07ms\n",
            "iter 920: loss 2.3893, time 202.05ms\n",
            "iter 930: loss 2.3304, time 201.42ms\n",
            "iter 940: loss 2.3424, time 201.18ms\n",
            "iter 950: loss 2.3432, time 198.81ms\n",
            "iter 960: loss 2.3174, time 200.51ms\n",
            "iter 970: loss 2.3260, time 201.55ms\n",
            "iter 980: loss 2.3184, time 200.24ms\n",
            "iter 990: loss 2.3342, time 201.60ms\n",
            "step 1000: train loss 2.2165, val loss 2.1939\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " his!\"\n",
            "\"E's d said,\" Herry id agoknt washe ared. \"You'te su warrid tid athit,\"\n",
            "Th, said the othe at s\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1000: loss 2.3334, time 2299.47ms\n",
            "iter 1010: loss 2.2913, time 200.66ms\n",
            "iter 1020: loss 2.3006, time 198.95ms\n",
            "iter 1030: loss 2.2756, time 200.61ms\n",
            "iter 1040: loss 2.2680, time 197.88ms\n",
            "iter 1050: loss 2.2378, time 201.56ms\n",
            "iter 1060: loss 2.2659, time 201.16ms\n",
            "iter 1070: loss 2.2185, time 201.92ms\n",
            "iter 1080: loss 2.2732, time 200.77ms\n",
            "iter 1090: loss 2.2161, time 202.36ms\n",
            "step 1100: train loss 2.1340, val loss 2.1016\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Hary ateng the.   you nu conat he the bent apesptile, to sto be worth moorded houst\n",
            "reat the boown t\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1100: loss 2.2113, time 2433.17ms\n",
            "iter 1110: loss 2.2188, time 200.25ms\n",
            "iter 1120: loss 2.1788, time 201.53ms\n",
            "iter 1130: loss 2.2301, time 198.17ms\n",
            "iter 1140: loss 2.2048, time 201.63ms\n",
            "iter 1150: loss 2.2102, time 201.66ms\n",
            "iter 1160: loss 2.1776, time 202.25ms\n",
            "iter 1170: loss 2.1867, time 202.08ms\n",
            "iter 1180: loss 2.1642, time 202.46ms\n",
            "iter 1190: loss 2.1418, time 202.23ms\n",
            "step 1200: train loss 2.0430, val loss 2.0239\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " ofrully now min't's the broy.   He watilf oven the all. \"Che the ad wad that was o rofoling ig. We p\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1200: loss 2.1614, time 2293.62ms\n",
            "iter 1210: loss 2.1467, time 202.65ms\n",
            "iter 1220: loss 2.1550, time 200.93ms\n",
            "iter 1230: loss 2.1450, time 201.04ms\n",
            "iter 1240: loss 2.1330, time 202.52ms\n",
            "iter 1250: loss 2.1354, time 201.63ms\n",
            "iter 1260: loss 2.1385, time 203.36ms\n",
            "iter 1270: loss 2.1130, time 203.46ms\n",
            "iter 1280: loss 2.1170, time 201.95ms\n",
            "iter 1290: loss 2.1238, time 200.96ms\n",
            "step 1300: train loss 1.9763, val loss 1.9485\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " sed the om now blas the muched a\n",
            "Pifir thave he you fold haut the and the staid.\n",
            "\n",
            "\"Whe of dand looke\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1300: loss 2.1089, time 2281.84ms\n",
            "iter 1310: loss 2.1506, time 201.98ms\n",
            "iter 1320: loss 2.0914, time 202.25ms\n",
            "iter 1330: loss 2.0884, time 201.87ms\n",
            "iter 1340: loss 2.1229, time 202.32ms\n",
            "iter 1350: loss 2.0469, time 202.35ms\n",
            "iter 1360: loss 2.0946, time 203.22ms\n",
            "iter 1370: loss 2.0668, time 203.36ms\n",
            "iter 1380: loss 2.0619, time 200.65ms\n",
            "iter 1390: loss 2.0764, time 203.11ms\n",
            "step 1400: train loss 1.9266, val loss 1.8961\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " the waized of -\"\n",
            "\n",
            "Harry shest of Gryfindor he whis, every his beeaghating didn't ard the seas and\n",
            "ab\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1400: loss 2.0589, time 2309.93ms\n",
            "iter 1410: loss 2.0204, time 201.81ms\n",
            "iter 1420: loss 2.0435, time 202.94ms\n",
            "iter 1430: loss 2.0063, time 199.85ms\n",
            "iter 1440: loss 2.0079, time 202.95ms\n",
            "iter 1450: loss 2.0283, time 202.41ms\n",
            "iter 1460: loss 2.0230, time 204.14ms\n",
            "iter 1470: loss 2.0823, time 200.71ms\n",
            "iter 1480: loss 2.0185, time 203.17ms\n",
            "iter 1490: loss 2.0093, time 203.32ms\n",
            "step 1500: train loss 1.8967, val loss 1.8598\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " me - quicking over down he fir mom got of\n",
            "tay who was that's the deesting üther andon the get wan't \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1500: loss 2.0356, time 2355.63ms\n",
            "iter 1510: loss 2.0164, time 199.38ms\n",
            "iter 1520: loss 2.0330, time 198.22ms\n",
            "iter 1530: loss 1.9653, time 202.04ms\n",
            "iter 1540: loss 2.0306, time 201.61ms\n",
            "iter 1550: loss 1.9922, time 203.70ms\n",
            "iter 1560: loss 2.0136, time 202.06ms\n",
            "iter 1570: loss 1.9781, time 203.73ms\n",
            "iter 1580: loss 1.9701, time 203.82ms\n",
            "iter 1590: loss 1.9746, time 201.95ms\n",
            "step 1600: train loss 1.8488, val loss 1.8057\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " he round of the coulded to The sacked from at Well them lomen the was abouren ever preant.  Harry st\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1600: loss 1.9564, time 2299.99ms\n",
            "iter 1610: loss 2.0128, time 197.92ms\n",
            "iter 1620: loss 1.9664, time 200.67ms\n",
            "iter 1630: loss 1.9588, time 202.78ms\n",
            "iter 1640: loss 1.9676, time 202.73ms\n",
            "iter 1650: loss 1.9251, time 202.87ms\n",
            "iter 1660: loss 1.9883, time 203.24ms\n",
            "iter 1670: loss 1.9442, time 203.00ms\n",
            "iter 1680: loss 1.9395, time 202.81ms\n",
            "iter 1690: loss 1.9951, time 205.24ms\n",
            "step 1700: train loss 1.8119, val loss 1.7853\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " se frown, whe just of a now\n",
            "Harry now have lat goott the town the coloss.\"\n",
            "\n",
            "On as of under of black \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1700: loss 1.9375, time 2297.86ms\n",
            "iter 1710: loss 1.9714, time 202.26ms\n",
            "iter 1720: loss 1.9575, time 202.25ms\n",
            "iter 1730: loss 1.9617, time 204.20ms\n",
            "iter 1740: loss 1.8916, time 202.89ms\n",
            "iter 1750: loss 1.9426, time 203.11ms\n",
            "iter 1760: loss 1.9407, time 202.80ms\n",
            "iter 1770: loss 1.9531, time 204.25ms\n",
            "iter 1780: loss 1.9286, time 205.37ms\n",
            "iter 1790: loss 1.9245, time 203.08ms\n",
            "step 1800: train loss 1.7939, val loss 1.7410\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " usne seme hid wen han the the loked to and the set nore didn't you - Profesor Magall. AMcGoname Gryf\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1800: loss 1.9221, time 2458.06ms\n",
            "iter 1810: loss 1.9133, time 202.23ms\n",
            "iter 1820: loss 1.8979, time 203.08ms\n",
            "iter 1830: loss 1.8594, time 202.16ms\n",
            "iter 1840: loss 1.9207, time 203.73ms\n",
            "iter 1850: loss 1.9014, time 202.16ms\n",
            "iter 1860: loss 1.8815, time 205.23ms\n",
            "iter 1870: loss 1.9326, time 202.12ms\n",
            "iter 1880: loss 1.8888, time 203.07ms\n",
            "iter 1890: loss 1.8928, time 205.07ms\n",
            "step 1900: train loss 1.7509, val loss 1.7148\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " and Mugle Mr. I'd be you've right to the they, and but know to of looked domerst of the from through\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 1900: loss 1.8985, time 2291.11ms\n",
            "iter 1910: loss 1.8899, time 201.25ms\n",
            "iter 1920: loss 1.9471, time 203.59ms\n",
            "iter 1930: loss 1.8997, time 201.63ms\n",
            "iter 1940: loss 1.9019, time 202.96ms\n",
            "iter 1950: loss 1.8911, time 201.81ms\n",
            "iter 1960: loss 1.9521, time 203.14ms\n",
            "iter 1970: loss 1.8923, time 203.81ms\n",
            "iter 1980: loss 1.9124, time 197.84ms\n",
            "iter 1990: loss 1.8558, time 201.82ms\n",
            "step 2000: train loss 1.7232, val loss 1.7048\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " the.  He larming expred on her a got the\n",
            "comone with beack. Scarred had out thing the\n",
            "schemed the he\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2000: loss 1.9153, time 2290.63ms\n",
            "iter 2010: loss 1.8694, time 201.57ms\n",
            "iter 2020: loss 1.8610, time 202.45ms\n",
            "iter 2030: loss 1.8442, time 202.78ms\n",
            "iter 2040: loss 1.8888, time 200.94ms\n",
            "iter 2050: loss 1.8844, time 202.15ms\n",
            "iter 2060: loss 1.8968, time 202.14ms\n",
            "iter 2070: loss 1.8477, time 202.16ms\n",
            "iter 2080: loss 1.8323, time 203.71ms\n",
            "iter 2090: loss 1.8667, time 201.78ms\n",
            "step 2100: train loss 1.7026, val loss 1.6792\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " reming they got dempost and agoing the ly stice.\n",
            "Sfires cat, and Nevilling to whis the happeed on an\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2100: loss 1.8879, time 2296.22ms\n",
            "iter 2110: loss 1.8425, time 201.05ms\n",
            "iter 2120: loss 1.8452, time 201.59ms\n",
            "iter 2130: loss 1.8554, time 198.33ms\n",
            "iter 2140: loss 1.8419, time 202.19ms\n",
            "iter 2150: loss 1.8442, time 199.08ms\n",
            "iter 2160: loss 1.7891, time 203.05ms\n",
            "iter 2170: loss 1.8302, time 202.34ms\n",
            "iter 2180: loss 1.8287, time 204.36ms\n",
            "iter 2190: loss 1.8113, time 201.59ms\n",
            "step 2200: train loss 1.6797, val loss 1.6783\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " wandd and thing didan't had work the w, a and of the\n",
            "had himsered shat in the bing some up\n",
            "mome, and\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2200: loss 1.8524, time 2439.50ms\n",
            "iter 2210: loss 1.8184, time 201.00ms\n",
            "iter 2220: loss 1.8861, time 201.93ms\n",
            "iter 2230: loss 1.8597, time 200.73ms\n",
            "iter 2240: loss 1.8563, time 200.90ms\n",
            "iter 2250: loss 1.8001, time 202.60ms\n",
            "iter 2260: loss 1.8053, time 203.06ms\n",
            "iter 2270: loss 1.8268, time 202.08ms\n",
            "iter 2280: loss 1.8503, time 201.90ms\n",
            "iter 2290: loss 1.8407, time 203.37ms\n",
            "step 2300: train loss 1.6833, val loss 1.6495\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " the word fath to am on to tears Sabout Harry and more voice at Harry and the beanted a that it was g\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2300: loss 1.8329, time 2300.21ms\n",
            "iter 2310: loss 1.7845, time 202.89ms\n",
            "iter 2320: loss 1.8291, time 202.15ms\n",
            "iter 2330: loss 1.8178, time 202.05ms\n",
            "iter 2340: loss 1.7967, time 202.83ms\n",
            "iter 2350: loss 1.7889, time 203.75ms\n",
            "iter 2360: loss 1.8024, time 202.88ms\n",
            "iter 2370: loss 1.7823, time 203.43ms\n",
            "iter 2380: loss 1.8039, time 202.81ms\n",
            "iter 2390: loss 1.8010, time 202.40ms\n",
            "step 2400: train loss 1.6639, val loss 1.6240\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " toome, expling, a the loaked at\n",
            "sgold of Furtly of the ir the tarnges.\n",
            "\n",
            "\"She Bagan for shrough of se\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2400: loss 1.8138, time 2304.53ms\n",
            "iter 2410: loss 1.8134, time 201.75ms\n",
            "iter 2420: loss 1.7867, time 200.53ms\n",
            "iter 2430: loss 1.7504, time 203.85ms\n",
            "iter 2440: loss 1.7836, time 202.81ms\n",
            "iter 2450: loss 1.7951, time 201.32ms\n",
            "iter 2460: loss 1.7332, time 202.27ms\n",
            "iter 2470: loss 1.8673, time 204.87ms\n",
            "iter 2480: loss 1.7674, time 202.06ms\n",
            "iter 2490: loss 1.7864, time 203.86ms\n",
            "step 2500: train loss 1.6452, val loss 1.6236\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " The were sumping. \"Filch she said. \"The down with they'd make to no the coon, appaaint. Thing worric\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2500: loss 1.8181, time 2357.11ms\n",
            "iter 2510: loss 1.7993, time 200.96ms\n",
            "iter 2520: loss 1.7951, time 202.92ms\n",
            "iter 2530: loss 1.8208, time 203.23ms\n",
            "iter 2540: loss 1.7744, time 201.91ms\n",
            "iter 2550: loss 1.8460, time 202.09ms\n",
            "iter 2560: loss 1.7983, time 202.37ms\n",
            "iter 2570: loss 1.7798, time 205.25ms\n",
            "iter 2580: loss 1.8044, time 201.37ms\n",
            "iter 2590: loss 1.7698, time 203.47ms\n",
            "step 2600: train loss 1.6361, val loss 1.6085\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " tand the reall srak shop real the him.\n",
            "\"Harry's from they promsh, his ben you say and few she what t\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2600: loss 1.7995, time 2326.31ms\n",
            "iter 2610: loss 1.7638, time 201.45ms\n",
            "iter 2620: loss 1.8090, time 201.93ms\n",
            "iter 2630: loss 1.7278, time 203.12ms\n",
            "iter 2640: loss 1.8119, time 201.44ms\n",
            "iter 2650: loss 1.7939, time 201.52ms\n",
            "iter 2660: loss 1.7312, time 203.60ms\n",
            "iter 2670: loss 1.7255, time 203.45ms\n",
            "iter 2680: loss 1.7783, time 202.27ms\n",
            "iter 2690: loss 1.7327, time 203.65ms\n",
            "step 2700: train loss 1.6010, val loss 1.5817\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " and precked set the was bright, -- and I trous strape of Dursley been the can't what the said was lo\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2700: loss 1.7679, time 2288.32ms\n",
            "iter 2710: loss 1.7349, time 201.06ms\n",
            "iter 2720: loss 1.7560, time 202.33ms\n",
            "iter 2730: loss 1.7582, time 202.37ms\n",
            "iter 2740: loss 1.7914, time 202.36ms\n",
            "iter 2750: loss 1.7882, time 202.30ms\n",
            "iter 2760: loss 1.7503, time 201.86ms\n",
            "iter 2770: loss 1.7583, time 201.61ms\n",
            "iter 2780: loss 1.7436, time 203.10ms\n",
            "iter 2790: loss 1.7647, time 202.77ms\n",
            "step 2800: train loss 1.5998, val loss 1.5791\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " any the fling for of\n",
            "Harry Harry and fiving with the the the Dight. Sirius -\n",
            "*\n",
            "Doby so arish, the fa\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2800: loss 1.7498, time 2299.41ms\n",
            "iter 2810: loss 1.7158, time 198.85ms\n",
            "iter 2820: loss 1.7675, time 202.16ms\n",
            "iter 2830: loss 1.7401, time 202.41ms\n",
            "iter 2840: loss 1.7219, time 203.58ms\n",
            "iter 2850: loss 1.7583, time 201.92ms\n",
            "iter 2860: loss 1.6847, time 202.99ms\n",
            "iter 2870: loss 1.7099, time 203.35ms\n",
            "iter 2880: loss 1.7205, time 202.18ms\n",
            "iter 2890: loss 1.7808, time 203.30ms\n",
            "step 2900: train loss 1.5872, val loss 1.5704\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " his a show as the to sit my sent of the very was sont of Harry's cortail about again.\n",
            "\n",
            "\"What have wa\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 2900: loss 1.7709, time 2442.43ms\n",
            "iter 2910: loss 1.7362, time 202.07ms\n",
            "iter 2920: loss 1.7447, time 202.33ms\n",
            "iter 2930: loss 1.7614, time 203.09ms\n",
            "iter 2940: loss 1.7507, time 199.51ms\n",
            "iter 2950: loss 1.7867, time 201.46ms\n",
            "iter 2960: loss 1.7392, time 203.90ms\n",
            "iter 2970: loss 1.7276, time 200.51ms\n",
            "iter 2980: loss 1.7544, time 203.50ms\n",
            "iter 2990: loss 1.7016, time 202.08ms\n",
            "step 3000: train loss 1.5744, val loss 1.5602\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " he manting was who was thos Dumbledore head conly for be.  He were was good to the mone hears.  Prof\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3000: loss 1.7013, time 2288.86ms\n",
            "iter 3010: loss 1.7950, time 200.50ms\n",
            "iter 3020: loss 1.6868, time 200.92ms\n",
            "iter 3030: loss 1.7568, time 202.94ms\n",
            "iter 3040: loss 1.7855, time 201.31ms\n",
            "iter 3050: loss 1.7049, time 200.06ms\n",
            "iter 3060: loss 1.7367, time 200.79ms\n",
            "iter 3070: loss 1.7024, time 199.06ms\n",
            "iter 3080: loss 1.7401, time 202.14ms\n",
            "iter 3090: loss 1.6968, time 202.03ms\n",
            "step 3100: train loss 1.5574, val loss 1.5512\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " a plien payeved and Snape, a looking ping his head-posider.\n",
            "\n",
            "\"Oh you to kick me,\" said Harry, pledly\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3100: loss 1.6931, time 2283.33ms\n",
            "iter 3110: loss 1.6966, time 200.65ms\n",
            "iter 3120: loss 1.7066, time 202.54ms\n",
            "iter 3130: loss 1.7358, time 202.19ms\n",
            "iter 3140: loss 1.7351, time 200.62ms\n",
            "iter 3150: loss 1.7226, time 200.12ms\n",
            "iter 3160: loss 1.7303, time 202.92ms\n",
            "iter 3170: loss 1.7142, time 200.73ms\n",
            "iter 3180: loss 1.6779, time 200.63ms\n",
            "iter 3190: loss 1.6652, time 202.35ms\n",
            "step 3200: train loss 1.5599, val loss 1.5292\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " us of the sudder. The stand god him, now to get him the furch. The cament before to the broom.  He s\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3200: loss 1.7051, time 2359.84ms\n",
            "iter 3210: loss 1.7347, time 201.54ms\n",
            "iter 3220: loss 1.7300, time 202.45ms\n",
            "iter 3230: loss 1.7382, time 201.73ms\n",
            "iter 3240: loss 1.7171, time 201.99ms\n",
            "iter 3250: loss 1.7446, time 199.34ms\n",
            "iter 3260: loss 1.6499, time 203.63ms\n",
            "iter 3270: loss 1.7029, time 202.06ms\n",
            "iter 3280: loss 1.7303, time 202.25ms\n",
            "iter 3290: loss 1.7218, time 201.90ms\n",
            "step 3300: train loss 1.5527, val loss 1.5377\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Moody of the will finots anything at\n",
            "way way sen the Dumbledore of doents had exples expected the en\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3300: loss 1.6848, time 2390.90ms\n",
            "iter 3310: loss 1.7085, time 199.77ms\n",
            "iter 3320: loss 1.7405, time 202.35ms\n",
            "iter 3330: loss 1.7171, time 202.70ms\n",
            "iter 3340: loss 1.7497, time 201.30ms\n",
            "iter 3350: loss 1.7012, time 202.02ms\n",
            "iter 3360: loss 1.6789, time 202.45ms\n",
            "iter 3370: loss 1.7211, time 202.27ms\n",
            "iter 3380: loss 1.6846, time 202.36ms\n",
            "iter 3390: loss 1.7242, time 202.26ms\n",
            "step 3400: train loss 1.5577, val loss 1.5033\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " the reater, her ground of now -- \n",
            "\"How know furged to with A where cabe face while on the I've bet e\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3400: loss 1.6692, time 2305.52ms\n",
            "iter 3410: loss 1.6534, time 202.84ms\n",
            "iter 3420: loss 1.6787, time 202.50ms\n",
            "iter 3430: loss 1.6984, time 202.68ms\n",
            "iter 3440: loss 1.6869, time 202.36ms\n",
            "iter 3450: loss 1.6545, time 202.12ms\n",
            "iter 3460: loss 1.7470, time 201.38ms\n",
            "iter 3470: loss 1.6670, time 201.73ms\n",
            "iter 3480: loss 1.7057, time 201.74ms\n",
            "iter 3490: loss 1.6800, time 198.63ms\n",
            "step 3500: train loss 1.5264, val loss 1.5050\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " arking to the\n",
            "Ither kill for heads a have in to saying the have were\n",
            "could he senton down still in h\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3500: loss 1.7261, time 2575.53ms\n",
            "iter 3510: loss 1.6836, time 201.13ms\n",
            "iter 3520: loss 1.6654, time 202.29ms\n",
            "iter 3530: loss 1.6716, time 202.61ms\n",
            "iter 3540: loss 1.7140, time 201.26ms\n",
            "iter 3550: loss 1.7170, time 200.90ms\n",
            "iter 3560: loss 1.6532, time 201.90ms\n",
            "iter 3570: loss 1.6460, time 203.64ms\n",
            "iter 3580: loss 1.6494, time 202.92ms\n",
            "iter 3590: loss 1.6778, time 201.22ms\n",
            "step 3600: train loss 1.5199, val loss 1.5157\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " thing, but the cast Cup, Percy and trying had with with should in good his had now, And them Dumbled\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3600: loss 1.6829, time 2292.41ms\n",
            "iter 3610: loss 1.6533, time 201.70ms\n",
            "iter 3620: loss 1.6579, time 203.05ms\n",
            "iter 3630: loss 1.6636, time 201.97ms\n",
            "iter 3640: loss 1.7123, time 202.68ms\n",
            "iter 3650: loss 1.7148, time 199.34ms\n",
            "iter 3660: loss 1.7006, time 202.18ms\n",
            "iter 3670: loss 1.6720, time 202.10ms\n",
            "iter 3680: loss 1.6408, time 204.45ms\n",
            "iter 3690: loss 1.6634, time 202.65ms\n",
            "step 3700: train loss 1.5063, val loss 1.5154\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " was benting pand to sturnaps. It hald about what he\n",
            "glooked up a was stop his hard. He was one from \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3700: loss 1.6526, time 2299.17ms\n",
            "iter 3710: loss 1.6722, time 200.79ms\n",
            "iter 3720: loss 1.6664, time 202.92ms\n",
            "iter 3730: loss 1.6907, time 197.27ms\n",
            "iter 3740: loss 1.6308, time 201.54ms\n",
            "iter 3750: loss 1.7038, time 200.84ms\n",
            "iter 3760: loss 1.6617, time 201.41ms\n",
            "iter 3770: loss 1.6729, time 204.12ms\n",
            "iter 3780: loss 1.6464, time 202.81ms\n",
            "iter 3790: loss 1.6540, time 202.88ms\n",
            "step 3800: train loss 1.4976, val loss 1.4926\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " uther to him not the was for his dilar.\n",
            "\t\"It is you allet.\"\n",
            "\n",
            "\"He arry,\" said Harry.\n",
            "\n",
            "Harry and to th\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3800: loss 1.6978, time 2309.38ms\n",
            "iter 3810: loss 1.6488, time 200.07ms\n",
            "iter 3820: loss 1.6626, time 200.97ms\n",
            "iter 3830: loss 1.6375, time 202.33ms\n",
            "iter 3840: loss 1.6939, time 200.87ms\n",
            "iter 3850: loss 1.6307, time 203.09ms\n",
            "iter 3860: loss 1.6013, time 201.03ms\n",
            "iter 3870: loss 1.6581, time 201.27ms\n",
            "iter 3880: loss 1.6519, time 203.26ms\n",
            "iter 3890: loss 1.6884, time 201.44ms\n",
            "step 3900: train loss 1.5085, val loss 1.4798\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " was the dork the casser on end at the bursed.\n",
            "\n",
            "\"Nevile, but and You'rel back,\" said Ron.\n",
            "\n",
            "\"There was\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 3900: loss 1.7096, time 2358.98ms\n",
            "iter 3910: loss 1.6616, time 201.39ms\n",
            "iter 3920: loss 1.6568, time 201.53ms\n",
            "iter 3930: loss 1.6434, time 201.61ms\n",
            "iter 3940: loss 1.6484, time 202.22ms\n",
            "iter 3950: loss 1.6978, time 202.15ms\n",
            "iter 3960: loss 1.5846, time 204.34ms\n",
            "iter 3970: loss 1.6671, time 202.86ms\n",
            "iter 3980: loss 1.6837, time 202.55ms\n",
            "iter 3990: loss 1.6325, time 205.34ms\n",
            "step 4000: train loss 1.4864, val loss 1.4764\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " that was pointed of the blise closs the around a the ewt. Harry before quite to the back ent the rea\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4000: loss 1.6578, time 2293.88ms\n",
            "iter 4010: loss 1.6386, time 201.37ms\n",
            "iter 4020: loss 1.6844, time 202.10ms\n",
            "iter 4030: loss 1.6461, time 202.18ms\n",
            "iter 4040: loss 1.6537, time 202.52ms\n",
            "iter 4050: loss 1.7044, time 202.09ms\n",
            "iter 4060: loss 1.6304, time 202.98ms\n",
            "iter 4070: loss 1.6593, time 202.84ms\n",
            "iter 4080: loss 1.6717, time 202.36ms\n",
            "iter 4090: loss 1.6543, time 203.49ms\n",
            "step 4100: train loss 1.4836, val loss 1.4761\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " sparted!  A cast have and ground the echose was had resem catured to who help in had been up at the \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4100: loss 1.6762, time 2288.85ms\n",
            "iter 4110: loss 1.6267, time 202.14ms\n",
            "iter 4120: loss 1.6343, time 202.47ms\n",
            "iter 4130: loss 1.6587, time 202.21ms\n",
            "iter 4140: loss 1.6653, time 203.40ms\n",
            "iter 4150: loss 1.6978, time 202.62ms\n",
            "iter 4160: loss 1.6446, time 203.16ms\n",
            "iter 4170: loss 1.6123, time 202.44ms\n",
            "iter 4180: loss 1.6261, time 203.52ms\n",
            "iter 4190: loss 1.6517, time 203.48ms\n",
            "step 4200: train loss 1.4760, val loss 1.4839\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Hagrid to of start,\" said Snape a corning from the hards and\n",
            "say hose had to be a a lot a large get \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4200: loss 1.6860, time 2462.75ms\n",
            "iter 4210: loss 1.6171, time 201.15ms\n",
            "iter 4220: loss 1.6338, time 202.96ms\n",
            "iter 4230: loss 1.6105, time 202.81ms\n",
            "iter 4240: loss 1.6019, time 201.06ms\n",
            "iter 4250: loss 1.6316, time 200.92ms\n",
            "iter 4260: loss 1.6311, time 202.36ms\n",
            "iter 4270: loss 1.6592, time 202.51ms\n",
            "iter 4280: loss 1.6291, time 203.19ms\n",
            "iter 4290: loss 1.6205, time 203.19ms\n",
            "step 4300: train loss 1.4651, val loss 1.4566\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " and rustent was\n",
            "long for and wrong his many wanted to him. He wised a beater for\n",
            "pace Snape to the c\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4300: loss 1.6362, time 2289.72ms\n",
            "iter 4310: loss 1.6211, time 198.10ms\n",
            "iter 4320: loss 1.5674, time 200.11ms\n",
            "iter 4330: loss 1.6303, time 199.67ms\n",
            "iter 4340: loss 1.6415, time 200.04ms\n",
            "iter 4350: loss 1.6545, time 202.92ms\n",
            "iter 4360: loss 1.6122, time 202.66ms\n",
            "iter 4370: loss 1.6488, time 202.47ms\n",
            "iter 4380: loss 1.6857, time 202.69ms\n",
            "iter 4390: loss 1.6485, time 202.65ms\n",
            "step 4400: train loss 1.4592, val loss 1.4596\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " it the for both I was put of of liked thought - a rob, here was on the started to Harry the bent the\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4400: loss 1.6557, time 2294.80ms\n",
            "iter 4410: loss 1.6034, time 201.88ms\n",
            "iter 4420: loss 1.6268, time 202.27ms\n",
            "iter 4430: loss 1.6152, time 202.23ms\n",
            "iter 4440: loss 1.6662, time 202.74ms\n",
            "iter 4450: loss 1.6686, time 201.70ms\n",
            "iter 4460: loss 1.6467, time 203.19ms\n",
            "iter 4470: loss 1.6350, time 202.86ms\n",
            "iter 4480: loss 1.6274, time 200.97ms\n",
            "iter 4490: loss 1.5950, time 202.73ms\n",
            "step 4500: train loss 1.4697, val loss 1.4454\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " large gone the jacked and horrough it was for were that he leave again.\n",
            "\n",
            "\"He another the Uncle Verno\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4500: loss 1.6199, time 2298.28ms\n",
            "iter 4510: loss 1.6050, time 202.15ms\n",
            "iter 4520: loss 1.6368, time 201.92ms\n",
            "iter 4530: loss 1.6125, time 200.02ms\n",
            "iter 4540: loss 1.5894, time 201.02ms\n",
            "iter 4550: loss 1.6175, time 201.42ms\n",
            "iter 4560: loss 1.6123, time 201.44ms\n",
            "iter 4570: loss 1.5822, time 201.67ms\n",
            "iter 4580: loss 1.6161, time 203.61ms\n",
            "iter 4590: loss 1.5781, time 202.16ms\n",
            "step 4600: train loss 1.4445, val loss 1.4588\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Harry see word be looked about he now to her was a urturning him.\n",
            "\n",
            "Harry? There was a back in the fo\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4600: loss 1.5820, time 2441.08ms\n",
            "iter 4610: loss 1.6361, time 198.27ms\n",
            "iter 4620: loss 1.5998, time 201.51ms\n",
            "iter 4630: loss 1.5629, time 202.70ms\n",
            "iter 4640: loss 1.5576, time 202.84ms\n",
            "iter 4650: loss 1.6448, time 202.27ms\n",
            "iter 4660: loss 1.6332, time 203.06ms\n",
            "iter 4670: loss 1.6679, time 201.87ms\n",
            "iter 4680: loss 1.6151, time 202.33ms\n",
            "iter 4690: loss 1.6399, time 200.97ms\n",
            "step 4700: train loss 1.4732, val loss 1.4323\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " id the explater ento the ratching noges, the ring in the creamed two Malfoy off strange and his hair\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4700: loss 1.5996, time 2290.51ms\n",
            "iter 4710: loss 1.6417, time 199.91ms\n",
            "iter 4720: loss 1.6299, time 200.34ms\n",
            "iter 4730: loss 1.6332, time 198.21ms\n",
            "iter 4740: loss 1.6191, time 202.34ms\n",
            "iter 4750: loss 1.6153, time 204.03ms\n",
            "iter 4760: loss 1.6030, time 202.45ms\n",
            "iter 4770: loss 1.6319, time 200.66ms\n",
            "iter 4780: loss 1.6341, time 202.24ms\n",
            "iter 4790: loss 1.5911, time 202.04ms\n",
            "step 4800: train loss 1.4483, val loss 1.4527\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " and little was think not in he had fores a should up founds.  Ron would great standing in the was po\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4800: loss 1.6119, time 2300.34ms\n",
            "iter 4810: loss 1.5744, time 201.01ms\n",
            "iter 4820: loss 1.6145, time 200.47ms\n",
            "iter 4830: loss 1.6215, time 200.05ms\n",
            "iter 4840: loss 1.6102, time 200.07ms\n",
            "iter 4850: loss 1.6181, time 202.29ms\n",
            "iter 4860: loss 1.6171, time 202.70ms\n",
            "iter 4870: loss 1.5968, time 201.82ms\n",
            "iter 4880: loss 1.6011, time 202.00ms\n",
            "iter 4890: loss 1.6457, time 201.89ms\n",
            "step 4900: train loss 1.4505, val loss 1.4335\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Professor McGonagall was bull in a\n",
            "him was saw long completely.\n",
            "\n",
            "\"No, whole say he can word,\" said R\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 4900: loss 1.6304, time 2406.91ms\n",
            "iter 4910: loss 1.6218, time 203.30ms\n",
            "iter 4920: loss 1.6320, time 198.89ms\n",
            "iter 4930: loss 1.5830, time 200.44ms\n",
            "iter 4940: loss 1.5810, time 199.99ms\n",
            "iter 4950: loss 1.6066, time 201.22ms\n",
            "iter 4960: loss 1.6134, time 202.16ms\n",
            "iter 4970: loss 1.5571, time 201.72ms\n",
            "iter 4980: loss 1.5798, time 203.52ms\n",
            "iter 4990: loss 1.5799, time 203.03ms\n",
            "step 5000: train loss 1.4335, val loss 1.4252\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " \"What it contriced Malfoy?\" said Harry. \"I want a boy a moment so wizard by,\" said Mr. Weasley, \"he \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5000: loss 1.6122, time 2295.97ms\n",
            "iter 5010: loss 1.5717, time 201.27ms\n",
            "iter 5020: loss 1.5802, time 202.15ms\n",
            "iter 5030: loss 1.5975, time 203.02ms\n",
            "iter 5040: loss 1.6149, time 203.84ms\n",
            "iter 5050: loss 1.6241, time 200.98ms\n",
            "iter 5060: loss 1.6324, time 202.86ms\n",
            "iter 5070: loss 1.5714, time 204.42ms\n",
            "iter 5080: loss 1.6459, time 201.46ms\n",
            "iter 5090: loss 1.6378, time 202.95ms\n",
            "step 5100: train loss 1.4233, val loss 1.4212\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " ery and enon who one have got a eft about unce the reful of the\n",
            "chiring the cate like put of pice ap\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5100: loss 1.6192, time 2289.77ms\n",
            "iter 5110: loss 1.6242, time 202.00ms\n",
            "iter 5120: loss 1.5858, time 201.17ms\n",
            "iter 5130: loss 1.5414, time 202.58ms\n",
            "iter 5140: loss 1.5598, time 201.89ms\n",
            "iter 5150: loss 1.6591, time 201.39ms\n",
            "iter 5160: loss 1.5965, time 201.44ms\n",
            "iter 5170: loss 1.5233, time 202.19ms\n",
            "iter 5180: loss 1.5995, time 201.07ms\n",
            "iter 5190: loss 1.5809, time 202.27ms\n",
            "step 5200: train loss 1.4304, val loss 1.4195\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " \"I was my and start to do from seem and the of the eggs stairs, show dressing visisibit wizard call,\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5200: loss 1.5645, time 2311.05ms\n",
            "iter 5210: loss 1.5883, time 201.30ms\n",
            "iter 5220: loss 1.5662, time 200.16ms\n",
            "iter 5230: loss 1.5430, time 203.03ms\n",
            "iter 5240: loss 1.5673, time 201.70ms\n",
            "iter 5250: loss 1.5301, time 202.29ms\n",
            "iter 5260: loss 1.5648, time 201.75ms\n",
            "iter 5270: loss 1.6251, time 201.86ms\n",
            "iter 5280: loss 1.5602, time 203.11ms\n",
            "iter 5290: loss 1.6149, time 202.17ms\n",
            "step 5300: train loss 1.4190, val loss 1.4336\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " he to The sort - the Dursleys he knew what he was oning the raight to through him the get the rot of\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5300: loss 1.6443, time 2440.68ms\n",
            "iter 5310: loss 1.5603, time 200.65ms\n",
            "iter 5320: loss 1.6474, time 202.72ms\n",
            "iter 5330: loss 1.6071, time 201.33ms\n",
            "iter 5340: loss 1.5591, time 201.59ms\n",
            "iter 5350: loss 1.5609, time 201.42ms\n",
            "iter 5360: loss 1.5851, time 203.80ms\n",
            "iter 5370: loss 1.5940, time 202.16ms\n",
            "iter 5380: loss 1.5789, time 199.87ms\n",
            "iter 5390: loss 1.5358, time 201.29ms\n",
            "step 5400: train loss 1.4243, val loss 1.4152\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " cont into the Owl, and a the pers. Well the batters show what the partrent voice seated to the sing \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5400: loss 1.5653, time 2310.30ms\n",
            "iter 5410: loss 1.5845, time 201.73ms\n",
            "iter 5420: loss 1.6159, time 200.94ms\n",
            "iter 5430: loss 1.5751, time 200.46ms\n",
            "iter 5440: loss 1.6038, time 201.33ms\n",
            "iter 5450: loss 1.5740, time 202.17ms\n",
            "iter 5460: loss 1.5968, time 202.64ms\n",
            "iter 5470: loss 1.5330, time 202.69ms\n",
            "iter 5480: loss 1.6185, time 202.36ms\n",
            "iter 5490: loss 1.5494, time 202.77ms\n",
            "step 5500: train loss 1.4176, val loss 1.4146\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            "  Harry's few him had pointed from the extrememed\n",
            "Harry seemed to should him! He seemed to to stood e\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5500: loss 1.5609, time 2294.76ms\n",
            "iter 5510: loss 1.5919, time 203.59ms\n",
            "iter 5520: loss 1.5749, time 202.31ms\n",
            "iter 5530: loss 1.5827, time 201.86ms\n",
            "iter 5540: loss 1.6487, time 202.19ms\n",
            "iter 5550: loss 1.6333, time 201.37ms\n",
            "iter 5560: loss 1.5484, time 202.87ms\n",
            "iter 5570: loss 1.5762, time 202.88ms\n",
            "iter 5580: loss 1.5586, time 200.54ms\n",
            "iter 5590: loss 1.5671, time 202.94ms\n",
            "step 5600: train loss 1.4083, val loss 1.4066\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Ron to surpled the stuffed at the dress of out of his old betom, with was stuffing to the wall of th\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5600: loss 1.5815, time 2299.98ms\n",
            "iter 5610: loss 1.5984, time 202.13ms\n",
            "iter 5620: loss 1.5898, time 202.86ms\n",
            "iter 5630: loss 1.5542, time 201.52ms\n",
            "iter 5640: loss 1.5686, time 203.38ms\n",
            "iter 5650: loss 1.5691, time 202.21ms\n",
            "iter 5660: loss 1.6177, time 202.48ms\n",
            "iter 5670: loss 1.6527, time 201.53ms\n",
            "iter 5680: loss 1.5685, time 203.10ms\n",
            "iter 5690: loss 1.5880, time 202.93ms\n",
            "step 5700: train loss 1.4046, val loss 1.3993\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " it's head go. What it? The with was a cosen't wre couldn't like a who would to right.  It's be that \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5700: loss 1.5644, time 2310.72ms\n",
            "iter 5710: loss 1.5733, time 201.08ms\n",
            "iter 5720: loss 1.5472, time 202.55ms\n",
            "iter 5730: loss 1.5690, time 200.75ms\n",
            "iter 5740: loss 1.5789, time 203.43ms\n",
            "iter 5750: loss 1.5673, time 200.86ms\n",
            "iter 5760: loss 1.6014, time 202.77ms\n",
            "iter 5770: loss 1.5497, time 203.28ms\n",
            "iter 5780: loss 1.5817, time 202.02ms\n",
            "iter 5790: loss 1.5787, time 201.50ms\n",
            "step 5800: train loss 1.4079, val loss 1.4071\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " not so team.  Harry was just shaking every down his over their room, besting his opened.\n",
            "\"Doby,\" sai\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5800: loss 1.5384, time 2300.51ms\n",
            "iter 5810: loss 1.5531, time 201.34ms\n",
            "iter 5820: loss 1.5239, time 201.95ms\n",
            "iter 5830: loss 1.5938, time 200.56ms\n",
            "iter 5840: loss 1.5791, time 203.74ms\n",
            "iter 5850: loss 1.5500, time 202.89ms\n",
            "iter 5860: loss 1.5617, time 204.58ms\n",
            "iter 5870: loss 1.5782, time 202.24ms\n",
            "iter 5880: loss 1.5665, time 203.65ms\n",
            "iter 5890: loss 1.5911, time 202.11ms\n",
            "step 5900: train loss 1.3934, val loss 1.4105\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Slytherin, now stared of and mess of his head she downs at the\n",
            "work.\n",
            "\n",
            "\"Hagrid look at a shoked in --\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 5900: loss 1.5938, time 2299.19ms\n",
            "iter 5910: loss 1.6168, time 201.69ms\n",
            "iter 5920: loss 1.5481, time 204.21ms\n",
            "iter 5930: loss 1.5402, time 200.86ms\n",
            "iter 5940: loss 1.6170, time 202.46ms\n",
            "iter 5950: loss 1.5744, time 201.34ms\n",
            "iter 5960: loss 1.5839, time 203.09ms\n",
            "iter 5970: loss 1.5965, time 202.82ms\n",
            "iter 5980: loss 1.5532, time 202.12ms\n",
            "iter 5990: loss 1.5531, time 201.55ms\n",
            "step 6000: train loss 1.4158, val loss 1.3935\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " he was shaking him.  They was talking to be holded being for the hool, so the good of his train.  He\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6000: loss 1.5740, time 2451.19ms\n",
            "iter 6010: loss 1.5865, time 198.23ms\n",
            "iter 6020: loss 1.5851, time 202.22ms\n",
            "iter 6030: loss 1.5492, time 199.60ms\n",
            "iter 6040: loss 1.5334, time 198.83ms\n",
            "iter 6050: loss 1.5991, time 201.67ms\n",
            "iter 6060: loss 1.5601, time 200.74ms\n",
            "iter 6070: loss 1.5375, time 202.97ms\n",
            "iter 6080: loss 1.5701, time 202.04ms\n",
            "iter 6090: loss 1.5630, time 202.05ms\n",
            "step 6100: train loss 1.4051, val loss 1.3934\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " on  of\n",
            "the Potter that all, but the point of his had ben his of a lappe\n",
            "to so the bargeath back and \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6100: loss 1.5600, time 2321.61ms\n",
            "iter 6110: loss 1.5427, time 201.33ms\n",
            "iter 6120: loss 1.5677, time 202.20ms\n",
            "iter 6130: loss 1.5405, time 202.73ms\n",
            "iter 6140: loss 1.5603, time 202.87ms\n",
            "iter 6150: loss 1.5734, time 201.31ms\n",
            "iter 6160: loss 1.5478, time 200.56ms\n",
            "iter 6170: loss 1.5554, time 203.65ms\n",
            "iter 6180: loss 1.5580, time 202.54ms\n",
            "iter 6190: loss 1.5557, time 202.52ms\n",
            "step 6200: train loss 1.3904, val loss 1.3859\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " \"What must the came a normals, and couple baging till the scare all of the broomstick a started at t\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6200: loss 1.5713, time 2282.48ms\n",
            "iter 6210: loss 1.5555, time 202.33ms\n",
            "iter 6220: loss 1.5764, time 202.21ms\n",
            "iter 6230: loss 1.5850, time 202.99ms\n",
            "iter 6240: loss 1.5510, time 201.66ms\n",
            "iter 6250: loss 1.5622, time 202.40ms\n",
            "iter 6260: loss 1.5797, time 202.22ms\n",
            "iter 6270: loss 1.5595, time 202.75ms\n",
            "iter 6280: loss 1.5878, time 203.28ms\n",
            "iter 6290: loss 1.5572, time 201.96ms\n",
            "step 6300: train loss 1.3853, val loss 1.3759\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " normod the a face look-but down him. \"They we his look in them.  When the windows the that demalnt t\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6300: loss 1.5328, time 2300.25ms\n",
            "iter 6310: loss 1.5895, time 201.69ms\n",
            "iter 6320: loss 1.5444, time 201.87ms\n",
            "iter 6330: loss 1.5671, time 202.24ms\n",
            "iter 6340: loss 1.5170, time 201.24ms\n",
            "iter 6350: loss 1.5779, time 202.37ms\n",
            "iter 6360: loss 1.5873, time 202.33ms\n",
            "iter 6370: loss 1.5799, time 202.81ms\n",
            "iter 6380: loss 1.5465, time 201.75ms\n",
            "iter 6390: loss 1.5807, time 201.21ms\n",
            "step 6400: train loss 1.3851, val loss 1.3814\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Weasley.\"\n",
            "\"It's a picked all if the open the Gryffindor tell to knew his wand saw to be be of the Gr\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6400: loss 1.6025, time 2375.69ms\n",
            "iter 6410: loss 1.5414, time 201.68ms\n",
            "iter 6420: loss 1.5597, time 202.90ms\n",
            "iter 6430: loss 1.5459, time 201.94ms\n",
            "iter 6440: loss 1.5532, time 202.70ms\n",
            "iter 6450: loss 1.5525, time 202.29ms\n",
            "iter 6460: loss 1.5546, time 203.61ms\n",
            "iter 6470: loss 1.5349, time 203.39ms\n",
            "iter 6480: loss 1.5817, time 200.62ms\n",
            "iter 6490: loss 1.5477, time 201.00ms\n",
            "step 6500: train loss 1.3920, val loss 1.3685\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " I say find the Firebolt?\" Harry muttered. \"It was with the Fudges what was happened expection up out\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6500: loss 1.5412, time 2315.18ms\n",
            "iter 6510: loss 1.5465, time 202.09ms\n",
            "iter 6520: loss 1.5616, time 202.24ms\n",
            "iter 6530: loss 1.5039, time 198.79ms\n",
            "iter 6540: loss 1.5024, time 202.90ms\n",
            "iter 6550: loss 1.5876, time 202.30ms\n",
            "iter 6560: loss 1.5617, time 203.30ms\n",
            "iter 6570: loss 1.6216, time 200.85ms\n",
            "iter 6580: loss 1.5036, time 202.47ms\n",
            "iter 6590: loss 1.5617, time 201.69ms\n",
            "step 6600: train loss 1.3848, val loss 1.3703\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Harry was now, the could of Harry's hosting to room dith point.\n",
            "\"What's -- gald, graming on the some\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6600: loss 1.5533, time 2287.24ms\n",
            "iter 6610: loss 1.5263, time 200.86ms\n",
            "iter 6620: loss 1.5223, time 203.73ms\n",
            "iter 6630: loss 1.4972, time 205.00ms\n",
            "iter 6640: loss 1.5799, time 201.45ms\n",
            "iter 6650: loss 1.5095, time 199.97ms\n",
            "iter 6660: loss 1.5639, time 200.62ms\n",
            "iter 6670: loss 1.6071, time 202.67ms\n",
            "iter 6680: loss 1.5297, time 201.50ms\n",
            "iter 6690: loss 1.5721, time 203.70ms\n",
            "step 6700: train loss 1.3903, val loss 1.3777\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " a teach. Harry and him. The passed Harry's shake a man Ginny ark put of the dibled to completely wou\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6700: loss 1.5673, time 2462.02ms\n",
            "iter 6710: loss 1.5455, time 200.65ms\n",
            "iter 6720: loss 1.6046, time 202.86ms\n",
            "iter 6730: loss 1.5338, time 201.92ms\n",
            "iter 6740: loss 1.5489, time 201.54ms\n",
            "iter 6750: loss 1.5174, time 201.07ms\n",
            "iter 6760: loss 1.5842, time 201.66ms\n",
            "iter 6770: loss 1.5790, time 203.25ms\n",
            "iter 6780: loss 1.5037, time 201.23ms\n",
            "iter 6790: loss 1.5419, time 202.15ms\n",
            "step 6800: train loss 1.3750, val loss 1.3742\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " wasing meany didn't rather.\n",
            "\n",
            "\"Well,\" said Harry, which was shouldn't up to mind seem to\n",
            "the find how\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6800: loss 1.4783, time 2284.56ms\n",
            "iter 6810: loss 1.5677, time 201.13ms\n",
            "iter 6820: loss 1.5331, time 202.90ms\n",
            "iter 6830: loss 1.5444, time 203.46ms\n",
            "iter 6840: loss 1.4948, time 202.21ms\n",
            "iter 6850: loss 1.5240, time 198.96ms\n",
            "iter 6860: loss 1.5675, time 201.72ms\n",
            "iter 6870: loss 1.5002, time 200.84ms\n",
            "iter 6880: loss 1.5296, time 202.29ms\n",
            "iter 6890: loss 1.5543, time 202.36ms\n",
            "step 6900: train loss 1.3913, val loss 1.3637\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " he Wheasley, he never had pected to jeze his left.  It was they for a sbetter\n",
            "thing few a carefully \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 6900: loss 1.5350, time 2299.81ms\n",
            "iter 6910: loss 1.5833, time 201.62ms\n",
            "iter 6920: loss 1.5422, time 202.78ms\n",
            "iter 6930: loss 1.5238, time 202.45ms\n",
            "iter 6940: loss 1.5395, time 202.98ms\n",
            "iter 6950: loss 1.5195, time 201.29ms\n",
            "iter 6960: loss 1.5130, time 201.17ms\n",
            "iter 6970: loss 1.5658, time 201.82ms\n",
            "iter 6980: loss 1.5588, time 201.60ms\n",
            "iter 6990: loss 1.5796, time 202.76ms\n",
            "step 7000: train loss 1.3743, val loss 1.3600\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " a said, and the crowd\n",
            "of the end to the did, he was a gurling on the look of very\n",
            "place of his feel \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7000: loss 1.5216, time 2348.43ms\n",
            "iter 7010: loss 1.5303, time 201.33ms\n",
            "iter 7020: loss 1.5698, time 202.48ms\n",
            "iter 7030: loss 1.5255, time 201.14ms\n",
            "iter 7040: loss 1.5306, time 201.40ms\n",
            "iter 7050: loss 1.5356, time 202.55ms\n",
            "iter 7060: loss 1.4832, time 201.89ms\n",
            "iter 7070: loss 1.5347, time 198.16ms\n",
            "iter 7080: loss 1.5726, time 200.88ms\n",
            "iter 7090: loss 1.5125, time 202.36ms\n",
            "step 7100: train loss 1.3689, val loss 1.3729\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " all to know light as however -- could Moody, draggoly spedruck for enough to guals, started over the\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7100: loss 1.5270, time 2471.54ms\n",
            "iter 7110: loss 1.5209, time 200.17ms\n",
            "iter 7120: loss 1.5034, time 201.24ms\n",
            "iter 7130: loss 1.4714, time 202.33ms\n",
            "iter 7140: loss 1.5397, time 201.04ms\n",
            "iter 7150: loss 1.5659, time 202.32ms\n",
            "iter 7160: loss 1.5345, time 201.78ms\n",
            "iter 7170: loss 1.4705, time 202.31ms\n",
            "iter 7180: loss 1.5048, time 202.26ms\n",
            "iter 7190: loss 1.5497, time 199.61ms\n",
            "step 7200: train loss 1.3810, val loss 1.3594\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " he knorecks.\n",
            "\n",
            "\"But you suck for to know,\" said Harry, looking checking felt summed\n",
            "out of the sleep.\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7200: loss 1.5628, time 2296.70ms\n",
            "iter 7210: loss 1.5418, time 203.58ms\n",
            "iter 7220: loss 1.5462, time 201.77ms\n",
            "iter 7230: loss 1.5100, time 201.24ms\n",
            "iter 7240: loss 1.5016, time 202.28ms\n",
            "iter 7250: loss 1.5352, time 203.66ms\n",
            "iter 7260: loss 1.5229, time 202.49ms\n",
            "iter 7270: loss 1.5031, time 205.10ms\n",
            "iter 7280: loss 1.5218, time 201.99ms\n",
            "iter 7290: loss 1.5571, time 201.45ms\n",
            "step 7300: train loss 1.3510, val loss 1.3511\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " the books around.  Dear who was to see seemed of the year.\"\n",
            "\n",
            "\"Uncle Vernon a four the bright point r\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7300: loss 1.5491, time 2293.31ms\n",
            "iter 7310: loss 1.5193, time 202.04ms\n",
            "iter 7320: loss 1.5453, time 203.51ms\n",
            "iter 7330: loss 1.5448, time 202.09ms\n",
            "iter 7340: loss 1.5293, time 201.25ms\n",
            "iter 7350: loss 1.4869, time 202.44ms\n",
            "iter 7360: loss 1.4766, time 202.34ms\n",
            "iter 7370: loss 1.5771, time 202.81ms\n",
            "iter 7380: loss 1.4806, time 202.95ms\n",
            "iter 7390: loss 1.5118, time 202.80ms\n",
            "step 7400: train loss 1.3729, val loss 1.3543\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " really room, but this just table in the fall.\n",
            "\n",
            "Harry was called into the black ears of your the pass\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7400: loss 1.4660, time 2423.42ms\n",
            "iter 7410: loss 1.5422, time 201.27ms\n",
            "iter 7420: loss 1.5042, time 201.93ms\n",
            "iter 7430: loss 1.5688, time 201.43ms\n",
            "iter 7440: loss 1.4859, time 202.58ms\n",
            "iter 7450: loss 1.4846, time 201.38ms\n",
            "iter 7460: loss 1.5111, time 202.06ms\n",
            "iter 7470: loss 1.5313, time 200.28ms\n",
            "iter 7480: loss 1.5149, time 200.94ms\n",
            "iter 7490: loss 1.5329, time 200.72ms\n",
            "step 7500: train loss 1.3612, val loss 1.3751\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " all up its the back door, the snapped forget away. Ron was pulling the saw on his gave way the picke\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7500: loss 1.4976, time 2284.80ms\n",
            "iter 7510: loss 1.5237, time 202.52ms\n",
            "iter 7520: loss 1.4996, time 202.33ms\n",
            "iter 7530: loss 1.4389, time 201.50ms\n",
            "iter 7540: loss 1.4955, time 202.13ms\n",
            "iter 7550: loss 1.4753, time 202.78ms\n",
            "iter 7560: loss 1.5008, time 201.98ms\n",
            "iter 7570: loss 1.4980, time 203.27ms\n",
            "iter 7580: loss 1.4915, time 202.83ms\n",
            "iter 7590: loss 1.5307, time 201.39ms\n",
            "step 7600: train loss 1.3596, val loss 1.3606\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " his bown and some up the certion arm at the more car.  It was not and it the barm, not what Harry fe\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7600: loss 1.5752, time 2301.57ms\n",
            "iter 7610: loss 1.5197, time 200.84ms\n",
            "iter 7620: loss 1.5168, time 202.27ms\n",
            "iter 7630: loss 1.5556, time 201.66ms\n",
            "iter 7640: loss 1.5417, time 203.06ms\n",
            "iter 7650: loss 1.5428, time 201.12ms\n",
            "iter 7660: loss 1.5057, time 202.05ms\n",
            "iter 7670: loss 1.4989, time 202.94ms\n",
            "iter 7680: loss 1.4787, time 202.08ms\n",
            "iter 7690: loss 1.5190, time 202.60ms\n",
            "step 7700: train loss 1.3524, val loss 1.3720\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " me his head slightly, had going with about until complete who in his cosing\n",
            "fire-Krum and up at he w\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7700: loss 1.5269, time 2293.45ms\n",
            "iter 7710: loss 1.5110, time 201.32ms\n",
            "iter 7720: loss 1.5007, time 203.16ms\n",
            "iter 7730: loss 1.5215, time 201.14ms\n",
            "iter 7740: loss 1.4954, time 200.27ms\n",
            "iter 7750: loss 1.5402, time 201.36ms\n",
            "iter 7760: loss 1.5554, time 202.37ms\n",
            "iter 7770: loss 1.5133, time 202.68ms\n",
            "iter 7780: loss 1.5133, time 202.82ms\n",
            "iter 7790: loss 1.5243, time 203.31ms\n",
            "step 7800: train loss 1.3618, val loss 1.3600\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " was his feast, and he were flast the trying to explaned a visit, and Harry near the troubles.  \"It w\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7800: loss 1.5463, time 2467.47ms\n",
            "iter 7810: loss 1.5053, time 200.70ms\n",
            "iter 7820: loss 1.5136, time 202.20ms\n",
            "iter 7830: loss 1.5286, time 201.86ms\n",
            "iter 7840: loss 1.5310, time 202.30ms\n",
            "iter 7850: loss 1.4908, time 203.25ms\n",
            "iter 7860: loss 1.5044, time 202.78ms\n",
            "iter 7870: loss 1.5038, time 202.26ms\n",
            "iter 7880: loss 1.5159, time 200.46ms\n",
            "iter 7890: loss 1.5076, time 201.40ms\n",
            "step 7900: train loss 1.3761, val loss 1.3639\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " row into the spotted on the rarge the castle, dark had been on of the mount dormitory.  It was a sto\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 7900: loss 1.5369, time 2294.97ms\n",
            "iter 7910: loss 1.4853, time 200.68ms\n",
            "iter 7920: loss 1.4692, time 202.32ms\n",
            "iter 7930: loss 1.5167, time 201.79ms\n",
            "iter 7940: loss 1.5219, time 201.35ms\n",
            "iter 7950: loss 1.5569, time 201.55ms\n",
            "iter 7960: loss 1.4498, time 202.16ms\n",
            "iter 7970: loss 1.4969, time 202.36ms\n",
            "iter 7980: loss 1.5145, time 202.92ms\n",
            "iter 7990: loss 1.4672, time 203.11ms\n",
            "step 8000: train loss 1.3509, val loss 1.3581\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Harry and Ron completely\n",
            "around the castle. \"Moody,\" said Harry.\n",
            "\n",
            "\"Harry getting you between Snape's\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8000: loss 1.4899, time 2298.84ms\n",
            "iter 8010: loss 1.5268, time 201.30ms\n",
            "iter 8020: loss 1.4882, time 201.77ms\n",
            "iter 8030: loss 1.4973, time 204.23ms\n",
            "iter 8040: loss 1.5187, time 202.75ms\n",
            "iter 8050: loss 1.4575, time 202.27ms\n",
            "iter 8060: loss 1.4856, time 202.72ms\n",
            "iter 8070: loss 1.5437, time 202.90ms\n",
            "iter 8080: loss 1.4791, time 202.27ms\n",
            "iter 8090: loss 1.5096, time 201.39ms\n",
            "step 8100: train loss 1.3519, val loss 1.3405\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " and Harry was take around.\n",
            "\n",
            "\"They're said, the good-black several paints from his wand Potter Did\n",
            "AP\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8100: loss 1.4852, time 2407.44ms\n",
            "iter 8110: loss 1.5146, time 201.50ms\n",
            "iter 8120: loss 1.5208, time 201.14ms\n",
            "iter 8130: loss 1.5090, time 204.47ms\n",
            "iter 8140: loss 1.5236, time 200.96ms\n",
            "iter 8150: loss 1.4881, time 201.38ms\n",
            "iter 8160: loss 1.5098, time 201.40ms\n",
            "iter 8170: loss 1.4733, time 203.02ms\n",
            "iter 8180: loss 1.5421, time 201.83ms\n",
            "iter 8190: loss 1.4817, time 203.38ms\n",
            "step 8200: train loss 1.3494, val loss 1.3534\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " Harry was voice the cering happened forward to heard.  They wouldn't the such back to get be they ha\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8200: loss 1.4883, time 2317.15ms\n",
            "iter 8210: loss 1.5364, time 201.80ms\n",
            "iter 8220: loss 1.5305, time 203.60ms\n",
            "iter 8230: loss 1.5288, time 201.73ms\n",
            "iter 8240: loss 1.4967, time 200.83ms\n",
            "iter 8250: loss 1.5095, time 204.50ms\n",
            "iter 8260: loss 1.4789, time 201.98ms\n",
            "iter 8270: loss 1.5148, time 202.92ms\n",
            "iter 8280: loss 1.4948, time 202.77ms\n",
            "iter 8290: loss 1.4945, time 203.06ms\n",
            "step 8300: train loss 1.3386, val loss 1.3537\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " they realized staffed.\n",
            "\n",
            "\"I've got to cerner yours Filch work, I'm a dep it's like a pofice.\n",
            "\n",
            "\"Though\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8300: loss 1.5340, time 2294.45ms\n",
            "iter 8310: loss 1.4862, time 201.46ms\n",
            "iter 8320: loss 1.5288, time 201.20ms\n",
            "iter 8330: loss 1.5047, time 202.88ms\n",
            "iter 8340: loss 1.5241, time 204.13ms\n",
            "iter 8350: loss 1.5050, time 201.90ms\n",
            "iter 8360: loss 1.5136, time 202.17ms\n",
            "iter 8370: loss 1.5499, time 202.87ms\n",
            "iter 8380: loss 1.4992, time 201.97ms\n",
            "iter 8390: loss 1.4935, time 202.51ms\n",
            "step 8400: train loss 1.3578, val loss 1.3521\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " from the cat was of the\n",
            "line, they're rembers.\"\n",
            "\n",
            "\n",
            "55\n",
            "\n",
            "was put greating and the feel the name of the \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8400: loss 1.4835, time 2308.18ms\n",
            "iter 8410: loss 1.5361, time 201.52ms\n",
            "iter 8420: loss 1.5314, time 199.96ms\n",
            "iter 8430: loss 1.4914, time 202.35ms\n",
            "iter 8440: loss 1.4788, time 203.02ms\n",
            "iter 8450: loss 1.5395, time 202.84ms\n",
            "iter 8460: loss 1.5221, time 203.27ms\n",
            "iter 8470: loss 1.4796, time 202.60ms\n",
            "iter 8480: loss 1.4751, time 202.84ms\n",
            "iter 8490: loss 1.5086, time 201.94ms\n",
            "step 8500: train loss 1.3381, val loss 1.3442\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " not to car, \"in the shouldn't have wand!\"\n",
            "\"I'll been a to common trying down to know work few the we\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8500: loss 1.4719, time 2451.32ms\n",
            "iter 8510: loss 1.5183, time 201.98ms\n",
            "iter 8520: loss 1.5302, time 203.24ms\n",
            "iter 8530: loss 1.5091, time 201.87ms\n",
            "iter 8540: loss 1.5315, time 203.57ms\n",
            "iter 8550: loss 1.5041, time 202.19ms\n",
            "iter 8560: loss 1.5161, time 203.29ms\n",
            "iter 8570: loss 1.4972, time 201.47ms\n",
            "iter 8580: loss 1.5506, time 203.34ms\n",
            "iter 8590: loss 1.4869, time 202.12ms\n",
            "step 8600: train loss 1.3327, val loss 1.3347\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " fist how was just eggting down started on the Gryffindor Hall.\n",
            "\n",
            "\"Dragon, what were meant,\" said Hagr\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8600: loss 1.4721, time 2302.05ms\n",
            "iter 8610: loss 1.4931, time 201.36ms\n",
            "iter 8620: loss 1.4787, time 202.68ms\n",
            "iter 8630: loss 1.4773, time 202.80ms\n",
            "iter 8640: loss 1.4950, time 202.45ms\n",
            "iter 8650: loss 1.5056, time 203.03ms\n",
            "iter 8660: loss 1.5113, time 201.17ms\n",
            "iter 8670: loss 1.4799, time 202.83ms\n",
            "iter 8680: loss 1.4998, time 203.40ms\n",
            "iter 8690: loss 1.4657, time 202.68ms\n",
            "step 8700: train loss 1.3321, val loss 1.3406\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " with you?\"\n",
            "\"How graped Hagrid,\" said Professor McGonagall.\n",
            "\"Who we've got a class,\" said Harry.\n",
            "\"Moo\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8700: loss 1.5152, time 2303.08ms\n",
            "iter 8710: loss 1.4988, time 202.66ms\n",
            "iter 8720: loss 1.4716, time 203.05ms\n",
            "iter 8730: loss 1.4672, time 201.45ms\n",
            "iter 8740: loss 1.4611, time 202.79ms\n",
            "iter 8750: loss 1.5235, time 202.90ms\n",
            "iter 8760: loss 1.5026, time 201.58ms\n",
            "iter 8770: loss 1.5072, time 203.35ms\n",
            "iter 8780: loss 1.4797, time 202.48ms\n",
            "iter 8790: loss 1.5110, time 202.27ms\n",
            "step 8800: train loss 1.3396, val loss 1.3458\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " cream, everyone squame steps into the balnt for room.  It was did a vary so and shaking into be the \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8800: loss 1.4507, time 2295.94ms\n",
            "iter 8810: loss 1.4697, time 201.03ms\n",
            "iter 8820: loss 1.5360, time 200.89ms\n",
            "iter 8830: loss 1.4522, time 200.63ms\n",
            "iter 8840: loss 1.4967, time 201.77ms\n",
            "iter 8850: loss 1.4480, time 198.85ms\n",
            "iter 8860: loss 1.4988, time 200.64ms\n",
            "iter 8870: loss 1.5106, time 201.79ms\n",
            "iter 8880: loss 1.4951, time 201.84ms\n",
            "iter 8890: loss 1.5158, time 202.85ms\n",
            "step 8900: train loss 1.3427, val loss 1.3434\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " he really had expected the Gryffindor toward the\n",
            "portrating.\n",
            "\n",
            "\"God for his was shoulder,\" said Harry\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 8900: loss 1.5356, time 2286.27ms\n",
            "iter 8910: loss 1.4916, time 202.54ms\n",
            "iter 8920: loss 1.5094, time 200.92ms\n",
            "iter 8930: loss 1.4851, time 202.16ms\n",
            "iter 8940: loss 1.4964, time 200.83ms\n",
            "iter 8950: loss 1.4900, time 202.11ms\n",
            "iter 8960: loss 1.5094, time 203.17ms\n",
            "iter 8970: loss 1.4768, time 201.89ms\n",
            "iter 8980: loss 1.4992, time 201.85ms\n",
            "iter 8990: loss 1.4747, time 201.93ms\n",
            "step 9000: train loss 1.3427, val loss 1.3438\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " comparked for the pills.\n",
            "\"I'm going to be something to the lands, and down began the can't going dow\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9000: loss 1.5060, time 2277.77ms\n",
            "iter 9010: loss 1.4657, time 201.82ms\n",
            "iter 9020: loss 1.5374, time 202.70ms\n",
            "iter 9030: loss 1.4929, time 201.11ms\n",
            "iter 9040: loss 1.4731, time 201.86ms\n",
            "iter 9050: loss 1.4985, time 199.22ms\n",
            "iter 9060: loss 1.4639, time 199.11ms\n",
            "iter 9070: loss 1.5104, time 201.11ms\n",
            "iter 9080: loss 1.4617, time 199.08ms\n",
            "iter 9090: loss 1.4469, time 201.20ms\n",
            "step 9100: train loss 1.3381, val loss 1.3432\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " mother, which the Burust it was could on the darkly for the floor, between staring on the crowd a la\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9100: loss 1.4855, time 2292.21ms\n",
            "iter 9110: loss 1.5250, time 202.16ms\n",
            "iter 9120: loss 1.4911, time 201.35ms\n",
            "iter 9130: loss 1.4876, time 200.87ms\n",
            "iter 9140: loss 1.5245, time 202.30ms\n",
            "iter 9150: loss 1.4995, time 202.14ms\n",
            "iter 9160: loss 1.4677, time 201.60ms\n",
            "iter 9170: loss 1.4991, time 202.11ms\n",
            "iter 9180: loss 1.5260, time 202.63ms\n",
            "iter 9190: loss 1.4958, time 202.48ms\n",
            "step 9200: train loss 1.3293, val loss 1.3436\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " with classss, The really and now his hands entrance, the spoke of and it was breakfast in the ductin\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9200: loss 1.4995, time 2428.13ms\n",
            "iter 9210: loss 1.5005, time 201.94ms\n",
            "iter 9220: loss 1.5079, time 201.39ms\n",
            "iter 9230: loss 1.5207, time 201.48ms\n",
            "iter 9240: loss 1.5162, time 202.85ms\n",
            "iter 9250: loss 1.4713, time 202.41ms\n",
            "iter 9260: loss 1.4652, time 202.96ms\n",
            "iter 9270: loss 1.5329, time 202.10ms\n",
            "iter 9280: loss 1.5028, time 202.31ms\n",
            "iter 9290: loss 1.4762, time 202.11ms\n",
            "step 9300: train loss 1.3445, val loss 1.3379\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " got on the from him the way giving to know and look it.\n",
            "\n",
            "\"No,\" said Ron, pulling his his wand visiti\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9300: loss 1.5474, time 2305.68ms\n",
            "iter 9310: loss 1.5248, time 202.00ms\n",
            "iter 9320: loss 1.4792, time 202.45ms\n",
            "iter 9330: loss 1.4835, time 203.11ms\n",
            "iter 9340: loss 1.4805, time 202.63ms\n",
            "iter 9350: loss 1.4847, time 203.92ms\n",
            "iter 9360: loss 1.5266, time 201.38ms\n",
            "iter 9370: loss 1.5090, time 202.62ms\n",
            "iter 9380: loss 1.4989, time 201.35ms\n",
            "iter 9390: loss 1.4950, time 204.00ms\n",
            "step 9400: train loss 1.3272, val loss 1.3401\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " had been and her next to the hurried shak of the crowd with all bran achment .. .\n",
            "\"Why could right, \n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9400: loss 1.4603, time 2282.47ms\n",
            "iter 9410: loss 1.4598, time 201.55ms\n",
            "iter 9420: loss 1.4450, time 202.75ms\n",
            "iter 9430: loss 1.4991, time 201.91ms\n",
            "iter 9440: loss 1.4755, time 200.74ms\n",
            "iter 9450: loss 1.4592, time 201.72ms\n",
            "iter 9460: loss 1.4577, time 202.64ms\n",
            "iter 9470: loss 1.4672, time 202.61ms\n",
            "iter 9480: loss 1.4751, time 203.28ms\n",
            "iter 9490: loss 1.5134, time 202.84ms\n",
            "step 9500: train loss 1.3362, val loss 1.3268\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " before you dold in his wand and its and from it.  He was ambout with a low in a so a really surprise\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9500: loss 1.4990, time 2327.70ms\n",
            "iter 9510: loss 1.4768, time 201.23ms\n",
            "iter 9520: loss 1.4359, time 202.27ms\n",
            "iter 9530: loss 1.4962, time 200.77ms\n",
            "iter 9540: loss 1.4843, time 203.71ms\n",
            "iter 9550: loss 1.4674, time 203.02ms\n",
            "iter 9560: loss 1.4738, time 202.95ms\n",
            "iter 9570: loss 1.4879, time 200.68ms\n",
            "iter 9580: loss 1.5268, time 201.02ms\n",
            "iter 9590: loss 1.4866, time 201.45ms\n",
            "step 9600: train loss 1.3596, val loss 1.3336\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " robes and a mind at over passed the first face.\n",
            "\"You see,\" said Harry, run having, opening his smoke\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9600: loss 1.5200, time 2290.32ms\n",
            "iter 9610: loss 1.4877, time 201.86ms\n",
            "iter 9620: loss 1.5070, time 201.81ms\n",
            "iter 9630: loss 1.4887, time 202.26ms\n",
            "iter 9640: loss 1.4909, time 201.50ms\n",
            "iter 9650: loss 1.4229, time 201.95ms\n",
            "iter 9660: loss 1.4506, time 203.00ms\n",
            "iter 9670: loss 1.5164, time 202.39ms\n",
            "iter 9680: loss 1.4541, time 201.82ms\n",
            "iter 9690: loss 1.4902, time 202.75ms\n",
            "step 9700: train loss 1.3475, val loss 1.3144\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " ruple of steped carefuls a had after brow the porty still of the corridor.  Was he'd looking at comp\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9700: loss 1.4798, time 2297.29ms\n",
            "iter 9710: loss 1.4642, time 203.66ms\n",
            "iter 9720: loss 1.4705, time 198.84ms\n",
            "iter 9730: loss 1.5128, time 200.77ms\n",
            "iter 9740: loss 1.4293, time 202.04ms\n",
            "iter 9750: loss 1.4934, time 202.61ms\n",
            "iter 9760: loss 1.5158, time 201.70ms\n",
            "iter 9770: loss 1.4858, time 203.06ms\n",
            "iter 9780: loss 1.4938, time 202.24ms\n",
            "iter 9790: loss 1.4677, time 203.06ms\n",
            "step 9800: train loss 1.3484, val loss 1.3421\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " and should the power\n",
            "bons' high playing hundred. They had been back room at the\n",
            "peace was busy shuti\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9800: loss 1.5427, time 2295.28ms\n",
            "iter 9810: loss 1.5184, time 201.91ms\n",
            "iter 9820: loss 1.5059, time 202.44ms\n",
            "iter 9830: loss 1.4899, time 203.63ms\n",
            "iter 9840: loss 1.4571, time 203.02ms\n",
            "iter 9850: loss 1.4728, time 201.66ms\n",
            "iter 9860: loss 1.5105, time 204.46ms\n",
            "iter 9870: loss 1.5027, time 202.98ms\n",
            "iter 9880: loss 1.4788, time 204.07ms\n",
            "iter 9890: loss 1.5147, time 202.37ms\n",
            "step 9900: train loss 1.3171, val loss 1.3239\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " whether was calling the two black your like see, and the rooms close of your the flaming in the will\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 9900: loss 1.4961, time 2441.70ms\n",
            "iter 9910: loss 1.5238, time 202.39ms\n",
            "iter 9920: loss 1.5087, time 202.06ms\n",
            "iter 9930: loss 1.4798, time 201.13ms\n",
            "iter 9940: loss 1.4477, time 202.49ms\n",
            "iter 9950: loss 1.4966, time 203.44ms\n",
            "iter 9960: loss 1.5135, time 202.27ms\n",
            "iter 9970: loss 1.4667, time 203.69ms\n",
            "iter 9980: loss 1.5309, time 202.38ms\n",
            "iter 9990: loss 1.4765, time 202.59ms\n",
            "step 10000: train loss 1.3349, val loss 1.3273\n",
            "----------------------------------------------------------------------------------------------------\n",
            "Example generated:\n",
            "----------------------------------------------------------------------------------------------------\n",
            " as he was trying from Dobby and Ron's came with the leg to after the tea all of black one the walls,\n",
            "----------------------------------------------------------------------------------------------------\n",
            "iter 10000: loss 1.5086, time 2312.10ms\n"
          ]
        }
      ],
      "source": [
        "# We define the model\n",
        "model = GPT(n_layer, n_embd, n_head, block_size, vocab_size, dropout)\n",
        "model.to(device)\n",
        "# optimizer\n",
        "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)\n",
        "\n",
        "# helps estimate an arbitrarily accurate loss over either split using many batches\n",
        "@torch.no_grad()\n",
        "def estimate_loss():\n",
        "    out = {}\n",
        "    model.eval()\n",
        "    for split in ['train', 'val']:\n",
        "        losses = torch.zeros(eval_iters)\n",
        "        for k in range(eval_iters):\n",
        "            X, Y = get_batch(split)\n",
        "            logits, loss = model(X, Y)\n",
        "            losses[k] = loss.item()\n",
        "        out[split] = losses.mean()\n",
        "    model.train()\n",
        "    return out\n",
        "\n",
        "# training loop\n",
        "X, Y = get_batch('train') # fetch the very first batch\n",
        "t0 = time.time()\n",
        "iter_num = 0 # number of iterations in the lifetime of this process\n",
        "while True:\n",
        "    # determine and set the learning rate for this iteration\n",
        "    lr = get_lr(iter_num)\n",
        "    for param_group in optimizer.param_groups:\n",
        "        param_group['lr'] = lr\n",
        "    # evaluate the loss on train/val sets\n",
        "    if iter_num % eval_interval == 0:\n",
        "        losses = estimate_loss()\n",
        "        print(f\"step {iter_num}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}\")\n",
        "        start = \" \"\n",
        "        start_ids = encode(start)\n",
        "        x = (torch.tensor(start_ids, dtype=torch.long, device=device)[None, ...])\n",
        "        # run generation\n",
        "        model.eval()\n",
        "        try:\n",
        "            with torch.no_grad():\n",
        "                y = model.generate(x, max_new_tokens, temperature=temperature, top_k=top_k)\n",
        "        except Exception as e:\n",
        "            pass # If you haven't implemented the generate code\n",
        "        model.train()\n",
        "        print('-' * 100)\n",
        "        print(\"Example generated:\")\n",
        "        print('-' * 100)\n",
        "        print(decode(y[0].tolist()))\n",
        "        print('-' * 100)\n",
        "    logits, loss = model(X, Y)\n",
        "    X, Y = get_batch('train')\n",
        "    # clip the gradient\n",
        "    if grad_clip != 0.0:\n",
        "        torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)\n",
        "    # Backward pass and optimization\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "    # timing and logging\n",
        "    t1 = time.time()\n",
        "    dt = t1 - t0\n",
        "    t0 = t1\n",
        "    if iter_num % log_interval == 0:\n",
        "        lossf = loss.item() # loss as float. note: this is a CPU-GPU sync point\n",
        "        print(f\"iter {iter_num}: loss {lossf:.4f}, time {dt*1000:.2f}ms\")\n",
        "    iter_num += 1\n",
        "    # termination conditions\n",
        "    if iter_num > max_iters:\n",
        "        break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eYhFkUx4MZvr"
      },
      "source": [
        "Now we will assess the English knowledge of our trained model (Task 3). We load the pairs of words and sentences and print some examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "TpOsxhkuMZvs",
        "outputId": "ddf11b79-6011-4c0d-d562-3e669b27784b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['objectivity', 'osbrectifity']\n",
            "[\"Harry hadn't attacked himself\", \"Harry hadn't attacked herself\"]\n"
          ]
        }
      ],
      "source": [
        "with open(\"wuggy.txt\", 'r') as f:\n",
        "    spelling_samples = [sample[:-1].split(',') for sample in f]\n",
        "with open(\"blimp.txt\", 'r') as f:\n",
        "    grammar_test_samples = [sample[:-1].split(',') for sample in f]\n",
        "print(spelling_samples[0])\n",
        "print(grammar_test_samples[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "referenced_widgets": [
            "64bb6e84e2764c618fad5542a7e90dbd",
            "3f1ad5de658148fcb9a6b8f2c94c94f1",
            "8ff127ce9bab4950807a7c1e49c5c17a",
            "8e5e4d218295481abd990c29aef7c97b",
            "3723265be8c944a690d9b045fd0a54e1",
            "66a57e3bca2845c1b81fc8835dcdb01f",
            "3d38b117f7ba4a7fa141668a935a9245",
            "68a86d5807ee49b395293c90bc2012f1",
            "ff7f31852e1d47dbaf3137a38268ca2f",
            "5441ca83e46d4e13b40ee1612084d8f2",
            "8e697e7a3af448be86e2d2137d493d22",
            "ff258bd2e052435d9fc136f68940701a",
            "2b71942f6f6943c2b035233e27c588c5",
            "283c6d137544414cbea5e3da1f8ca04c",
            "4be7cfaf383e4113b785f848a6d59b75",
            "977043a387a845efadabfdeee993a7b1",
            "67ef647e91144401ae6d4e94d5b98df3",
            "4622d08381ff46a0b5e23875f4be511a",
            "7f38187341594281b65c3fac174ac26b",
            "14949b2458ba46a6b85eaa8fa5c2754a",
            "ef757a7cc3bf4a2d9720c2700b80012e",
            "d5ed48b288924c67abdae6b44735133f"
          ],
          "base_uri": "https://localhost:8080/",
          "height": 117
        },
        "id": "KxcFeqhjMZvs",
        "outputId": "0e66a412-897e-403e-9f30-67f89228d9e5"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/40000 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "64bb6e84e2764c618fad5542a7e90dbd"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Spelling score:  0.5112999677658081\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/500 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "ff258bd2e052435d9fc136f68940701a"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Grammar score:  0.5160000324249268\n"
          ]
        }
      ],
      "source": [
        "from tqdm.notebook import tqdm\n",
        "def get_sample_prob(X):\n",
        "    #\n",
        "    # TODO TASK 3\n",
        "    #\n",
        "    # Compute the probability of sequence X\n",
        "    #\n",
        "    logits, _ = model(X[:, :-1]) # Forward pass through the model. Exclude the last token for prediction purposes\n",
        "    log_probs = F.log_softmax(logits, dim=-1) # Compute the log probabilities of the tokens\n",
        "\n",
        "    targets = X[:, 1:]  # The targets are the tokens shifted by one position\n",
        "\n",
        "    gathered_log_probs = torch.gather(log_probs, 2, targets.unsqueeze(1)).squeeze(2)\n",
        "    # print(gathered_log_probs.shape)\n",
        "    # Sum the log probabilities for the entire sequence\n",
        "    sequence_log_prob = gathered_log_probs.sum()\n",
        "\n",
        "    return sequence_log_prob # Convert back from log probabilities\n",
        "# Evaluate spelling correctness using the model\n",
        "spelling_scores = []\n",
        "for sample in tqdm(spelling_samples):\n",
        "    word, non_word = sample\n",
        "    # Tokenize and prepare the word and non-word for the model\n",
        "    tokenized_word = encode(word)\n",
        "    tokenized_word = torch.tensor(tokenized_word, dtype=torch.long).unsqueeze(0)\n",
        "    prob_word = get_sample_prob(tokenized_word.to(device))\n",
        "    tokenized_non_word = encode(non_word)\n",
        "    tokenized_non_word = torch.tensor(tokenized_non_word, dtype=torch.long).unsqueeze(0)\n",
        "    prob_non_word = get_sample_prob(tokenized_non_word.to(device))\n",
        "    # Compare the probabilities and score for spelling correctness\n",
        "    spelling_score = 1.0 * (prob_word > prob_non_word)\n",
        "    spelling_scores.append(spelling_score)\n",
        "# Calculate and print the average spelling score\n",
        "print(\"Spelling score: \", torch.stack(spelling_scores).mean().item())\n",
        "\n",
        "grammar_scores = []\n",
        "for sample in tqdm(grammar_test_samples):\n",
        "    sentence, non_sentence = sample\n",
        "    tokenized_sentence = encode(sentence) # # Tokenize and prepare the sentence and non-sentence for the model\n",
        "    tokenized_sentence = torch.tensor(tokenized_sentence, dtype=torch.long).unsqueeze(0)\n",
        "    prob_sentence = get_sample_prob(tokenized_sentence.to(device))\n",
        "    tokenized_non_sentence = encode(non_sentence)\n",
        "    tokenized_non_sentence = torch.tensor(tokenized_non_sentence, dtype=torch.long).unsqueeze(0)\n",
        "    prob_non_sentence = get_sample_prob(tokenized_non_sentence.to(device))\n",
        "    # # Compare the probabilities and score for grammar correctness\n",
        "    grammar_scores.append(1.0 * (prob_sentence > prob_non_sentence))\n",
        "# Calculate and print the average grammar score\n",
        "print(\"Grammar score: \", torch.stack(grammar_scores).mean().item())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l_AcuA8BMZvs"
      },
      "source": [
        "# Problem 3. Vision transformer\n",
        "\n",
        "Transformers go well beyond text. They have been applied with tremendous success to many modalities (audio, images, video, graphs, etc). However, its application to images can be unintuitive, as we do not tend to think of them as the 1D sequences for which transformers were designed. In this exercise we will implement a vision transformer to illustrate how this works.\n",
        "\n",
        "We use the classic MNIST dataset and will try to get a vision transformer to do classification of handwritten numbers."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g2GPktOHMZvs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "18399d17-3b3f-43d2-dbb9-d4540539db69"
      },
      "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, 167415825.38it/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, 40204345.78it/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, 36251940.25it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-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/t10k-labels-idx1-ubyte.gz\n",
            "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, 4700352.52it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=None)\n",
        "mnist_testset = datasets.MNIST(root='./data', train=False, download=True, transform=None)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kLh4XZhrMZvs"
      },
      "source": [
        "Let's take a look at one of the samples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rp0MkesmMZvs",
        "outputId": "285c159a-3fbe-49a0-82b1-571e83075328",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "first_image = np.array(mnist_trainset[1][0])\n",
        "plt.imshow(first_image, cmap='gray')\n",
        "plt.title('First MNIST image')\n",
        "plt.xlabel('Columns')\n",
        "plt.ylabel('Rows')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Ys_TIVNMZvs"
      },
      "source": [
        "The way we turn an image into a 1D sequence is pretty straightforward. We can simply flatten it in a row major form. That is, we will turn our 28x28 pixels image into a 784 long sequence, with the first row becoming the first 24 elements, the second row the next, and so on."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fs6I3mroMZvt",
        "outputId": "c4c11861-318a-4f51-e8e8-89be98566c1b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x10 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "flattened_image = first_image.reshape(-1)\n",
        "plt.figure(figsize=(10, 0.1))\n",
        "plt.imshow([flattened_image], cmap='gray', aspect='auto')\n",
        "plt.title('Flattened sequence of pixels')\n",
        "plt.xlabel('Pixel Index')\n",
        "plt.yticks([])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vGb5k5CtMZvt"
      },
      "source": [
        "This should work fine, but there is a technical issue. Remember that transformer's computational cost scales quadratically with the length of the sequence. Notice that our tiny 24x24 pixels image already results in a sequence of length 784. This is ok as long as you have a moderately large GPU and you use a not too large batch size, but in Colab, or in the smallest GPUs in our cluster we might already run into memory issues. Moreover, in most practical applications we will be dealing with much larger images. For a standard HD image of 1024 x 768 pixels we would have a sequence length of 786432! This is already almost 10 times more than what the state-of-the-art models like GPT-4 support.\n",
        "\n",
        "In practice, instead of working on sequences of pixels, we use sequences of image patches. We will split our image into non-overlapping 4x4 patches:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VzRJxtmSMZvt",
        "outputId": "606a557a-5edb-480e-f5ec-57f7163efaee",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 451
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Image with 4x4 Patches')"
            ]
          },
          "metadata": {},
          "execution_count": 39
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "image_size = first_image.shape[0]\n",
        "patch_size = 4\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(first_image, cmap='gray')\n",
        "for i in range(0, image_size, patch_size):\n",
        "    for j in range(0, image_size, patch_size):\n",
        "        rect = Rectangle((j, i), patch_size, patch_size, linewidth=1, edgecolor='r', facecolor='none')\n",
        "        ax.add_patch(rect)\n",
        "ax.set_xticks(np.arange(0, image_size, patch_size))\n",
        "ax.set_yticks(np.arange(0, image_size, patch_size))\n",
        "ax.set_xticklabels([])\n",
        "ax.set_yticklabels([])\n",
        "ax.grid(True, which='both', linestyle='--', linewidth=1, color='gray', alpha=0.5)\n",
        "plt.title(f'Image with {patch_size}x{patch_size} Patches')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DGiVMgt4MZvt"
      },
      "source": [
        "When we flattened it, it becomes a sequence of 49 patches:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xEwWeKT6MZvt",
        "outputId": "dcefad95-d5c3-418d-dc2e-183f2cd61e13",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 55
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x200 with 49 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "patch_sequence = []\n",
        "for i in range(0, image_size, patch_size):\n",
        "    for j in range(0, image_size, patch_size):\n",
        "        patch = first_image[i:i+patch_size, j:j+patch_size]\n",
        "        patch_sequence.append(patch)\n",
        "num_patches = (image_size // patch_size) ** 2\n",
        "fig, axs = plt.subplots(1, num_patches, figsize=(15, 2))\n",
        "for i, patch in enumerate(patch_sequence):\n",
        "    axs[i].imshow(patch, cmap='gray')\n",
        "    axs[i].set_title(i)\n",
        "    axs[i].axis('off')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h3Y_kDyqMZvt"
      },
      "source": [
        "_Note: in most practical applications we will be dealing with much larger images, so we will need larger patches in order to sufficiently shorten the sequence length._\n",
        "\n",
        "\n",
        "Finally we transform each patch, a 4x4 matrix, into a vector of 16 elements, which is the input our transformer expects. We simply flatten each patch:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bBmpxlOTMZvt",
        "outputId": "d0714264-e132-4a91-cbe4-1599f59c7f72",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 91
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x100 with 49 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, axs = plt.subplots(1, num_patches, figsize=(15, 1))\n",
        "for i, patch in enumerate(patch_sequence):\n",
        "    axs[i].imshow(patch.reshape(-1, 1), cmap='gray')\n",
        "    axs[i].set_title(i)\n",
        "    axs[i].axis('off')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-obeOeYjMZvu"
      },
      "source": [
        "We have our inputs ready. Now onto the model. This is the architecture our digit classifier will use:\n",
        "    \n",
        "  <div>\n",
        "        <img src=\"attachment:image.png\" width=\"500\"/>\n",
        "    </div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1SerZ32rMZvu"
      },
      "source": [
        "**Tasks**:\n",
        "1. **(3 pt)** Implement the architecture of the classifier in the class `VisionTransformer` and train it on the MNIST dataset. Note that you can reuse most of the elements that you already implemented for `GPT`. You just need to avoid auto-regressive masking and figure out how to input the patches instead of discrete tokens.\n",
        "2. **(2 pt)** Implement a simple convolutional network classifier and compare its performnace with the vision transformer.\n",
        "3. **(4 pt máx)** Implement any of the two methods from the paper [Vision Transformer for Small-Size Datasets](https://arxiv.org/pdf/2112.13492v1.pdf) to try to improve the performance of our model. You can find a Keras tutorial implementing them [here](https://keras.io/examples/vision/vit_small_ds/#implement-locality-self-attention). Each method is worth **2 pt**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bINeEARWMZvu"
      },
      "source": [
        "Let's start defining some parameters. As before, it works with these defaults, but you can play with them"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MTLP38N-MZvu"
      },
      "outputs": [],
      "source": [
        "mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=None)\n",
        "mnist_testset = datasets.MNIST(root='./data', train=False, download=True, transform=None)\n",
        "\n",
        "device = \"cuda\" if CUDA else \"cpu\"\n",
        "# data\n",
        "batch_size = 32\n",
        "patch_size = 4\n",
        "img_w, img_h = np.array(mnist_trainset[1][0]).shape\n",
        "block_size = img_w // patch_size * img_h // patch_size\n",
        "# model\n",
        "n_layer = 6\n",
        "n_head = 6\n",
        "n_embd = 384\n",
        "dropout = 0.2\n",
        "input_size = patch_size * patch_size\n",
        "n_classes = 10 # 10-digit classification\n",
        "# adamw optimizer\n",
        "learning_rate = 5e-4 # max learning rate\n",
        "max_iters = 10000 # total number of training iterations\n",
        "grad_clip = 1.0 # clip gradients at this value, or disable if == 0.0\n",
        "# learning rate decay settings\n",
        "warmup_iters = 1000 # how many steps to warm up for\n",
        "lr_decay_iters = max_iters\n",
        "min_lr = 5e-5\n",
        "# logging\n",
        "eval_interval = 1000\n",
        "log_interval = 100"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wWlC1d3aMZvu"
      },
      "source": [
        "Now we preprocess our dataset to transform every image into patch sequences of shape `(49, patch_size, patch_size)`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Am4K_dgBMZvu"
      },
      "outputs": [],
      "source": [
        "# Transformation to extract patches and flatten them\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Lambda(lambda x: x.unfold(1, patch_size, patch_size).unfold(2, patch_size, patch_size)),\n",
        "    transforms.Lambda(lambda x: x.contiguous().view(-1, patch_size, patch_size)),\n",
        "])\n",
        "\n",
        "# Apply the transform to the loaded datasets\n",
        "mnist_trainset.transform = transform\n",
        "mnist_testset.transform = transform"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RM4WP1tdMZvu"
      },
      "source": [
        "Here you have to define the model:"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class MultiheadAttention(nn.Module):\n",
        "\n",
        "    def __init__(self, n_embd, n_head, block_size, dropout):\n",
        "        super().__init__()\n",
        "        assert n_embd % n_head == 0, \"The embedding dimension bust be divisible by the number of heads\"\n",
        "        self.n_head = n_head\n",
        "        self.n_embd = n_embd\n",
        "        # key, query, value projections for all heads, but in a batch\n",
        "        self.c_attn = nn.Linear(n_embd, 3 * n_embd, bias=False)\n",
        "        # output projection\n",
        "        self.c_proj = nn.Linear(n_embd, n_embd, bias=False)\n",
        "        # regularization\n",
        "        self.attn_dropout = nn.Dropout(dropout)\n",
        "        self.resid_dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd)\n",
        "        # calculate query, key, values for all heads in batch and move head forward to be the batch dim\n",
        "        q, k, v  = self.c_attn(x).split(self.n_embd, dim=2) # ?\n",
        "        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
        "        # print(f'q: {q.shape}')\n",
        "        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
        "        # print(f'k: {k.shape}')\n",
        "        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
        "        # print(f'v: {v.shape}')\n",
        "        #\n",
        "        # TODO TASK 1.1\n",
        "        #\n",
        "        # Implement the forward pass of MultiheadAttention\n",
        "        #\n",
        "        att = torch.matmul(q, k.transpose(-2, -1)) # (B, nh, T, T)\n",
        "        mask = torch.tril(torch.ones((T, T), device=x.device)).unsqueeze(0).unsqueeze(0) # (1, 1, T, T)\n",
        "        masked_att = att.masked_fill(mask == 0, float('-inf')) # (B, nh, T, T)\n",
        "        scores = torch.softmax(masked_att, dim=-1) # ?\n",
        "        scores = self.attn_dropout(scores)\n",
        "\n",
        "\n",
        "        # Compute attention output\n",
        "        y = torch.matmul(scores, v) # (B, nh, T, hs) hs = C / nh\n",
        "        y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side\n",
        "        # output projection\n",
        "        y = self.c_proj(y)\n",
        "        y = self.resid_dropout(y)\n",
        "        return y\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "class MLP(nn.Module):\n",
        "\n",
        "    def __init__(self, n_embd, dropout):\n",
        "        super().__init__()\n",
        "        self.c_fc    = nn.Linear(n_embd, 4 * n_embd, bias=False)\n",
        "        self.gelu    = nn.GELU()\n",
        "        self.c_proj  = nn.Linear(4 * n_embd, n_embd, bias=False)\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.c_fc(x)\n",
        "        x = self.gelu(x)\n",
        "        x = self.c_proj(x)\n",
        "        x = self.dropout(x)\n",
        "        return x\n",
        "class Block(nn.Module):\n",
        "\n",
        "    def __init__(self, n_embd, n_head, block_size, dropout):\n",
        "        super().__init__()\n",
        "        self.ln_1 = nn.LayerNorm(n_embd)\n",
        "        self.attn = MultiheadAttention(n_embd, n_head, block_size, dropout)\n",
        "        self.ln_2 = nn.LayerNorm(n_embd)\n",
        "        self.mlp = MLP(n_embd, dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        #\n",
        "        # TODO TASK 1.2\n",
        "        #\n",
        "        # Implement the forward pass of the attention block\n",
        "        #\n",
        "        x_norm = self.ln_1(x)\n",
        "        x_attn = self.attn(x_norm)\n",
        "        x = x + x_attn # residual\n",
        "        x_norm = self.ln_2(x)\n",
        "        x_mlp = self.mlp(x_norm)\n",
        "        x = x + x_mlp # residual\n",
        "        return x"
      ],
      "metadata": {
        "id": "cxSwgwQgP3Em"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VmHHK5jHMZvv"
      },
      "outputs": [],
      "source": [
        "class VisionTransformer(torch.nn.Module):\n",
        "    def __init__(self, input_size, n_classes, n_layer, n_embd, n_head, block_size, dropout):\n",
        "        super().__init__()\n",
        "        #\n",
        "        # TODO TASK 1\n",
        "        #\n",
        "        # Define the architecture of the vision transformer as illustrated in the pic above\n",
        "        #\n",
        "        patch_size= int(input_size ** 0.5)\n",
        "        n_patches = block_size\n",
        "        self.patch_size = patch_size\n",
        "        self.pos_embedding = nn.Parameter(torch.zeros(1, n_patches+1, n_embd))\n",
        "        self.patch_to_embedding = nn.Linear(patch_size * patch_size, n_embd)\n",
        "        self.cls_token = nn.Parameter(torch.zeros(1, 1, n_embd))\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "        self.block_size = block_size\n",
        "        self.transformer = nn.ModuleList([\n",
        "            Block(n_embd, n_head, n_patches + 1, dropout) for _ in range(n_layer)\n",
        "        ]) # ?\n",
        "        self.to_cls_token = nn.Identity()\n",
        "        # self.avgpool = nn.AdaptiveAvgPool1d(1)\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.Linear(n_embd, n_classes),\n",
        "            # nn.Softmax(dim=1)\n",
        "        )\n",
        "        self.block_size = block_size\n",
        "        self.transformer = None # ?\n",
        "        self.classifier = None # ?\n",
        "        # init all weights\n",
        "        self.apply(self._init_weights)\n",
        "\n",
        "    def _init_weights(self, module):\n",
        "        if isinstance(module, nn.Linear) or isinstance(module, nn.LayerNorm):\n",
        "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
        "            if module.bias is not None:\n",
        "                torch.nn.init.zeros_(module.bias)\n",
        "        elif isinstance(module, nn.Embedding):\n",
        "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
        "\n",
        "    def forward(self, x, targets=None):\n",
        "        device = x.device\n",
        "        b, t = x.size(0), x.size(1)\n",
        "        assert t <= self.block_size, f\"Cannot forward sequence of length {t}, block size is only {self.block_size}\"\n",
        "        #\n",
        "        # TODO TASK 1\n",
        "        #\n",
        "        # Define the forward pass of the vision transformer\n",
        "        #\n",
        "        x = self.patch_to_embedding(x)\n",
        "        x = x.view(b, t, -1)\n",
        "\n",
        "        cls_tokens = self.cls_token.expand(b, -1, -1).to(device)\n",
        "        x = torch.cat((cls_tokens, x), dim=1)  # [batch_size, num_patches+1, n_embd]\n",
        "\n",
        "        x += self.pos_embedding.to(device)\n",
        "        x = self.dropout(x)\n",
        "\n",
        "        for block in self.transformer:\n",
        "            x = block(x)\n",
        "\n",
        "        x = x[:, 1:, :].mean(dim=1)\n",
        "\n",
        "\n",
        "\n",
        "        logits = self.classifier(x)\n",
        "        loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))\n",
        "        return logits, loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WZKpWLppMZvv",
        "outputId": "1cbec69c-b341-4836-c9e8-214bb0d79c74",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 405
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-49-ecdfd4d219cc>\u001b[0m in \u001b[0;36m<cell line: 12>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0;31m# Forward pass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m         \u001b[0mlogits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpatch_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\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     24\u001b[0m         \u001b[0;31m# Backward pass and optimization\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1517\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1518\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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   1519\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1520\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1525\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1526\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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   1528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1529\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-45-9f0319a950b0>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, targets)\u001b[0m\n\u001b[1;32m     57\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdropout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     58\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 59\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mblock\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransformer\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     60\u001b[0m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mblock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'NoneType' object is not iterable"
          ]
        }
      ],
      "source": [
        "# Create data loaders\n",
        "train_loader = DataLoader(dataset=mnist_trainset, batch_size=batch_size, shuffle=True)\n",
        "test_loader = DataLoader(dataset=mnist_testset, batch_size=batch_size, shuffle=False)\n",
        "\n",
        "# Model\n",
        "model = VisionTransformer(input_size, n_classes, n_layer, n_embd, n_head, block_size, dropout)\n",
        "model.to(device)\n",
        "# Optimizer\n",
        "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)\n",
        "\n",
        "iter_counter = 0\n",
        "while iter_counter < max_iters:\n",
        "    model.train()\n",
        "    total_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for batch_idx, (data, target) in enumerate(train_loader):\n",
        "        # Flatten the patch\n",
        "        patch_sequence = data.view(-1, block_size, patch_size * patch_size).to(device)\n",
        "        target = target.to(device)\n",
        "        # Forward pass\n",
        "        logits, loss = model(patch_sequence, target)\n",
        "        # Backward pass and optimization\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        # Calculate accuracy\n",
        "        _, predicted = torch.max(logits, -1)\n",
        "        total += target.size(0)\n",
        "        correct += (predicted == target).sum().item()\n",
        "        total_loss += loss.item()\n",
        "        iter_counter += 1\n",
        "        # Log loss and accuracy\n",
        "        if iter_counter % log_interval == 0:\n",
        "            avg_loss = total_loss / log_interval\n",
        "            accuracy = correct / total\n",
        "            print(f'Iter [{iter_counter}/{max_iters}], Batch [{batch_idx+1}/{len(train_loader)}], '\n",
        "                  f'Loss: {avg_loss:.4f}, Accuracy: {accuracy * 100:.2f}%')\n",
        "            total_loss = 0.0\n",
        "            correct = 0\n",
        "            total = 0\n",
        "        # Evaluate test loss\n",
        "        if iter_counter % eval_interval == 0 or iter_counter == max_iters:\n",
        "            model.eval()\n",
        "            test_loss = 0.0\n",
        "            test_correct = 0\n",
        "            test_total = 0\n",
        "            with torch.no_grad():\n",
        "                for test_data, test_target in test_loader:\n",
        "                    test_patch_sequence = test_data.view(-1, block_size, patch_size * patch_size).to(device)\n",
        "                    test_target = test_target.to(device)\n",
        "                    test_outputs, loss = model(test_patch_sequence, test_target)\n",
        "                    test_loss += loss.item()\n",
        "                    _, test_predicted = torch.max(test_outputs, -1)\n",
        "                    test_total += test_target.size(0)\n",
        "                    test_correct += (test_predicted == test_target).sum().item()\n",
        "            avg_test_loss = test_loss / len(test_loader)\n",
        "            test_accuracy = test_correct / test_total\n",
        "            print(f'Iter [{iter_counter}/{max_iters}], Batch [{batch_idx+1}/{len(train_loader)}], '\n",
        "                  f'Test Loss: {avg_test_loss:.4f}, Test Accuracy: {test_accuracy * 100:.2f}%')\n",
        "            model.train()\n",
        "        if iter_counter == max_iters:\n",
        "            break"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.12"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "64bb6e84e2764c618fad5542a7e90dbd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_3f1ad5de658148fcb9a6b8f2c94c94f1",
              "IPY_MODEL_8ff127ce9bab4950807a7c1e49c5c17a",
              "IPY_MODEL_8e5e4d218295481abd990c29aef7c97b"
            ],
            "layout": "IPY_MODEL_3723265be8c944a690d9b045fd0a54e1"
          }
        },
        "3f1ad5de658148fcb9a6b8f2c94c94f1": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_66a57e3bca2845c1b81fc8835dcdb01f",
            "placeholder": "​",
            "style": "IPY_MODEL_3d38b117f7ba4a7fa141668a935a9245",
            "value": "100%"
          }
        },
        "8ff127ce9bab4950807a7c1e49c5c17a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_68a86d5807ee49b395293c90bc2012f1",
            "max": 40000,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_ff7f31852e1d47dbaf3137a38268ca2f",
            "value": 40000
          }
        },
        "8e5e4d218295481abd990c29aef7c97b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_5441ca83e46d4e13b40ee1612084d8f2",
            "placeholder": "​",
            "style": "IPY_MODEL_8e697e7a3af448be86e2d2137d493d22",
            "value": " 40000/40000 [08:18&lt;00:00, 80.19it/s]"
          }
        },
        "3723265be8c944a690d9b045fd0a54e1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "66a57e3bca2845c1b81fc8835dcdb01f": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3d38b117f7ba4a7fa141668a935a9245": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "68a86d5807ee49b395293c90bc2012f1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ff7f31852e1d47dbaf3137a38268ca2f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "5441ca83e46d4e13b40ee1612084d8f2": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "8e697e7a3af448be86e2d2137d493d22": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "ff258bd2e052435d9fc136f68940701a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_2b71942f6f6943c2b035233e27c588c5",
              "IPY_MODEL_283c6d137544414cbea5e3da1f8ca04c",
              "IPY_MODEL_4be7cfaf383e4113b785f848a6d59b75"
            ],
            "layout": "IPY_MODEL_977043a387a845efadabfdeee993a7b1"
          }
        },
        "2b71942f6f6943c2b035233e27c588c5": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_67ef647e91144401ae6d4e94d5b98df3",
            "placeholder": "​",
            "style": "IPY_MODEL_4622d08381ff46a0b5e23875f4be511a",
            "value": "100%"
          }
        },
        "283c6d137544414cbea5e3da1f8ca04c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7f38187341594281b65c3fac174ac26b",
            "max": 500,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_14949b2458ba46a6b85eaa8fa5c2754a",
            "value": 500
          }
        },
        "4be7cfaf383e4113b785f848a6d59b75": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_ef757a7cc3bf4a2d9720c2700b80012e",
            "placeholder": "​",
            "style": "IPY_MODEL_d5ed48b288924c67abdae6b44735133f",
            "value": " 500/500 [00:06&lt;00:00, 76.29it/s]"
          }
        },
        "977043a387a845efadabfdeee993a7b1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "67ef647e91144401ae6d4e94d5b98df3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4622d08381ff46a0b5e23875f4be511a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "7f38187341594281b65c3fac174ac26b": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "14949b2458ba46a6b85eaa8fa5c2754a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "ef757a7cc3bf4a2d9720c2700b80012e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d5ed48b288924c67abdae6b44735133f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}