LSTMVisualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing gating variables in a LSTM\n",
    "\n",
    "Here we will train a one-unit LSTM network and visualize its gating variables.\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/gyyang/nn-brain/blob/master/LSTMVisualization.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def memory_task(seq_len, batch_size, n_repeat=1):\n",
    "    \"\"\"Return a batch from a simple memory task.\"\"\"\n",
    "    inputs = np.zeros((seq_len * n_repeat, batch_size, 3))\n",
    "    outputs = np.zeros((seq_len * n_repeat, batch_size, 1))\n",
    "\n",
    "    for i in range(n_repeat):\n",
    "        t_start = i * seq_len\n",
    "        inputs[t_start:t_start+seq_len, :, 0] = np.random.uniform(-1, 1, size=(seq_len, batch_size))\n",
    "        t_stim = np.random.randint(int(seq_len)/2, size=(batch_size,))\n",
    "        t_test = np.random.randint(int(seq_len)/2, seq_len-1, size=(batch_size,))\n",
    "        inputs[t_start + t_stim, range(batch_size), 1] = 1\n",
    "        inputs[t_start + t_test, range(batch_size), 2] = 1\n",
    "\n",
    "        outputs[t_start + t_test, range(batch_size), 0] = inputs[t_start + t_stim, range(batch_size), 0]\n",
    "    \n",
    "    return inputs, outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.YTick at 0x11736aa90>],\n",
       " <a list of 1 Text yticklabel objects>)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "inputs, outputs = memory_task(seq_len=100, batch_size=32, n_repeat=3)\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(inputs[:, 0, :].T, aspect='auto', vmin=-3, vmax=3, cmap='RdBu')\n",
    "# plt.plot(inputs[:, 0, :].T)\n",
    "plt.title('Sample trial inputs')\n",
    "plt.xlabel('Time step')\n",
    "plt.ylabel('Input units')\n",
    "plt.yticks([0, 1, 2])\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(outputs[:, 0, :].T, aspect='auto', vmin=-3, vmax=3, cmap='RdBu')\n",
    "plt.title('Sample trial target')\n",
    "plt.xlabel('Time step')\n",
    "plt.ylabel('Output unit')\n",
    "plt.yticks([0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Defining a LSTM network\n",
    "\n",
    "Here we define a LSTM network explicitly using raw pytorch so we can access its gating variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "\n",
    "class MyLSTM(nn.Module):\n",
    "    \"\"\"Manual implementation of LSTM.\"\"\"\n",
    "\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super().__init__()\n",
    "        self.input_size = input_size\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.input2h = nn.Linear(input_size, 4*hidden_size)\n",
    "        self.h2h = nn.Linear(hidden_size, 4*hidden_size)\n",
    "        \n",
    "        self.readout = False  # whether to readout activity\n",
    "\n",
    "    def init_hidden(self, input):\n",
    "        batch_size = input.shape[1]\n",
    "        return (torch.zeros(batch_size, self.hidden_size).to(input.device),\n",
    "                torch.zeros(batch_size, self.hidden_size).to(input.device))\n",
    "\n",
    "    def recurrence(self, input, hidden):\n",
    "        \"\"\"Recurrence helper.\"\"\"\n",
    "        \n",
    "        hx, cx = hidden\n",
    "        gates = self.input2h(input) + self.h2h(hx)\n",
    "        ingate, forgetgate, cellgate, outgate = gates.chunk(4, dim=1)\n",
    "\n",
    "        ingate = torch.sigmoid(ingate)\n",
    "        forgetgate = torch.sigmoid(forgetgate)\n",
    "        cellgate = torch.tanh(cellgate)\n",
    "        outgate = torch.sigmoid(outgate)\n",
    "\n",
    "        cy = (forgetgate * cx) + (ingate * cellgate)\n",
    "        hy = outgate * torch.tanh(cy)\n",
    "        \n",
    "        if self.readout:\n",
    "            result = {\n",
    "                'ingate': ingate,\n",
    "                'outgate': outgate,\n",
    "                'forgetgate': forgetgate,\n",
    "                'input': cellgate,\n",
    "                'cell': cy,\n",
    "                'output': hy,\n",
    "            }\n",
    "            return (hy, cy), result\n",
    "        else:\n",
    "            return hy, cy\n",
    "\n",
    "    def forward(self, input, hidden=None):\n",
    "        if hidden is None:\n",
    "            hidden = self.init_hidden(input)\n",
    "\n",
    "        if not self.readout:\n",
    "            # Regular forward\n",
    "            output = []\n",
    "            for i in range(input.size(0)):\n",
    "                hidden = self.recurrence(input[i], hidden)\n",
    "                output.append(hidden[0])\n",
    "\n",
    "            output = torch.stack(output, dim=0)\n",
    "            return output, hidden\n",
    "\n",
    "        else:\n",
    "            output = []\n",
    "            result = defaultdict(list)  # dictionary with default as a list\n",
    "            for i in range(input.size(0)):\n",
    "                hidden, res = self.recurrence(input[i], hidden)\n",
    "                output.append(hidden[0])\n",
    "                for key, val in res.items():\n",
    "                    result[key].append(val)\n",
    "\n",
    "            output = torch.stack(output, dim=0)\n",
    "            for key, val in result.items():\n",
    "                result[key] = torch.stack(val, dim=0)\n",
    "\n",
    "            return output, hidden, result\n",
    "    \n",
    "\n",
    "class Net(nn.Module):\n",
    "    \"\"\"Recurrent network model.\"\"\"\n",
    "    def __init__(self, input_size, hidden_size, output_size, **kwargs):\n",
    "        super().__init__()\n",
    "\n",
    "        # self.rnn = nn.LSTM(input_size, hidden_size, **kwargs)\n",
    "        self.rnn = MyLSTM(input_size, hidden_size, **kwargs)\n",
    "        self.fc = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        rnn_activity, _ = self.rnn(x)\n",
    "        out = self.fc(rnn_activity)\n",
    "        return out, rnn_activity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training the network\n",
    "\n",
    "Loss should drop to almost 0 if the training is successful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 500, Loss 0.0383\n",
      "Step 1000, Loss 0.0332\n",
      "Step 1500, Loss 0.0327\n",
      "Step 2000, Loss 0.0323\n",
      "Step 2500, Loss 0.0328\n",
      "Step 3000, Loss 0.0325\n",
      "Step 3500, Loss 0.0322\n",
      "Step 4000, Loss 0.0081\n",
      "Step 4500, Loss 0.0006\n",
      "Step 5000, Loss 0.0004\n",
      "Step 5500, Loss 0.0003\n",
      "Step 6000, Loss 0.0002\n",
      "Step 6500, Loss 0.0002\n",
      "Step 7000, Loss 0.0005\n",
      "Step 7500, Loss 0.0002\n",
      "Step 8000, Loss 0.0002\n",
      "Step 8500, Loss 0.0002\n",
      "Step 9000, Loss 0.0001\n",
      "Step 9500, Loss 0.0002\n",
      "Step 10000, Loss 0.0002\n",
      "Step 10500, Loss 0.0001\n",
      "Step 11000, Loss 0.0001\n"
     ]
    }
   ],
   "source": [
    "import torch.optim as optim\n",
    "import time\n",
    "\n",
    "# Using custom LSTM, ~30% slower on CPUs compare to native LSTM\n",
    "# net = nn.LSTM(input_size=3, hidden_size=1)\n",
    "# net = MyLSTM(input_size=3, hidden_size=1)\n",
    "net = Net(input_size=3, hidden_size=1, output_size=1)\n",
    "\n",
    "# Use Adam optimizer\n",
    "optimizer = optim.Adam(net.parameters(), lr=0.01)\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "running_loss = 0\n",
    "start_time = time.time()\n",
    "\n",
    "print_step = 500\n",
    "for i in range(20000):\n",
    "    seq_len = np.random.randint(5, 20)  # Help learning and generalization\n",
    "    inputs, labels = memory_task(seq_len=seq_len, batch_size=16, n_repeat=3)\n",
    "    inputs = torch.from_numpy(inputs).type(torch.float)\n",
    "    labels = torch.from_numpy(labels).type(torch.float)\n",
    "\n",
    "    optimizer.zero_grad()   # zero the gradient buffers\n",
    "    output, activity = net(inputs)\n",
    "\n",
    "    loss = criterion(output, labels)\n",
    "    loss.backward()\n",
    "    optimizer.step()    # Does the update\n",
    "\n",
    "    running_loss += loss.item()\n",
    "    if i % print_step == (print_step - 1):\n",
    "        running_loss /= print_step\n",
    "        print('Step {}, Loss {:0.4f}'.format(i+1, running_loss))\n",
    "#         print('Time per step {:0.3f}ms'.format((time.time()-start_time)/i*1e3))\n",
    "        if running_loss < 1e-4:\n",
    "            break\n",
    "        running_loss = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnn = net.rnn\n",
    "\n",
    "rnn.readout = True\n",
    "\n",
    "inputs, labels = memory_task(seq_len=20, batch_size=16, n_repeat=2)\n",
    "inputs = torch.from_numpy(inputs).type(torch.float)\n",
    "\n",
    "with torch.no_grad():\n",
    "    rnn_activity, _, result = rnn(inputs)\n",
    "    output = net.fc(rnn_activity).detach()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1208a1290>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAAD0CAYAAABQH3cdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO2de7BsVX3nP2vv3c/T5wKX++CC4kUREaJCciUZmUQNechURhnLhCQT8Q4hl1SmlMrDwaTUxFQNGR/4GBMVFIIlUzKVR+VhZsLEMakpEkoEdVSYcCURDRcuXLj3cu/pPt29H2v+2L367O7e/TyPtbrP71N16pzeZ+/T6+zV67t+67t+ey2ltUYQBEGYDzzbBRAEQRAmR0RbEARhjhDRFgRBmCNEtAVBEOYIEW1BEIQ5ItjsN9i1a5fev3//Zr+NIAjCQvHQQw89q7Xe3X9800V7//79PPjgg5v9NoIgCAuFUuq7ecfFHhEEQZgjRLQFQRDmCBFtQRCEOUJEWxAEYY4Q0RYEQZgjRLQFQRDmCBFtQRCEOWKiPG2l1I8CP6+1vqHz+s3AG0hF/5e11tHmFVEQeomSiJOtk5xonuBE8wTHW8c50TzB863nKfkllovL3a8dxR3dn2uFGgWvgFLK9r8wl7TiVnq/m8c53jze/bkVt9hd2c3e6l72Lu1lb3UvtWLNdnEXlrGirZS6EPh+oJw5/DNa659VSl0HXAXc23fNIeAQwPnnnz9Twf7g63/AF/7pCzNdO4z+xqqYvPFqetcdX8865J7y+LUf+DWuetFVU1/72InHeOf/eSftuD30nI0s67i/PQv9932YiPaXW6NZCVc41Tq1rnIEKiDw0q+CV+j+7Ct/5HXTvGf2f1RKUfAK/O6Vv8urdr9q6vL+w5P/wC1fvoU4iUe/5xSd0TSf/VjHnGydpB7WJ75mqbDEnuoe9lb3slxcJoxD2kmbMAkHfh51X7OfAXPeqM+zuQf9938zmKRdve817+PAOQc29H3HirbW+jHgQ0qpuzOHw873p4Dzcq65Hbgd4MCBAzO1rvNq53HZnstmuTSXaYVMo8eKyzQf/Cz3Pn4vDxx9YCbRfvi5h3ns5GO8/oWvpxJUhp43a1nz/u+Bvz3j/23+/sjXWveUvf+9lgpLnFU+i7NKZ7GzspOdpZ3p6/JZnFE6gzAOOdU+xen26e6Xeb0SrhAmIVESdb/M6zAJiXW8If97V1w636Mk4t7H7+Ubx74xk2h/7Zmv8d1T3+WnXvxTY99zEvI6w1H/l6c8ziydyc7y2r0+u3x29+eyX+bY6jGerj/N042n1753vo41jlH0ixS8AgW/QDkos+wtd197arRLmyfAeeXNE/WNCDImLVsey8XlDX/PWR9jN13+PuDoBpWlh2suvIZrLrxmM/60dR44+gCr0epM15rr3vuv3suuyq6NLNZCUPAKVAtVzlk6x3ZRuoRxyL2P3zt7nYerVIIKv/fDv7fBJds4zqudx3m1gfhN2ASmEm2l1FuBh4A/Ukp9GlDAjZtRsEWmGlRpRs2ZrjXXVYPqRhZJ2EQKfoFABbPXedwcOaoSthcTi7bW+hcyLx8B/mrji7M9KAdlVuMZo67OdSW/tJFFEjaZclBe1+iq7JfHnyhsCyTlzwJlf30NuOgV8b3Rk2aCW6xbtAMRbSFFRNsClaCyLnukUpCh8rxRCSo043XUudgjQgcRbQuUg/K6RFuGyvPHeupcIm0hi4i2BdY7VJaoa/6o+JWZ67wZNUW0hS4i2hZYb/aIiPb8sS5LLG5KtpDQRUTbAjIptf2Q7BFhoxDRtkDZX1/KnzTg+UMsMWGjENG2QCWodB+dnhaxR+aT9WaPyOhKMIhoW8A0wFk8TrFH5pNZc/O11lLnQg8i2hYwkfIsoi2R9nxSKcw2EdlO2mi01LnQRUTbAiLa24+KX6EVt0h0MtV15jMidS4YRLQtYIa6jagx9bUyVJ5PZrXEjKUik8+CQUTbAt1Ie8qJqTAJiXQkUdccYupsWl/bnC91LhhEtC1goqZpoy5zvkRd80c30p6yo+5G2jK6EjqIaFtgvVGXNOD5w9TZajhdnXc7aqlzoYOItgVmnYiUSan5xTyGPm2kLZteCP2IaFugG3WJv7ltMJaWjK6E9SKibYH1irY04Plj5jqPJXtE6EVE2wKzZo+Y8yXSnj/EEhM2ChFtC5j9HaeOukKJtOcVGV0JG4WItgU85c20vrJE2vPLeiNtmYgUDCLalphlAaHuUNkX0Z43ZrXEVqNVfOUTeMFmFEuYQ0S0LTHL+srmsXcZKs8fZiJx2qULzLIFSqnNKJYwh4hoW2Ime0QmpeYW3/MpesWZLDGpbyGLiLYlZom0zflmIlOYL2bZkb0ZNSXdT+hBRNsSZb8809NxlaAiQ+U82nX4gx+C795vuyRDmbWjdtoOO3wvfOqHIY5sl2TbIKJtiVkWxZeh8ghOH4Vj/w+e+r+2SzKUalCdKdJ2OnPkya/B0W9A83nbJdk2iGhbouJXZou6ZKicT3ul97uDlIPpN3R2PtKeg/u+aIhoW2Ihh8o2add7vzvILGmeztf5HNz3RUNE2xKzZo+IPTKEORCPWR+ocrrO5+C+Lxoi2paQSHuD6Q7T3RWPmevcZUusK9pij2wVItqWqAQVmnETrfXE10ikPYI5EI+ZU/5c7qjnoLNcNES0LVEJKiQ6IUzCia9xfqhskzkYpi9k9sgc3PdFY6RoK6Veo5T6bOfrzM6xn1JKfVQpdY9S6rytKebiMWxR/OcbIT/8gS/xjSdODlzj/FDZJnMQ8Q2zR1pRzOfuf5w46R11JTqhGbseabs/wlk0xkXah4AbgTuAazvH/jVwIbATeHbzirbYDNsn8l9ONPiX46s88uSpgWtWo1WJtIcxB+JRCSq5KX9//9izvOfPH+br/3Ki5/hcLFswB53lojFOtH2tdRN4CtjXOfYXwBuBPwV+KO8ipdQhpdSDSqkHjx07tmGFXSSGra9cb6VPlq20Bp8wk4nIEczBML3sl4mSaMASO91M6/pUs7fOzROzTtf5HNz3RWOcaDeUUiVSwT7aOfZrWusEOAacnXeR1vp2rfUBrfWB3bt3b1xpFwjTEPs9zkY77vlu0Fq7PyllkzmI+IbVeb3VqfNWb513N0Bw2RKbgxHOojFukd7bgduAAvDXSqlLgP+tlPpDIAH+4yaXb2EZtr6yibDrfZF2O2mj0W4PlW0yBxFfdiOE5eJy93h9SJ137ZGCo3UeR2A6IIfv+6IxUrS11g8BB/sOPwJ8crMKtF3oetrhZPaIOU9EewjZiE9rcHBRrWG716wMq/NOpO3sphdhRqhFtLcMSfmzRDd7pG9iqj7EHun6my4PlW3SFQ0N4XQPsGwVxh7p3whhWKTt/P6QbRFtG4hoW2JY1DU00o4k0h5J1lN1VECGWWKmo673d9SuZ4/0iLZ42luFiLYlxmWPzF3UZZs5EJBhuflzW+dz0FEuIiLalhgaabc7DXjeoi7btOtQOWvtZwcZN7oamIiMHd/I2dznylnO3vNFRETbEkOHyp20r6GZBCLa+bTrUNu79rODjO+o5yx7pNWJtGt7nR3dLCIi2pYoeAU85dEIeyelhqX8OT9UtonWqWjU9qSvHRWQ4ZZY3PPd4HyetrnPtT3O3vNFRETbEkqp7kp/WRrtIaIdy0TkUKIm6MT5SHvap2Cd76jNfa7tdfaeLyIi2hbJ28lkpbWWSZBdttX5qMsm2WE6OBv1Dc8eScW6kWOPFLwCgTfuGThLZEU7bkPUtluebYKItkXy1lc2UVecaFpR0j1uznM26rJJdpgOzkZ9Jb8ETGePOF3f5j4vdZaqCN2874uGiLZF8rafamSGyFmLxJzn9NrKtshGfOBspO0pb6DOtdbdSLvfHnF+/fT2CvhF57N2Fg0RbYtUgsEd2VdaEbVSOhzORl6r0Sq+8t0dKtvEiEV1F6CcFo9+S6zRjtEaAk9Rb0W9lljo+FK87ToUl9Iv81rYdES0LdK/KH4adcXs2ZEOo7ORlxkqKwfX1LCOiaxLNSjWnBaP/jo3Ufae5RJRomnHa5bYauz4phftenq/i7XOazdHOIuGiLZF+rNHWlFCnGj2LKeinZ2Ycn6obBMj0ibqc1g8+u0RM5ravaPc8xrmYE/Q9opE2hYQ0bZI/1DZeNh7ltMGPBBpuxx12WRAtN0Vj4FIu7UWaWdfw5xMRIpobzki2hYZFnXt3VHqeQ2dqMvVJ+NsYyLrYs190fbLPaMrI9LdOm/3Tj7Ph2jX1l4Lm46ItkX6U/7W/M1yz2voiLara1DYpifSdtvTrhQqo+u8NUeWWNfTNpG2u7bUIiGibZH+7JHuUHnHHA6VbdKuAwqCivuett9b5+ZhKmOPrGQzhpzPHhFP2wYi2hYxE5GJTjMGVlrDoy7ZiX0EZpjuee7bI0M87b07cup8LrJHRLS3GhFti/Rv9Gp2qzlrqUDBVz3Ls0qkPQIT8YH79sjAPMbw0ZX72SMde8QvgF9yeoSzSIhoW8REUWZiykTaS8WAajEY8DedjrpsYiI+cN4eGYy0Oyl/fdkjURIRJqG7HXWSpI+t99x3dzvLRUJE2yL96yubBrtUCqiVgp6UP+ejLpsMiHY9Xa7VQYwlZp58rLcjSoHHjnKh8zoVcefXTzdLCpvMkZLbI5xFQkTbIt0d2TuRl7FHlko+SyWfRt9j7M42YNu0V9bEo7gESZSuOucglaBCohPCJATSjrpWCigFXvdRdpiDPUGzGTvQsaXcHeEsEiLaFun3tFdaEQVfUQp8lkpBNx0s0QmtuOXuUNk2xlsFKC2vHXOQ/n0i662IpVKAUiqt845oO7+qYzY3HsQe2UJEtC3SH2nXWxHVYrog1FJxzR5xfqhsm357BJyN+vrrfKUVUy36ACwV/W7Kn/ObXgxE2iLaW4WItkX6dzKpt+LuCn9Ze8T5HUxsk420HU8/66/zRjvK1HkwYI84O/mca4+4ec8XDRFti/TvZJIOlTtRV2Yisrsrt6tRl236U/7AWQHpt8SMPQL0WGLu2yNGtLP2iJujm0VDRNsi5rH0bqTd7rVHTANeDSXSHskc2iPZNM+1jtof8LSd3fSi62mLPbLViGhbJC/qyg6VjT3SjbRl7ZFBojYkYY5ouykgXU87XLPElrId9bxYYuJpW0NE2yKDE5FxN+qqlXzacUI7StxP/7LJQBaD4/aIyR6J10ZXxh6pZeyR+RHtzH0PG5DEw68RNgQRbYuUgt6NXldaUTfqMjZJvRW534Btkhfxgfv2SJQ+YNM/uqrPyzxGnj0CznaWi4SItkUKXoHACzJrj/RGXZBGYs5PStlkqGi7KR7Z7JFmmJBoqHZGV9WSP2iPOJs9sgLKh07g4fp9XyREtC2T3XIstUfWoi5zzPmoyyb9w/RCtfe4Y2QjbWOFmA66Vgy6lpjzHbVJszR7ljpuSy0SItqWMesrt6OEdpywVFyLuiC1TMyklYh2Du3T6XcT6Xl+Ktyt0/bKNIJs9kg9s0AYrHXUjc7oquyX8ZSjTTSbZgnO21KLhKOfiO2DWfXNbOLbb4802lE30nZ2qGyTfnvE/OxoxFfwCnjKoxE21lZ1zKT8QdpRN6KGu1E29KZZgtgjW0gw6pdKqdcAN3Ze3qS1PqmUei3wM4AP/I7W+ugml3GhMesrmwbcnZTKTkTGMhE5lH57BJwWbaVU1xIz/nWuJeb6qo4Dou2WPRKGIU888QTNZnP8yY6wb98+zjzzzLHnjRRt4BCpaF8BXAvcBrwNeBooAc/kXaSUOtS5lvPPP3/iQm9HTKRtGnB1IOqKWWW1O2kp9NGfxQDOP1Jd9jt13je6WspMPju/6UV26QBwzh554oknWF5eZv/+/SjjuzvM6uoqR44cmUi0x9kjvta6CTwF7Osc2w/8NvAI8Ia8i7TWt2utD2itD+zevXvigm9HTKQ9rAEbf9PpqMsmQ+0RN8QjD7Ohc7+n3c0YakXub3ox1NN2o7NsNpucffbZcyHYAOVymTAMJzp3nGg3lFIlUsE2NsgRrXUbOD7B9cIY1iLtvkyCzveV1hxEXTaZM08bMh11n6dtVvurt+ago3bcHgE2TbCff/556vWN/T+nKes40b2d1BK5EagrpS4B7lFK3QH8OPDFWQsppFT8Sk8mgWm4pcDDU3PSgG3SXkl3Yff8tWNzINpZS6y/o663Yvc3vRg6EenuCGej+OhHP8pTTz1l7f1HmqRa64eAg32HHwH+arMKtN2oFPIb8Nqi+DGrBccbsE36xQPc97T7RlfVYr6nvae6x1oZx9LvaftF8AKn7/s0PPDAA3zsYx+jWCxy+PBhLr74Yp555hne//73c99997G0tMTFF1/Mvffey6lTp3jf+97H/v37t6RsYm9YZtikFHTWojD2iMv+pk1yRdttT9tkj6y0I4q+RzFIm6HxtldcH11pPehpK+X8CGcaPv3pT/PZz36WX/mVX+GFL3wh1113HS996Uv5yle+wpVXXsk111zDpz71KZaWlqjVatx///1bVjZJR7CMmZRa6ZuUgtQqqctE5Gj6Iz5wXjxMR92I1hYIAygX1iwxp+cxoiboZO5GONPQbqd7jCql2L17N8ePH+eVr3wlWuse//mWW27h8OHDNBqNLSubiLZlKkGFMAlZabbxVNpwDbWOPdKMmuws77RYSofpj/ggFY+4BXEIfsFOuUbQzR6Jo56RVdYSczp7JC83Hpwf4UzDDTfcwA033EAYhlxyySV86Utf4vjx47z61a/mxS9+MbfddhvXX3891113HfV6nU9+8pNbVjYRbcuYCPr5Vr27wathKWuPuBp12WZYpG1+Vxmf97rVdB+oakc9Iyvo7A3aDN0eXeXlxpvXCxJpHz9+nH379vHcc89x7bXXcuGFF+ae9+Y3v3mLSyaibR0TTZ1uNQYacLUYcLzeIHS5AdumXYfa3t5jcyDaZh4ja49Amv630m4S69jdOs9Ls4SFskfe9KY38aY3vcl2MXKRiUjLVAppw1xprw404FrJp9GOWY0le2Qo7ZWcSNu9nOEs3YnIVthjj0BqiZ1uO75AmLmvpZz7viD2iMuIaFvGRNor7UY33c+wJNkj4xmWPQLOCoixuuqtZm6dr7QbPec5R/9uQYYFskdcRkTbMiaaqoer3XxdQ7oje4soidyNumzTrudHfOZ3DtLtqMPGQJ1Xi/Mg2sPsERHtYRw5cmTD/paItmVMw2xEqwND5aViQCtp9ZwnZIijNP1s1ESkg5gOuBGuUsuzxFzfE3QbeNqjuPPOO6cW4Xe9610b9v4yEWmZ7O7c/Q14qeSjvHbPeUKGcIR4gLP2SHZD54GOuhTQDDs7FfmO1vlIe2QlffjGkYWa3veXD/PIk6dmuvaSc3fw2//20oHj3/ve97juuut4/etfz6OPPspdd93FVVddxdVXX83Jkye55ZZbeOtb38rdd9/NwYMHeec738nXv/51vva1r3H55Zev91+SSNs22Z1MqjkNGBX2nCdkGDVMz/7eMcyoKaadK9rOr58+8r5r6Oy0tMicccYZvPvd7+b888/nyJEjnHfeedx8882cc845fOtb3+o599JLL+VVr3rVhgg2SKRtHdMwW/Fq7qSUibSdbcA2GfWQR/b3jmE6YKXa3e3lDEvFgChpUcDhjrpdB1S6UFeW7H0vVre8WHnkRcobQbWa/n+FQoEkSdBaA+mSsEEQdF+fPHlyw99bIm3LmEmpSLcH8rRrJb8baUv2SA6jHvIAZ0W72wF7gyl/SyUfvLD3PNcwGTten3w4bkttJt/5znf49V//dZ599lkuvvhiyuUyb3/727urAUZRxN/93d9tyHtJpG2ZbjSl2gN52tViIJ72KIYN0/0C+CVnxcN0wMobtEdqpTmo87ylA8D5znKj+J3f+Z2Bn1/ykpdw6623do/fcccdPdfcc889G/b+EmlbxkRTwxowrjdgmwwTbXPMUfGoBh3rQA1G2tV5mMfIy42HbSPaedx9991b9l4i2pbxlEfRK6Jyh8oBSjk+VLbJsCwGc8xR8ch21Hkpf87PY7SGRdrGHjm9teXZZohoO0DRr6RR18Ck1Jq/6WzUZZOxkbaj9sgoT7sYgBeiSDtzJ8lbOgC2daS9lYhoO0BBlXLtEckeGUNryESkOeaoeHQjbTU4+ZyOrtoUvZK7m9KKPTKUSfePfOqpp7oZJtMiou0ABa8EXjiQ8lcp+CiJtIdjxKEwX5F2wSvgEQzJHkmPB17JUukmYKhou718wFYw6f6Rv/Vbv0UcxzO9h2SPOICvSijV7m7qa/A8RTFIRbvkO9yIbdFeSfcmDHJshGINGs9tfZkmJOiOrnKeglVtAuVwfeetYQ5uLtT1P98FR78527XnvAKu/i8Dh++//34+8YlPkCQJSZLwuc99jvvuu4/HH3+8u3/k4cOHOffcczlx4gTvfve7+dVf/VXuvvtu7rrrLvbs2cNXv/pV/uzP/oy3vOUtUxdLIm0H8CmC1x6ItAEKhRiPIp6SqhpgWMQHTkfaAL4q4nkhRb+3Xk3GkI/Loj1kIrJQAdTCR9q33XYbd955Jx/5yEcGthkz+0fGccy73vUurr/++oF0v2q1yuWXX84111wz0/tLpO0Ani6hvNMDQ2WAIIiIXW7ANhkW8YHTnjaAR4kgiAZ8a2OJeTg6CQnDO0ul3MvayYmU10vWi965cydRFHWffMzWp9Z66BOS65mvENF2AV0A1aZS8Ad+5fshiXZvn0MnGBbxgfuirYsEQTRwXCmF70co7ejEc9SGJJzbEc5GcOjQIQ4dOoTnebz85S/nbW97G0tLS/zIj/xId/9IE2mfPn2aD33oQ4RhyPXXX8+pU6e47LLLuPDCC/nkJz/J29/+9qnfX0TbBXQRzw/xvMHe1/dDQu1w1GWTkfZIDcIGJDF4g52hdXQRz2/n/sr326B3bHGBJmRUbjw431luBFdeeSVXXnnlyHMOHjzIrbfeShCkEvuOd7yj5/eve93rZn5/MUpdICl2s0T6UV4IiYh2LuM8bUiF20F0UsAbWucROnF0dDUqN94cX3DRnoS77rqrK9gbjYi2A8TJ2pOP/SgvJHG1AdtmnKdtznEQnRS6D04N4LXnWLQd87QXEBFtB0jiAlq185PtVVtEexgjPW23c4aTOJ3HyEW1iWNH63zYcriGbeBp20ZE2wGiqAAqIUoGJ6a0ahNHMvWQyyT2iKMCEsUBmnzR1jhc58OWwzWIPTKSOI45evTouv6GiLYDhJ0G2ogG/deYFlFcIElme+R1oZljeySKCiQ5kXaiExLVJnQ+0t6+9sgXv/hF3vjGN/Lkk09Ofe19993HF77whXW9v6Pd+fYi6oh2M2pyRumMnt8ltNFJkUYY5z58s21JknSPyDm1R8IoQOnWwPFWnB4LQ0frepw9Uqo5Nbp5/wPv5x+P/+NM116882JuvuLmgeOf+cxnaLVa3HzzzSRJwnvf+14+/OEPo7Xm4MGDfPzjH+fss8/myJEjfOYzn+E973kPAFdccQVHjhzh/vvv54Ybbpj5f5JI2wFa7bSBrkaDe+tFugVJgXpr0DrZ1piskDm0R9pRQhwXSIgGLLFmlG7q23ZWtCdM+ZtxMaR54A1veAMPP/xw96nIT3ziE7RaLT7wgQ/wjW98g5tuuomPfvSjJEnCPffcQ7PZZMeOHdx///3dJybXg6OfjO1FM/TwSTf3zaK1JkxaaF1gpRWx107x3GSSCbHseQ5Rb62l9DWjJrXM/2A67nboEycaPyd33yqTpPwlEcRtCOw/yZsXKW8E2aSBJEkAqNVqhGGIUqr7FccxP/3TP83VV1/N5z//+Q1ZuVEibcskie5G2ibKMoRJiCaBpEijNduKYAvLuIivtNw5z0HRbkfd3Pv+jrr7GdDF9DzXmMTTzp63oJinIn/zN3+Tm266qXv82muv5eMf/zi/8Ru/AcDP/dzPcccdd/DWt74VgHPPPZd77rmHVmvQGpuUkZG2Uuo1wI2dlzdprU92jr8c+JjW+idmfmcBgEYYdxtw/0Skibp0kkbaQoZJIj5w0h6pt2J0Z2mCfktsNV6r80YrZkfZsQnJ9kq6C/uwp0yz9726c+vKtYUcPHhw4Nhdd90FwIkTJ9i3bx9hGHLw4EF2797NH//xH/ec+8UvfnFd7z/OHjlEKtpXANcCtymlSsAvAcfW9c4C0Bkq67WhcpZug9ZF8bT7GSfafhG8wMmIb6W1FmkPiHbYeZ0U3eyoR6VZglO2lNZ6yzeSeNnLXsYHP/jBqa+bZkOEcfaIr7VuAk8B+zrHbgY+DAx9F6XUIaXUg0qpB48dE20fRepvdobKUf5QWSeODpVtMs7TVsrZnOF+TzuLsUu0dnTyeaxou2GPlMtlnnvuuZl3h9lqms0mhcJko6pxkXajE1nvA44qparADwHnAlcopX5Ua/2l/ou01rcDtwMcOHBgPu6aJeqtGJIhQ2XzOimk5wlrjHvIAzo5w+7ZI412BHp0R42rHfWw/SENjthSL3jBC3jiiSeYp6Bx3759409ivGjfDtwGFIC/BvZrrf8NgFLq7jzBFqZjJWuP9E9KuR512WScPWJ+52CkvdKKu5H2sI5au9pRz4k9UigUuOCCC6yWYbMYKdpa64eAg0N+9wubUaDtRqM9mb/pZNRlk3H2CDgr2vWspx0PGV25Oo8xJ/bIIiMpf5ZZaUWgAxRqaCZB0Su72YBtMrE94p541NvDJ5+dn8eYONJ2z5ZaFES0LZMOgRXloDK0AVcKZVZcHCrbpF0H5Y9+gMPRFefqrQilh4yueuYxXBTtCT3tlnv3fVEQ0bZMoxNNlf3y0Aa8VKh0zxM6mMWiRqV0OWuPxCwVKkB+9kjgBYDvZkc9ajlcgEK1c557931RENG2jMnFrQTloZF2tVB1M+qySfv0aPEAh0U7YqmYinZeR13xK1SLvpt1Ps4e8fxUuB0c4SwKsvaIZeqtiHLBo1qoDs0eqRUrbj5oYZNx4gFpJO7gML3ejqiVikR+KbejLgdllkqBe6OrOIKoOdoeAWc7y0VBIm3L1NvpkqtlvzzwGHsjbOApj1qpTKPt4FDZJhOJdsfTdmBbQOcAABWISURBVOwBi5VWzFLRpxJU8iPtoMJS0UF7JJwgzdL8XkR70xDRtky9FbFUCijn2SNxk7JfplaStUcGGLUBgqG4BGgIB5e8tUm2zvNE20Taztkjk+TGg7NZO4uCiLZl6q2IajGgMiR7xERdzjVg24ybEANnc4a7ou2Xc1f5c1+0J7FH3LOlFgURbcvUWzG1kj826pKlWfuY1B4B5wSk3o669kje6KoSVKiVAvfytCfJjTe/d6yjXCREtC1Tb6dR16hI2zTgeVn8ZkuYSrTdEpB6K+7W+ejsEcc66ontERHtzURE2zIrrYil4ogGHFSoFgMSDauhY43YJhN72jgnIPVWlE4+D0nzLAdlaqXAvXmMie0R8bQ3ExFtyzRaMUslP9ffNPZIrZQuOO9c5GULraf0tN2xR6I4oRUla5F2ztojlaDSscRcE+1p7BF37vmiIaJtGTMpVSmkkXbWAjH+5lJnF3bnJqZsETVBJ3Npj5iOt1rszGOEQ+Yxij71dkySOGSJiT3iBCLaFtFadyal0kwC6F2edTVapeyXqRZT0XZuuGyLabIYsuc7wEpncrE2QfYIdLajc4VpUv7iFsTh5pdpGyKibZFmmJBoujm70LsWRdbfBOQBG8PEw3T37BFjeeRNRMZJTDtp94yunLJIxm2mbHCws1wkRLQtYiLnWsmnGqQL7fSLdtqAjaftUAO2yTTD9Oz5DrDSFe21lD9jiZmou+JXuh21U6Ordj3dezMojj7P0fz4RUFE2yJGhKvFtUg7G3llJ6XAsQZsk0ntkaACKKfEw3jaJmMo1jFRktarqfs0Y8jByedJ0izByc5ykRDRtshKZqhsPG2TTZDoJH2MPetvuvawhS3MML00RrQ9z7lJMfPATNYSM2vOGNHOWmJOddSTpFmCk7bUIiGibRHjUdc62SOwZo+04haQRl217kSkQ1GXTSa1R8C5zX3rrUHRNnVuvjvbUU+SZgkSaW8ysjSrRbr2SMnH83vtkW7U5Zepiqfdy1Si7Vik3edpw5qX3d2pqLPeDLgYaYto20ZE2yJrE5EBOuiNtLMNuOB7FAPPvbUobDFpFgO4J9rZ0ZXfuxFC1tNey813aHQ1sWiLPbKZiD1ikUa7N/0L8hswpI1cIu0Oc26PKAWVgj9oj3Qi7rLvsj0yYUcJTnWWi4SItkVWupkE/kD2SNbfBNxcQMgW7TqgOtkhY3As0jZrzSilRnbU1YLYI0I+ItoWqbcGI20j1hJpj8CIhzfBx9cx0U6XLUgFub+jzmaPBL5HueC5Veci2k4gnrZF6u2IYuBR8D1QwxswpMIunnaHSbMYwLkV5+rtuGt9jMoeATor/Tk0upo05c8vgF9yypZaJCTStki6K3cadRW8AoEK1jIJMv4mpPaIUw3YJpNGfODcinP1jj0CdJ+C7e+ozXGnNvdNkhnuuzud5SIhom0Rsxi+IbsRgvluGnDNxaU6bTHH4tFjj/QtEmbqvOSXgPRJWWfskWgV0FOOcNzpLBcJEW2LmMXwDdktx3LtEVcasG0mzWKAVGSSEKL25pZpQtLt5XrtkW6dx6uU/BK+l4p6reS7MxHZmnCRLoNjI5xFQkTbIvV21F1jAsaIdtGhBmyb1pSeNjgjIGZ7OUgjaoVaq/NwtVvfYOwRRyyxaXLjwbkRziIhom2RlQnskWyk3WjHsk8kTG+PgDui3Yq666MrpXq2HGvGza5lAumiUs501NPkxpvzRLQ3BRFtizTG2COBF1DwCkAq2lGiaUWJlbI6xaRZDOBc+tlKK+puHweDHXUlk3u+VPLdscSmFm23snYWCRFti2SjLkjXUc5mj5jHnIFulokzjdgm06b8gRMCEieaZpgMjK6yHXWvaAc0XMkYmnQ5XIN42puGiLZF8qKuUQ0YZPcaYG7tke6yrJmOOrvlmNmpyFDr5OY7YYlNuluQQeyRTUNE2xJaaxrtXk8762+aDV4NTq6vbIOonWaDTC3a9gUk+wSsoaejjns76moxINGw6sI+keJpO8NI0VZKvUYp9dnO15mdY/9eKXWHUupPlFLnbU0xF49WlBAlemgD7vc3q7Ije8rUWQzu2CPdXWtKwzOGshORZhTmREc9tT1Sg7ABiQMdzoIxLtI+BNwI3AFc2zl2Wmv9i8DdwGvyLlJKHVJKPaiUevDYsWMbVthFoht1jUj56420O572drdHZon4wA17pJVjj2SzR/rskbXNfR2o81nsEUiFW9hQxom2r7VuAk8B+wC01n+hlNoN/DvgC3kXaa1v11of0Fof2L1794YWeFEw3vQwe2RYA5ZIe1bRdiHSzrdHhmWPVIsOWWLtOigPMp/JkTh03xeNcaLdUEqVSAX7KIBS6gLgPwPv0FqvjrpYGM7KkAbcTtrESZxmj2QnIl1qwDaZJYshe51FshsgGEZNPtdc6qhNmqVSk53vkC21aIwT7duB20gtkrpS6hLgs8BO4PeVUq/b3OItLrlRl7+2/dRqtNqb8udSA7bJtMN0z0/X3XbJHsl62iOyR8x5TmQMTZNmCU7ZUovGyKVZtdYPAQf7Dv/IppVmG7EWdfV62pBGXP2etlMN2CbT2iPmXAcivmGjq9VolTAOiXSUm+bpxOhqmjRLgJJE2puFpPxZorupb7G3AcOaaGcbcNH3CDzlRgO2ybT2CDgj2nmjKzP53IjSCbuex9hdGl1N8xQqiD2yiYhoWyK7qa8huyh+/1BZKSUr/cH09gg480i1GV2ZrcRgraM+1TqVvi5kPG2X5jGmFm2xRzYLEW1LNIYMlQHqYZ0wCXtEG8yWY2KPANMJSMmNtZ3TZQt8PG9tMs/U8fHW8fR1JtKuumSJzexp2+8sFw0RbUt0o67iYNR1onki/V1nAwRDurmvA1GXTebY0043QOidRuqv86wlVvA9ioEj+0RO62mLPbJpiGhbYqUVEXiKUrBWBSbKOtE60fPaIPtEkkZ8QSXNCpkUV0S7HffYYTBatMHsE+lAnU8t2mKPbBYi2pZodKIulcl7HWjAhcEG7ETUZZNpxQOc2frK2CNZBjrqoL+j9h2xR6b0tP0ieIETneWiIaJtiZVW3PMIO6w1WCPa/ZF2ao840IBtMpNouxFpr+TYIwN13i/aLmyEoPX0nrZSztz3RUNE2xJ5/ma3AQ+JupwZKttkmv0hDY6IR/+eoDDeHnEiYyhqgY7ndoSzaIhoWyK7V6DBTDyOasCNbe9pz2iPRE2I7d67/qV4ISPanY46+xQsOCLas2TsgDOd5aIhom2JNNLutUdKfgkYLtrVktgjM9sjAKFdAVlpReMtsYHRlW9/ZcdZcuPN+SLaG46ItiXqrbhniU4A3/MpesWh2SO1YkA7Tmhv530i1yPalgVkVMrf8ebxnteGatGlSHsWe0REe6MR0bZEvT3ob0KaMdJtwIXBoTKwvS2SmTxt+znDSTK4UxEMRtpmtGVwYh5jPfZI6/TGl2ebI6JtiXor6j7xlqXsr22EMJin7dBOJrZYV6Rtb1Ks0dkyrN8eMR52I2pQCSo9KaCwlvJndZ/Idkd4xR5xAhFtS9Rbg1EX9A6P8yYizbXbljm1R/IWiwIo+AUClR7rr29I7ZE40bRsWmIz2yMi2puBiLYF2lFCO066CwJlyTbcwQctOqK9Xe2ROIJodbZhOlgVkLwFwgymnvtHVtnzrY6uxNN2ChFtCxhPujqiAZf8Ep7qrR4zcWl9YsoW4TrEA6z6q43W4PZyBtNR50XaTuwTOe1myobiUnqtTWtnARHRtsBa1DXoaY9uwJ3NfberaK9nmJ693gLdDRCKOfMYJtLO2X/RnD+fkfYSoCGUXQk3EhFtC+Rt6mswQ+S8Blzb7p72erIYstdbYJinDWNE2wVLzNy3QnX0ef04kLWziIhoW2At6prO3zS73GxbT3vWhzwKDoh2e7hoT2KPWI+0C0vgTSkXDmTtLCIi2hYYFXWNasBOTErZZNZhelBMV52zKB71rqedY4n54+vcuqc97T0HJ0Y4i4iItgVGNuARol0ueHjKcgO2yaz2CFhPP5vIHskdXTkwjzFLmiWIaG8SItoWqE9ij+T4m0opN5bqtMWs9ghYTz/r2iMj0jydHV1Nu5a2oetpiz2ykYhoW2BWf9NcI9kjM0Z9Vu2RiHLBw/fUwO8mmYi0unSB2CNOIaJtAWOP5D5oMSJ7BBzaycQG6xZtmyl/g1uNGUbVeTHwKPiKFauettgjLiGibYF6K8JTqUfdzyh/E9LIS+yR+fS080ZWsLYwmLOjq5lFe7lzvdgjG4mItgXSdZWDgcWBYAJ7xIWlOm3RroNXSLNBpsWyp91oR7l+NozOHgEH6rxdh9Ly9NdJpL0piGhboJGza41hIk97O9sjpRmibLDuaa/kbHphGFfntVJg+eGaGT3tQgVQItobjIi2BeqtOHdZVphEtP3tHWnPYo2A9Uh72KqOMN4Ss75j0az2iFLW7/siIqJtgZWcDV4NozIJwAF/0yazRnxg39MeMboaV+dWN0KI2hC313nfxdPeSES0LTDK35ykAW/fx9hnjPggjfjCOiR21qWu5+wPaZhkHsNayl+4jgeawHpnuYiIaFtgpRUP9TfPKJ7R872fatGnGSZE8TbcJ3Jdom02921sXHmmYJQ9slxIJ/mWi/mTfVbtkfWkWZrrRLQ3FBFtC4xK/3rB8gu48yfv5PXnvz73992V/rbjZOQs+0MaLGYyaK2H7gkK8IP7fpCPvO4jXHr2pbm/t2qPrFu0a2KPbDD5nyIH+MfvPc1Tx58H6Nkfr3c59cGUuTX0wFkmxW7tde8VORl4Peu39/zcPab7Xg/+DfN3zZ+PG8epFXcOLfmrz3n10N8tFX2WafB3Xz/MmdXC0POyZekv62D5ht/H/mvSV6rn7/fXSt9f77zH2rnj6mNYuX/o9Ema1RdTHDEn0E+SaL57vMHJp0MuB/773z7A6tILKfqKIPAo+h6FzlfQ97Ri/381ei3/zOdNpf+TUgoFREnCsq5TLeSPrnzP58de9GND//JS0cdrPc8Xv3q45/jA53eisq3d8+7nMnNh9953vi+feIQfAI42A3YnOveJzlGEQZXk9FGe+O73CGNNnGjCJEl/jtOfR93WbHmyn4e8a8w9H/X/bTb9n5FL95/LrjNmDDSGoEZtGKqUeg1wY+flTVrrk0qpNwNvII3Sf1lrPTIEOHDggH7wwQenLtiXf/8/8IPP/unU180LoVeisOci2PUy2HUR7Hop7H4Z7HwJFMrp1lonvwvHHoVnD8Oz34ZnHyV8+lEK4SnbxbfG56If4z3R9Zx3ZoWL9ta46JxlLtqzzEV7l9m/q8qRk6s8fOQU33ryeR5+8hSPPHmKlVbEVd5D3FG81WrZw6BGYW+mvk3d77wA/EI66Xf8nzr1fRiOpd/DZx6lENvdSOAtrffyTf8SXrK7xkV7a7x0b3rPL9pbY1etxPeON3j82Tr//Gydx5+t851n6zz+XJ33tD7Mm/x/sFp2m3zjtXfwyte/ZaZrlVIPaa0PDBwfI9p3Ab8MXAG8XGt9m1LqHq31zyqlrgOe1lrfO+qNZxXtY9/8G6InvznijEm2MBrsYvujuGF/TmevzvyZ7F8c1oObvj4/HkgLsUc/i//ct9PGefJ7mQIo2HEurDwDSbh2Te0c2PVS9K6LOBbsIyQ/ausvfO6oQuuhhR/xq8wJay/VyNGOKU7fECXzBgP10Sl7Xrm1hm/vfC3fXNnB4adXOPz0af75WJ12jr9fKfi8fN8yl557Bt933g6+b0+Ji45+ARU1iRNNnCTEWhPFmlinEWCS5A2T+l+O+n8H69xEiD4Je+OjqOe+nYrx6SfXTvICqO2F00dBZ2yvHS+A3Rehz34px/w9JBk3c+CzNa459N3z7P3u+azDwGen7Vf5yhk/yeFjqxx+eoVvP32aJ59vDn2r3cslLti1xAVnL/Gqpee4tP5lfE/hK/CUh+eRvvYUngJv3GcoU57Bz+ZA6Qf+v1EMXj05Q6/NHNxx2ZtYPuclM/39YaI9bozpa62bSqmngB/tHDNK8hRw3pA3OwQcAjj//PNnKvDuV/w4vOLHZ7p27mg30gjr2KNpRH3icVg+J43Cdr8Mzr4QKmcC6edhj9XC2uVc4LWZ11Gc8PhzDb799Gm+81yd886scOm5O7hgV21wKP+iXwQc8QRbpzMjqMPw/BE484WdKPyitM47DxK5UOf7+16fboY89swK3356hWMrLc7fWeWCXUvs37WUY13lz88IszHu89tQSpWAfcDRzjETCmSP9aC1vh24HdJIewPKudgUq3DOK9IvYSoC3+PCPTUu3LOxvuGmU1qG834g/ZpDlssFLj//LC4//yzbRdl2jBPt24HbgALw10qpS4A/Ukp9mjQAuHHUxYIgCMLGMlK0tdYPAQf7Dj8C/NVmFUgQBEEYjuRpC4IgzBEi2oIgCHOEiLYgCMIcIaItCIIwR4hoC4IgzBEi2oIgCHPEyMfYN+QNlDoGfHfGy3cBz25gcTYSKdtsSNlmQ8o2G/NcthdprXf3H9x00V4PSqkH8569dwEp22xI2WZDyjYbi1g2sUcEQRDmCBFtQRCEOcJ10b7ddgFGIGWbDSnbbEjZZmPhyua0py0IgiD04nqkLQiCIGQQ0RYEQZgjnNjEo5+8vSltlqcfpdRlwH8F/hn4rNb6by0XCQCl1I8CPw/8D6bYx3MryJTtC6S7Gj0D3Kq1HrWn3FaU6yrgbUAV+CbpbkxO3Lecsv0g7ty3HwB+nXQnqzuB6zu/st5e+8r2CeCDONRWlVJ7SNvoLczQTp0UbdJGfSPp3pTXkm7E4BJXkO7aEwMPWy4LAEqpC4HvB8rAz2T28bwKGLmP5xaXzdy7VeCfbJarQ5VUGC8DHtRa+67cN3rL9g/A53HnvpWBXwF+Avhz4Bzcaa/Zsr0Wh9qqSreL/0+kDxzO1E5dtUd8rXWTdB/KfbYLk8N9wC8B7wd+w3JZANBaP6a1/lDnZXYfT+v3r69sf0K6WfSfM7jBxpajtf5LUnF8B/C/OodduW/Zsr0Ot+7b3wOXkH7+v+ZSe+0r25dxq63+MvDfSDvfmdqpq6KdtzelS1xGeu9O4OZoZew+nhY5QFo+J+6dUups4GPAe4GnO4eduG99ZbsMt+7bq4EHgauBf3apvfaV7Q9xq63+OGsuwps7x6a6by78E3lk96Z0cR/Kx4GPk/aU77NblFxc3sfzGPBpQONG5PMRYDfwe8DfOHbfsmX7C9y6bztIvWxF6hu71F6zZfsFHGqrWus3Ayil7gY+P8vnTfK0BUEQ5ghX7RFBEAQhBxFtQRCEOUJEWxAEYY4Q0RYEQZgjRLQFQRDmCBFtQRCEOeL/A7TBQWJc9rpLAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i_trial = 0\n",
    "plt.figure()\n",
    "plt.imshow(inputs[:, i_trial, :].T, aspect='auto', cmap='winter')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(labels[:, i_trial, 0], label='target')\n",
    "plt.plot(output[:, i_trial, 0], label='output')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(result['ingate'][:, i_trial, 0], label='input')\n",
    "plt.plot(result['outgate'][:, i_trial, 0], label='output')\n",
    "plt.plot(result['forgetgate'][:, i_trial, 0], label='forget')\n",
    "plt.legend(title='gate')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x12011ea50>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.scatter(labels.flatten(), output.flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Supplementary Materials\n",
    "\n",
    "Code for making publication quality figures as it appears in the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "mpl.rcParams['font.size'] = 7\n",
    "mpl.rcParams['font.family'] = 'arial'\n",
    "\n",
    "i_trial = 1\n",
    "\n",
    "fig, axes = plt.subplots(4, 1, sharex=True, figsize=(3, 3))\n",
    "for i in range(4):\n",
    "    ax = axes[i]\n",
    "    kwargs = {'marker': 'o', 'markersize': 3}\n",
    "    cmap = mpl.cm.get_cmap('Set1')\n",
    "    title = None\n",
    "    if i == 0:\n",
    "        ax.plot(inputs[:, i_trial, 0], label='stimulus', color='black', **kwargs)\n",
    "        title = 'Input'\n",
    "    elif i == 1:\n",
    "        ax.plot(inputs[:, i_trial, 1], label='memorize', color=cmap(0), **kwargs)\n",
    "        ax.plot(inputs[:, i_trial, 2], label='report', color=cmap(1), **kwargs)\n",
    "        title = 'Input'\n",
    "    elif i == 2:\n",
    "        ax.plot(labels[:, i_trial, 0], label='target', color=cmap(0), **kwargs)\n",
    "        ax.plot(output[:, i_trial, 0], label='predicted', color=cmap(1), **kwargs)\n",
    "        title = 'Output'\n",
    "#     elif i == 3:\n",
    "#         ax.plot(result['input'][:, i_trial, 0], label='cell input', color=cmap(0), **kwargs)\n",
    "#         ax.plot(result['cell'][:, i_trial, 0], label='cell state', color=cmap(1), **kwargs)\n",
    "#         ax.plot(result['output'][:, i_trial, 0], label='cell output', color=cmap(2), **kwargs)\n",
    "    else:\n",
    "        ax.plot(result['ingate'][:, i_trial, 0], label='input', color=cmap(0), **kwargs)\n",
    "        ax.plot(result['outgate'][:, i_trial, 0], label='output', color=cmap(1), **kwargs)\n",
    "        ax.plot(result['forgetgate'][:, i_trial, 0], label='forget', color=cmap(2), **kwargs)\n",
    "        title = 'Gate'\n",
    "        ax.set_xlabel('Time step')\n",
    "    \n",
    "    l = ax.legend(loc='center left', bbox_to_anchor=(1, 0.5),\n",
    "                  frameon=False, title=title)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    if i in [1, 3]:\n",
    "        ax.set_ylim([-0.15, 1.15])\n",
    "        ax.set_yticks([0, 1])\n",
    "    else:\n",
    "        ax.set_ylim([-1.3, 1.3])\n",
    "        ax.set_yticks([-1, 0, 1])\n",
    "plt.tight_layout()\n",
    "    \n",
    "from pathlib import Path\n",
    "fname = Path('figures/lstmvisualization')\n",
    "fig.savefig(fname.with_suffix('.pdf'), transparent=True)\n",
    "fig.savefig(fname.with_suffix('.png'), dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}