03_01_ConvLSTM_SeqToOne_RMSProp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "from torch.utils import data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import moving MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 10000, 64, 64)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Moving_MNIST = np.load('data/mnist_test_seq.npy')\n",
    "Moving_MNIST = Moving_MNIST / 255\n",
    "Moving_MNIST.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Give `torch` the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10000, 20, 1, 64, 64])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Making into PyTorch tensor\n",
    "Moving_MNIST_tensor = torch.from_numpy(Moving_MNIST)\n",
    "\n",
    "# Putting the existing dimensions into appropriate order\n",
    "Moving_MNIST_tensor = Moving_MNIST_tensor.permute(1, 0, 2, 3)\n",
    "\n",
    "# Added the acknowledge that this is 1 spectral band\n",
    "Moving_MNIST_tensor = Moving_MNIST_tensor.unsqueeze(2)\n",
    "\n",
    "# Checking shape\n",
    "Moving_MNIST_tensor.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train/validation split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_indices = np.random.choice(range(10000), size = 8000, replace = False)\n",
    "\n",
    "OutofSample_indices = [index for index in range(10000) if index not in train_indices.tolist()]\n",
    "validation_indices = np.random.choice(OutofSample_indices, size = 1000, replace = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Separating $x$ (first $10$ in each sequence) and $y$ (last $10$ in each sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sep_x_y(tensor_to_separate):\n",
    "    x = []\n",
    "    y = []\n",
    "    for i in range(len(tensor_to_separate)):\n",
    "        current_seq = tensor_to_separate[i, :, :, :, :]\n",
    "        for j in range(current_seq.shape[0]):\n",
    "            if j >= 10:\n",
    "                current_x = current_seq[(j-10):j].numpy()\n",
    "                x.append(current_x)\n",
    "                current_y = current_seq[j].unsqueeze(dim = 0).numpy()\n",
    "                y.append(current_y)\n",
    "    x = np.asarray(x)\n",
    "    x = torch.from_numpy(x).type(torch.FloatTensor)\n",
    "    y = np.asarray(y)\n",
    "    y = torch.from_numpy(y).type(torch.FloatTensor)\n",
    "    return(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = sep_x_y(Moving_MNIST_tensor[train_indices])\n",
    "x_validation, y_validation = sep_x_y(Moving_MNIST_tensor[validation_indices])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing the overlaid $(x, y)$ sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random_index = np.random.choice(len(x_validation))\n",
    "\n",
    "for i in range(10):\n",
    "    plt.imshow(x_validation[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "plt.imshow(y_validation[random_index, 0, 0], cmap = 'Reds', alpha = 0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import torch\n",
    "\n",
    "\n",
    "class ConvLSTMCell(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, GPU):\n",
    "        \"\"\"\n",
    "        Initialize ConvLSTM cell.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        input_size: (int, int)\n",
    "            Height and width of input tensor as (height, width).\n",
    "        input_dim: int\n",
    "            Number of channels of input tensor.\n",
    "        hidden_dim: int\n",
    "            Number of channels of hidden state.\n",
    "        kernel_size: (int, int)\n",
    "            Size of the convolutional kernel.\n",
    "        bias: bool\n",
    "            Whether or not to add the bias.\n",
    "        \"\"\"\n",
    "\n",
    "        super(ConvLSTMCell, self).__init__()\n",
    "\n",
    "        self.height, self.width = input_size\n",
    "        self.input_dim  = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "\n",
    "        self.kernel_size = kernel_size\n",
    "        self.padding     = kernel_size[0] // 2, kernel_size[1] // 2\n",
    "        self.bias        = bias\n",
    "        self.GPU         = GPU\n",
    "        \n",
    "        self.conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n",
    "                              out_channels=4 * self.hidden_dim,\n",
    "                              kernel_size=self.kernel_size,\n",
    "                              padding=self.padding,\n",
    "                              bias=self.bias)\n",
    "\n",
    "    def forward(self, input_tensor, cur_state):\n",
    "        \n",
    "        h_cur, c_cur = cur_state\n",
    "        \n",
    "        combined = torch.cat([input_tensor, h_cur], dim=1)  # concatenate along channel axis\n",
    "        \n",
    "        combined_conv = self.conv(combined)\n",
    "        cc_i, cc_f, cc_o, cc_g = torch.split(combined_conv, self.hidden_dim, dim=1) \n",
    "        i = torch.sigmoid(cc_i)\n",
    "        f = torch.sigmoid(cc_f)\n",
    "        o = torch.sigmoid(cc_o)\n",
    "        g = torch.tanh(cc_g)\n",
    "\n",
    "        c_next = f * c_cur + i * g\n",
    "        h_next = o * torch.tanh(c_next)\n",
    "        \n",
    "        return h_next, c_next\n",
    "\n",
    "    def init_hidden(self, batch_size):\n",
    "        to_return = (Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)),\n",
    "                     Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)))\n",
    "        if self.GPU:\n",
    "            to_return = (to_return[0].cuda(), to_return[1].cuda())\n",
    "        return(to_return)\n",
    "\n",
    "\n",
    "class ConvLSTM(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, num_layers,\n",
    "                 batch_first, bias, return_all_layers, GPU):\n",
    "        super(ConvLSTM, self).__init__()\n",
    "\n",
    "        self._check_kernel_size_consistency(kernel_size)\n",
    "\n",
    "        # Make sure that both `kernel_size` and `hidden_dim` are lists having len == num_layers\n",
    "        kernel_size = self._extend_for_multilayer(kernel_size, num_layers)\n",
    "        hidden_dim  = self._extend_for_multilayer(hidden_dim, num_layers)\n",
    "        if not len(kernel_size) == len(hidden_dim) == num_layers:\n",
    "            raise ValueError('Inconsistent list length.')\n",
    "\n",
    "        self.height, self.width = input_size\n",
    "\n",
    "        self.input_dim  = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.kernel_size = kernel_size\n",
    "        self.num_layers = num_layers\n",
    "        self.batch_first = batch_first\n",
    "        self.bias = bias\n",
    "        self.return_all_layers = return_all_layers\n",
    "        self.GPU = GPU\n",
    "\n",
    "        cell_list = []\n",
    "        for i in range(0, self.num_layers):\n",
    "            cur_input_dim = self.input_dim if i == 0 else self.hidden_dim[i-1]\n",
    "\n",
    "            cell_list.append(ConvLSTMCell(input_size=(self.height, self.width),\n",
    "                                          input_dim=cur_input_dim,\n",
    "                                          hidden_dim=self.hidden_dim[i],\n",
    "                                          kernel_size=self.kernel_size[i],\n",
    "                                          bias=self.bias,\n",
    "                                          GPU=self.GPU))\n",
    "\n",
    "        self.cell_list = nn.ModuleList(cell_list)\n",
    "\n",
    "    def forward(self, input_tensor, hidden_state=None):\n",
    "        \"\"\"\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        input_tensor: todo \n",
    "            5-D Tensor either of shape (t, b, c, h, w) or (b, t, c, h, w)\n",
    "        hidden_state: todo\n",
    "            None. todo implement stateful\n",
    "            \n",
    "        Returns\n",
    "        -------\n",
    "        last_state_list, layer_output\n",
    "        \"\"\"\n",
    "        if not self.batch_first:\n",
    "            # (t, b, c, h, w) -> (b, t, c, h, w)\n",
    "            input_tensor.permute(1, 0, 2, 3, 4)\n",
    "\n",
    "        # Implement stateful ConvLSTM\n",
    "        if hidden_state is not None:\n",
    "            raise NotImplementedError()\n",
    "        else:\n",
    "            hidden_state = self._init_hidden(batch_size=input_tensor.size(0))\n",
    "\n",
    "        layer_output_list = []\n",
    "        last_state_list   = []\n",
    "\n",
    "        seq_len = input_tensor.size(1)\n",
    "        cur_layer_input = input_tensor\n",
    "\n",
    "        for layer_idx in range(self.num_layers):\n",
    "\n",
    "            h, c = hidden_state[layer_idx]\n",
    "            output_inner = []\n",
    "            for t in range(seq_len):\n",
    "\n",
    "                h, c = self.cell_list[layer_idx](input_tensor=cur_layer_input[:, t, :, :, :],\n",
    "                                                 cur_state=[h, c])\n",
    "                output_inner.append(h)\n",
    "\n",
    "            layer_output = torch.stack(output_inner, dim=1)\n",
    "            cur_layer_input = layer_output\n",
    "\n",
    "            layer_output_list.append(layer_output)\n",
    "            last_state_list.append([h, c])\n",
    "\n",
    "        if not self.return_all_layers:\n",
    "            layer_output_list = layer_output_list[-1:]\n",
    "            last_state_list   = last_state_list[-1:]\n",
    "\n",
    "        return layer_output_list, last_state_list\n",
    "\n",
    "    def _init_hidden(self, batch_size):\n",
    "        init_states = []\n",
    "        for i in range(self.num_layers):\n",
    "            init_states.append(self.cell_list[i].init_hidden(batch_size))\n",
    "        return init_states\n",
    "\n",
    "    @staticmethod\n",
    "    def _check_kernel_size_consistency(kernel_size):\n",
    "        if not (isinstance(kernel_size, tuple) or\n",
    "                    (isinstance(kernel_size, list) and all([isinstance(elem, tuple) for elem in kernel_size]))):\n",
    "            raise ValueError('`kernel_size` must be tuple or list of tuples')\n",
    "\n",
    "    @staticmethod\n",
    "    def _extend_for_multilayer(param, num_layers):\n",
    "        if not isinstance(param, list):\n",
    "            param = [param] * num_layers\n",
    "        return param"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Picking one of the like-sequence tensors within the list to set parameters\n",
    "channels = x.shape[2]\n",
    "height = x.shape[3]\n",
    "width = x.shape[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_lstm = ConvLSTM(input_size = (height,\n",
    "                                   width),\n",
    "                     input_dim = channels,\n",
    "                     hidden_dim = [128, 64, 64, 1],\n",
    "                     kernel_size = (5, 5),\n",
    "                     num_layers = 4,\n",
    "                     batch_first = True,\n",
    "                     bias = True,\n",
    "                     return_all_layers = False,\n",
    "                     GPU = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConvLSTM(\n",
       "  (cell_list): ModuleList(\n",
       "    (0): ConvLSTMCell(\n",
       "      (conv): Conv2d(129, 512, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (1): ConvLSTMCell(\n",
       "      (conv): Conv2d(192, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (2): ConvLSTMCell(\n",
       "      (conv): Conv2d(128, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (3): ConvLSTMCell(\n",
       "      (conv): Conv2d(65, 4, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_lstm.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = torch.nn.MSELoss()\n",
    "optimizer = torch.optim.RMSprop(conv_lstm.parameters(),\n",
    "                                lr = 10**(-3),\n",
    "                                alpha = 0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class train_Dataset(data.Dataset):\n",
    "    'Characterizes a dataset for PyTorch'\n",
    "    def __init__(self, data_indices):\n",
    "        'Initialization'\n",
    "        self.data_indices = data_indices\n",
    "    \n",
    "    def __len__(self):\n",
    "        'Denotes the total number of samples'\n",
    "        return len(self.data_indices)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample\n",
    "        IDs = self.data_indices[index]\n",
    "\n",
    "        # Load data and get label\n",
    "        curr_x = x[IDs, :, :, :, :]\n",
    "        curr_y = y[IDs, :, :, :, :]\n",
    "\n",
    "        #return X, y\n",
    "        return(curr_x, curr_y)\n",
    "    \n",
    "class validation_Dataset(data.Dataset):\n",
    "    'Characterizes a dataset for PyTorch'\n",
    "    def __init__(self, data_indices):\n",
    "        'Initialization'\n",
    "        self.data_indices = data_indices\n",
    "    \n",
    "    def __len__(self):\n",
    "        'Denotes the total number of samples'\n",
    "        return len(self.data_indices)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample\n",
    "        IDs = self.data_indices[index]\n",
    "\n",
    "        # Load data and get label\n",
    "        curr_x = x_validation[IDs, :, :, :, :]\n",
    "        curr_y = y_validation[IDs, :, :, :, :]\n",
    "\n",
    "        #return X, y\n",
    "        return(curr_x, curr_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_set = train_Dataset(data_indices=range(y.shape[0]))\n",
    "validation_set = validation_Dataset(data_indices=range(y_validation.shape[0]))\n",
    "\n",
    "batch_size = 100\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(dataset = training_set,\n",
    "                                           batch_size = batch_size,\n",
    "                                           shuffle = True)\n",
    "validation_loader = torch.utils.data.DataLoader(dataset = validation_set,\n",
    "                                                batch_size = batch_size,\n",
    "                                                shuffle = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_lstm = torch.nn.DataParallel(conv_lstm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total epochs: 9\n",
      "Epoch:  0 \n",
      "\tBatch loss:  0.04217589274048805 \n",
      "\n",
      "Epoch:  1 \n",
      "\tBatch loss:  0.042935580015182495 \n",
      "\n",
      "Epoch:  2 \n",
      "\tBatch loss:  0.04044114053249359 \n",
      "\n",
      "Epoch:  3 \n",
      "\tBatch loss:  0.04347480833530426 \n",
      "\n",
      "Epoch:  4 \n",
      "\tBatch loss:  0.04103399068117142 \n",
      "\n",
      "Epoch:  5 \n",
      "\tBatch loss:  0.04302350804209709 \n",
      "\n",
      "Epoch:  6 \n",
      "\tBatch loss:  0.04244740307331085 \n",
      "\n",
      "Epoch:  7 \n",
      "\tBatch loss:  0.04271619766950607 \n",
      "\n",
      "Epoch:  8 \n",
      "\tBatch loss:  0.043203506618738174 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "epochs = int(np.ceil((7*10**5) / x.shape[0]))\n",
    "print('Total epochs:', epochs)\n",
    "for i in range(epochs):\n",
    "    for data in train_loader:\n",
    "        \n",
    "        # data loader\n",
    "        batch_x, batch_y = data\n",
    "        \n",
    "        # move to GPU\n",
    "        batch_x = batch_x.to(device)\n",
    "        batch_y = batch_y.to(device)\n",
    "        \n",
    "        # run model and get the prediction\n",
    "        batch_y_hat = conv_lstm(batch_x)\n",
    "        batch_y_hat = batch_y_hat[0][0][:, -2:-1, :, :, :]\n",
    "        \n",
    "        # calculate and store the loss\n",
    "        batch_loss = loss(batch_y, batch_y_hat)\n",
    "        loss_list.append(batch_loss.item())\n",
    "        \n",
    "        # update parameters\n",
    "        optimizer.zero_grad()\n",
    "        batch_loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    print('Epoch: ', i, '\\n\\tBatch loss: ', batch_loss.item(), '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(loss_list,\n",
    "         color = 'cyan',\n",
    "         label = 'Batch')\n",
    "plt.plot(np.convolve(loss_list, 1/10*np.ones(10))[10:-10],\n",
    "         color = 'navy',\n",
    "         label = 'Running average')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting random predictions for the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand_x, rand_y = next(iter(validation_loader))\n",
    "\n",
    "rand_y_hat = conv_lstm(rand_x.to(device))[0][0][:, -2:-1, :, :, :]\n",
    "rand_y_hat = rand_y_hat.cpu().data.numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing random predictions for the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_random_validation_pred():\n",
    "    f, axarr = plt.subplots(1, 2)\n",
    "    f.set_figheight(4)\n",
    "    f.set_figwidth(8)\n",
    "    random_index = np.random.choice(len(rand_x))\n",
    "    for i in range(10):\n",
    "        axarr[0].imshow(rand_x[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "        axarr[1].imshow(rand_x[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "    axarr[0].imshow(rand_y[random_index, 0, 0], cmap = 'Reds', alpha = 0.5)\n",
    "    axarr[0].set_title('Red = True', fontsize = 15)\n",
    "    axarr[1].imshow(rand_y_hat[random_index, 0, 0], cmap = 'Greens', alpha = 0.5)\n",
    "    axarr[1].set_title('Green = Predicted', fontsize = 15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeMAAAD8CAYAAABEgMzCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XucXFWVL/Dfqqp+p7vzJAlJIGCCiMgzcmVABwkwiAxh5iqKjjcgXnSuevX6QNQ7M4yPGXXwwefqh2sUBJ+ACBMERUMAwRcSJMqFgEAIkEenk3TS3elnVfe6f5zTZ69zUqe6uruqTnX17/v59Ce7qk7V2ZWu1bvOOvusLaoKIiIiSk4q6Q4QERHNdByMiYiIEsbBmIiIKGEcjImIiBLGwZiIiChhHIyJiIgSxsG4TETkGhFR89MhIneLyAkl3Me1IrKtVK8Xs4+bIu8j389N5ewDUSEicrGI/FJE9onIsIjsEJHbReT8pPtWSSJyWSQuO0XkFyJySpn3G/o7ZPoxawKvcZWInFXCPl3o92F5qV6z3DgYl1c3gNP9nw8DOAbABhGZm2ivJuazcO/hdAAPAHg8ct9nE+sdzWgi8lUAPwGwA8B7AJwD4GoATQB+LiKvSLB7STkbXly+F8ACAA+IyOEV3P89/v77J/CcqwCcVZbeTBOZpDtQ43Kq+nu//Xv/2+PvAJwP4IeJ9WoCVPV5AM+P3RaRLgAp875iiUiTqg6Us380c4nIGnhfci9X1ZsiD39PRP4WQOznr4Y/n4+q6kEAEJFNAF4E8E4A/xHdUEQEQIOqDpZq56q6B8CeUr3eTMEj48r6k//vMnuniMwVkXUisltEBkXktyLyXyLbzBaRH4rIQRHZJSKfrliviyAijX5a6AMi8nUR2QvgUf+xDhH5XGT79/nbZ8x9C0TkBj+9NiAiD4vIqRV+KzR9fBjewHNTvgdV9aequnPstv95+4iIfE1E9gB4wjy2RkQ2+fHXISJfEpE6+3oicryI3CMivf7Pj0VkkXn8LH8fZ/mPHRSRrSLyP0r+zoukqi/DGxiX+328RkT2isiZIvIogEEAb/UfK8nfoXxpahFp8v9PXxSRIRF5QUT+3X9sG4B5AP7FpNjP8h9LicjVIvKc/7y/iMjayP7Ef1+d/u/luwDaSvV/WCk8Mq6sI/x/Xxi7Q0QaANwHYDaAjwPoBPCPAO4TkZWq2uFv+h14aZz/BaADwMcAvAJArtAO/W++6fE6pqoFX2cCPg1gI4B/mMiTRKQJXgq8AcBHAOwD8EEAG0VkharuLVH/qAb4X+JOB3DtBJ/6cQAPAXgX/IMREbkEwI8AfBPAp+DF1b/7j3/M32YFgN8A2ATvs52Bd3rmpyJymobrCn8LwM0A1gG4FMA3RGSTqv6hwPtJYfyDI1XVkYm8WRFpBTAX3t+MMc1+/74E4C8Adpbz75D/N2g93CmtxwAsAfB6f5O/gxf7twP4tn/fU/6//wfAWgCfAfBHAOcCuFFE9qnq3f42/xPAPwP4NwAPA/h7/71NL6rKnzL8ALgGwF54QZuB94HdAO98a4PZ7goAwwBWmvsy8FLD/+HffjUABfA2s80sAF0Ato3Tj8v85xb8mcD7uh3Ag3nub/Rf63d5HusA8LnIfe/zt8/4t98PL6W43GzTAOBlAJ9N+vfJn+r6AbDQ//y8N3K/mJjLABDzmAL4Y57tXwTwncj97/Y/j/P8298D8AyAerPNSgAjAN7s3z7L38dnzDZ18I5MvzDO+7mpiDh9cJzXGIv1dv+9LwNwK7yB8iR/m2v8bdZEnluyv0OmH7P823/j376oQN/3Argmct8KAKMA1kbu/y68jAjgHWjsBHB9ZJsN/j6XJ/1ZLfaHR8blNQ9A1tzeB+C1qjpk7jsH3jfFF2zKFsCvAKzy26/1/10/9qCqHhSRDQBCaaQ8fmqeXwn3TPJ55wB4BMB28/8wAu+b7qrYZ9FMF13p5qMInxv9IICvm9s/i2x/DLyM1W2R+Lsf3hfM4+HF4jnwjiZHzXYvANgG7/NpP/e/DDqnmhWRZwEsHed9XBPpZz694zw+5oBp7wXwblXdbO5TAD+PPKecf4fOBtClqncV2f8xq+ENxndG+rQRwKUikob3hWOx7ZPvDnjvadrgYFxe3fA+EGkAJ8JLqf1QRM5Q1VF/m/kAXofwoD1mbOLUIgC9eugki84i+tDl96NSdk/yefMBnIn8/w9PTr47VKP2ARjCoYPc9wA86LcfzfO86Odzvv9vdJAes8xs9wn/J26bMQcit4fhDeyFvARg+zjbFLvE3hvgzWTeC+Bl87dmzH5VHY7cV86/Q/MA7Bq314eaD+9vZ9zfr8V+n/L1oZi/jVWFg3F55VR1k99+REQG4KVY3govfQR4g+UmeOdnosaOoDsAtIpIYyQQDiuiD2vhnecZjxSxTTHy/cEYBFAfuW9O5HYXvHNyH87z/Fqc8UpToKo5EfkdgPPgnS8cu383/AHXO1V56FMjt7v8f6+Edwop6gWz3Z1w5zStUsxnuBFerBbyKxR3+c/j6s+mjpEvRsv5d2gfvIFzorrgpdjPgHeEHNUJN4ZF+1DM38aqwsG4sr4P9+16bDDeCO8PykuqGvdtbuwb/pqx5/kzFc8F0DPOPiudps5nO4BXRe47L3J7I4B/ArBVVbtANL6vAfhPEXmXqn5vkq/xDLxrlJer6rcKbLcR3jnTx9Q/KVli16B0aerJKOffoY0ArhKRC9VNuorKlz24H96Rcbuqbsj3JBF5Gd6XhDUA7jUP/X2B/lQlDsYVpKoqIv8G4AcislpVN8I7Un4fgAdF5FoAW+GldU4D0KGqX1XVJ0XkLgDXi0gbvJTPx1HERfWqug/eN9Mk3QngiyJyFYDNAC6BN6HN+jaA/w7v/+Er8I5I5sObgfmCqn6jgv2laUBV14vI1wDcJCJvhPfFcy+8+Bn7slfoCBGqOioiH4V3XXIbvHOpwwCOBnAxgLeoaj+8wfIPAO4RkRv9/SyBNxDdpKoPTvG9bIN3/jkp5fw7tAHAL+CdohubFb0YwBtU9b3+Nk8DeLOI3Avvd/aMqj4jIv8XwC0i8iV4R+6N8L4UHaOq71HVEf+xa8W7nPJhAP8Vh375r35JzyCr1R/4s6nz3J+GdznBL8x97QCugzdzeBjekeQdAM4w28wBcAuAPnhpuH+Gdw56W4Xf13izqd+T57F6eJcodML7YnAtgA/AzKb2t5sL4BvwjlSG/f+PHwM4LenfJ3+q9wfepTEb4KU1s/Bm1/4EwJsi2ymAD8S8xpvg/SHvg3eUtxnA5yKfz2P9z38XvFMnz8G7HGqp//hZ/j6Oj7z2gwBur8D/w2Uws5hjtsn7d8l/rCR/h/L1A15FtGv91xyC92X78+bxUwH83n9dBXCWf7/AO3X1pP+8PfDS9f/NPFfgXTK1B1724AcA3oFpNpta/DdDRERECWEFLiIiooRxMCYiIkoYB2MiIqKETWkwFpHzReQZv4j31aXqFBFVHuOZKDmTnsDllyL7C7yp/dvhXYN2qao+VfCJRFR1GM9EyZrKdcanAXhOVbcCgIjcAu/C69jgbWlu1tmzZ09hl0Qzw85du/aq6oIK7nJC8dzc3Kzts9sBALsPmAJUvDqDZipT8a2xuSFoD+zrKyqWpzIYL4F3PdqY7chTLFxEroRXag7t7e14/3vfM4VdEs0Mn77msy9WeJfjxrON5bb2Nlz+Xq9645fvNNVWhya0wh9R7ahzZ31XnHx00H7iu48UFctln8ClqutUdZWqrmppbi737oioTGwsNzOWiUpqKkfGOxBerWSpfx8RTT8TiufdB/biy3f4R8TDPBomQtatZfHM5hcKbJjfVI6MHwWwUkSOEpF6AG8HMNH1KomoOjCeiRI06SNj9ZYw+wC8AuBpADeqKtedJZqGGM9EyZrSqk2q+jPEL8pNRNPIhOJZlelpojiTiA1W4CIiIkoYB2MiIqKEcTAmIiJKGAdjIiKihHEwJiIiShgHYyIiooRN6dKm6UZMIe/4beK/n6iOxj7mtmGhfKJyKyaWUwVieZSxTFWGR8ZEREQJ42BMRESUsJpPU9u0cyo1te8e3vrrhxodTbYSUUODWzvTvt9sNhu07XtPpcRskwu9VtLvhShOqoSxnI6J5ZHEY7kxaKfExmn+WBbTzpltgOTfC00Mj4yJiIgSxsGYiIgoYTWXpo7OsiwmnVXExMy8r+3udykvOwFzZMSmiSozMzOTcb9SO/s7lNoy7yOXYyqLqtNkYhlTjOVQ+jomljWBWB41f1jiYnkkFz7lRNMLj4yJiIgSxsGYiIgoYTWYpk5Fbotpu/tTqbRpuwdGR+OLAdgiADYdbfeRTqdM2+0jlyvdrOVDU2xxuTl3f7i/k941UcVEi3aEPvemmTaxbGcXF45l81hMLKeKjOWpzFqOxvL4kQwGc43ikTEREVHCOBgTERElrCbS1OGCFuHvFzZtHC4AEjObMp2/GAAQmVEZU7c2nKbO5L0fAAYHh8xrjV8nNyzc96YmVyjA7jOXc0UAwul6praoOhWK5ZSJTVsQQ2JmWReOZdeOiz+7v4zdd+R1hwYHg3YxNa8ticRyY1NT3n1mTWqcsVybeGRMRESUMA7GRERECeNgTERElLBxzxmLyI0ALgTQqarH+/fNBXArgOUAtgG4RFX3l6+b+fplzy3FnxuylzfY87ajo/acb/7zv4eefzaXUIh7TrjSlt3ePV813Ef72iMjEzvPFD3HZfdvC83btv1/GBlx55+4ZuvMUo3xbC9hSheMZfc5T5m5EWo+23Gf5kKxrLaKVUws2/PE6UjM2NcenWAsR88x2/03mgVgbNvGcq6IeSw0PRRzZHwTgPMj910NYKOqrgSw0b9NRNXvJjCeiarOuIOxqj4EoCty9xoAN/vtmwFcXOJ+EVEZMJ6JqtNkL21aqKq7/HYHgIUl6s+UFSomb9M7mYxNObt24cuX8l9SYNPRdm1h2+7vHwi/0gSvSLD7y2TqQo/V17v9hNJvoYphTGFRrKqM52JjOW0WVEjHpJyjn38bfuGqWy5+4mJ5oL8/3JkpxHJdJJYb6uuDNmN5ZpnyBC71Phmxnw4RuVJENonIpr7oh5iIqkqheLaxrDkOCESlNNnBeLeILAYA/9/OuA1VdZ2qrlLVVS3NzZPcHRGVUVHxbGNZMiw2QVRKk01T3wVgLYAv+P+uL1mPimRnFIu4t2HTz8UKp5zt88Pf/m1qLJw2dqml+nrbdqmt4eHhCfcrro/19eHUVniWuEvNZbPDpp1FPhOv/kU1KNF4tjOKMyaWbfq5WHGxHD2Oj4vlerPPcCy7diljuc68LhBOk4+YPg6b+LVxbU20+hdVl3GPjEXkRwB+B+CVIrJdRK6AF7TnisizAM7xbxNRlWM8E1Wncb96quqlMQ+tLnFfiKjMGM9E1WnaLhQRLigff/7KpqOmOgvRLsIQt07y8LBLJ9liHrlcuJhAccXeTTqrzqWmW1tbY1/Lvt+2tvag3d3dHbSHhlxh++iM1VL+fxEVw34G4xZ9AEr72cyECvjYdZJdO2vS0aNmZvZIZD3jYmJZQrHsUtPFxnJ7W1vQtrE8yFiuGSyHSURElDAOxkRERAmbtmlqy9aZHh0Np5DScekow9a5jrvQHojUoDUpINtOpeyMxnTebaKvZWtIh4uR2LWYXd8bGt32AFBvUtg2hWXT9xkzS3TILaWMaMUCux+mtqjSbJ3pXCRmionlVNxs6knE8qjZxl5jcWgsu0cbG/LPBk/FpLIbG90VF0D4dFR3d497jumLjWWYWI6ujcxYnl54ZExERJQwDsZEREQJm7Zp6rjUsE3zAIfWcR6PLaBhZ09H5XJu1nRLi5sRaQt92Nq40Rnf2Wxd3u3i0km2X/V19ZFH8y/nGLd8pC1gEF5KcuLLORJNVTg1bGM5/Dmvm2AREFtAI5OOLwaUNbOjW1tagraNExtX0Rnfddls3u3iYtn2K/oei4ll+3z790Yj6fOJLudIyeKRMRERUcI4GBMRESWMgzEREVHCpu054zjRc8R24YTo+VH3HFtZq7jvJ43m8qLGpqagnTbnk/r7+4J2LlK1x55DNqeGYgvdN5l9tLe7yloA0NNjKvIMumsdWkLnv1y/sqFzXOGi87wEgqpF9ByxXTghen50TCbmcqJCbCw3Nbl2KhTLbvnXaCyHziHbc8tTjOWhQVddy8ZyypzLtrE8PBLuF2N5euGRMRERUcI4GBMRESWsJtLUNv1c7FqjmZjLJGwFLHvZABAt4p7/Ega7UIS9HGFoKNwv+3y7n5aW5qBtL3sYMSmogQGXMvO2c6n5uPWY41JW8YtUEFWeljCWbQWshobwJUT2c28v5ysmlofDJexC6fMGk0JuNqllG6P2kqViY9lGL2O5NvHImIiIKGEcjImIiBJWI2lqO2M6/P3CFnGvq3Nvt7GxydzvUkOh2ZiRSjtiZkDXp106araZETkw4GZADpl0VmNjOLVk92Mr/UT36bZ3fYxW7RkKpc3sflx/7cuGF6CI7s+mujgbkyprxMRyKhLLaRPLGROzTWY2dCjNWyCW7dUMNv7aY2LZpqY1slCLjeW6omLZbF8glvNHMkLBbGeMpyKxbBeOUMZy1eORMRERUcI4GBMRESWsJtLUVi43Errd3OxmKtuUtZ3RaIULgMSvD9rclD/Nbdcm7u4+YF43XKg+LjVtZ0rGzbgeGnLpMwDoHxgI2ja1Zl/L9itcgD7//wNR0kYisdxgYtkW14mL5XSRsdxUVCy7YhzpyOztuNR0OJbdjGsb+9FYHjCxPGja9rUaG/IvRjPCWJ7WeGRMRESUMA7GRERECau5NLVquGbtoKnv2tzcZB4xF9Rr/ov+05HUsp3NadNOtlbt6KgrVGBrVvf29Eb65VJQNh1m2ZnObW1tQdumsqIWLlwYtHt6eoK2LaBgZ5IeWj+Asy6pOowWiOWmZlccx0bpaOgD7drR00SpCcayrVl9aCy7fjU2hgsFuf25mCs6lheZWO7OH8uhutiR0OUM6ull3CNjEVkmIg+IyFMi8qSIfMi/f66IbBCRZ/1/55S/u0Q0WYxloupVTJo6B+CjqnocgNcBeL+IHAfgagAbVXUlgI3+bSKqXoxloio1bppaVXcB2OW3e0VkC4AlANYAOMvf7GYADwL4RFl6OQU2BW3TvjZt1NzcYtp2ZmX4gvx0OmXadkk0lzKzNaRtzeyhwXA9W7tsm53oGZ0Nnm/7xkjRge3bX87bZzsz3BYTsAVEbP1dgMuu1bLpHss2bW2LXdhUra3tHp4lXcJYjtSmtqeZph7L202f8xcjsvu3y0xmh7kc6nQ2oQlcIrIcwMkAHgGw0A9uAOgAsDDmaURUZRjLRNWl6MFYRGYB+AmAD6tqj31Mva9geb+GiciVIrJJRDb19ffn24SIKqgUsaw5HnURlVJRg7GI1MEL3h+o6h3+3btFZLH/+GIAnfmeq6rrVHWVqq5qMTMgiajyShXLkuFyfUSlNO45Y/FK1dwAYIuqfsU8dBeAtQC+4P+7viw9nCJbaSeXc+dHW8xao/YSJrvucPSciz2fNG/evLz76O09mHd/9nIG7zF3PsruJ2XOZdlLLuylGf2RDEP43JTbZ4Op1GMrbWWzbt/RJVDtefXoZWI0vdVSLGdN/IRiOV3+WG5tLS6W05OI5ZFc/ti0sWzXT85lzZyPSCzbhSOil4lR9SnmOuMzALwLwBMistm/71PwAvc2EbkCwIsALilPF4moRBjLRFWqmNnUv8Yh37kCq0vbHSIqF8YyUfWquQpchQrC28sTbAWsuMUhbDoICKeqbGrKLuJgX8uujRq9HMKmlm0Vntywe92VK1cEbXsJ0nDkEoYmcznWkKkGFLcIhL1k49C/zZyYQ9WhUCyric0B85kPr2FsY7/ysTw8xVgeNJdDRv8WBfs2C0VIJJZZgWt6YW1qIiKihHEwJiIiSljNpanT6Uzkdv6qWzbVZKvgzJo1y9xvF5YIV+ey1X1aWtxzbCqtr8/NxrRVvoBwesqmzCy7NrF9HzaV5j3mZmfuNDNAbQH7+npXzSdVYC3Y8Gxqro9KyclEYjllPue26lZ8LLeY+4uL5VlVFMsHY2I5bv3k8Omn8GzqEcZy1eORMRERUcI4GBMRESWs5tLUUdEZmfnY4gBtbfHfT+xr2aIBlk372tnbIyPhWZMDA+5ifzu70s7gtEXvbTH6ffv2xe4zzK7nmv9XPTISnqXJQh9UrYqJ5WGTsk61tRb1Ws0VjuXGScSynRcdF8ujkVhmoY/phUfGRERECeNgTERElLCaS1NHL+4H0nm3s2v62nqyBw50B+1oPekjjzwyaM+dOzdo79ixI2j39LhFcOx6pHZ7ABgedrM2u7pcqsr2xc7yPHiwL2h3du4JvZYtNGDTzLaebX+/KSwSs84qUTWJxnL+SA6v6Wvjp9vEcmuRsby9wrG8p0Asj5rn21geMPWsbS1rmt54ZExERJQwDsZEREQJq7k0tb1oHgjPFrYFQaLbjYnWirVsCnj//q6gbQsN2OXY6s3F+dGJoHV1+Wvo2v3f96l/DdonnurSanULjwq91rZvXBe0m09wNXDr3rgmaNtZmnYftgABACjL2VKViMboqPkMZ8xjU43lLhPLTTGx3GBiOVrOvZhY7urab/btgswW8ACAvXv35u1vvUmTx8VyKhLLLE09vfDImIiIKGEcjImIiBLGwZiIiChhNXfOuDB3EiVXxCUBtjg7EK58Y9v79+/P+5z6+jlB21b5AoBs1u3fnk9uaXFF6O35q9/+/vmgPefU8CUfv+10l0P89fMvBe3c6101IHteze7PFpr3Hw1a0cLzRNXCng6tdCwPTyKWbR/7+tylSdF+2fWYc1kXv1nz/NA58gKxbNc3zjGWqx6PjImIiBLGwZiIiChhNZemjq4naitt2bV649jLkZYuXRp6rHvTr4L2cM6lqvYfeXzQtqkim4JKpcKXX9jLoWbPbg/aPV3u0oa0qbqjpoIWIu+jrc69dijNbar+dHd3Ix9bAB8IX3ZBlKRsJJbrTCynilg0olAs9/b2Bm2bQrZp6snF8myzD1PBy/Q9esrKsu9rorGsjOVpjUfGRERECeNgTERElLCaS1NHUzM21WSr7oi4VJOdTTmr1RV9t8XhAaDnz38K2j9+dFvQvuByU0T+5DOD9rJly4rtddAa3OFSW4c1u9TUnIzrb8/RLi0OAK+/4IWgPe9oV4Fr0CwIEV23ONizRlNbXAOVqkOhWLaLKKRNarfYWLZp6v37DwTt+nq7IISrwHVEkbFsezw87NZWtotetLe7RSsaGxtg9fW5RSTaTcrbLg4xGrfmceT/i+sZTy/jHhmLSKOI/EFE/iQiT4rIv/r3HyUij4jIcyJyq4jUj/daRJQsxjNRdSomTT0E4GxVPRHASQDOF5HXAfgigK+q6goA+wFcUb5uElGJMJ6JqtC4aWr1ch8H/Zt1/o8COBvAO/z7bwZwDYDrS9/F0gmv4+vaYtJcPd0uTbx16/OwGjtdQXn7So3PPhu0W99wftAOz3oMp5BmzXIptFCx9wVu1ucrXr0oaP/0oaeD9gnPPR56rfTqi4O2TYfNMzMw7Tqp2azb36Fpac7ArGW1Es92HV8bi/GxvDX0/La21qBtZ0M3N7sZzK0mzW1jWQ+JZfdasYtTmKcMD7tZ4osWLQptZmdq21ieaxatsLE8bGI5mpaO9pOqW1ETuEQkLSKbAXQC2ADgeQAHVHUsIrYDWFKeLhJRKTGeiapPUYOxqo6o6kkAlgI4DcCxxe5ARK4UkU0isqnPTEIgomRMNp5tLGuOR11EpTSh2dSqekBEHgBwOoDZIpLxv00vBbAj5jnrAKwDgCWHH17xCLZpo4yZkWxnV9o1SJubm4N2uj98cf2WXS49ZC/It+uL2tmQra1u1mR9fXjWZO6J3wXtgz0unaZbtwXtPz7rCoAcOHgwaDcufFXotdq2bwna3XPdAc1IaK1U+1/v3m+0nq1NW7NoQG2baDzbWE41ZRKN5XQols264ebz3NziYtnOsgbCcW4LasTFcpuJ5YZILNt0cn+/e46NLbvWsN3GpsiBcAGgAwfcLG/br3Akx8fyKGN5WilmNvUCEZntt5sAnAtgC4AHALzF32wtgPXl6iQRlQbjmag6FXNkvBjAzeJdmJsCcJuq3i0iTwG4RUQ+B+BxADeUsZ9EVBqMZ6IqVMxs6j8DODnP/VvhnW+qajbtms26dlOTS1PZmtXz57oL7V/85p2h1xo06bD5JqfQdNbqoG3TTvaC/pGH7gm91j2/crOjs3Y2dcbOpnTb2zq7v7rPFR8BgAFTN/eYE9yM7/5XnBS0bf3dUPosktoaGbHpLKa2as10jmebdh01sdxsYtnWdp43b37QjhbXsPFkr7JoabHx69oNNp0cSfna2Mqk8y/NaFPZdt/R7HGby4Zj7x53mqrfLLto6+8XimU1scyZ1dWP5TCJiIgSxsGYiIgoYRyMiYiIElZzC0UUy553se1dmx4O2ksWNoees+K0U4P2YPthQXufunNAo/vcOduWF58M2j99wLUBoPegWU912J1zajVF5O0lT7Ywvr2cAQCGs67/993zh6B9XN1vgvasy94dtDMZd/7q0LVVeW6JppesOWdr27t37w7aixcvDj3HXupjK1oNDLhzs/ZyolZTZSubDa+zfNBcdmhjsd2cAO4xaxsXusrIvnadWbSixyxsUW/mroyaK8yGh9zCFADPE083PDImIiJKGAdjIiKihM3YNPXgoEvp1NW5/4aB+UcE7b1HhCtdiUn7aK9LbR3eahZnEJf23Xr3r91rmcsUACA34tJpgwPu0qTOTpdaa250lYEaTcWg+rrwr61jt6voc9QRR7r30tUZtOd0bQ/a2bluMYoR0w+i6WjIXNqXMZX1bAWtXTt3hp5jK3Wpuezo8CWHB+0F892lUQf7XCq6p8eljIFwDA3ExHLcYhTRymC2z0cc4f4W2Spj+/a6vyW2KlmOsTyt8ciYiIgoYRyMiYiIEjZj09Sjo26m5NCQaze/7CpjjXaFU8svbX45aA+bKjq7jz4maD9r1kCixFBLAAAQqElEQVTd07kn7/6A8JxlO2tT0q4CV5NZjKKhyVUQ0pHwLMlQ1S+Tzt7T7/oC+15MmjrKrqdqRftPVC1GzGdzxMSyXTM8ys6mbjIxs2iRm3Vt10beY04zHRoLbjsby2kTyy0tri9NJl5HRsNrEMels9vb3QISNk1dSDomlkcYy1WJR8ZEREQJ42BMRESUsBmbpo7z0B0PBu392XAKydbaWLliZdBeZNZNtUXj7UX3ff2umAAQns1pS3ic/xo3m3POKW6hh/vudsU8eroPwLJFBLLmwv8+U4zg6f98MGi/8upVQbu93S2MAYRTcH194T4TTSd2ARY76xgIx9zhh7uYazEp6/DsZBdk/ZFYji7QkI9dKMIWBrFrFgPhWB4acjOzbWER27brMs+OxLJNgfebWdpUnXhkTERElDAOxkRERAljmjrihJPcTOPfPPJC6LHWZleE45wjXUGAZatPCNq68sSg/dTnvxC0N0fXDR51+ag3HO5mWqYvfFvQFlOn+pxjXWr5pS9fG3qth3eb1LSps7t9546gPZpzKasT9rsCCLL46NBrDZoCCpxBTdNZX79LzdbXh9czbmrMv26xfc7IiIuZffv2uec2ub8DADBqYtnOpq4LFecxNaSHXbwORepJmwncoQIiO3e4WLaFTWzfo2wscwZ19eORMRERUcI4GBMRESWMgzEREVHCeM44Ql93btA+/dTw+ZwlS9z55IXHvyZoN5hLmzb/0/8O2o/1uEsYhiKXVhzT6M771F94QdCeN2/uuH2cPSd8CUNrn1nAwlzOYC/TSJmLOfruvT9oz7o8fM44Tjqd/6PChSaoWtnzt3adYgCYO9fFWWOjO59s1wr+y7Zng3azmS9i1z8GwtW8bJzYfcSZPTtyOZKJJ3vO2l7CNFWZmFjmQhPJ4pExERFRwjgYExERJYxp6gKkLnw5ROscl3bq6uoK2rtv+VbQ/u0el8IazrrU9LFNLv0FAEe+42+DdvuyFXn3b6vx2EseRnLhyxQGh9x+9u5xi1PY5SRGza3mFa4YfrQCUFtba9BesGBB0M6Zffb09OTtL9F0MWuWW4TBxrJdEKLOXEJkq25peJ2WUGzOmZM/NR0byyPhWB4ysbzHxHIxorHc2uYujVyw4DC3T1MlkLFcPYo+MhaRtIg8LiJ3+7ePEpFHROQ5EblVROrHew0iSh5jmaj6TCRN/SEAW8ztLwL4qqquALAfwBWl7BgRlQ1jmajKFJWmFpGlAN4M4PMAPiLeQp9nA3iHv8nNAK4BcH0Z+lg1Ojo6gnZLx3NBe8sT7v76epfaOr7RfddZ+LYLQ681b+Xx7rXMbGxbUN4uOjH80l+C9lM7XTUgABg0szuHBl27zsyabDIzRkfMjPF6U7QeAJrNGsqWLTTPGdTTF2PZ09GxO2i3mjXIFy9enG/zQxaasObMmRO0i4ll27ZVsoBwmtrO2k5nXCw3NLhYtqnpuvpwQsP2xbILwHAGdfUo9sj4awCuAjD26ZoH4ICqjv0mtwNYku+JInKliGwSkU3RlYuIqOJKEsua03ybENEkjTsYi8iFADpV9bHJ7EBV16nqKlVd1VLCa+WIaGJKGcuSkfGfQERFKyZNfQaAi0TkAgCNANoAXAdgtohk/G/USwHsKPAaNcHOKB74zeNBeyjr0kN/tbw9aNeteWvQbpvjFpYAgKYm98XErk8aWvfUpKZ/ftP6oB39M1jf4PY/b77bz5BJQb92jptZ2WJmWaLQAU4RBz/aH52N6Xonza2gqsJY9tkZxfYzm826++0iDnYGdGuriR8UF8u5XHHp4AYTywsWuFjOmli2i17YxVyis7ytQo9RdRj3yFhVP6mqS1V1OYC3A7hfVd8J4AEAb/E3WwtgfcxLEFEVYCwTVa+pFP34BLwJIM/BO+90Q2m6REQVxlgmStiEin6o6oMAHvTbWwGcVvouVa+DB9ws5mf+7FLIhy1aFLR7L3u7e0K3S1ml68NroBaTA7Y1pG1qOhVJVNuCHqOmiICdZT3rb07Jv+cCp/5s0YGOr1+X9ymN88KzrzPnhmeNU3Wa8bHcdzBvOxe5uiCfVCoduac8OeDQaTETy9Ha2GOkQCzbYkB2zWaqHiyHSURElDAOxkRERAljbeoJOPj97wftXWbWpexz6esj77sjaM9586VB216oX0h2/Y+C9sMdvUE7Z5ZTy2XDBQjsrOkBc0H/8bPMrMsjjnH9NTOgR7c+FXqtvXtdbV47m/ThDpfKs9mwMyP9b+MMaprG9nW5WG5pdqdg2me7qySKjeU4dmnEbCSW7axpW5zDpqDj6lxHZ0zb1LSNZapOPDImIiJKGAdjIiKihHEwJiIiShjPGU9AyynHBu037HaLQ/x+8/ag3d3dHbSPNJWuMpno5RDO6MM/C9o/2/xy0B4wtbyz5pKlkWy4mo+9tCllTiL9vz53nij1LXe+e9CcP3qyL3wuaecu975S5nxU6NKqmPuJpjt7zvZAt1uEYemyZUG7UCzHvZY9/2urZmULXEoVd6mSvX9o0MVv9AIrXsI0vfDImIiIKGEcjImIiBLGNPUk/fmJnUH79NOODtqpM98UtHsPukuTentdG0Aov9v7sFt0Ym+X205M3kltajiSj7KPjZrrG+z9v97pLnPo7nWXNkUzYfalRzX//eet+augnTpuRhVuohnqYIFYnuhlR4UuRyrmOd3dLn57e6ILtdB0xSNjIiKihHEwJiIiShjT1BOQOvGMoH2yacfp2LUraLe1RdZA7d4dtLcdcIXfw7OW3a24GdMAkDVrpWaH3ezKATPT8qBJTdv0cyqSp46bNW1T07L8VSCaSXaZqwyisdzS4tYzLmYGdKH77eIQtmqWbff0dINqD4+MiYiIEsbBmIiIKGFMU5eRTS3ZtYEB4LfXfy9ot5u0V9zMaFuoo7c3PIPSpraGh/IXAbDZsLgZ0wDw6pb6oG2/qXHWNM1kQ0ODQXvPnsHQY7nc3KBtU9hxM6Pt34XobOjciE1Th/dDtY1HxkRERAnjYExERJQwpqkTcmD//qDdc8C142Y6F5oBPdHn2PvPe83i0GulV19QsN9EFLZ/f1feNtFE8MiYiIgoYRyMiYiIEsY0dULOv+yioN137/1B+6GOg0E7rjZ0dAZ03GOHN7il3l4xpylot6w8PGinXs+0NBFR0ooajEVkG4BeACMAcqq6SkTmArgVwHIA2wBcoqr7416DiKoD45mo+kwkTf1GVT1JVVf5t68GsFFVVwLY6N8moumB8UxURaZyzngNgJv99s0ALp56d4goIYxnogQVe85YAfxSRBTAN1V1HYCFqjq2EkIHgIXl6GCtSh3u1kBufbdrn3fXLUF745OuOH2hS5te3eyqZi0577Xugdnz3XMWHzWV7lJtYTwTVZliB+MzVXWHiBwGYIOIPG0fVFX1A/sQInIlgCsBoL29fUqdJaKSmFQ821hGhhdiEJVSURGlqjv8fzsB3AngNAC7RWQxAPj/dsY8d52qrlLVVS3Nzfk2IaIKmmw821iWTMyagEQ0KeMeGYtIC4CUqvb67fMAfAbAXQDWAviC/+/6cnZ0pqi76O1B+/yLCmxINAmMZ6LqVEyaeiGAO8VbgiQD4Ieqeq+IPArgNhG5AsCLAC4pXzeJqEQYz0RVaNzBWFW3Ajgxz/37AKwuR6eIqDwYz0TVibMwiIiIEsbBmIiIKGEcjImIiBLGwZiIiChhHIyJiIgSxsGYiIgoYRyMiYiIEsbBmIiIKGEcjImIiBLGwZiIiChhHIyJiIgSxsGYiIgoYRyMiYiIEsbBmIiIKGEcjImIiBLGwZiIiChhHIyJiIgSxsGYiIgoYRyMiYiIEsbBmIiIKGEcjImIiBLGwZiIiChhHIyJiIgSVtRgLCKzReR2EXlaRLaIyOkiMldENojIs/6/c8rdWSKaGsYyUXUq9sj4OgD3quqxAE4EsAXA1QA2qupKABv920RU3RjLRFVo3MFYRNoBvAHADQCgqsOqegDAGgA3+5vdDODicnWSiKaOsUxUvYo5Mj4KwB4A3xGRx0Xk2yLSAmChqu7yt+kAsLBcnSSikmAsE1WpYgbjDIBTAFyvqicD6EMkjaWqCkDzPVlErhSRTSKyqa+/f6r9JaLJK1ksay7vJkQ0ScUMxtsBbFfVR/zbt8ML6N0ishgA/H878z1ZVdep6ipVXdXS3FyKPhPR5JQsliUjFekw0Uwx7mCsqh0AXhaRV/p3rQbwFIC7AKz171sLYH1ZekhEJcFYJqpemSK3+yCAH4hIPYCtAC6HN5DfJiJXAHgRwCXl6SIRlRBjmagKFTUYq+pmAKvyPLS6tN0honJiLBNVp2KPjImIHBGgIe21h0aS7QtRtWme+NDKcphEREQJ42BMRESUMKapiWjCWmc148zXnwoAuO/hx9wDTFnTTDV22gbAp//uH4P2v/zxmqKeziNjIiKihHEwJiIiSph41e8qtDORPfBK8O2t2E6rz3zM3Pc/k987MLH3f6SqLihnZ6bCj+UXMbN/pzP5vQMz+/2XPJYrOhgDgIhsUtV81znOCDP5/c/k9w7U5vuvxfdUrJn83oGZ/f7L8d6ZpiYiIkoYB2MiIqKEJTEYr0tgn9VkJr//mfzegdp8/7X4noo1k987MLPff8nfe8XPGRMREVEY09REREQJq+hgLCLni8gzIvKciFxdyX1XmogsE5EHROQpEXlSRD7k3z9XRDaIyLP+v3OS7mu5iEhaRB4Xkbv920eJyCP+7/9Wfxm/miQis0XkdhF5WkS2iMjptfS7n0mxDDCeAcZzueO5YoOxiKQBfAPAmwAcB+BSETmuUvtPQA7AR1X1OACvA/B+//1eDWCjqq4EsNG/Xas+BGCLuf1FAF9V1RUA9gO4IpFeVcZ1AO5V1WMBnAjv/6EmfvczMJYBxjPAeC5vPKtqRX4AnA7gF+b2JwF8slL7T/oHwHoA5wJ4BsBi/77FAJ5Jum9ler9L/Q/o2QDuBiDwLpLP5Ps81NIPgHYAL8Cfk2Hur4nf/UyPZf89M54ZzyX93VcyTb0EwMvm9nb/vponIssBnAzgEQALVXWX/1AHgIUJdavcvgbgKgCj/u15AA6oas6/Xcu//6MA7AHwHT+t920RaUHt/O5nbCwDjGf/NuO5xL97TuAqMxGZBeAnAD6sqj32MfW+UtXcdHYRuRBAp6o+Nu7GtSkD4BQA16vqyfBKwIZSWLX6u691jOcZqSLxXMnBeAeAZeb2Uv++miUidfAC9weqeod/924RWew/vhhAZ1L9K6MzAFwkItsA3AIvtXUdgNkiMrZsZy3//rcD2K6qj/i3b4cXzLXyu59xsQwwnhnP5Y3nSg7GjwJY6c/AqwfwdgB3VXD/FSUiAuAGAFtU9SvmobsArPXba+Gde6opqvpJVV2qqsvh/Z7vV9V3AngAwFv8zWryvQOAqnYAeFlEXunftRrAU6id3/2MimWA8cx4Ln88V3rVpgvgnXtIA7hRVT9fsZ1XmIicCeBhAE/AnWf5FLzzTLcBOALeqjeXqGpXIp2sABE5C8DHVPVCETka3jfruQAeB/APqjqUZP/KRUROAvBtAPUAtgK4HN6X35r43c+kWAYYz2MYz+WLZ1bgIiIiShgncBERESWMgzEREVHCOBgTEREljIMxERFRwjgYExERJYyDMRERUcI4GBMRESWMgzEREVHC/j/An+mkUvd9LgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_random_validation_pred()\n",
    "plot_random_validation_pred()\n",
    "plot_random_validation_pred()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def overlay_pred_true():\n",
    "    random_index = np.random.choice(len(rand_x))\n",
    "    plt.imshow(rand_y[random_index, 0, 0], cmap = 'Reds', alpha = 0.5)\n",
    "    plt.imshow(rand_y_hat[random_index, 0, 0], cmap = 'Greens', alpha = 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "overlay_pred_true()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mimicking sequence-to-sequence by shuffling in predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFRlJREFUeJzt3XuMVdXZx/Hv48AoogOCSKcMVgi2BNsiSgvWpn29YPESsSkSDTXE0NC0qLRR6qU21sbYmiYqrY1hqlVe6ys3UQm1XgCrfYPyOog3RMpNAhMQL2C9VUGe94+z954Zh5lz3eey5vdJJrPPWufs/Xh8WLPO2metZe6OiIjUvkMqHYCIiJSGGnQRkUCoQRcRCYQadBGRQKhBFxEJhBp0EZFAqEEXEQlEUQ26mU00sw1mtsnMrilVUCKVptyWWmSFTiwyszrgX8AEYAfwPHCxu79WuvBEyk+5LbWqmB76N4FN7r7F3T8F5gOTShOWSEUpt6Um9SritUOA7e0e7wDGdfcCM9M6A5Iqd7cSnCav3B5w9AAfemwTL2/d0Fb4mVJdCnRIWwr3O7oBgPc2v/22uw/K9tJiGvScmNkMYEba1xEppw553aeOPV96HwZm/fcmkpf3juidOdj89rZcnl/MkEsrMLTd46aorAN3b3b3se4+tohriZRT1tzukNeH1pU1OJGuFNOgPw8cb2bDzKweuAhYWpqwRCpKuS01qeAhF3ffb2aXAY8DdcBf3H1dySITqZC8c/szhw/2lSs86UnyzKuixtDd/VHg0WLOIVKNlNtSizRTVEQkEGrQRUQCoQZdRCQQatBFRAKhBl1EJBBq0EVEAqEGXUQkEGrQRUQCoQZdRCQQatBFRAKhBl1EJBBq0EVEAqEGXUQkEGrQRUQCoQZdRCQQWRt0M/uLme02s1fblQ0wsyfNbGP0+6h0wxQpPeW2hCaXHvq9wMTPlV0DrHD344EV0WORWnMvym0JSNYG3d2fAd79XPEkYF50PA+4oMRxiaROuS2hKXQMfbC774yOdwGDSxSPSKUpt6VmFbWnKIC7u5l5V/VmNgOYUex1RMqtu9zukNeH1ZUzLJEuFdpDf9PMGgGi37u7eqK7N7v7WHcfW+C1RMopp9zukNe99WUxqQ6FZuJSYFp0PA14pDThiFSccltqVi5fW3wAeBb4ipntMLPpwO+ACWa2ETgzeixSU5TbEhpz73L4u/QX62asXaQU3N3KfU1rqHfGHVPuy0pPsrx1TS7D1hr8ExEJhBp0EZFAqEEXEQmEGnQRkUCoQRcRCYQadBGRQKhBFxEJhBp0EZFAqEEXEQmEGnQRkUCoQRcRCYQadBGRQBS9wUWoBg/ObFQza9aspGzcuHEAjB49OilbsWJFh9etWrUqOW5qagJg5MiRSdkXv/hFAK6//noA/v73v5cybBHpwdRDFxEJRNYeupkNBf6bzN6KDjS7+xwzGwAsAI4D3gCmuPue9EItr927MxvVfPTRR0nZaaed1ul5F154YYfH48ePT46HDh3a5fn/9re/AfDggw92eS5JV0/NbQlXLj30/cCV7j4KGA/MNLNRwDXACnc/HlgRPRapJcptCUrWBt3dd7r7C9Hx+8B6YAgwCZgXPW0ecEFaQYqkQbktocnrpqiZHQeMAVYDg919Z1S1i8zH1mDEN0W/853vdKrbvHlzcnzTTTcB0L9/fwDOOuuspG7r1q1dniPWXZ2UT0/KbQlXzjdFzewI4EHgZ+7+7/Z1ntnH7qDby5nZDDNrMbOWoiIVSUkhud0hr/cdKFOkIt3LqYduZr3JJPz97r4kKn7TzBrdfaeZNQK7D/Zad28GmqPz1Myeort27QJgwYIFSdmZZ54JwLBhw5Kyww8/HIA5c+Z0+A1wyCGZv5d9+/ZNyuIbpa+++moaYUueCs3tDnndUF8zeS1hy9pDNzMD7gbWu/ut7aqWAtOi42nAI6UPTyQ9ym0JTS499FOBS4BXzOzFqOw64HfAQjObDmwDpqQTokhqlNsSlKwNurv/L2BdVJ9R2nCqz2OPPZYcb9myBYDhw4cnZX/4wx86PP/OO+9Mjg8cyIytvv/++0nZ1KlTU4lT8tfTc1vCo5miIiKB0FouWbS2tibHY8aMAeCOO+5Iyi655BIAbrzxRgA++OCDpO6+++4DYOzYsUnZ7NmzO5z/rrvuKnHEItJTqYcuIhIIy3zNtkwXq6GvLXansbExOY6/pjh58mQA9u/fn9TFPfT4647Q9rXFdevWAXDyyScndZ9++mlKEfcc7t7VmHhqrKHeGXdMuS8rPcny1jXuPjbb09RDFxEJhBp0EZFA6KZoAXbu3JkcX3HFFQBk5qjAD37wg6Tu0ksv7fTavXv3AvD9738f0DCLiJSOeugiIoFQD71I8XotdXV1OT0/3nJu06ZNqcUkIj2TeugiIoFQgy4iEggNuRTgq1/9anIcD6EMGTIEgE8++SSp2759OwAjRoxIys4991wALrroIgDmz5+fbrAi0mOohy4iEgj10PNw7LHHAm29cmjrmcc3Oa+66qqkbtWqVQD8+c9/TsomTZoEwNy5cwF45ZVXkrp49qiISCHUQxcRCUTWHrqZHQY8AxwaPX+xu99gZsOA+cBAYA1wibsHPUvm5z//OdDWK4e2nvnEiROBtjXT2/vRj36UHDc0NABw2mmnAXD77bcndRMmTChxxNId5baEJpce+ifA6e4+GjgRmGhm44FbgNvcfQSwB5ieXpgiqVBuS1CyNuieES/y3Tv6ceB0YHFUPg+4IJUIRVKi3JbQ5HRT1MzqyHz0HAH8CdgM7HX3eK3YHcCQLl5e09pvTjFz5kyg41ou3Q21xN55553k+MorrwTghRdeAGD8+PFJ3ciRIwF4/fXXiw1bctSTc1vCk9NNUXf/zN1PBJqAbwIjc72Amc0wsxYzaykwRpHUFJrbHfJ634FUYxTJVV5fW3T3vWb2FHAK0N/MekU9mSagtYvXNAPNUJsbXBx55JHJca9embdr27ZtSVl3PfODWb9+PQAtLZm/b+0/AcQrN/70pz8tLFgpWL653SGvG+prLq8lTFl76GY2yMz6R8d9gAnAeuApYHL0tGnAI2kFKZIG5baEJpceeiMwLxprPARY6O7LzOw1YL6Z3QSsBe5OMc5gxEsDXHbZZQA899xzSd0ZZ5xRkZh6MOW2BCVrg+7uLwNjDlK+hcyYo0hNUm5LaDRTVEQkEFrLpQCjRo1KjocPHw7kf3P0C1/4QqeyeBapiEgh1EMXEQmEeuhZvPTSS8nx2rVrARgzZkynsgsuyEwmfPrpp5O6Awe6/n5y//79O5UtWrSouGBFpEdTD11EJBBq0EVEAmHu5ZvkVoszRdv77ne/C8DDDz+clMVDJ/H7uGzZsqRuyZIlnc7Rp08fAG6++WYADj300KTupJNOArSWSzHc3cp9TWuod8YdU+7LSk+yvHWNu4/N9jT10EVEAqEeegEGDBiQHF9//fVA2zoshxzS+W+kWVunMX6/P/ggs2rrT37yk6Tu/vvv7/KaU6dOBTquLRMf//73v8/vPyBg6qFLkNRDFxHpWdRDL5ETTjgBgBtuuCEpmzw5s77Thx9+mJQtXLgQgNmzZwPw7rvvdnnOgQMHJscrV64E2iYytT9+6623ioo9JOqhS5DUQxcR6VnUoIuIBEIzRUtk3bp1AEyZMqXoc40bNw6Ahx56KCk7/PDDAbj44ouTMg21iEh76qGLiAQi5x56tAlAC9Dq7ueZ2TBgPjCQzCa7l7j7p+mE2TPEvfD4a4jHHNN2o+2OO+4AOk5ckuIpryUk+fTQZ5HZnit2C3Cbu48A9gDTSxmYSJkoryUYOTXoZtYEnAvcFT024HRgcfSUecAFaQQokhbltYQm1yGX24FfAPE0xYHA3mhXdIAdwJASx9bjfPnLXwbgW9/6Vqe6e++9t8zR9AjKawlK1h66mZ0H7Hb3NYVcwMxmmFmLmbUU8nqRNJQ0r/d1ve69SDnl0kM/FTjfzM4BDgMagDlAfzPrFfVmmoDWg73Y3ZuBZgh7pmgp/PCHPwRgz549AFx++eVJ3aZNmyoSU8BKl9cN9cprqQpZe+jufq27N7n7ccBFwEp3nwo8BUyOnjYNeCS1KEVKTHktISpmYtHVwHwzuwlYC9xdmpB6lvarJ55yyikA1NfXAx3XRY9XZ5TUKa+lZuXVoLv7P4B/RMdbgG+WPiSR8lJeSyg0U1REJBBay6VC4lmh9913X1IWr+HS0pL5QtCGDRvKH5iI1Cz10EVEAqEeeoX069cPgPPOOy8pi1dPvOyyywD4+OOP8zpnfDMV4Mc//jEA55xzTlL29a9/vcvXxjdgf/vb3yZly5cvz+v6IlJZ6qGLiARCDbqISCA05FJmZ511FgCLFy/uVNfampmUGN8UzVW89svjjz+elPXp0yevcwwePBiAU089NSmbM2cOAFdffXVe5xKRylAPXUQkEOqhl9kNN9wAQN++fTvVZVZvzV18jvicRxxxRFJ34EBmwaglS5YkZY8++igA99xzT6dz3XrrrQDMmjUrKbvqqqsA+PTTzP4Ov/rVr/KKT0TKSz10EZFAqIdeZl/72tcAcM8s0Pfkk08mdWvXrs36+nhCErStwDho0CAAPvvss6QunrB0yy23JGXt14b5vGeffRaAK664olPdRx99lDUuEak89dBFRAKhBl1EJBAacimziRMnAvDMM88A8NxzzyV18+bN6/J18TK77dd+iYdaYnPnzk2OZ86cmVdc8fK8+/btS8p69+4NwJYtW/I6l4hUhnroIiKBsPjmXLdPMnsDeB/4DNjv7mPNbACwADgOeAOY4u57spynx2/VFfe0423mtm/fntSNGTMGgL1793Z63YUXXgjAAw880OW5e/Uq/APXUUcdBXS8MdvU1ATA+vXrgbYbutXM3fP67mcpctsa6p1xxxQaskh2y1vXuPvYbE/Lp4d+mruf2O6k1wAr3P14YEX0WKQWKbclCMUMuUwC4kHfecAFxYcjUhWU21KTcv2M7sAT0ZDJ3GjH88HuvjOq3wUMTiPA0MT7hm7evBnoOLuzubkZgClTpnR63cHKYgsWLCg6rhNPPBGAgQMHdqprH2OAlNsSjFwb9G+7e6uZHQM8aWYdZqi4u3c1Pm5mM4AZRcYpkpaCcrtDXh9WV5ZARbLJqUF399bo924ze4jMJrpvmlmju+80s0ZgdxevbQaaQTdFAf75z38CbSsjjh8/Pqn73ve+B7RtRbd69eqk7mA3r7dt2wa0reWSlrPPPjvV81dSobndIa8b6nt8Xkt1yDqGbmZ9zezI+Bg4C3gVWApMi542DXgkrSBF0qDcltDk0kMfDDwUrQTYC/gfd3/MzJ4HFprZdGAb0PUgryTibeWuu+46AFauXJnUxasnxtvSxePsADt27Oh0rqVLlwJta7rkq7GxMTk+99xzgYOvox7wGLpyW4KStUF39y3A6IOUvwOckUZQIuWg3JbQaKaoiEggcpopWrKL6aZoJyNHjkyOb775ZgDOP/98oG1LOmibBRpvFQfw3nvvAW3DJe3XhelOvA3ejTfemJR94xvfAGDjxo1JWbwF3aJFiwB45513cjp/JeU7U7QUNFNUUpfCTFEREali6qFXkXh1w9/85jcAzJ49O6fXxZtkjB7dNhz8xBNPALB169akbMaMzNem43Vb6uvrk7pf//rXAPzxj39MyuJPALVEPXQJknroIiI9i3roVaiuLjPz8IQTTkjKbrvtNgBWrVqVlMXbxb300ksAPP3000ldPE5+8sknJ2V33nknANdc03mtqf/85z9Ax23sapF66BIk9dBFRHoWNegiIoHQkIsERUMuEiQNuYiI9Cxq0EVEAqEGXUQkEGrQRUQCoQZdRCQQatBFRAKRU4NuZv3NbLGZvW5m683sFDMbYGZPmtnG6PdRaQcrUmrKbQlJrj30OcBj7j6SzIYA64FrgBXufjywInosUmuU2xKMrBOLzKwf8CIw3Ns92cw2AP/VbiPdf7j7V7KcSxOLJFX5TCwqVW5rYpGkroQTi4YBbwH3mNlaM7sr2lB3sLvvjJ6zi8z+jJ2Y2QwzazGzllxjFymTgnO7Q17vO1DGkEW6lkuD3gs4CbjT3ccAH/K5j6BR7+agvW93b3b3sbn8dREps4Jzu0Ne99Z3C6Q65JKJO4Ad7r46eryYzD+CN6OPo0S/d6cTokhqlNsSlKwNurvvArabWTyGeAbwGrAUmBaVTQMeSSVCkZQotyU0vXJ83uXA/WZWD2wBLiXzx2ChmU0HtgFT0glRJFXF53adQUNv+Pe+tGOVnubow/J6ek4Nuru/CBxsDPyMvK4mUmWU2xIS3c0REQmEGnSRIg1pHMTvfjkD+tW3/YgUqqF38vPxX1/m47++nPNL1aCLiASi3FvQvUXmu75vl+2ipXc0tRt/LccO2eP/krsPKlcwsSivt1Hb728txw61HX8useeU22Vt0AHMrKWWJxnVcvy1HDtUf/zVHl93ajl2qO34Sxm7hlxERAKhBl1EJBCVaNCbK3DNUqrl+Gs5dqj++Ks9vu7UcuxQ2/GXLPayj6GLiEg6NOQiIhKIsjboZjbRzDaY2SYzq+pdYMxsqJk9ZWavmdk6M5sVldfM9mRmVhet870sejzMzFZH7/+CaP2SqlRLW8PVUl6DcrvS0sztsjXoZlYH/Ak4GxgFXGxmo8p1/QLsB65091HAeGBmFG8tbU82i8yWarFbgNvcfQSwB5hekahyUxNbw9VgXoNyu9LSy213L8sPcArweLvH1wLXluv6JYj/EWACsAFojMoagQ2Vjq2LeJuixDgdWAYYmckLvQ72/6OafoB+wFaiezztyqvuva/1vI5iVm6XL/ZUc7ucQy5DgO3tHu+IyqqemR0HjAFWk+PWe1XgduAXQLw/2kBgr7vvjx5X8/tf1LaHZVazeQ3K7QpINbd1UzQLMzsCeBD4mbv/u32dZ/6cVt3XhMzsPGC3u6+pdCwFKmrbQ8mNcrsiUs3tcjborcDQdo+borKqZWa9yST8/e6+JCquhe3JTgXON7M3gPlkPprOAfqbWbwGfjW//7W0NVzN5TUotyso1dwuZ4P+PHB8dDe6HriIzFZfVcnMDLgbWO/ut7arqvrtydz9WndvcvfjyLzPK919KvAUMDl6WlXGDjW3NVxN5TUotysp9dwu8w2Bc4B/AZuBX1b6BkWWWL9N5mPPy8CL0c85ZMbrVgAbgeXAgErHmuW/47+AZdHxcOD/gE3AIuDQSsfXTdwnAi3R+/8wcFS1vve1lNdRvMrtysadWm5rpqiISCB0U1REJBBq0EVEAqEGXUQkEGrQRUQCoQZdRCQQatBFRAKhBl1EJBBq0EVEAvH/ovj9ePk+4ikAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFOZJREFUeJzt3XuMVeW5x/Hv48BURAFBpJTBCsGWoBU4omBtm6JCUYyQFIkGDTmxh6YVpRdRtDao8diaJipqS6C2yrEeuYlCqPU23nqCejqK1wLlJgeIFFSw4o3bc/7Ya62ZcWbYl9lrX975fZLJrP2+a6/1uH149zvvWut9zd0REZHqd0S5AxARkeJQgy4iEgg16CIigVCDLiISCDXoIiKBUIMuIhIINegiIoFoV4NuZuPMbJ2ZbTCzWcUKSqTclNtSjazQB4vMrAb4BzAG2Ab8DbjE3f9evPBESk+5LdWqPT30M4AN7r7J3fcBC4EJxQlLpKyU21KVOrXjvf2ArU1ebwNGHu4NZqZ5BiRV7m5FOExeud3zuJ7e/4Q63ti8rrHwoFJdCnREYwp3P64bAB9ufO89d++d7a3tadBzYmbTgGlpn0eklJrldZcadn/1I+iV9d+bSF4+PLpzZmPje1ty2b89Qy7bgf5NXtdFZc24+3x3H+HuI9pxLpFSyprbzfL6SzUlDU6kLe1p0P8GnGRmA8ysFrgYWFGcsETKSrktVangIRd3P2Bm04EngBrgj+7+dtEiEymTvHP7oMPe/aUKTzqSPPOqXWPo7v4Y8Fh7jiFSiZTbUo30pKiISCDUoIuIBEINuohIINSgi4gEQg26iEgg1KCLiARCDbqISCDUoIuIBEINuohIINSgi4gEQg26iEgg1KCLiARCDbqISCDUoIuIBEINuohIILI26Gb2RzPbaWZvNSnraWZPmdn66Pex6YYpUnzKbQlNLj30+4FxXyibBdS7+0lAffRapNrcj3JbApK1QXf3F4APvlA8AVgQbS8AJhY5LpHUKbclNIWOofdx93ej7R1AnyLFI1Juym2pWu1aUxTA3d3MvK16M5sGTGvveURK7XC53Syvj6wpZVgibSq0h/5PM+sLEP3e2daO7j7f3Ue4+4gCzyVSSjnldrO87qybxaQyFJqJK4Cp0fZUYHlxwhEpO+W2VK1cblt8CHgR+LqZbTOzy4FfA2PMbD1wbvRapKootyU05t7m8HfxT3aYsXaRYnB3K/U5rVutM/L4Up9WOpKnt7+Sy7C1Bv9ERAKhBl1EJBDtvm0xVH36ZG4/njFjRlI2cuRIAIYOHZqU1dfXN3vfqlWrku26ujoABg8enJR95StfAeCGG24A4C9/+UsxwxaRDkw9dBGRQKhBFxEJhIZc2rBzZ+Z5kk8++SQpGz16dIv9LrroomavR40alWz379+/zeP/+c9/BuDhhx9u81giIvlQD11EJBDqobchvij6ne98p0Xdxo0bk+1bbrkFgB49egAwduzYpG7z5s1tHiN2uDoRkXyohy4iEgg16CIigdCQSxt27NgBwKJFi5Kyc889F4ABAwYkZUcddRQAc+bMafYb4IgjMt+XXbt2TcriC6VvvZWseiYiUhTqoYuIBEI99Cwef/zxZHvTpk0ADBw4MCm76667mu0/d+7cZPvQoUMAfPTRR0nZlClTUolTREQ9dBGRQGTtoZtZf+C/yKyt6MB8d59jZj2BRcCJwDvAZHffnV6o5bF9+/Zke/jw4QDcc889Sdlll10GwE033QTA3r17k7oHHngAgBEjGme9nDlzZrPj33vvvUWOWHLV0XNbwpNLD/0A8HN3HwKMAq4wsyHALKDe3U8C6qPXItVEuS1Bydqgu/u77v5qtP0RsAboB0wAFkS7LQAmphWkSBqU2xKavFYsMrMTgReAU4D/c/ceUbkBu+PXh3l/ECsW9e3bN9mOb1OcNGkSAAcOHEjq4iGX+HZHaLxt8e233wbgtNNOS+r27duXUsQdR6ErFrUnt7VikaSu2CsWmdnRwMPAT9z9X03rPPOt0GpjbWbTzKzBzBpyPZdIKRWS283yev+hEkUqcng59dDNrDOwEnjC3W+PytYB33X3d82sL/Ccu389y3GC6KE39eUvfxmAu+++G4Dvf//7h91/z549AJxxxhkAbNiwIcXoOp58e+jFyG310CV1xeqhR39y/gFYEyd8ZAUwNdqeCiwvJE6RclFuS2hyebDoLOAy4E0zey0qux74NbDYzC4HtgCT0wlRJDXKbQlK1gbd3f8HaOvP2HOKG071iedrqampyWn/eA1RDbWUn3JbQqMnRUVEAqG5XApwyimnJNtxj7tfv34AfP7550nd1q1bARg0aFBSNn78eAAuvvhiABYuXJhusCLSYaiHLiISCPXQ83DCCScAjb1yaOyZx2PiV199dVK3atUqAH7/+98nZRMmTABg3rx5ALz55ptJXfywkYhIIdRDFxEJhBp0EZFAaMglDz/96U+BxmEWaBxqGTduHNC4CEZTP/jBD5Ltbt26ATB69GgA7rzzzqRuzJgxRY5YRDoS9dBFRAKR12yL7T5ZFc7l0nRxivgi565du5Kyb3/720DrPfPWDBs2DIBXX30VgI8//jipO/300wFYu3ZtOyLu2AqdbbE9NJeLpK7Ysy2KiEhlU4MuIhIIXRTN4phjjkm2O3XKfFxbtmxJynIdaomtWbMGgIaGzPTwTYd0rrrqKgB+/OMfFxasiHRo6qGLiARCPfQSi+d6mT59OgAvvfRSUnfOOZrgT0QKpx66iEggsvbQzexIMovnfinaf6m7zzazAcBCoBfwCnCZu3eIVY6HDBmSbA8cOBDIfyw9XrquqfihIykN5baEJpce+ufA2e4+FBgGjDOzUcBtwB3uPgjYDVyeXpgiqVBuS1CyNuiesTd62Tn6ceBsYGlUvgCYmEqEIilRbktocrooamY1ZP70HAT8FtgI7HH3A9Eu24B+bby9qr3++uvJ9urVqwEYPnx4i7KJEzP/5p9//vmk7tChQ20et0ePHi3KlixZ0r5gJW8dObclPDldFHX3g+4+DKgDzgAG53oCM5tmZg1m1lBgjCKpKTS3m+X1/ra/uEVKKa/bFt19j5k9C5wJ9DCzTlFPpg7Y3sZ75gPzoTrncvnggw+S7Z/97GcAPProo0lZ3NOur68HYOXKlUndsmXLWhyvS5cuANx6660AfPbZZ0nd7373u2KFLXnKN7eb5XW32qrLawlT1h66mfU2sx7RdhdgDLAGeBaYFO02FVieVpAiaVBuS2iyzrZoZqeSuTBUQ+YLYLG732xmA8nc2tUTWA1c6u6ft32k6uyht6Znz57J9g033AA0PrZ/xBEtvyPNGicAjD/vvXsz1+J+9KMfJXUPPvhg8YPtYPKZbbFYua3ZFiV1Oc62mHXIxd3fAIa3Ur6JzJijSFVSbkto9KSoiEggtMBFkZx88skAzJ49OymbNCkzDNt0EYvFixcDMHPmTKD5RVdpPy1wIUHSAhciIh2LeugBmDJlCtB87vZ4+ze/+U1ZYioX9dAlSOqhi4h0LGrQRUQCoQUuqlivXr0AuOaaa4DGqXy/uC0iHYN66CIigVAPvcqMHDky2X7kkUcAOOqoowC45JJLkrpdu3aVNjARKTv10EVEAqEeepWIe+FNb0M8/vjMrXL33HMP0HymRxHpeNRDFxEJhBp0EZFAaMilSnzta18D4Jvf/GaLuvvvv7/E0YhIJVIPXUQkEDn30KPFdBuA7e5+gZkNILMIQC8yi+xe5u770glTLr30UgB2796dlF155ZUAbNiwoSwxhUB5LSHJp4c+g8zyXLHbgDvcfRCwG7i8mIGJlIjyWoKRU4NuZnXAeODe6LUBZwNLo10WABPTCFAkLcprCU2uQy53AtcA8fysvYA90aroANuAfkWOrcNrOh3umWeeCUBtbW1StnbtWqBxfVLJm/JagpK1h25mFwA73f2VQk5gZtPMrMHMGgp5v0gaiprX+w8VOTqRwuTSQz8LuNDMzgeOBLoBc4AeZtYp6s3UAdtbe7O7zwfmgxa4yFX8VOgDDzyQlMVzuDQ0NH4vrlu3rrSBhaV4ed2tVnktFSFrD93dr3P3Onc/EbgYeMbdpwDPApOi3aYCy1OLUqTIlNcSovY8WHQtsNDMbgFWA38oTkjSvXt3AC644IKkLJ49cfr06UnZp59+mtdx4/H3H/7whwCcf/75Sd2pp57a5vvisfpf/epXSdnTTz+d17mriPJaqlZeDbq7Pwc8F21vAs4ofkgipaW8llDoSVERkUBoLpcKMnbsWACWLl3aom779sy1uaYXRXPRdO6XJ554AoAuXbrkdYw+ffoAcNZZZyVlc+bMAeDaa6/N61gikh710EVEAqEeegWZPXs2AF27dm1Rl3mIMXfxMeJjAhx99NEAHDqUuW962bJlSd1jjz0GwH333dfiWLfffjsAM2bMSMquvvpqAPbta5zm5Je//GVeMYpIcamHLiISCDXoIiKB0JBLBfnGN74BgHvmwcOnnnoqqVu9enXW98dPmELjlLq9e/dOyg4ePAg0PoF62223JXXxveatefHFFwG46qqrWtR98sknWeMSkdJQD11EJBDqoVeQcePGAfDCCy8A8NJLLyV1CxYsaPN98ayMTed+adozj82bNw+AK664Iq+44tkc9+/fn5R17twZgE2bNuV1LBFJj3roIiKBsHi8tiQn02yLhxX3tONl5rZu3ZrUDR8+HIA9e/a0eN9FF10EwEMPPXTY43fqVNgfZMceeyzQfBy/rq4OgDVrGhf7ia8BlJO753d/ZxFYt1pn5PGlPq10JE9vf8XdR2TbTT10EZFAqEEXEQmELopWkHiZuY0bNwKNT3YCzJ8/H4DJkye3eF9rZbFFixa1O65hw4YB0KtXrxZ1TWMUkfJSD11EJBA59dDN7B3gI+AgcMDdR5hZT2ARcCLwDjDZ3XenE2bH8Ne//hVonBVx1KhRSd33vvc9oHEpOoCXX34ZaHwQqaktW7YAzedyScN5552X6vHTptyWkOTTQx/t7sOaXGmdBdS7+0lAffRapBoptyUI7RlymQDET7ssACa2PxyRiqDclqqU60VRB56M7iOfF6143sfd343qdwB90giwI4nXCL3++usBeOaZZ5K6eDrcpuuMxhdPt23b1uJYK1asABrndClE3759ARg/fjzQ+sIYAVwUVW5LMHJt0L/l7tvN7HjgKTNrNpOTu3tbDw2Z2TRgWjvjFElLQbndLK+PrClJoCLZ5P2kqJndCOwF/gP4rru/a2Z9gefc/etZ3qsnRfMwePDgZPvWW28F4MILL0zK4mXp4idA46XiAD788EOgsXcNzeeGaUu8DB7ATTfdBMDpp58OwPr165O6eAm6JUuWJGXvv/9+1uOnrT1Pihaa23pSVFJXrCdFzayrmR0TbwNjgbeAFcDUaLepwPLCoxUpPeW2hCZrD93MBgKPRC87Af/t7v9pZr2AxcAJwBYyt3Z9kOVY6qEXKJ7d8Oabb07KZs6cmfV9TedUHzp0KABPPvkkAJs3b07qpk3LjB7E87YA1NbWAnDjjTcCcPfddyd18V8AlSafHnqxcls9dEldjj30rGPo7r4JGNpK+fvAOYVFJ1J+ym0JjZ4UFREJhKbPrTI1NY13VJx88skA3HHHHQCsWrUqqYuXi3v99deTsueffx5ovPB52mmnJXVz584FYNasls/QfPbZZ0DjEnaVTNPnSpA0fa6ISMeiHroERT10CZJ66CIiHYsadBGRQKhBFxEJhBp0EZFAqEEXEQmEGnQRkUCoQRcRCYQadBGRQKhBFxEJhBp0EZFAqEEXEQlETg26mfUws6VmttbM1pjZmWbW08yeMrP10e9jsx9JpLIotyUkufbQ5wCPu/tgMgsCrAFmAfXufhJQH70WqTbKbQlGLkvQdQdeAwZ6k53NbB1aJFoqTJ5L0BUltzXboqSuiLMtDgB2AfeZ2WozuzdaULePu78b7bMD6NPam81smpk1mFlDrrGLlEjBud0sr/cfKmHIIm3LpUHvBPwbMNfdhwMf84U/QaPeTau9b3ef7+4jcvl2ESmxgnO7WV531r0FUhlyycRtwDZ3fzl6vZTMP4J/Rn+OEv3emU6IIqlRbktQsjbo7r4D2Gpm8RjiOcDfgRXA1KhsKrA8lQhFUqLcltB0ynG/K4EHzawW2AT8O5kvg8VmdjmwBZicTogiqWp/btcYdOsM/9qfdqzS0Rx3ZF6759Sgu/trQGtj4OfkdTaRCqPclpDoao6ISCDUoIu0U7++vfn1L6ZB99rGH5FCdeuc/Hz6pzf49E9v5PxWNegiIoHI+qRoUU9mtovMvb7vleykxXcc1Rt/NccO2eP/qrv3LlUwsSivt1Ddn281xw7VHX8useeU2yVt0AHMrKGaHzKq5virOXao/PgrPb7DqebYobrjL2bsGnIREQmEGnQRkUCUo0GfX4ZzFlM1x1/NsUPlx1/p8R1ONccO1R1/0WIv+Ri6iIikQ0MuIiKBKGmDbmbjzGydmW0ws4peBcbM+pvZs2b2dzN728xmROVVszyZmdVE83yvjF4PMLOXo89/UTR/SUWqpqXhqimvQbldbmnmdskadDOrAX4LnAcMAS4xsyGlOn8BDgA/d/chwCjgiijealqebAaZJdVitwF3uPsgYDdweVmiyk1VLA1XhXkNyu1ySy+33b0kP8CZwBNNXl8HXFeq8xch/uXAGGAd0Dcq6wusK3dsbcRbFyXG2cBKwMg8vNCptf8flfQDdAc2E13jaVJecZ99ted1FLNyu3Sxp5rbpRxy6QdsbfJ6W1RW8czsRGA48DI5Lr1XAe4ErgHi9dF6AXvc/UD0upI//3Yte1hiVZvXoNwug1RzWxdFszCzo4GHgZ+4+7+a1nnm67TibhMyswuAne7+SrljKVC7lj2U3Ci3yyLV3C5lg74d6N/kdV1UVrHMrDOZhH/Q3ZdFxdWwPNlZwIVm9g6wkMyfpnOAHmYWz4FfyZ9/NS0NV3V5DcrtMko1t0vZoP8NOCm6Gl0LXExmqa+KZGYG/AFY4+63N6mq+OXJ3P06d69z9xPJfM7PuPsU4FlgUrRbRcYOVbc0XFXlNSi3yyn13C7xBYHzgX8AG4FflPsCRZZYv0Xmz543gNein/PJjNfVA+uBp4Ge5Y41y3/Hd4GV0fZA4H+BDcAS4Evlju8wcQ8DGqLP/1Hg2Er97Kspr6N4ldvljTu13NaToiIigdBFURGRQKhBFxEJhBp0EZFAqEEXEQmEGnQRkUCoQRcRCYQadBGRQKhBFxEJxP8D1esKkpOEolAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFMNJREFUeJzt3XuMVeW5x/Hv48B4QQFBSqcMVij2EHoBFAvW3tBKUYzQFImGGmJop0nVYltRtDbWxtiaJiqtDelUqhzbIzcvEGrxglabUjni9YhI5SKBCYhWsKJWQJ7zx15rzd4yw77MXvvyzu+TTGbtd+291uP24Zl3v2uv9zV3R0RE6t8R1Q5ARETKQwVdRCQQKugiIoFQQRcRCYQKuohIIFTQRUQCoYIuIhKILhV0M5toZhvMbKOZzSlXUCLVptyWemSl3lhkZg3AP4Gzge3A08BF7v5y+cITqTzlttSrrvTQvwBsdPfN7r4PWAhMLk9YIlWl3Ja61KMLrx0EbMt6vB0Ye7gXmJnmGZBUubuV4TBF5Xa/E/r54BObeXHLhvbGD5XqUqIj2lO4zwm9AXh705tvuvuAfC/tSkEviJm1AC1pn0ekknLy+ugGdn/yHeif99+bSFHePrZnZmPTm1sLeX5XhlzagMFZj5ujthzu3uruY9x9TBfOJVJJeXM7J6+PbKhocCKd6UpBfxo42cyGmFkjcCGwvDxhiVSVclvqUslDLu5+wMwuAx4CGoA/uPu6skUmUiVF5/aHDnv3Vyo86U6KzKsujaG7+4PAg105hkgtUm5LPdKdoiIigVBBFxEJhAq6iEggVNBFRAKhgi4iEggVdBGRQKigi4gEQgVdRCQQKugiIoFQQRcRCYQKuohIIFTQRUQCoYIuIhIIFXQRkUCooIuIBCJvQTezP5jZLjN7Kautn5k9YmavRr+PTzdMkfJTbktoCumh3wVM/EjbHGCVu58MrIoei9Sbu1BuS0DyFnR3fxJ46yPNk4EF0fYCYEqZ4xJJnXJbQlPqGPpAd98Rbe8EBpYpHpFqU25L3erSmqIA7u5m5p3tN7MWoKWr5xGptMPldk5eH9VQybBEOlVqD/11M2sCiH7v6uyJ7t7q7mPcfUyJ5xKppIJyOyeve+rLYlIbSs3E5cCMaHsGsKw84YhUnXJb6lbeIRczuwf4GnCCmW0Hrgd+CSw2s5nAVmBamkHWioEDM8Ops2bNStrGjh0LwMiRIwFYtWrVIa9bvXp1st3c3AzA8OHDAfjEJz6R7LvuuusA+Mtf/lLOsKUTym0JTd6C7u4XdbLrrDLHIlJRym0JTZcvinYnu3ZlhlPfe++9pG38+PE5z7ngggsOed24ceOS7cGDB3d6/D//+c8A3HvvvZ0eS0SkM7qaIyISCPXQixCPoX/lK185ZN+mTZsAuPHGG5O2vn37AjBhwoSkbcuWLZ0eI3a4fSIinVEPXUQkECroIiKB0JBLEXbu3AnAokWLkravf/3rAAwZMgSAY445Jtk3d+7cnN8ARxyR+Rvaq1cvIPci6UsvJZP+iYgUTT10EZFAqIdegpUrVybbmzdvBmDo0KEA/PrXvz7k+fPmzUu2Dx48CMA777wDwPTp01OLU0S6F/XQRUQCoYIuIhIIDbmUoK2tLdkePXo0ALfffjsAF198cbLvhhtuAGDv3r1J29133w3AmDGZySdnz559yPHvuOOOMkcsIt2BeugiIoEw907Xpij/yQ6zEEa9a2pqAnK/ojh16lQADhw4kLTFPfT4647ZX1tct24dAKeeeioA+/btSzHiMLm7Vfqc1rvRGfuxSp9WupNH254pZE0J9dBFRAJRyHzog4H/JrO2ogOt7j7XzPoBi4CTgNeAae6+O71Qa9uOHZllKH/wgx8kbWaZzuK3vvWtpO2SSy7Jed2ePXuS7W9+85uAeuaVotyW0BTSQz8A/NjdRwDjgEvNbAQwB1jl7icDq6LHIvVEuS1ByVvQ3X2Huz8bbb8DrAcGAZOBBdHTFgBT0gpSJA3KbQlNUV9bNLOTgNHAGmCgu++Idu0k87G124vnagFoaMi/Gnz2cnMbN25MJSbJT7ktISj4oqiZHQvcC1zh7v/O3ueZr8p0+A0WM2sxs7VmtrZLkYqkpJTczsnr/QcrFKnI4RXUQzeznmQS/k/ufl/U/LqZNbn7DjNrAnZ19Fp3bwVao+ME+7XFz372s0Buj3vQoEEAfPDBB0nbtm3bABg2bBgAkyZNSvZdeOGFACxcuDDdYCVRam7n5HXvxmDzWupL3h66Zb6qMR9Y7+63ZO1aDsyItmcAy8ofnkh6lNsSmkJ66GcAFwP/Z2bPR23XAr8EFpvZTGArMC2dEEVSo9yWoOhO0S468cQTAfj73/8OtA+zQPtFziuvvDJpW716NQC///3vAZg8eXKyL55S94tf/CLQfueoFE53ikqQdKeoiEj3otkWu+iHP/wh0N4zz/7q4cSJE4H2RTCyfec73wGgd+/eSdv48eMBuO222wA4++yzU4hYREKlHrqISCA0hl6CeC5zaB8Tf+ONNwD48pe/nOzrqGf+UaNGjUq2n332WQDeffddAE477bRk3yuvvNKFiLsPjaFLkDSGLiLSvaigi4gEQhdFS3Dccccl2z16ZN7CrVu3AoUNs2Rbv359sr12bWZ2hHhIJ3sq3u9///ulBSsi3YZ66CIigVAPvcqy53m57LLLAHjqqacAOOussyoWx/Tp04HcTx/x9q9+9auKxSEipVMPXUQkECroIiKB0JBLmYwYMQKAoUOHJm3FXiD9+Mc/nvM4+y7SNPTv3z/Zvuqqq4Dc+LO3RaT2qYcuIhII9dBL8MILLyTbzz33HACjR4/OeQwwZUpmKconnngiaTt4sPPVbfr27ZvzeMmSJV0PtgNjx44F4P7770/ajjnmGAAuuuiipC2++1VE6oN66CIigcg7l4uZHQU8CRxJpke/1N2vN7MhwEKgP/AMcLG778tzrCDmcsn21a9+FYAHHngAyO1lx+/tihUrkrb77ruPbEcffXSyfdNNNwFw5JFHAnDKKack+8oxl0vcC1+5ciXQPu86wO233w7AFVdc0eXzVFMxc7mUK7c1l4ukroxzuXwAnOnuI4FRwEQzGwfcDNzq7sOA3cDMrsQrUgXKbQlK3oLuGXujhz2jHwfOBJZG7QuAKalEKJIS5baEpqCLombWQOaj5zDgt8AmYI+7H4iesh0Y1MnLgxZf8PzUpz4FwHXXXZfsi+diOe+885K2eDuzPnH7sAzA3r2Z2vLd734XKP+UuZ/+9KeB3KGW2F133VXWc9UL5baEpKCLou7+obuPApqBLwDDCz2BmbWY2VozW1tijCKpKTW3c/J6f+ffXBKppKK+tujue8zsceB0oK+Z9Yh6Ms1AWyevaQVaIcyLorG33noLgB/96EdJ2/z58wG4/vrrk7apU6cC7b3xxYsXJ/tmz56dc6xy+/a3vw3A7t27Abj88suTfdlL53VHxeZ2Tl73bgw2r6W+5O2hm9kAM+sbbR8NnA2sBx4HpkZPmwEsSytIkTQotyU0hfTQm4AF0VjjEcBid19hZi8DC83sRuA5YH6KcdaldevWATBt2rSqxZA9e+Lpp58OQGNjI5A7Rh9/YuhmlNsSlLwF3d1fBEZ30L6ZzJijSF1SbktodKeoiEggNJdLoOK7Qu++++6kLZ7DJV7qbsOGDZUPTERSox66iEgg1EMPVJ8+fYDcm5ri2RPjpe7ef//9oo4ZX0wF+N73vgfAueeem7R9/vOf7/S18QXYX/ziFwA8+uijRZ1bRPJTD11EJBAq6CIigdCQS0AmTJiQbC9duvSQ/W1tmRse44uihYrnfnnooYeStuxpfwsxcOBAAM444wwA5s6dm+y7+uqrizqWiHRMPXQRkUCohx6Q7DljevXqdcj+eIbHQsXHiI977LHHJvvipfSyF+x48MEHAbjzzjsPOdYtt9wCwKxZswC48sork3379mXWjvjpT39aVHwikks9dBGRQKiHHpDPfe5zyXY8z/ojjzyStGUvYN2Z+IYkaJ+BccCAAQB8+OGHyb74hqWbb745aTvc/O3/+Mc/gPY54rO99957eeMSkfzUQxcRCYQKuohIIDTkEpCJEycm208++SQATz31VNK2YMGCTl8bT7ObPfdLPNQS+93vfpdsX3rppUXFFk/Pu3//fgB69uyZ7Nu8eXNRxxKRjqmHLiISCMtepPiwT8wsArAWaHP388xsCLAQ6E9mkd2L3X1fnmNoqa4UZS9mES8zt23btqRt9OjM1N979uw55LUXXHABAPfcc0+nx+/Ro/QPdMcffzzQfmG2ubk52bd+/Xog96Juqdy9qO9mliWvezc6Yz9Wasgi+T3a9oy7j8n3tGJ66LPILM8Vuxm41d2HAbuBmcVFKFITlNcSjIIKupk1A5OAO6LHBpwJxPeXLwCmpBGgSFqU1xKaQj9D3wZcBcSf6fsDe6JV0QG2A4PKHJsUKV4zFGDTpk1A7t2dra2tQMdrnB5u3dNFixZ1ObZRo0YB0L9//0P2ZcdYYcprCUreHrqZnQfscvdnSjmBmbWY2VozK25GKJEUlTWv9x8sc3QipSmkh34GcL6ZnQscBfQG5gJ9zaxH1JtpBto6erG7twKtoIuiafvb3/6WbMczI44bNy5p+8Y3vgG0L0W3Zs2aZF9HF8e3bt0K5M4Rk4Zzzjkn1eN3onx53btReS01IW8P3d2vcfdmdz8JuBB4zN2nA48DU6OnzQCWpRalSJkpryVEXbmx6GpgoZndCDwHzC9PSFKq7CXlrr32WgAee+yxpC2ePTFeli4eZwfYvn37Icdbvnw50D6nS7GampqS7UmTJgEdz6NexTH0jiivpW4VVdDd/a/AX6PtzcAXyh+SSGUpryUUulNURCQQBd8pWpaT6aJoxQ0fPjzZvummmwA4//zzgfYl6aD9LtB4qTiAt99+G2gfLsmeF+Zw4qXwbrjhhqTttNNOA+DVV18FcpegW7JkCQD/+te/Cjr+4RR7p2g56E5RSV0Kd4qKiEgNUw+9G4lnOPz5z38OwOzZswt6XbxIxsiRI5O2hx9+GIAtW7YkbS0tLUD7vC2NjY3Jvp/97GcA/OY3vwHae//lph66BEk9dBGR7kUFXUQkEBpy6YYaGhoA+MxnPpO03XrrrQCsXr06aYvX/3zhhRcAeOKJJ5J98YXPU089NWmbN28eAHPmzDnknP/5z3+A3HVJ06AhFwmShlxERLoX9dAlKOqhS5DUQxcR6V5U0EVEAqGCLiISCBV0EZFAqKCLiARCBV1EJBAFzYduZq8B7wAfAgfcfYyZ9QMWAScBrwHT3H13OmGKpEO5LSEppoc+3t1HZX0Xcg6wyt1PBlZFj0XqkXJbgtCVIZfJwIJoewEwpevhiNQE5bbUpUILugMPm9kzZtYStQ109x3R9k5gYMcvFalpym0JRqFrin7J3dvM7GPAI2b2SvZOd/fObuuP/pG0dLRPpAaUlNs5eX1UQ0UCFcmnoB66u7dFv3cB95NZRPd1M2sCiH7v6uS1re4+ppB5CEQqrdTczsnrnvqymNSGvJloZr3M7Lh4G5gAvAQsB2ZET5sBLEsrSJE0KLclNIUMuQwE7jez+Pn/4+4rzexpYLGZzQS2AtPSC1MkFcptCYqmz5WgaPpcCZKmzxUR6V5U0EVEAqGCLiISCBV0EZFAqKCLiARCBV1EJBAq6CIigVBBFxEJhAq6iEggVNBFRAKhgi4iEggVdBGRQKigi4gEQgVdRCQQKugiIoEoqKCbWV8zW2pmr5jZejM73cz6mdkjZvZq9Pv4tIMVKTfltoSk0B76XGCluw8HRgLrgTnAKnc/GVgVPRapN8ptCUbeFYvMrA/wPDDUs55sZhuAr7n7jmgh3b+6+3/lOZZWLJJUFbNiUblyWysWSerKuGLREOAN4E4ze87M7ogW1B3o7jui5+wksz7jIcysxczWmtnaQmMXqZCSczsnr/cfrGDIIp0rpKD3AE4B5rn7aOBdPvIRNOrddNj7dvdWdx9TyF8XkQorObdz8rqnvlsgtaGQTNwObHf3NdHjpWT+EbwefRwl+r0rnRBFUqPclqDkLejuvhPYZmbxGOJZwMvAcmBG1DYDWJZKhCIpUW5LaHoU+LzLgT+ZWSOwGbiEzB+DxWY2E9gKTEsnRJFUdT23Gwx694R/7087VuluTjiqqKcXVNDd/XmgozHws4o6m0iNUW5LSHQ1R0QkECroIl00qGkAv/xJC/RpbP8RKVXvnsnP+398kff/+GLBL1VBFxEJRN47Rct6MrM3yHzX982KnbT8TqB+46/n2CF//J909wGVCiYW5fVW6vv9refYob7jLyT2gnK7ogUdwMzW1vNNRvUcfz3HDrUff63Hdzj1HDvUd/zljF1DLiIigVBBFxEJRDUKemsVzllO9Rx/PccOtR9/rcd3OPUcO9R3/GWLveJj6CIikg4NuYiIBKKiBd3MJprZBjPbaGY1vQqMmQ02s8fN7GUzW2dms6L2ulmezMwaonm+V0SPh5jZmuj9XxTNX1KT6mlpuHrKa1BuV1uauV2xgm5mDcBvgXOAEcBFZjaiUucvwQHgx+4+AhgHXBrFW0/Lk80is6Ra7GbgVncfBuwGZlYlqsLUxdJwdZjXoNyutvRy290r8gOcDjyU9fga4JpKnb8M8S8DzgY2AE1RWxOwodqxdRJvc5QYZwIrACNz80KPjv5/1NIP0AfYQnSNJ6u95t77es/rKGblduViTzW3KznkMgjYlvV4e9RW88zsJGA0sIYCl96rAbcBVwHx+mj9gT3ufiB6XMvvf5eWPaywus1rUG5XQaq5rYuieZjZscC9wBXu/u/sfZ75c1pzXxMys/OAXe7+TLVjKVGXlj2Uwii3qyLV3K5kQW8DBmc9bo7aapaZ9SST8H9y9/ui5npYnuwM4Hwzew1YSOaj6Vygr5nFc+DX8vtfT0vD1V1eg3K7ilLN7UoW9KeBk6Or0Y3AhWSW+qpJZmbAfGC9u9+Stavmlydz92vcvdndTyLzPj/m7tOBx4Gp0dNqMnaou6Xh6iqvQbldTanndoUvCJwL/BPYBPyk2hco8sT6JTIfe14Eno9+ziUzXrcKeBV4FOhX7Vjz/Hd8DVgRbQ8F/hfYCCwBjqx2fIeJexSwNnr/HwCOr9X3vp7yOopXuV3duFPLbd0pKiISCF0UFREJhAq6iEggVNBFRAKhgi4iEggVdBGRQKigi4gEQgVdRCQQKugiIoH4fz3t65r/6hDaAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random_index = np.random.choice(len(rand_x) - 1)\n",
    "rand_x = rand_x[random_index:(random_index+1)]\n",
    "\n",
    "for i in range(10):\n",
    "    f, axarr = plt.subplots(1, 2)\n",
    "    f.set_figheight(3)\n",
    "    f.set_figwidth(6)\n",
    "    axarr[0].imshow(rand_x[0, 0, 0], cmap = 'gist_gray')\n",
    "    rand_y_hat = conv_lstm(rand_x.to(device))[0][0][:, -2:-1, :, :, :]\n",
    "    axarr[1].imshow(rand_y_hat[0, 0, 0].data.cpu().numpy(), cmap = 'Greens')\n",
    "    rand_x = torch.cat([rand_x, rand_y_hat.data.cpu()], dim = 1)\n",
    "    rand_x = rand_x[:, 1:]\n",
    "    plt.pause(0.01)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}