RelationNetwork/RelationalNetworkPyTorch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_uuid": "43b88cafca9ae9442db11854a7978442bb072079"
   },
   "outputs": [],
   "source": [
    "import torch as t\n",
    "import numpy as np\n",
    "import h5py\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from time import time\n",
    "import math\n",
    "from IPython.display import clear_output\n",
    "from torch.autograd import Variable\n",
    "import json\n",
    "from sklearn.utils import shuffle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_uuid": "cdaa83809d8c69a5d745a3ee0c135fcdf4775c8c"
   },
   "outputs": [],
   "source": [
    "def plotRandom(train_index, train_images, train_data, lstm_in, nn_out, out_dict):\n",
    "    \n",
    "    \"\"\"\n",
    "    Plot a random element from the dataset.\n",
    "\n",
    "    The function selects a random element from the given dataset and prints \n",
    "    all available information.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    train_images : h5py\n",
    "        image dataset\n",
    "    train_data : pandas\n",
    "        train dataset\n",
    "    lstm_in : numpy.ndarray\n",
    "        feature data used for input to NN\n",
    "    nn_out : numpy.ndarray\n",
    "        targets for the NN output\n",
    "    out_dict : dict\n",
    "        dictionary encoding the targets from index to word\n",
    "        \n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    int\n",
    "        the index of the random element\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    idx = np.random.randint(0, len(train_images))\n",
    "    \n",
    "    print(\"=> ORIGINAL\")\n",
    "    print(train_data[\"index\"].values[idx])\n",
    "    print(train_data[\"question\"].values[idx])\n",
    "    print(train_data[\"encoding\"].values[idx])\n",
    "    print(train_data[\"answer\"].values[idx])\n",
    "    print(train_data[\"type\"].values[idx])\n",
    "    \n",
    "    print(\"\\n=> CONVERTED\")\n",
    "    print(lstm_in[idx])\n",
    "    print(nn_out[idx])\n",
    "    print(nn_out[idx], out_dict[nn_out[idx]])\n",
    "    plt.imshow(train_images[train_index[idx]] / 255)\n",
    "    plt.show()\n",
    "    \n",
    "    return idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_uuid": "62b3fbbc4f0f47a71fb1bfa2c9730bde95c4d758"
   },
   "outputs": [],
   "source": [
    "def loadData(file_name):\n",
    "    \n",
    "    \"\"\"\n",
    "    Load the data by a given file name. \n",
    "\n",
    "    Data comes in pairs of CSV and H5PY files. For the training of the\n",
    "    model, we'll need both files per set.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    file_name : string\n",
    "        the name of the data pair to load\n",
    "        \n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    h5py array\n",
    "        the h5py array to prevent loading all the images to RAM\n",
    "    pandas dataframe\n",
    "        the training data for each image (more information here: https://www.kaggle.com/gruberpatrick/sortofclevr)\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    # load the data;\n",
    "    train_images = h5py.File(\"./sort-of-clevr/\"+file_name+\".h5\")[file_name]\n",
    "    train_data = pd.read_csv(\"./sort-of-clevr/\"+file_name+\".csv\")\n",
    "\n",
    "    # show the shapes;\n",
    "    print(train_images.shape, train_data[\"index\"].values.shape)\n",
    "    \n",
    "    return train_images, train_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "_uuid": "30ca8d29983babf3ab5a99edb81242a2d7cc8eed"
   },
   "outputs": [],
   "source": [
    "def loadQuestionEncoding(train_images, train_data):\n",
    "    \n",
    "    \"\"\"\n",
    "    Load JSON encoded catgorical question encoding.\n",
    "    \n",
    "    Since the categorical encoding is JSON encoded, we'll have to\n",
    "    decode the information before we can use it.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    file_name : string\n",
    "        the name of the data pair to load\n",
    "        \n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    numpy.ndarray\n",
    "        the simulated outputs of the LSTM\n",
    "    numpy.ndarray\n",
    "        each image is assigned whether it is used as a relational or non-relational example\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    print(\"Loading question encoding.\")\n",
    "    \n",
    "    # load the encoding;\n",
    "    count = 0\n",
    "    lstm_in = []\n",
    "    train_index = []\n",
    "    for it in range(len(train_data[\"encoding\"].values)): \n",
    "        enc = json.loads(train_data[\"encoding\"].values[it])\n",
    "        #if enc[8] == 1: count += 1\n",
    "        #if count >= 22000: continue\n",
    "        lstm_in.append(enc)\n",
    "        train_index.append(it)\n",
    "    \n",
    "    return np.array(train_index), np.array(lstm_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_uuid": "96c51140cdda68a04d9d9519823aead9b1120cfe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(70000, 128, 128, 3) (70000,)\n",
      "Loading question encoding.\n",
      "(70000, 10)\n"
     ]
    }
   ],
   "source": [
    "train_images, train_data = loadData(\"data_train\")\n",
    "train_index, lstm_in = loadQuestionEncoding(train_images, train_data)\n",
    "print(lstm_in.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "_uuid": "b8b9ec795b08239d063192afb84970589cca5ddf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 128, 128, 3) (10000,)\n",
      "Loading question encoding.\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "val_train_images, val_train_data = loadData(\"data_val\")\n",
    "_, val_lstm_in = loadQuestionEncoding(val_train_images, val_train_data)\n",
    "print(val_lstm_in.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "_uuid": "f7ce9be7731054a63580f0d726c1ccdf60e6c0d9"
   },
   "outputs": [],
   "source": [
    "def getOutputs(train_data, lstm_in, nrout_tokenizer=None):\n",
    "    \n",
    "    \"\"\"\n",
    "    Encode the targets.\n",
    "\n",
    "    We'll use a categorical representation to train the network. For this\n",
    "    we need to take the current word answers, assign them indexes and\n",
    "    encode the output. Previously we assigned the image a representation,\n",
    "    which means that a question input is either relational or non-relational.\n",
    "    Here we also load the correct relational or non-relational answer.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    train_data : pandas\n",
    "        train dataset\n",
    "    lstm_in : numpy.ndarray\n",
    "        feature data used for input to NN\n",
    "    dist_encoding : numpy.ndarray\n",
    "        the assignment of the dataset (relational or non-relational)\n",
    "    nrout_tokenizer : dict\n",
    "        the word encoding (given that we want to use the same encoding for validation and test)\n",
    "        if not given, a new dict is created\n",
    "        \n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    numpy.ndarray\n",
    "        the categorically encoded targets\n",
    "    dict\n",
    "        index to word dictionary\n",
    "    dict\n",
    "        word to index dictionary\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    nn_full = []\n",
    "    for it in range(lstm_in.shape[0]): \n",
    "        nn_full.append(train_data[\"answer\"][it])\n",
    "    \n",
    "    # combine the data and tokenize the input;\n",
    "    highest = 16\n",
    "    if not nrout_tokenizer:\n",
    "        \n",
    "        word_index = {}\n",
    "        index_word = {}\n",
    "        idx = 0\n",
    "        for it in range(len(nn_full)):\n",
    "            if nn_full[it] not in word_index:\n",
    "                word_index[nn_full[it]] = idx\n",
    "                index_word[idx] = nn_full[it]\n",
    "                idx += 1\n",
    "                \n",
    "    else:\n",
    "        \n",
    "        word_index = nrout_tokenizer\n",
    "        index_word = {}\n",
    "        for it in word_index:\n",
    "            index_word[word_index[it]] = it\n",
    "        \n",
    "    nn_out = []\n",
    "    for it in range(len(nn_full)):\n",
    "        nn_out.append(word_index[nn_full[it]])\n",
    "    nn_out = np.array(nn_out)\n",
    "        \n",
    "    return nn_out, index_word, word_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "_uuid": "64dce33162e59b9eda526223d3e2b6e17066f2ea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(70000,)\n",
      "{0: 'right', 1: 'blue', 2: 'circle', 3: 'left', 4: 'bottom', 5: 'yellow', 6: 'square', 7: 'green', 8: 'red', 9: 'top', 10: 'gray'}\n"
     ]
    }
   ],
   "source": [
    "nn_out, train_dict, nrout_tokenizer = getOutputs(train_data, lstm_in)\n",
    "print(nn_out.shape)\n",
    "print(train_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "_uuid": "be1a12dd01d0186b3f0704268554d1e4664c4b3e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000,)\n",
      "{0: 'right', 1: 'blue', 2: 'circle', 3: 'left', 4: 'bottom', 5: 'yellow', 6: 'square', 7: 'green', 8: 'red', 9: 'top', 10: 'gray'}\n"
     ]
    }
   ],
   "source": [
    "val_nn_out, val_dict, nrout_tokenizer = getOutputs(val_train_data, val_lstm_in, nrout_tokenizer)\n",
    "print(val_nn_out.shape)\n",
    "print(val_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_uuid": "952ceb6394cd03470b0c18e3efdd15267541d2c7",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> ORIGINAL\n",
      "49815\n",
      "What is the color of the object that is closest to the blue object?\n",
      "[0, 0, 0, 1, 0, 0, 0, 0, 0, 1]\n",
      "gray\n",
      "0\n",
      "\n",
      "=> CONVERTED\n",
      "[0 0 0 1 0 0 0 0 0 1]\n",
      "10\n",
      "10 gray\n"
     ]
    },
    {
     "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": {
      "text/plain": [
       "49815"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plotRandom(train_index, train_images, train_data, lstm_in, nn_out, val_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_uuid": "c6950a905c817486750cab67f0d1e0d24352517f"
   },
   "source": [
    "# Relation Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "_uuid": "0e88e82ea5271ce159d91b6a00d4eac867b5dd64"
   },
   "outputs": [],
   "source": [
    "class RelationNetwork(t.nn.Module):\n",
    "    \n",
    "    # -----------------------------------------------------------\n",
    "    def __init__(self, out_size=16, batch_size=128, img_size=5):\n",
    "        \n",
    "        self._step = 0\n",
    "        \n",
    "        super(RelationNetwork, self).__init__()\n",
    "        self._conv1 = t.nn.Conv2d(3, 24, 3, stride=2, padding=1).cuda()\n",
    "        self._conv2 = t.nn.Conv2d(24, 24, 3, stride=2, padding=1).cuda()\n",
    "        self._conv3 = t.nn.Conv2d(24, 24, 3, stride=2, padding=1).cuda()\n",
    "        self._conv4 = t.nn.Conv2d(24, 24, 3, stride=2, padding=1).cuda()\n",
    "        self._conv5 = t.nn.Conv2d(24, 24, 3, stride=2, padding=2).cuda()\n",
    "        self._batch_norm1 = t.nn.BatchNorm2d(24).cuda()\n",
    "        self._batch_norm2 = t.nn.BatchNorm2d(24).cuda()\n",
    "        self._batch_norm3 = t.nn.BatchNorm2d(24).cuda()\n",
    "        self._batch_norm4 = t.nn.BatchNorm2d(24).cuda()\n",
    "        self._batch_norm5 = t.nn.BatchNorm2d(24).cuda()\n",
    "        self._g1 = t.nn.Linear(62, 256).cuda()\n",
    "        self._g2 = t.nn.Linear(256, 256).cuda()\n",
    "        self._g3 = t.nn.Linear(256, 256).cuda()\n",
    "        self._g4 = t.nn.Linear(256, 256).cuda()\n",
    "        self._g5 = t.nn.Linear(256, 256).cuda()\n",
    "        self._g6 = t.nn.Linear(256, 256).cuda()\n",
    "        self._relu = t.nn.ReLU().cuda()\n",
    "        self._dropout = t.nn.Dropout(.5).cuda()\n",
    "        self._f1 = t.nn.Linear(256, 256).cuda()\n",
    "        self._f2 = t.nn.Linear(256, 256).cuda()\n",
    "        self._f3 = t.nn.Linear(256, 256).cuda()\n",
    "        self._f4 = t.nn.Linear(256, 256).cuda()\n",
    "        self._f5 = t.nn.Linear(256, 29).cuda()\n",
    "        self._f_out = t.nn.Linear(29, out_size).cuda()\n",
    "        \n",
    "        self._tags, self._locations = self.tagging(img_size, batch_size)\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def tagging(self, img_size, batch_size):\n",
    "        \n",
    "        locations = []\n",
    "        tags = []\n",
    "        for x in range(img_size):\n",
    "            row = []\n",
    "            for y in range(img_size): row.append([x, y])\n",
    "            tags.extend(row)\n",
    "            locations.extend(row)\n",
    "        tags = np.array(tags)\n",
    "        X = t.from_numpy((2 * tags / (img_size-1)) - 1).float().cuda()\n",
    "        print(X.size())\n",
    "        size = X.size()\n",
    "        return X.expand(batch_size, size[0], size[1]), locations\n",
    "    \n",
    "    # -----------------------------------------------------------\n",
    "    def g(self, X):\n",
    "        \n",
    "        X = self._g1(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._g2(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._g3(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._g4(X)\n",
    "        #X = self._relu(X)\n",
    "        #X = self._g5(X)\n",
    "        #X = self._relu(X)\n",
    "        #X = self._g6(X)\n",
    "        return self._relu(X)\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def f(self, X):\n",
    "        \n",
    "        X = self._f1(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._f2(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._dropout(X)\n",
    "        X = self._f3(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._f4(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._f5(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._f_out(X)\n",
    "        return t.nn.functional.log_softmax(X, dim=1)\n",
    "        #return X\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def forward(self, imgs, questions, debug=False):\n",
    "        \n",
    "        # convolutional model;\n",
    "        if debug: print(\"CONV_IN\", imgs.size())\n",
    "        X = self._conv1(imgs)\n",
    "        X = self._relu(X)\n",
    "        X = self._batch_norm1(X)\n",
    "        X = self._conv2(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._batch_norm2(X)\n",
    "        X = self._conv3(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._batch_norm3(X)\n",
    "        X = self._conv4(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._batch_norm4(X)\n",
    "        X = self._conv5(X)\n",
    "        X = self._relu(X)\n",
    "        X = self._batch_norm5(X)\n",
    "        if debug: print(\"CONV_OUT\", X.size())\n",
    "        \n",
    "        #tagging;\n",
    "        X_size = X.size()\n",
    "        tags, locations = self._tags, self._locations\n",
    "        if debug: print(\"TAGS\", tags.size())\n",
    "        #print(X_size)\n",
    "        X = X.view(64, 24, 5*5).permute(0, 2, 1)\n",
    "        X = t.cat([X, tags],2)\n",
    "        #X = t.cat([X, tags], dim=1)\n",
    "        if debug: print(\"TAGGED\", X.size())\n",
    "        \n",
    "        # slice and run g();\n",
    "        g_all = []\n",
    "        \n",
    "        for obj1 in range(5*5):\n",
    "            for obj2 in range(5*5):\n",
    "                if debug: print(\"\\rSLICES\", obj1, obj2, end=\"\")\n",
    "                g_in = t.cat([ X[:,obj1,:], X[:,obj2,:], questions ], dim=1)\n",
    "                g_all.append( self.g(g_in) )\n",
    "        \n",
    "        \"\"\"for obj1 in locations:\n",
    "            for obj2 in locations:\n",
    "                if debug: print(\"\\rSLICES\", obj1, obj2, end=\"\")\n",
    "                g_in = t.cat([ X[:,:,obj1[0],obj1[1]], X[:,:,obj2[0],obj2[1]], questions ], dim=1)\n",
    "                g_all.append( self.g(g_in) )\"\"\"\n",
    "                \n",
    "        print(\"\")\n",
    "        # sum g() outputs;\n",
    "        X = t.stack(g_all, dim=1)\n",
    "        if debug: print(\"PRE_SUM\", X.size())\n",
    "        X = t.mean(X, 1)\n",
    "        if debug: print(\"POST_SUM\", X.size())\n",
    "        \n",
    "        # run f()\n",
    "        X = self.f(X)\n",
    "        if debug: print(\"f()\", X.size())\n",
    "        \n",
    "        return X\n",
    "    \n",
    "    # -----------------------------------------------------------\n",
    "    def loss(self, outputs, targets):\n",
    "        \n",
    "        return self._loss(outputs, targets)\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def optimizer(self):\n",
    "        \n",
    "        self._optimizer = t.optim.Adam(self.parameters(), lr=self._lr)\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def prepTraining(self, lr=.001, decay_rate=.5, decay_steps=10000):\n",
    "        \n",
    "        self._lr = lr\n",
    "        self._decay_rate = decay_rate\n",
    "        self._decay_steps = decay_steps\n",
    "        self.optimizer()\n",
    "        self._loss = t.nn.NLLLoss()\n",
    "        #self._loss = t.nn.CrossEntropyLoss()\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def exponentialDecay(self):\n",
    "        \n",
    "        lr = self._lr * pow(self._decay_rate, self._step / self._decay_steps)\n",
    "        for param_group in self._optimizer.param_groups:\n",
    "            param_group[\"lr\"] = lr\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def train(self, imgs, questions, answers, decay=True):\n",
    "        \n",
    "        # training step;\n",
    "        outputs = self(imgs, questions)\n",
    "        loss = self.loss(outputs, answers)\n",
    "        self._optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self._optimizer.step()\n",
    "        \n",
    "        # calculate accuracy;\n",
    "        pred = outputs.data.max(1)[1]\n",
    "        correct = pred.eq(answers.data).float().cpu().sum()\n",
    "        accuracy = correct / len(answers)\n",
    "        \n",
    "        # decay;\n",
    "        self._step += 1\n",
    "        if decay: self.exponentialDecay()\n",
    "        \n",
    "        return loss.item(), accuracy.item()\n",
    "\n",
    "    # -----------------------------------------------------------\n",
    "    def test(self, imgs, questions, answers):\n",
    "        \n",
    "        # calculate loss;\n",
    "        outputs = self(imgs, questions)\n",
    "        loss = self.loss(outputs, answers)\n",
    "        \n",
    "        # calculate accuracy;\n",
    "        pred = outputs.data.max(1)[1]\n",
    "        correct = pred.eq(answers.data).float().cpu().sum()\n",
    "        accuracy = correct / len(answers)\n",
    "\n",
    "        return loss.item(), accuracy.item()\n",
    "    \n",
    "    # -----------------------------------------------------------\n",
    "    def predict(self, imgs, questions, debug=False):\n",
    "        \n",
    "        return self(imgs, questions, debug=debug)\n",
    "        \n",
    "    # -----------------------------------------------------------\n",
    "    def initializeWeights(self):\n",
    "        \n",
    "        t.nn.init.xavier_uniform_(self._conv1.weight),\n",
    "        t.nn.init.xavier_uniform_(self._conv2.weight),\n",
    "        t.nn.init.xavier_uniform_(self._conv3.weight),\n",
    "        t.nn.init.xavier_uniform_(self._conv4.weight),\n",
    "        t.nn.init.xavier_uniform_(self._conv5.weight),\n",
    "        t.nn.init.xavier_uniform_(self._g1.weight),\n",
    "        t.nn.init.xavier_uniform_(self._g2.weight),\n",
    "        t.nn.init.xavier_uniform_(self._g3.weight),\n",
    "        t.nn.init.xavier_uniform_(self._g4.weight),\n",
    "        t.nn.init.xavier_uniform_(self._g5.weight),\n",
    "        t.nn.init.xavier_uniform_(self._g6.weight),\n",
    "        t.nn.init.xavier_uniform_(self._f1.weight),\n",
    "        t.nn.init.xavier_uniform_(self._f2.weight),\n",
    "        t.nn.init.xavier_uniform_(self._f3.weight),\n",
    "        t.nn.init.xavier_uniform_(self._f4.weight),\n",
    "        t.nn.init.xavier_uniform_(self._f5.weight),\n",
    "        t.nn.init.xavier_uniform_(self._f_out.weight)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "_uuid": "d920be99ac23c61addae8d01168a99da5d998ee7"
   },
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "lr = 2.5e-4\n",
    "decay_steps = 3120\n",
    "decay_rate = 0.5\n",
    "epochs = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "_uuid": "a2fdbfc8efab5f4127ebfe3c7df438d6c1cad5bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([25, 2])\n"
     ]
    }
   ],
   "source": [
    "rn = RelationNetwork(out_size=11, batch_size=batch_size)\n",
    "rn = rn.cuda()\n",
    "rn.prepTraining(lr=lr, decay_rate=decay_rate, decay_steps=decay_steps)\n",
    "rn.initializeWeights()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "_uuid": "30a25b135cc32176d2c7731c2456aeda80182a5b",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONV_IN torch.Size([64, 3, 128, 128])\n",
      "CONV_OUT torch.Size([64, 24, 5, 5])\n",
      "TAGS torch.Size([64, 25, 2])\n",
      "TAGGED torch.Size([64, 25, 26])\n",
      "SLICES 24 24\n",
      "PRE_SUM torch.Size([64, 625, 256])\n",
      "POST_SUM torch.Size([64, 256])\n",
      "f() torch.Size([64, 11])\n"
     ]
    }
   ],
   "source": [
    "y = rn.predict(\n",
    "    t.randn(batch_size,3,128,128).float().cuda(),\n",
    "    t.randn(batch_size,10).float().cuda(),\n",
    "    debug=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "_uuid": "92fec077aafface0e68e7d4fcd56c5d913601c16"
   },
   "outputs": [],
   "source": [
    "losses = []\n",
    "accuracies = []\n",
    "val_losses = []\n",
    "val_accuracies = []\n",
    "model_time = str(int(time()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "_uuid": "d9da40760e4f9c784438cd3cded9a68db60a43f9"
   },
   "outputs": [],
   "source": [
    "stop = True\n",
    "try: thr.join()\n",
    "except: print(\"Thread not started...\")\n",
    "queue = []\n",
    "stop = False\n",
    "def queueBatch(train_index, images, lstm, out, batch_size=64, total=1):\n",
    "    global queue\n",
    "    amount = math.floor(lstm.shape[0] / batch_size)\n",
    "    #amount = 157\n",
    "    #amount = 10\n",
    "    batches = list(range(amount))\n",
    "    train_index, lstm, out = shuffle(train_index, lstm, out)\n",
    "    while True:\n",
    "        np.random.shuffle(batches)\n",
    "        c = 0\n",
    "        for it in batches:\n",
    "            if stop: return True\n",
    "            while len(queue) >= 10:\n",
    "                if stop: return True\n",
    "                sleep(1)\n",
    "            imgs = []\n",
    "            for jt in range((it)*batch_size, (it+1)*batch_size):\n",
    "                imgs.append(images[train_index[jt]] / 255)\n",
    "            imgs = np.array(imgs)\n",
    "            #print(np.moveaxis(imgs, 3, 1).shape)\n",
    "            data = [\n",
    "                t.from_numpy(np.moveaxis(imgs, 3, 1)).float().cuda(),\n",
    "                t.from_numpy(lstm[(it)*batch_size:(it+1)*batch_size]).float().cuda(),\n",
    "                t.from_numpy(out[(it)*batch_size:(it+1)*batch_size]).long().cuda()\n",
    "            ]\n",
    "            \n",
    "            c += 1\n",
    "            queue.append((data[0], data[1], data[2], c, amount))\n",
    "import threading\n",
    "from time import sleep\n",
    "thr = threading.Thread(target=queueBatch, args=(train_index, train_images, lstm_in, nn_out, batch_size, 0))\n",
    "thr.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "_uuid": "da4875246301d8266605109a7cebc81e0a1a88d5"
   },
   "outputs": [],
   "source": [
    "def getBatch(images, lstm, out, batch_size=64, total=1):\n",
    "    amount = math.floor(lstm.shape[0] / batch_size)\n",
    "    batches = list(range(amount))\n",
    "    np.random.shuffle(batches)\n",
    "    c = 0\n",
    "    for it in batches:\n",
    "        imgs = []\n",
    "        for jt in range((it)*batch_size, (it+1)*batch_size):\n",
    "            imgs.append(images[train_index[jt]] / 255)\n",
    "        imgs = np.array(imgs)\n",
    "        data = [\n",
    "            t.from_numpy(np.moveaxis(imgs, 3, 1)).float().cuda(),\n",
    "            t.from_numpy(lstm[(it)*batch_size:(it+1)*batch_size]).float().cuda(),\n",
    "            t.from_numpy(out[(it)*batch_size:(it+1)*batch_size]).long().cuda()\n",
    "        ]\n",
    "        c += 1\n",
    "        yield (data[0], data[1], data[2], c, amount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "_uuid": "da6ef14fa0e606e9326916aaaca645723d2765aa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(len(queue))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "_uuid": "1dcbe83a1814f7486d3a59f6e8049a691d672791",
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# EPOCH 15 / 50 [ 180 / 1093 ] Loss: 0.4605939984321594  || Accuracy: 0.609375\n",
      "\n",
      "# EPOCH 15 / 50 [ 181 / 1093 ] Loss: 0.4034155607223511  || Accuracy: 0.734375\n",
      "\n",
      "# EPOCH 15 / 50 [ 182 / 1093 ] Loss: 0.48894262313842773  || Accuracy: 0.65625\n",
      "\n",
      "# EPOCH 15 / 50 [ 183 / 1093 ] Loss: 0.4981045722961426  || Accuracy: 0.78125\n",
      "\n",
      "# EPOCH 15 / 50 [ 184 / 1093 ] Loss: 0.4142833948135376  || Accuracy: 0.765625\n",
      "\n",
      "# EPOCH 15 / 50 [ 185 / 1093 ] Loss: 0.5016788840293884  || Accuracy: 0.65625\n",
      "\n",
      "# EPOCH 15 / 50 [ 186 / 1093 ] Loss: 0.4826604723930359  || Accuracy: 0.6875\n",
      "\n",
      "# EPOCH 15 / 50 [ 187 / 1093 ] Loss: 0.45866331458091736  || Accuracy: 0.765625\n",
      "\n",
      "# EPOCH 15 / 50 [ 188 / 1093 ] Loss: 0.4202791154384613  || Accuracy: 0.6875\n",
      "\n",
      "# EPOCH 15 / 50 [ 189 / 1093 ] Loss: 0.5265445709228516  || Accuracy: 0.65625\n",
      "\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-58-65549b6a198e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     17\u001b[0m         \u001b[0mcurrents\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcurrent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0macc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlstms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdecay\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0mepoch_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-47-f1eee14ceb06>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self, imgs, questions, answers, decay)\u001b[0m\n\u001b[1;32m    178\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0manswers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    179\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    181\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    182\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m     91\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     92\u001b[0m         \"\"\"\n\u001b[0;32m---> 93\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     95\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     88\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     89\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 90\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m     91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     92\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# run epochs;\n",
    "for epoch in range(epochs):\n",
    "\n",
    "    print(\"# EPOCH\", str(epoch + 1), \"/\", str(epochs), \"====================================\")\n",
    "    epoch_losses = []\n",
    "    epoch_acc = []\n",
    "    totals = 1\n",
    "    currents = 0\n",
    "\n",
    "    # run mini-batches;\n",
    "    while currents < totals:\n",
    "\n",
    "        while len(queue) <= 0: sleep(2)\n",
    "\n",
    "        images, lstms, targets, current, total = queue.pop(0)\n",
    "        totals = total\n",
    "        currents = current\n",
    "        \n",
    "        loss, acc = rn.train(images, lstms, targets, decay=False)\n",
    "        \n",
    "        epoch_losses.append(loss)\n",
    "        epoch_acc.append(acc)\n",
    "        \n",
    "        if currents % 10 == 0:\n",
    "            clear_output()\n",
    "            plt.ylim((0, max(1, np.max(epoch_losses))))\n",
    "            plt.plot([it for it in range(len(epoch_losses))], epoch_losses)\n",
    "            plt.plot([it for it in range(len(epoch_acc))], epoch_acc)\n",
    "            plt.plot([0, len(epoch_losses)-1], [1, 1])\n",
    "            plt.plot([0, len(epoch_losses)-1], [.5, .5])\n",
    "            plt.show()\n",
    "            \n",
    "        print(\"# EPOCH \"+str(epoch+1)+\" / \"+str(epochs)+\" [\", current, \"/\", total,\"] Loss:\", loss, \" || Accuracy:\", acc)\n",
    "        \n",
    "    losses.append(np.mean(epoch_losses))\n",
    "    accuracies.append(np.mean(epoch_acc))\n",
    "    print(\"\\r[\", current, \"/\", total,\"] Complete - Loss:\", np.mean(epoch_losses), \"|| Accuracy:\", np.mean(epoch_acc), \"                               \")\n",
    "    \n",
    "    plt.ylim((0, max(1, np.max(losses))))\n",
    "    plt.plot([it for it in range(len(losses))], losses)\n",
    "    plt.plot([it for it in range(len(accuracies))], accuracies)\n",
    "    plt.plot([0, len(losses)-1], [1, 1])\n",
    "    plt.plot([0, len(losses)-1], [.5, .5])\n",
    "    plt.show()\n",
    "    \n",
    "    rval = {\"acc\":[], \"loss\":[]}\n",
    "    for batch in getBatch(val_train_images, val_lstm_in, val_nn_out, batch_size=batch_size, total=2):\n",
    "        images, lstms, targets, current, total = batch\n",
    "        loss, acc = rn.test(images, lstms, targets)\n",
    "        rval[\"acc\"].append(acc)\n",
    "        rval[\"loss\"].append(loss)\n",
    "        print(\"\\r[ validation ]\", current/total*100, \"%\", end=\"\")\n",
    "    print(\"\\r[ validation ]\",\"Loss:\",np.mean(rval[\"loss\"]),\"|| Accuracy:\",np.mean(rval[\"acc\"]))\n",
    "    val_losses.append(np.mean(rval[\"loss\"]))\n",
    "    val_accuracies.append(np.mean(rval[\"acc\"]))\n",
    "    \n",
    "    t.save(rn, \"./model.ckpt\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "_uuid": "10b8dea7bc1225bd713274b1b57cbbb30d39caff"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8FPX9x/HXd+9ssrlDAjm55BARMIDgRcEDL/CnFY96VS21VuvR1tp61tZWsfawVitVq3hW6wFeeMSryq0ccssZEsh9bjZ7f39/zBISDgmQZJPN5/l47GNmZ4bdz2T1vbPf+c53lNYaIYQQscUU7QKEEEJ0PAl3IYSIQRLuQggRgyTchRAiBkm4CyFEDJJwF0KIGHTQcFdKPa2UqlBKrT7A+h8opVYppb5RSi1QSh3b8WUKIYQ4FO05cn8GmPod67cCp2itjwF+B8zugLqEEEIcAcvBNtBaf66UKviO9QtaPV0E5Bx5WUIIIY7EQcP9EF0DvHeglUqpmcBMgPj4+OOGDh16yG9Q3xyguMZDQZoTl8N62IUKIURP9NVXX1VprTMOtl2HhbtS6nsY4X7igbbRWs8m0mxTWFioly1bdsjvEwiFOeGBjxnWN5Fnrx53uOUKIUSPpJTa3p7tOqS3jFJqJPAkMF1rXd0Rr3kgVrOJH4zP57ONlWytaurMtxJCiB7riMNdKZUHvA5crrXeeOQlHdwl43OxmhXPLWzXF5gQQvQ67ekK+RKwEBiilCpRSl2jlLpOKXVdZJO7gTTgMaXUCqXUobe1HKI+LgdnjujLq8t20OQLdvbbCSFEj9Oe3jKXHGT9tcC1HVZRO105sYB5K3fyxvJSLjs+v6vfXgghurUee4XqmLxkRmQnMmfhNmRMeiGEaKvHhrtSiismFLCx3M2iLTXRLkcIIbqVHhvuANOO7UeK08qzC7ZFuxQhhOhWenS4O6xmLhqbxwdryyita452OUII0W306HAH+MH4PABeXCzdIoUQYrceH+65qU6mDMvkpSU78AZC0S5HCCG6hR4f7gBXTiigpsnPO6t2RbsUIYToFmIi3E8YlMbAjHjmLNwW7VKEEKJbiIlwV0px5cQCVpbUs2JHXbTLEUKIqIuJcAc4f0wOCXYLc6RbpBBCxE64J9gtXDAmm7dX7aLK7Yt2OUIIEVUxE+4Al08owB8K8/KS4miXIoQQURVT4T6oTwInDU7n+UXFBEPhaJcjhBBRE1PhDnDFhALKGrx8uLY82qUIIUTUxFy4Tx7ah5yUOJ6RE6tCiF4s5sLdbFJcfnw+i7fWsL6sIdrlCCFEVMRcuAPMKMzFbjExR27DJ4TopWIy3FPibUwf1Y83vi6lvjkQ7XKEEKLL9chwr/Me/CrUKyYU0BwI8eqyHV1QkRBCdC89Ltw/3fEpZ7x2Bi+ue5GwPnB3xxHZSRTmp/Dcou2Ew3IbPiFE79Ljwn1wymBG9RnFH5f8kSveu4JNtZsOuO0VEwvYXu3hs28ru7BCIYSIvh4X7tkJ2fzz1H/yhxP/wPaG7Vz49oU8tuIx/CH/PttOPTqLDJddxpsRQvQ6PS7cwRgF8tyB5zL3vLmcnn86j698nBlvzWBFxYo229ksJi4dl8enGytZslVuoi2E6D16ZLjvlupI5cGTH+SxKY/hCXq44r0ruH/R/TQFmlq2uez4fPq47Mx4YiG3/GcFu+rlXqtCiNintI7OycbCwkK9bNmyDns9T8DDI8sf4cV1L9LH2Ye7jr+LU3JPAcDtC/LYJ5t48outmBTMPHkg150yAKfN0mHvL4QQXUEp9ZXWuvCg28VKuO+2snIl9y64l011mziz4Ex+Ne5XpMWlAbCjxsMD89fzzqpdZCba+eUZQzl/dDYmk+rwOoQQojP02nAHCIQCPLX6KWavmo3T6uQXhb9g+sDpKGWE+LJtNfzu7bWsLKnnmOwk7jpnOOP6p3ZKLUII0ZHaG+4HbXNXSj2tlKpQSq0+wHqllHpEKbVJKbVKKTXmcAruSFazleuOvY7/nvtfBiQN4K4v7+Ky9y5jecVyAAoLUnnj+hP4y0XHUuX2MeOJhfzk+a8orvZEuXIhhOgYBz1yV0qdDLiBOVrrEftZfxZwI3AWMB74m9Z6/MHeuDOP3FsL6zBzN83l0eWPUtFcwZS8Kdw85mYKkgoAaPaHmP35Fv752WZCYc0PTyjgp5MHkeiwdnptQghxqDq0WUYpVQC8fYBwfwL4VGv9UuT5BmCS1nrXd71mV4X7bp6Ahzlr5/Dv1f/GH/Jz4ZALue7Y60h1GM0xZfVeHnp/A699XUJavI1fnDGEiwpzpT1eCNGtdFizTDtkA60HcCmJLNtfUTOVUsuUUssqK7v2qlGn1cl1x17HO+e/w/mDz+eVDa9w1utn8eQ3T+INeslKcvDwjGN564YTGZARz69f/4bzH1/A6tL6Lq1TCCE6Qpf2c9daz9ZaF2qtCzMyMrryrVukx6Vz14S7eH3664zNGsvfvv4b57xxDnM3zSWswxyTk8QrP57AwxceS0mth2mPfsHdc1fL6JJCiB6lI8K9FMht9TwnsqxbG5A0gL9P/jtPn/E0GXEZ3Pnlncx4awYLdi5AKcUFx+VQ9PNJXHZ8Ps8v2s6Uhz/lta9KiFbvIiGEOBQdEe7zgCsivWaOB+oP1t7enYzNGssLZ7/ArJNn4Q64+fGHP+a6D69jU+0mkuKs3Dd9BPNuOJGcFCc/f3UlFz2xSO7wJITo9trTW+YlYBKQDpQD9wBWAK31P5XRefxRYCrgAX6otT7omdKuPqHaHv6Qn5fWv8TsVbNpCjRx0ZCLuH7U9STZkwiHNa8s28ED89fT6A3yw4kF3HzaUSTY5SpXIUTX6dUXMR2pOm8dj654lFc3vkqiLZEbR9/IBYMvwGwyU9vkZ9b763l56Q76uOzccfZwzh3Zt+UCKSGE6EwS7h1gQ80GHljyAMvKlzEkZQi3j7udwizjb7q8uJa75q5mdWkDJwxK47fTRjCoT0KUKxZCxDoJ9w6iteaD7R/w8LKH2dW0izMKzuDnx/2cvgl9CYU1Ly7ezqz3N9DsD3H5hHxunnIUSU65AEoI0Tkk3DtYc7CZZ1Y/w1Orn0KhuPqYq/nh0T/EYXFQ5fbx8AcbeXlpMclxVm49fQiXjM3FYu7RIyoLIbohCfdOstO9k4eXPcwH2z+gX3w/fl74c07LPw2lFGt3NnDf22tYtKWGIZku7j53OCcMSo92yUKIGCLh3smWli3lgSUPsLF2I2OzxvKbcb9hUMogtNbMX13G/e+uo6S2mdOGZ3LHWcMoSI+PdslCiBgg4d4FguEgr218jb+v+DvNgWZuLbyVS4deilIKbyDEU19s5bFPNuEPhbn6hP7cMHkQLhmQTAhxBCTcu1CNt4a7v7ybz0o+44TsE/j9Cb8nPc5ojqlo8DLr/Q3896sS0hNs/OL0IVxYmItZBiQTQhwGCfcuprXmlQ2v8NCyh3BanNx3wn1Myp3Usn5VSR33vbWWZdtrObpfInefM5zxA9KiV7AQokfqylEhBaCU4qKhF/HKOa+QGZ/JjR/fyO8X/Z7moHFD7pE5ybx63QQeuWQ0tU1+Lpq9iBtfWi437BZCdAo5cu8E/pCfR5c/yr/X/Jv+Sf158KQHGZY2rGV9sz/E459t5p+fbcasFDdMHsQ1J/bHYTVHsWohRE8gzTLdwKJdi7jjf3dQ46vhptE3ccXRV2BSe34s7ajxcP8765i/poy8VCd3nTOcU4f1kaEMhBAHJM0y3cDxfY/ntWmvMSlnEg9/9TAzP5xJeVN5y/rcVCf/vPw4nrtmHDaLiR/NWcZV/17K5kp3FKsWQsQCOXLvAlpr3tz0Jn9c8kdsZhv3TriXU/NPbbNNIBRmzsLt/PXDjTQHQlx9Yn9ulK6TQoi9SLNMN7S9YTu3f347q6tXM7VgKjOGzOC4zOPaNNVUNvqYNX89r35VQobLzu1Th/J/o7PlXq5CCEDCvdsKhAM8sfIJnl/3PE2BJvrG9+WcAedw7sBz6Z/Uv2W7FTvquGfeGlbuqGNMXjK/nTaCY3KSoli5EKI7kHDv5pqDzXxS/Anztsxj4c6FhHWYkekjmTZwGlP7T225Qch/vy5h1vz11HkC/P2S0Zx5TN9oly6EiCIJ9x6k0lPJO1veYe7muWyq24TFZGFSziTOHXguJ2WfhMcHVz+7lBU76vjrRaM499h+0S5ZCBElEu49kNaaDbUbmLtpLu9ufZcabw0p9hTO7H8mZxZM5w9v1LNsew1/uWgU00dlR7tcIUQUSLj3cIFwgIU7FzJv8zw+Kf6EsA7z1OlzmDXPzZKtNTz0/WO54LicaJcphOhiEu4xpLq5mgvfupBkRzLPnPYi17+wki83V/Hg+SOZMTY32uUJIbqQXMQUQ9Li0rhnwj18W/stc9Y/yZNXFnLS4Axue20VLy4ujnZ5QohuSMK9hzgl9xSmDZzGk988yZaGDcy+/DgmD+3Db974hjkLt0W7PCFENyPh3oPcNvY2Uh2p3PnlnZhNYR6/bAynDc/k7rlrePqLrdEuTwjRjUi49yBJ9iTunnA339Z+yxOrnsBuMfOPS8cw9egs7nt7LbM/3xztEoUQ3YSEew8zKXcS5w44lye/eZK11WuxWUz8/dLRnH1MX/7w7noe+3RTtEsUQnQDEu490K/G/aqleSYQCmA1m/jbxaOYPqofs+Zv4JGib6NdohAiyiTce6C9m2cALGYTf54xivPHZPPnDzfy5w83Eq1urkKI6JNw76H2bp4BMJsUD33/WGYU5vBI0bc8/pm0wQvRW7Ur3JVSU5VSG5RSm5RSt+9nfZ5S6hOl1HKl1Cql1FkdX6rY2+7mmbu+vItAKAAYAf/A+SNbmmheXiL94IXojQ4a7kopM/AP4ExgOHCJUmr4XpvdCbyitR4NXAw81tGFin3tbp7ZWLuxpXkGwBQ5gj/lqAx+88Y3zF+9K4pVCiGioT1H7uOATVrrLVprP/AyMH2vbTSQGJlPAnZ2XIniu+yveQbAZjHx+GVjGJWbzM9eWsGCzVVRrFII0dXaE+7ZwI5Wz0siy1q7F7hMKVUCvAvcuL8XUkrNVEotU0otq6ysPIxyxf78atyvSHGktGmeAXDaLDx91VgK0p3MnPMVq0vro1ilEKIrddQJ1UuAZ7TWOcBZwHNKqX1eW2s9W2tdqLUuzMjI6KC3Fkn2JO6ZcA8bazcy+5vZbdYlO23MuXo8SXFWrnx6CVvk5ttC9ArtCfdSoPXQgzmRZa1dA7wCoLVeCDiA9I4oULTPpNxJnDPgHJ5c9STrqte1WZeV5OC5a8YBcPlTSyhv8EajRCFEF2pPuC8FBiul+iulbBgnTOfttU0xMAVAKTUMI9yl3aWL3T7udpIdyS0XN7U2ICOBZ344jvrmAFc8tYR6T+AAryKEiAUHDXetdRC4AXgfWIfRK2aNUuo+pdS0yGY/B36klFoJvARcpeUKmi6XZE/i7uPv3m/zDMAxOUnMvuI4tlY1cfWzS2n2h6JQpRCiK8jNOmLQr//3a+Zvnc8Tpz3BuL7j9lk/f/Uurn/ha04+KoN/XVGI1SzXsgnRU8jNOnqx28fdTkFSATd+fCOrq1bvs37qiL7c/3/H8OmGSn756krCYfmRJUSskXCPQUn2JJ447QlSHClc99F1bK7bdxiCS8bl8cszhvDmip387p21Mg6NEDFGwj1G9XH24V+n/QurycrMD2ZS0liyzzbXTxrI1Sf0599fbuMfn8hQwULEEgn3GJabmMvs02bjDXn50Qc/otLTtgOTUoo7zx7G/43O5k8fbOTVZTsO8EpCiJ5Gwj3GDU4ZzOOnPk61t5qZH86k3tf2KlWTSTHr+yM5cVA6d7yxmq+La6NUqRCiI0m49wIjM0byyORH2N6wnes/uh5PwNNmvdVs4tFLR5OV5OC6576Si5yEiAES7r3E8X2P56GTH2JN9Rp+9snP8If8bdYnO208eWUhTb4gM5/7Cm9A+sAL0ZNJuPciU/KncN8J97F412Ju+/w2guFgm/VHZbr4y0WjWLmjjt+8/o30oBGiB5Nw72WmDZzG7eNup6i4iHsX3EtYh9usP/3oLG497SheX17KU19sjVKVQogjZYl2AaLr/WDYD2jwNfDYysdw2VzcNvY2lFIt62/43iDW7WrgD++uY0iWi5MGywieQvQ0cuTeS1137HVcNuwynl/3PP9c9c8260wmxZ8uPJajMl3c8OJytlU1RalKIWJQKACB5k5/Gzly76WUUvxy7C9p9Dfy2IrHcFldXDb8spb18XYL/7qikHMf/YJr5yzjjesn4nJYo1ixEFGiNQR9EPJB0B+Z+lot84G3HprrwFu373TvdYEmOOnnMOXuTi1bwr0XMykT9068F3fAzYNLHyTBlsB5g85rWZ+b6uSxS8dw+dNLuOU/K5l9+XGYTOo7XlGITqB1JCBrwFNjBKTfHXk0ga/RmO7vuc8NwWbjNYwX22uefZfrcNsg36tnWbvYEsCRDHHJxjS1f9vn+ROO7G/SDhLuvZzFZGHWybO4oegG7llwD3aznTP7n9myfuKgdO4+Zzj3zFvDXz/ayK2nD4litaLbCQWN8Ax4Ieg1jmLDAQgHIRwyHjoyDQdbze9eHjQC2FMdCe/qyCMS5LuX79Wzax/KDPYEsLki03gjYJ3pYHWAMgGRAxOlvnteAWY7WOxgtoHFARbbnmUW+17zNiOwHUmR8E4Cc/R/5Uq4C2xmG3+b/Dd+8tFP+PX/fo3NbGNK3pSW9VdMyGftzgYe+XgTQ7ISOXtk3yhWK9rY3X4b9LZ/GvJHjkr9rY5QWz2CPuN1d68Levc8Al4jzIM+4/V0B14PoczgTAVnmvFIGwi54/Y8373OkWQE9+4wt8UbIavkV2VrMp67aNEUaGLmBzNZV7OORyY/wonZJ7as8wVDXDJ7Eet2NfLaTyYyvF9iFCuNEeGw0f7qb9rTnOBr3LedtmW+ft91wSO4mliZI0emNmNqthtHnLuPRnc/rA6wxBnLrXGRI1lHZPnu+ch6i8N4DWUGkxlMllbz5si8JTJvMqa2hD2hfYCA1loTbmwkUFaG9noxuVyYk5IwJySgbLbD/xschPb7CbndhBsbCTW6CbsbCTU0EG6ZbyTs8WBOSsSSno45PR1LRgaW9AwsqSkoa8cfwbd3PHcJd9FGg7+Ba9+/li31W3hsymNtbvZR0ehl2t+/xGxSvHXjiaTGd97/VN2K1hDw7Alhf1PkuRv8keUtIR1Z3rK9u+2/a/18r2Eg9k+BI3Gvn/2t5u2JrcI1Mm09v8+0VZOCydy+3Q+FjEBraCAUeYQbGgjVR+YbW883oux2I3iTkjAnJ7XMm5KSMCcltywzJSSglDKCu76eQHk5gV27CJaVEygvM6Zlu5+Xoz37/3upuDjMLhemRBdmV2LL1JzowuRKxBTnQPv9hH0+tD+A9vmMR8BP2Oc35v3GNOz3o71eQu5Gwo1utPfgX57Kbkf7fPtZoTCnpGBJTzceGZHwT8/AOWY0ccce266//74vK+EuDlOtt5Yfzv8hO5t2Mvu02YzqM6pl3aqSOi7850JG5yXz3DXje8ZdnMIho+3WXQFNFeCuBHc5eKqM9t424dwqoNuEcPv/P9FmBwFvPN6GOMIhO9psA5MNbbaDKTJvshpHxcpqzEceGgtam9FhE+GwCR0CHQgY4bN72voRDqPMZpTFYhwlWi0oi9V4brGgrBaw7FmG2RQJsj2hFvb7jOctAdcqBL1ewgcI1d2U1WoEdyRgtc9PqL6eUH39AQMZAJMJc2KiEbrNzfuss/TpgzUzE0tWFtasrMg0E+VwEHa7W75MQg2NhBrqCTc0EmpsiEwbjS+gxkYIhUAplM2GsttRdhsma2Q+ssxks7Vab8fsSsCU4MLkSjC+MFwJxv4luCJfGi7MCQnGF5TFQtjnI1RVRXD3o3L3fCXBqipClVUEK4157feTdt2P6XPzze3+b6rN31vCXRyJquYqrpp/FdXN1Tx5xpMcnXZ0y7o3lpdwy39WcsbRmfzpwmOj00VSa6MJo7EM3GXGtLHMCO2mykiQR6aeKqMHROt/HoJg0IE5IR7ldKLskbZbq9NoJrDF7/tos84J1ni0suMrrcK7pRTvpm14N27Gt3494abDvzZAWa1G0Oz9aFluNcLIagOzGR0KQiCIDrZ+BIxlgUCb5YRCLaFmsttQtj0Bp2xWTHZ7q2U2THa7EWhJiZgSEzEnJhnzu5tFEhNRDkebi+BaC/v9hCNBv+fRQKi+zpivq8Nkd2DJysTaKsQt6enGl9ER0lpDIABW6wFr7Eq7m5cAzImH17Qp4S6OWFlTGVfNvwp3wM1Tpz/FkNQ9PWWe/mIr97+7jrxUJ49fNoahWR3XBh92u/F+9QXB4vWYVDNmmjCFGzCHazAFqjA1VxhBHthPgFocEN+HsCOdYCiZgM+J32Ml0KAJ1PsJVDcRqKwlWFVjtHkDyuHAkppq/GROTcWcloolNc2YpqVjSUvFnJaGOTGRQEkJ3nXr8K5bj3fdOnybNxvhASinE8eQITiGDcU+bBiOoUOxpKeDyWQcOZrNYDIZIWM22pyVSRnLTCZjO7O5W4SQ6L4k3EWH2NG4g6vmX0UwHOTfU//NgKQBLeuWbK3hhhe/psEb4PfnHcP3j8s55NcPlRfjXfQh3hVL8W7YiHdbJf6aAC3d0/ZDmRWmOBvmeAemhHhMrkTMSSkoRzyBimoCpaUEKytb9WcGTCbjyDA7G2u/flizs7H0ySDsdhOsriFUU02wqppgTQ2hamNK8MDd78xpaTiGDYs8jDC35eUZAS5EJ5JwFx1ma/1Wrpp/FRZl4Zmpz5CbmNuyrrLRx89eWs7CLdVcPDaXe6cdjcO6n4ALeAltWoJ36Wd4V6/Cu2k7zSUNBBr2hLjFGcbRLx7HgGwcRx+NdeAIwiqBUMhG2BuM9FpwGyfwGiM9GNyNRhuruxEdCGDN6msEeHY/rP2MqS07G0tm5iH9zNdaE25oMIK/usqY1tVi7dcP+9ChWPv0OaK/qRCHS8JddKiNtRu5+v2ribfE88zUZ+ibsKevezAU5q/vr+WV+cspdAb5+egkkt21BEq2E9z0DYGdxQRq3ISa95x8tSaacOSm4jhqAI5Rx+EYNxlLwdHSV1mIg5BwFx1ubfVarn3/WrLDifyp+lTMm3cQKCsjWFa2bzMIYLKEsThDWF0WLNm52I4aQVzhidjHTcKSmhalvRCiZ2tvuMsVqqLdjjL15YmtpxD4z5u4A0+hcvthzepL3Jhh2M19sXg3Yw1ux+oMsc3eh6r+ZzD+rCuwZI8xThYKIbqMhLs4qFBdHdXPPEPtc89j8XjQk8Zxx6CVbE6vACpQWpMSDtPHZCc9/jjSUoewrtLFqm0w6L0l/Op0GJqRQ0ZcBuZ2XjgjhDgyEu7igFqHeripCdeZU0m/6lIcW//N498Us6HSSUXmMKrS+lOZkEplwE1lcyUbqldR7a/G0TdMCXDjZ48DkJ2QzfWjrufs/mdLyAvRydoV7kqpqcDfADPwpNb6gf1sMwO4F+NSvpVa60s7sE7RhUJ1dVQ/+yy1c54zQn3qVNJ/8hMcnqUwfwb4Gug78Sb6nnQr2F37f41wiBpvDV+VbOf38xdR0VyOJ3sld3xxB09/8zQ3jL6BKXlTpE+3EJ3koCdUlVJmYCNwGlACLAUu0VqvbbXNYOAVYLLWulYp1UdrXfFdrysnVLufUH09Nc8+S82c5wi73bjOOIP066/HkQq8fQts/wJyj4dz/gKZw9v9uk2+IPfMW8Mby0tQ8d+Q1K8Iv6mMYanDuXnMTUzoN0FCXoh26rDeMkqpCcC9WuszIs9/DaC1/mOrbWYBG7XWT7a3QAn37iPkbqLm6aepmTOnbagPyIMv/gxf/MUYdOq0+2D0FYd9crSiwct/vy7hP0u3URpcQFzGR2CtZVjyKG4//hbGZI7p4D0TIvZ0ZLh/H5iqtb428vxyYLzW+oZW27yJcXR/AkbTzb1a6/n7ea2ZwEyAvLy847Zv397+PRIdTodC1L/xBhV//Ruhqipcp59O+k+vxzFkCGz5zDhar9kMx8yAM+6HhI65cEdrzeKtNby8ZAsflMxDpRRhsjTS31nInRNvYVz2yA55HyFiUVd3hbQAg4FJQA7wuVLqGK11XeuNtNazgdlgHLl30HuLw9C0aDHlDz6Ib9064kaNIvMfjxpDkDZVwes/hlUvQ0p/uPwNGDi5Q99bKcXxA9I4fkAa9c2jeG35ZTzzzQtsCc3nmo9+QB/TOK4/9qf834jRcls/IQ5Te8K9FMht9Twnsqy1EmCx1joAbFVKbcQI+6UdUqXoMP5t2yh/6E+4i4qw9OtL9p8fxnXmmSit4es58OHdxjC4J//SuImvNa5T60mKs3L1xCFcPfE+lm7/MbMWzmZ989vc8/VV/H7BMQxOGcKJeUdz+lEjGZhSgNUUnduXNfob2dG4g/zEfOKt8VGpQYhD0Z5mGQtGk8sUjFBfClyqtV7TapupGCdZr1RKpQPLgVFa6+oDva60uXetUH09VY89Ts2LL2KyWkmbOZPUq67E5HBA2Wp495dQvADyJsK5f4WM6N0rdWdjJff971GWVn6Gnz3/CSnMpNuzOTp9MEPTBzMwaSADkgdQkFiAzdwxNw6p89axuX4zm+s2s6V+S8u0wmP0D7CZbEzoN4EpeVOYlDuJFEdKh7yvEO3VocMPKKXOAv6K0Z7+tNb6fqXUfcAyrfU8ZXR1eBiYCoSA+7XWL3/Xa0q4dw0dDFL7n/9Q9fdHCdXXk3TB+fS56SYsGRnQXAuf/AGWPmnc3ee038Koy7rV1aS1zW7mrllO0ebVrK7YSLPaidlegclaDcr4b9eszOS6csl15RJvjcdutuOwOHCYHdgtduIscW2WOSwO7GY7JmWiuKG4TYjXeGta3jvOEseApAHGI3kAOQk5rKxcSVFxEbuadmFSJsb0GcOUvClMyZvSZrwdITqLjC0jcH/+OeUPzsK/eTPO8ePJvP1XOIYNM8YxX/4cFP3WCPjCq+F7dxg3IO7GwmHN6p31fLS2nA/WlbKxZgsmewVpKbWkJdehrNUocwBOuffjAAAXnElEQVRfyIsv6MMb8uINetEHuYuSy+piQPIABiYPbAnzgckDyYrPwqT2/aLTWrOuZh1FxUV8XPwxm+o2ATAsdRhT8qZwav6pDEgaIN07RaeQcO/FArt2seuuu2n64gus+Xlk3nYbCZMnG2FTsgze/QXsXA55E+CshyDrmGiXfFhKaj18vL6CD9eWs2hLNYGQxmJSDOubyOi8ZEblGo9+KRZ8IR/eoBdfyEdzsBlfyEcwHCTXlUt6XPoRBfH2hu0UFRdRVFzEqspVABQkFjA5bzIj0keQHpdOuiOdtLg0nFZnR+2+6KUk3HuppiVLKL35FrTXS/qNN5L6g0uNu8O7K+Cje2HFC+DqC6f9Do75fswMsdvoDbB4Sw0rdtSxfEctK3fU4/YZN9tIcVoZlZvM6LwURuclc2xuMomddGvACk8FnxR/QlFxEUvLlhLUbW/4EWeJM8I+Lp00RxppcWltnvdN6Et+Yj5xls49kS16Lgn3XkZrTe1zz1P+4IPY8vLI+cej2AcMgFAAlsyGTx+AQDNM+Cmc/IsDDhsQK0JhzaYKN8uLa1leXMeKHXVsrGhEa+P7bGBGAqNykxncJ4GBGQkMyIgnN9XZoTf8dvvdlLpLqW6upspbRVXznkd1c7Ux9VZT76vf599mxWdRkFhA/6T+FCQWUJBUQP/E/mTGZ+63qUh0f8FwkOUVyykqLmJc1jgm5x1eF2MZ8rcXCXu9lN1zD/Vz55EweTL9Zj2IOSHBuBDpvdugcj0MOhWmPgDpg6NdbpcwmxRDslwMyXJx8bg8wDi6X1VS3xL4n26o5L9flbT8G4tJkZfmZEB6AgMz4ltCf0BGAqnxh94bJ8GW0Oa+swfiD/mp8dZQ6amktKmUbfXb2NawjW3125i3eR5Nre4VG2eJIz8xvyXws5xZmE1mTMqEQqGUwoTJeK4UJmXCxJ55gJAOEdZhYxo2pruXBcPBPesiNxXvG9+XvMQ88lx5OCyOQ/47RIM/5GdFxQoW7FzA9obtpMelkxWfRWZ8JpnOTLKcxnxH9bI6EF/Ix6KdiygqLuLTHZ9S66vFZrKRHpfOZDr2+pG9yZF7DxfYuZOSG27Eu3Yt6TfeQPpPfoJyl8H822HtXEjON0J9yJkx0wTTkeqbA2ypdLO5soktlW62VDaxpcrNtioP/lC4Zbtkp5UB6fEclelq+dIYkukiLcHeqfVpralsrmwJ/K31W1uCv9RdetCTxR1JociKzyIvMY+CxALyE/NbHv0S+rX7GoSwDuMNeltOeLtsLly2I/slqbVmW8M2FuxcwIKdC1hatpTmYDMWZSHHlUO1t5pGf+M+/y7VkUqmM3NP6MdnkenMJMeVQ05CzmGdj2n0N/K/kv9RVFzEF6Vf4Al6SLAmcHLOyUzJm8KJ2Sce0bkXaZbpBZoWLab0llvQgQD9HpqFa9IkoxfM+3dCyGdchDTxZ2DtGUdb3UkorCmp9bClsonNlW62VDWxucLNxvJGaj2Blu3SE+wMzXJxVKaLoZHQH5yZgNPW+T+KfSEfNc01hAkT1mHjvq86TJgwaFrm915uUsaRvVmZMZvMmJVx5G8xWVrWWZQFk8mE1ppSdynbG7a3eWxr2NYmLC3KQrYrmzxXHmaT2QjvVgHeHGxumfeFfPvsS6ojlfzEfPJceRQkFZDnyiM/MZ9cV+4Bg7DeV8/iXYtbAn1X0y4A8hPzmdB3AhP7TWRc33EtF515Ah7KPGWUN5VT7imnvKm8zfOypjIa/A1t3sNhdtAvoV9L2Oe4cshOyG55vru2quYqPtlhnGtZvGsxwXCQNEcak/MmMyVvCuOyxmE1d8x5Hgn3GKa1pnbOHMpnPYStoICcR/+OPdkEb/0MtnwK+SfCtEcgbWC0S405Wmsq3T42lDXueZQ3srG8EW/AONJXCvJSnQzJdDEgI4H8NCf5qU5yU530S47DHANDKmitqfPV7RP6Oxp3oNEt1xM4LA7izHEt8/s8NzvavE5xQzEVzW0HlO3j7ENBYgF5iXnku/LxBD18ufNLVletJqzDuKwuxvcdz4R+RqDnuHIOe792fwGUNpZS6i6lpLGEEncJpe5SdjTuaNNEBsaXUqojlc11m9FochJyjOse8qcwMn1kp9y3QMI9RoWbm9l19z00vPUWCadOod8f/oB5/X/gw3uMVDntt3Dc1d3qQqTeIBTW7KjxsD4S+BvLG1lf1kBxjYdAaM//Y1azIifFCPr8VCd5qU7y0pzkpxnzXXHE3915Ah6KG4vbfGkUNxjPa321mJSJEekjOKHfCUzsN5ER6SOwmDr/76a1pt5XT4nbCPySRuNR2VzJiLQRTM6bzFEpR3X69Q0S7jHIX1JKyc9uxLduPRk3/Yy08yej3r7JGDZg4BRj2IDkvGiXKVoJhTW76psprvFQXO2huMbD9lbz9c2BNtunJ9jISXGSkxJHbqqT3Fbz/ZId2C29+w5W9b56TMp0xG30PZn0lokxTQsXUnrLrehQiNzHHiXB9g3MPgksdpj+GIy6VE6YdkNmk4qEtZOJ+2klq/cEIoHfxPZqDyW1HnbUNPNNaT3vrylrc9SvFGS6HOSmxrWEfnZKHJmJDrKSHGS6HCQ7rTF9ZWySPSnaJfQYEu7dWKixEffnn+MuKqJh/vvYBvQn97c3Y/vqd7DzaxhyNpzzZ3BlRbtUcZiSnFaOcSZxTM6+oRUKa8obvOyo8VBS28yOSPCX1HpYvLWGN1c0E97rh7fNYiIz0U5WooPMyCMr0UGfVsvSXXbibeaY/hIQEu7dTqC8HPfHH9P4URFNS5ZAIIA5LY2Uiy8iY7wZ8zsXgyMRvv80HH2+HK3HMLNJ0S85jn7JcYzfz/pAKExZvZeKRi9l9T7KGrxUNHgpa/BS3uBlzc4GitZV0BwI7fNv7RYT6Ql20hNspCfYSWuZ7lm2e32K0ybj6vdAEu5RprXGv2ULjR8V0VhUhHeVMTaJLT+f1CsuxzXpFOLiylD/mwULv4ERF8CZsyA+PcqVi2izmk1Gu3zqgftMa61p9AUpr/dS3uCjvMFLdZOPKrefqkYfVU1+dtV7Wb2znmq3n+DePwUwTgJnJjrom+TYaxpHVpLRJNTHZe/Qq3vFkZNwjwIdDtO8YiWNRR/h/qgIf+R2g46RI8m45RZcUyZjs9eiVr0MH18EzTXg6gcXvQDDzoly9aInUUqR6LCS6LAyOPO7T0KGw5oGb4AqdyT83T6qGn2URb4UdtU3s2ZnAx+tK2/p9rnnfYw+/32THKTG20iOs5LstJEUZyXZaSXFaSPJaW1ZnhxnJTHOGhPdQrsrCfcuFGpooO7116l94UUCO3aA1Ur8+PGk/vAqEr43GautGVa9Au9dBNWbwOKAoWfDyIuNW92Z5eMSncdkUkbwOm0M+o7b5WqtqW8OUNbgZVe9l/L6yDTyvKbJz5bKJuo8fhq8wQO/EJDosJCWYCcjwU6Gy3ikJ9ha5jMSHGS4jGYj+WVwaCQtuoBv82Zqnn+e+rnz0B4PcYXHkfGzG0mYNAmzNQxr3oR3rjS6NAIUnAQn3AzDp4FDegeI7kWpPV8CQ7MSv3PbUFjT0BygrjlArcdPvSdAXbOfOk8g8vBT3eSnstHHurIGPv/WR+MBvhBSnFYyXHaSnTbibWacNgtOm9l42C04rWbibGbi7buXG9N4u4VEh4XEOOMXjM3SO74kJNw7iQ6HcX/2GbXPPU/TggUom43Ec84h9bIf4BgyGDYVwfwbYf27xlABaYNh8l0wcob0VRcxw2xSpMTbSIm30Z/23XvWGwhR5fZR2Rh5uH1UNfqpdHupbPRR6wlQ5fbj8Xto9odo8odo9ofajAX0XRxWE0mRoDcCf0/wJ8VZSYyzkBxnI9lpNCGlRKbJTmuP+vUg4d7BQo2N1L/+OjUvvEiguBhLZiYZN99M8oXfx+LdBiufgbdfA08VONPguCvh2Iuh3xjp+SIE4LCaW64NOBSBUBhPJOib/EFj6gvS5A/S6A1S3xygoTlAgzcYmQaobza+KLZUNbWsC+3npPJuCXZLJPSN8wi7zx8kxVlxRb4kXA5LyxfHnnlLl1+AJuHeQXxbtlD7/AvUvfmm0fQyZgx9brkZ19ghqLWvw0tToWojmO0wZKrRjj7oVLB07pCjQvQWVrOJpDjjqPxwaa1x+4LUeYzgr/X4qfUEqI9Mdzct1Xr81DUHKKltptbjp/EgXwpgXINgnNy2cOn4PK49acBh19keEu6HSWuNf/Nm3J99hvuTT/EsW4ayWkk8+2xSZpxHHBtg5aPw6BfGP8ibCOf+FIafB3HJ0S1eCLFfSilcDisuh5XcQ/h3Wms8/hAN3gCNrX4Z7JkP0uAN0NAcpNEbIC2h8w/qJNwPQdjjoWnxYtyff07TZ58T2LkTAPtRR5F+w09JGZuJpfgdeHcaBL2QNgi+dyeMvBBSCqJbvBCi0yiliLdbiLdb6NtN+kBIuB+Ef/t23J99jvvzz/EsWYL2+1FOJ/ETJpA280ckDHRirfgc1vwF3quCuFQYfbnRjp59nLSjCyGiQsJ9LzoUwrNkCe5PP8X92ef4t20DwNa/PymXXELCSScQl+HD9O27sO4uWF9h9Ec/6gxpRxdCdBsS7hHejRtpmDeP+nlvEayoQNntOMePI+Wyy0g4YSK28DZY+yYsuMro6WJ1wuDTYfh0Y2pPiPYuCCFEi14d7sHKSurfeYf6efPwrV0HFgsJJ51E0m9+TcKJEzGVLTHuQ/rKncYQANZ44wj96POMI3Rb+/rtCiFEV+t14R72emksKqJ+7lyavlwAoRCOESPIvOMOEs8+C0uoChY+Co/+GLx1YHMZXReHnweDpoA1Ltq7IIQQB9Urwl2Hw3iWLqN+3lwa579PuKkJS9++pF1zDUnTp2EfOBBKvoIPboT17xht6MOnGYE+cLLcYFoI0eO0K9yVUlOBvwFm4Emt9QMH2O4C4L/AWK11VO+hFygrw7N4MU1LltC0YCHBXbswOZ24zjiDpOnTcY4ba9ysYPPH8MxNsO1/4EiGU26DcTNlSF0hRI920HBXSpmBfwCnASXAUqXUPK312r22cwE3AYs7o9CDCVZW0rR4SSTQFxPYXgyAOSkJ57ixuG69FdepUzDFxUE4ZJwc/eIvULbKGE73jD/AmCvlxKgQIia058h9HLBJa70FQCn1MjAdWLvXdr8DHgR+2aEVHkCwpgbPkiU0LV6MZ/ES/Fu2AGByuXAWFpJyySXEjx+PfcgQlCky2E/AC8uehi8fgdqtxmBd0/8Bx8yQ7otCiJjSnnDPBna0el4Cbe/6pZQaA+Rqrd9RSh0w3JVSM4GZAHl5hzfyofuLL6l48AF8324CwOR0Eje2kOQLLsA5fjyOYUNR5r0G6PHWG6G+8DFoqjAuLjr9d8Y9SE09Z5Q3IYRoryM+oaqUMgF/Bq462LZa69nAbIDCwsLvHmXnAMyJLix9Mkk8dxrx48fhOPpolGU/uxFoNobVXTsXNrwH/kbj5OiJtxjjpcuVo0KIGNaecC+FNmPo5ESW7eYCRgCfRu6mngXMU0pN64yTqnEjR5L31JP7X+lzw6YPjUDf+AEEmozhAI4+D8ZeC/1GdXQ5QgjRLbUn3JcCg5VS/TFC/WLg0t0rtdb1QEvXEqXUp8Avuqy3jLcBNr5vnCDd9JExYFd8Bhx7kXH1aP6Jcns6IUSvc9DU01oHlVI3AO9jdIV8Wmu9Ril1H7BMaz2vs4vcR3Ot0dSydh5sLoKQH1x9YcwVRqDnTQBT1w6ML4QQ3Um7Dmm11u8C7+617O4DbDvpyMv6Dqtfg9dnQjgIiTkw9kdGoOeMlZOjQggR0fPaK/qNgQk/hWHTIVtuTSeEEPvT88I9tT+cdl+0qxBCiG5N2jGEECIGSbgLIUQMknAXQogYJOEuhBAxSMJdCCFikIS7EELEIAl3IYSIQRLuQggRgyTchRAiBkm4CyFEDJJwF0KIGCThLoQQMUjCXQghYpCEuxBCxCAJdyGEiEES7kIIEYMk3IUQIgZJuAshRAyScBdCiBgk4S6EEDFIwl0IIWKQhLsQQsQgCXchhIhBEu5CCBGDJNyFECIGSbgLIUQMale4K6WmKqU2KKU2KaVu38/6W5VSa5VSq5RSRUqp/I4vVQghRHsdNNyVUmbgH8CZwHDgEqXU8L02Ww4Uaq1HAv8FZnV0oUIIIdqvPUfu44BNWustWms/8DIwvfUGWutPtNaeyNNFQE7HlimEEOJQtCfcs4EdrZ6XRJYdyDXAe/tboZSaqZRappRaVllZ2f4qhRBCHJIOPaGqlLoMKAQe2t96rfVsrXWh1rowIyOjI99aCCFEK5Z2bFMK5LZ6nhNZ1oZS6lTgDuAUrbWvY8oTQghxONpz5L4UGKyU6q+UsgEXA/Nab6CUGg08AUzTWld0fJlCCCEOxUHDXWsdBG4A3gfWAa9ordcope5TSk2LbPYQkAC8qpRaoZSad4CXE0II0QXa0yyD1vpd4N29lt3dav7UDq5LCCHEEZArVIUQIgZJuAshRAyScBdCiBgk4S6EEDFIwl0IIWKQhLsQQsQgCXchhIhBEu5CCBGDJNyFECIGSbgLIUQMknAXQogYJOEuhBAxSMJdCCFikIS7EELEIAl3IYSIQRLuQggRgyTchRAiBkm4CyFEDJJwF0KIGCThLoQQMUjCXQghYpCEuxBCxCAJdyGEiEES7kIIEYMk3IUQIgZJuAshRAyScBdCiBjUrnBXSk1VSm1QSm1SSt2+n/V2pdR/IusXK6UKOrpQIYQQ7XfQcFdKmYF/AGcCw4FLlFLD99rsGqBWaz0I+AvwYEcXKoQQov3ac+Q+Dtiktd6itfYDLwPT99pmOvBsZP6/wBSllOq4MoUQQhwKSzu2yQZ2tHpeAow/0DZa66BSqh5IA6pab6SUmgnMjDx1K6U2HE7RQPrer90LyD73DrLPvcOR7HN+ezZqT7h3GK31bGD2kb6OUmqZ1rqwA0rqMWSfewfZ596hK/a5Pc0ypUBuq+c5kWX73UYpZQGSgOqOKFAIIcSha0+4LwUGK6X6K6VswMXAvL22mQdcGZn/PvCx1lp3XJlCCCEOxUGbZSJt6DcA7wNm4Gmt9Rql1H3AMq31POAp4Dml1CagBuMLoDMdcdNODyT73DvIPvcOnb7PSg6whRAi9sgVqkIIEYMk3IUQIgb1uHA/2FAIsUgptU0p9Y1SaoVSalm06+kMSqmnlVIVSqnVrZalKqU+VEp9G5mmRLPGjnaAfb5XKVUa+axXKKXOimaNHUkplauU+kQptVYptUYpdVNkecx+zt+xz53+OfeoNvfIUAgbgdMwLqZaClyitV4b1cI6mVJqG1CotY7ZCz2UUicDbmCO1npEZNksoEZr/UDkizxFa/2raNbZkQ6wz/cCbq31n6JZW2dQSvUF+mqtv1ZKuYCvgPOAq4jRz/k79nkGnfw597Qj9/YMhSB6IK315xg9rVprPazFsxj/U8SMA+xzzNJa79Jafx2ZbwTWYVzdHrOf83fsc6fraeG+v6EQuuQPFWUa+EAp9VVkCIfeIlNrvSsyXwZkRrOYLnSDUmpVpNkmZpooWouMHDsaWEwv+Zz32mfo5M+5p4V7b3Wi1noMxsicP438nO9VIhfF9Zw2xMP3ODAQGAXsAh6ObjkdTymVALwG3Ky1bmi9LlY/5/3sc6d/zj0t3NszFELM0VqXRqYVwBsYzVO9QXmkzXJ322VFlOvpdFrrcq11SGsdBv5FjH3WSikrRsi9oLV+PbI4pj/n/e1zV3zOPS3c2zMUQkxRSsVHTsSglIoHTgdWf/e/ihmth7W4EpgbxVq6xO6Qi/g/YuizjgwD/hSwTmv951arYvZzPtA+d8Xn3KN6ywBEugz9lT1DIdwf5ZI6lVJqAMbROhjDRbwYi/uslHoJmIQxFGo5cA/wJvAKkAdsB2ZorWPmBOQB9nkSxk91DWwDftyqPbpHU0qdCPwP+AYIRxb/BqMNOiY/5+/Y50vo5M+5x4W7EEKIg+tpzTJCCCHaQcJdCCFikIS7EELEIAl3IYSIQRLuQggRgyTchRAiBkm4CyFEDPp/KRjD1H2g6OMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.ylim((0, max(1, np.max(losses))))\n",
    "plt.plot([it for it in range(len(losses))], losses)\n",
    "plt.plot([it for it in range(len(accuracies))], accuracies)\n",
    "plt.plot([it for it in range(len(val_losses))], val_losses)\n",
    "plt.plot([it for it in range(len(val_accuracies))], val_accuracies)\n",
    "#plt.plot([0, len(losses)-1], [1, 1])\n",
    "#plt.plot([0, len(losses)-1], [.5, .5])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}