mnist_continual.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:100% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.6.8\n",
      "Sat Sep 25 14:22:58 2021       \r\n",
      "+-----------------------------------------------------------------------------+\r\n",
      "| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |\r\n",
      "|-------------------------------+----------------------+----------------------+\r\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\r\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\r\n",
      "|                               |                      |               MIG M. |\r\n",
      "|===============================+======================+======================|\r\n",
      "|   0  GRID V100D-32Q      On   | 00000000:02:00.0 Off |                  N/A |\r\n",
      "| N/A   N/A    P0    N/A /  N/A |   3601MiB / 32768MiB |      0%      Default |\r\n",
      "|                               |                      |                  N/A |\r\n",
      "+-------------------------------+----------------------+----------------------+\r\n",
      "                                                                               \r\n",
      "+-----------------------------------------------------------------------------+\r\n",
      "| Processes:                                                                  |\r\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\r\n",
      "|        ID   ID                                                   Usage      |\r\n",
      "|=============================================================================|\r\n",
      "|    0   N/A  N/A       853      C   ...terThesis/env/bin/python3     1409MiB |\r\n",
      "+-----------------------------------------------------------------------------+\r\n"
     ]
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
    "%reset -f\n",
    "%config Completer.use_jedi = False\n",
    "from platform import python_version\n",
    "print(python_version())\n",
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_style(\"white\")\n",
    "import os\n",
    "import math\n",
    "import copy\n",
    "import time\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import random_split, DataLoader\n",
    "import statistics\n",
    "from tqdm import tqdm\n",
    "import torchvision\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)\n",
    "    \n",
    "class StopExecution(Exception):\n",
    "    def _render_traceback_(self):\n",
    "        pass\n",
    "    \n",
    "def stop():\n",
    "    raise StopExecution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change root_dir to your directory, MNIST should download itself\n",
    "\n",
    "transforms = torchvision.transforms.Compose([\n",
    "    torchvision.transforms.ToTensor()\n",
    "])\n",
    "    \n",
    "root_dir = \"/data/s2967057/MNIST/\"\n",
    "train = torchvision.datasets.MNIST(root=root_dir, train=True, download=True, transform=transforms)\n",
    "test = torchvision.datasets.MNIST(root=root_dir, train=False, download=True, transform=transforms)\n",
    "\n",
    "params = {'batch_size': 64,\n",
    "          'shuffle': True,\n",
    "          'num_workers': 6,\n",
    "          'pin_memory': True}\n",
    "\n",
    "trainloader = DataLoader(train, **params)\n",
    "testloader = DataLoader(test, **params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "These are the boolean conceptor operations. Adopted directly from Jaeger's 2017 report. \n",
    "NB: these operations work only on conceptors with singular values between 0 and 1, \n",
    "which is completely fine for this project. If you want to use them for other matrices use the \n",
    "operations defined in terms of the svd, also explained in Jaeger 2017, adopted by Xu He found here:\n",
    "https://github.com/he-xu/CAB/blob/master/logic.py\n",
    "'''\n",
    "\n",
    "def NOT(C):\n",
    "    dim = C.shape[0]\n",
    "    not_C = np.eye(dim) - C\n",
    "    return not_C\n",
    "\n",
    "def AND(C, B, tol = 1e-14):\n",
    "    dim = C.shape[0]\n",
    "    C_and_B = np.linalg.inv(np.linalg.inv(C) + np.linalg.inv(B) - np.eye(dim))\n",
    "    return C_and_B\n",
    "\n",
    "def OR(R, Q):\n",
    "    R_or_Q = NOT(AND(NOT(R), NOT(Q)))\n",
    "    return R_or_Q\n",
    "    \n",
    "def plot_spectrum(S):\n",
    "    x = np.linspace(0,S.shape[0],S.shape[0])\n",
    "    plt.autoscale(True)\n",
    "    plt.plot(x, S)\n",
    "    plt.show()\n",
    "\n",
    "def conceptor(X, alpha=4):\n",
    "    R = (X.T).dot(X) / X.shape[0]\n",
    "    U, S, _ = np.linalg.svd(R)\n",
    "    S_C = (np.diag(S).dot(np.linalg.inv(np.diag(S) + alpha ** (-2) * np.eye(X.shape[1]))))\n",
    "    plot_spectrum(np.diag(S_C))\n",
    "    C = U.dot(S_C).dot(U.T)\n",
    "    return C, S, np.diag(S_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters for kernel size and padding\n",
    "k = 5\n",
    "p = 2\n",
    "\n",
    "'''\n",
    "All the operations are done by hand, because this made it easier to get activations without having to use hooks and \n",
    "allowed for using a weight matrix which is the sum of a constant matrix and a variable matrix.\n",
    "First two layers are conv. layers. To get an idea of how this works when done without using\n",
    "conv2d: https://pytorch.org/docs/stable/generated/torch.nn.Unfold.html\n",
    "Essentially a conv. layer is implemented by flattening patches of an image, flattening the weight filter \n",
    "and performing a multiplication. Unfold does the flattening with consideration for kernel size, padding, stride and such.\n",
    "In this case weight filters don't need to flattened as they are initialized flat.\n",
    "'''\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        # w1, w2 are conv. layers \n",
    "        self.w1 = nn.Parameter(torch.empty((k*k*1, 16)))\n",
    "        self.w2 = nn.Parameter(torch.empty((k*k*16, 32)))\n",
    "        # w3, w4 linear layers\n",
    "        self.w3 = nn.Parameter(torch.empty((7*7*32, 7*7*16)))        \n",
    "        self.w4 = nn.Parameter(torch.empty((7*7*16, 1)))\n",
    "        \n",
    "        self.w1_old = nn.Parameter(torch.zeros((k*k*1, 16), requires_grad=False))\n",
    "        self.w2_old = nn.Parameter(torch.zeros((k*k*16, 32), requires_grad=False))\n",
    "        self.w3_old = nn.Parameter(torch.zeros((7*7*32, 7*7*16), requires_grad=False))\n",
    "        self.w4_old = nn.Parameter(torch.zeros((7*7*16, 1), requires_grad=False))\n",
    "        self.act = nn.ReLU()\n",
    "        \n",
    "        self.pool = nn.MaxPool2d(kernel_size=2)\n",
    "        \n",
    "        # only the incremental weights are changed\n",
    "        self.weights = [self.w1, self.w2, self.w3, self.w4]\n",
    "        \n",
    "        # used for multi-head\n",
    "        self.head = []\n",
    "        \n",
    "    def forward(self, x):\n",
    "        self.x0 = F.unfold(x, k, 1, p, 1).transpose(1,2)\n",
    "        # conv operation\n",
    "        self.x1 = F.relu(self.x0.matmul(self.w1 + self.w1_old)).transpose(1,2)\n",
    "        self.x1 = self.x1.view(self.x1.shape[0], 16, 28, 28)\n",
    "        self.x1 = self.pool(self.x1)\n",
    "        self.x1 = F.unfold(self.x1, k, 1, p, 1).transpose(1,2)\n",
    "        # conv operation, flattened afterwards to perform linear operation\n",
    "        self.x2 = F.relu(self.x1.matmul(self.w2 + self.w2_old)).transpose(1,2)\n",
    "        self.x2 = self.x2.view(self.x2.shape[0], 32, 28//2, 28//2)\n",
    "        self.x2 = self.pool(self.x2)\n",
    "        self.x2 = torch.flatten(self.x2, 1)\n",
    "\n",
    "        self.x3 = F.relu(self.x2.matmul(self.w3 + self.w3_old))\n",
    "        \n",
    "        self.x4 = self.x3.matmul(self.w4 + self.w4_old)\n",
    "        return torch.squeeze(self.x4)\n",
    "    \n",
    "    def initialise(self):\n",
    "        nn.init.xavier_uniform_(self.w1, gain=nn.init.calculate_gain('relu'))\n",
    "        nn.init.xavier_uniform_(self.w2, gain=nn.init.calculate_gain('relu'))\n",
    "        nn.init.xavier_uniform_(self.w3, gain=nn.init.calculate_gain('relu'))    \n",
    "        nn.init.xavier_uniform_(self.w4, gain=nn.init.calculate_gain('sigmoid'))      \n",
    "\n",
    "    \n",
    "model = Net().to(device)\n",
    "model.initialise()\n",
    "\n",
    "ce_loss = nn.BCEWithLogitsLoss()\n",
    "optimizer = optim.Adam(model.weights)\n",
    "\n",
    "# /2 instead of sqrt for speed. Also done in Xu He paper, works just as well\n",
    "def l2_norm(x):\n",
    "    return torch.sum(torch.pow(x, 2)) / 2\n",
    "\n",
    "# l2 weight decay\n",
    "def l2_loss(params):\n",
    "    loss = 0\n",
    "    for p in params:\n",
    "        loss += l2_norm(p)\n",
    "    return loss\n",
    "\n",
    "'''\n",
    "Conceptor regularization by pseudo-rehearsal. Details on this regularization in Xu He 2018 \n",
    "https://marcpickett.com/cl2018/CL-2018_paper_55.pdf\n",
    "Here defined for convolutions. Essentialy: perform forward pass with new weights and old weights\n",
    "take the difference and multiply with conceptor. Because it's a conv operation, activation map\n",
    "has to be \"unfolded\" again before multiplying with conceptor\n",
    "'''\n",
    "def c_loss(m, c1, c2, c3):\n",
    "    # Pseudo-rehearsal, so create noise tensor\n",
    "    noise1 = torch.cuda.FloatTensor(model.x0.shape).normal_()\n",
    "    # Old weights activation\n",
    "    a_old1 = F.relu(noise1.matmul(m.w1_old)).transpose(1,2)  \n",
    "    # New weights activation\n",
    "    a_new1 = F.relu(noise1.matmul(m.w1 + m.w1_old)).transpose(1,2)\n",
    "#     a_old1 = F.max_pool2d(a_old1.view(a_old1.shape[0], 16, 28, 28), kernel_size=2)\n",
    "#     a_new1 = F.max_pool2d(a_new1.view(a_new1.shape[0], 16, 28, 28), kernel_size=2)\n",
    "\n",
    "    # Take diff of activations, reshape to multiply with conceptor\n",
    "    # Doing .view before unfold is required, because unfold only works with properly sized\n",
    "    # activation maps\n",
    "    diff1 = (a_new1 - a_old1).view(a_new1.shape[0],16,28,28)\n",
    "    diff1 = F.unfold(diff1, k, 1, p, 1).transpose(1,2)\n",
    "    diff1 = diff1.matmul(c1)\n",
    "    reg1 = l2_norm(diff1)\n",
    "    \n",
    "    # Same as before, but here difference is flattened, because next layer is a linear layer\n",
    "    noise2 = torch.cuda.FloatTensor(model.x1.shape).normal_()\n",
    "    a_old2 = F.relu(noise2.matmul(m.w2_old)).transpose(1,2)  \n",
    "    a_new2 = F.relu(noise2.matmul(m.w2 + m.w2_old)).transpose(1,2)\n",
    "    a_old2 = F.max_pool2d(a_old2.view(a_old2.shape[0], 32, 28//2, 28//2), kernel_size=2)\n",
    "    a_new2 = F.max_pool2d(a_new2.view(a_new2.shape[0], 32, 28//2, 28//2), kernel_size=2)\n",
    "    diff2 = (a_new2 - a_old2)\n",
    "    diff2 = torch.flatten(diff2, 1)\n",
    "    diff2 = diff2.matmul(c2)\n",
    "    reg2 = l2_norm(diff2)\n",
    "    \n",
    "    # Conceptor regularization for linear layer. Same as for conv. layer, but without the \n",
    "    # reshaping stuff\n",
    "    noise3 = torch.cuda.FloatTensor(model.x2.shape).normal_()\n",
    "    a_old3 = F.relu(noise3.matmul(m.w3_old)) \n",
    "    a_new3 = F.relu(noise3.matmul(m.w3 + m.w3_old))\n",
    "    diff3 = a_new3 - a_old3\n",
    "    diff3 = diff3.matmul(c3)\n",
    "    reg3 = l2_norm(diff3)\n",
    "\n",
    "    loss = reg1 + reg2 + reg3\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_tasks = 10\n",
    "# Accuracy on a single task, pass task number [0,9]\n",
    "def task_accuracy(task):\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    for x,y in testloader:\n",
    "        x,y = x.to(device), y.to(device)\n",
    "        y = F.one_hot(y,10)\n",
    "        y = y[:,task]\n",
    "        model(x.float())\n",
    "        out = torch.squeeze(model.x3.matmul(model.head[task]))\n",
    "        gts = torch.greater(out, 0.5).int()\n",
    "        eqs = gts == y\n",
    "        correct += sum(eqs.int())\n",
    "        total += len(eqs)\n",
    "    return correct/total*100\n",
    "\n",
    "\n",
    "#Accuracy on all tasks\n",
    "def overall_accuracy():\n",
    "    model.w4_old = nn.Parameter(torch.zeros(model.w4_old.shape, device=device))\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    for x,y in testloader:\n",
    "        x,y = x.to(device), y.to(device)\n",
    "        outs = []\n",
    "        for i in range(num_tasks):\n",
    "            model.w4 = nn.Parameter(model.head[i])\n",
    "            out = model(x.float())\n",
    "            outs.append(torch.unsqueeze(out,dim=1))\n",
    "        out = torch.cat(outs, dim=1)\n",
    "        eqs = y == torch.argmax(out, dim=1)\n",
    "        correct += sum(eqs.int())\n",
    "        total += len(eqs)\n",
    "    return correct/total*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 0.09440603567513703\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 1/2 [00:07<00:07,  7.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.007125764152936131\n",
      "Train loss: 0.03965829581077864\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:15<00:00,  7.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.0038450215205366304\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAluElEQVR4nO3deXhTZaIG8DdL032hWwI0lKWlbIWiICAFJd3oBqWAIypwVfSOI4uCoujAKKMzyijaGRXp4D4Oc1kqCnVEaSkF2YelQBEoNLYUklK60r3pd/9AM1bAFkl6kvT9PQ9PzMmh5+XjyevhO5tMCCFAREQORS51ACIisjyWOxGRA2K5ExE5IJY7EZEDYrkTETkgpVQbHjVqFHr27CnV5omI7FJJSQn27dvX7nqSlXvPnj2RkZEh1eaJiOxSampqh9bjtAwRkQNiuRMROSCWOxGRA2K5ExE5IJY7EZEDarfclyxZgjFjxiApKem6nwsh8NJLLyEmJgbJyck4ceKExUMSEdHNabfcU1NTsWbNmht+npubC71ej6+//hp//OMf8cILL1gyHxER/QrtlvvIkSPh7e19w8+zsrKQkpICmUyGiIgIVFdXo7S01KIhf6rsSiO25F0A71RMRHRjtzznbjQaodFozO81Gg2MRuOt/tgbOqgvx9x/HsamIyVW2wYRkb2zuwOqugFqjAjuhkXrjmLfuctSxyEiskm3XO5qtRoGg8H83mAwQK1W3+qPvSGVUo6PHroDQd3c8GzGMTQ0m6y2LSIie3XL5a7T6bBp0yYIIXDkyBF4enoiMDDQEtluyN1ZiZenDEFhWS3WHSy26raIiOxRuzcOW7hwIfbv34+KigqMHz8e8+bNQ0tLCwBgxowZuOuuu7Bjxw7ExMTA1dUVf/rTn6weGgDGhQYgvKc3/rmvCDNHB0Mmk3XKdomI7EG75b5y5cpf/Fwmk+EPf/iDxQLdjBl39MJznx3DoaJK3B7cTZIMRES2yO4OqP7UpIgecFcp8NFuvdRRiIhsil2Xu4ezEtNuD8IXRy9gf2G51HGIiGyGXZc7ADw9cQBcnRT44ijPeyci+pHdl7uHsxJRAwPxxZELqG/iaZFERIADlDsAzBwdjOqGFu69ExH9wCHK/Y4+vghTe+Kj3d/znjNERHCQcpfJZHhgTDDyL1bjxIVqqeMQEUnOIcodAJKHdoezUo5/HSiSOgoRkeQcptx93FS4q38Adpy+JHUUIiLJOUy5A8CYfn4oLq9HQekVqaMQEUnKoco9brAGni5KLFp/lAdWiahLc6hy7+Hjit/dHYKjxZWoqGuWOg4RkWQcqtwBYHAPLwBALufeiagLc7hyHxviD3eVApuPXpA6ChGRZByu3BVyGe4b1Qs5py/hUk2j1HGIiCThcOUOAPeM0MLUKvAF996JqItyyHIPVXticA8vbD1uaH9lIiIH5JDlDgAje/viwPflnJohoi7JYct9ckQPCAFsP1UqdRQiok7nsOU+LMgHQd1c8eG3el7QRERdjsOWu1wuw2/v6of8i9U4VFQhdRwiok7lsOUOAFOG94SnsxL/d6BY6ihERJ3Kocvd3VkJ3cBAZBwqQdHlOqnjEBF1GocudwB4KjYMLa0Cm47wEXxE1HU4fLlrfd0wqo8v/rW/CE0trVLHISLqFA5f7gDwyLi+uFDVgOzveFokEXUNXaLcx/Tzg5NChq0neMUqEXUNXaLc3Z2VGNPPHzmnStHYYpI6DhGR1XWJcgeAmaODUVHXjK94vxki6gK6TLlHDQiEp7MSB/TlUkchIrK6LlPucrkM4UHe2JZfCmN1g9RxiIisqkPlnpubi7i4OMTExCA9Pf2azy9cuICZM2ciJSUFycnJ2LFjh8WDWsIzEwfgcm0jVuWclToKEZFVtVvuJpMJy5cvx5o1a5CZmYktW7agoKCgzTqrVq1CfHw8Nm3ahDfeeAMvvvii1QLfimFaH8QP6Y6Nh86jvokHVonIcbVb7nl5eQgODoZWq4VKpUJiYiKysrLarCOTyXDlyhUAQE1NDQIDA62T1gLuG9ULNQ0t+PLYRamjEBFZTbvlbjQaodFozO/VajWMRmObdebOnYvNmzdj/PjxePTRR/H73//e8kktZFQfX/T1d8fHe/RSRyEishqLHFDNzMzElClTkJubi/T0dCxevBitrbZ5qb9MJsOsMcE4er4K+wt55gwROaZ2y12tVsNg+O+54UajEWq1us06GzZsQHx8PABg+PDhaGxsREWF7d5DPWV4T3i7OuGdnIL2VyYiskPtlnt4eDj0ej2Ki4vR1NSEzMxM6HS6Nut0794de/bsAQCcPXsWjY2N8PX1tU5iC/BxU2H2nb2x4/QlFJfzVsBE5HjaLXelUolly5Zhzpw5SEhIQHx8PEJDQ5GWlmY+sPrss89i3bp1mDRpEhYuXIhXXnkFMpnM6uFvxb0jtZAB+Gi3XuooREQWJxMSPWA0NTUVGRkZUmza7H8+2I/ThhrkLp4ApaLLXM9FRHaso93ZpRtt2u1BuFDVgO2nLkkdhYjIorp0uccN1iDA0xn/d6BI6ihERBbVpcvdSSHHtNuDsO1kKU5cqJI6DhGRxXTpcgeuPqVJpZTj/V16qaMQEVlMly93X3cVpt7WE58fKcF3hmqp4xARWUSXL3cAWBDVHzIZsP7geamjEBFZBMsdgMbbBSN7++KbfCMkOjOUiMiiWO4/iA/vjqLyOnyTb2x/ZSIiG8dy/8GMkVp4OCuxOY+3AiYi+8dy/4FSIUfK8B74Jt/AB3kQkd1juf/ExMHd0dDciqzvODVDRPaN5f4To/tefZDHq199h7qmFqnjEBH9aiz3n1Aq5HgmfgCKy+uxhXPvRGTHWO4/EztIjUHdvfDmN6fRbLLNp0kREbWH5f4zMpkMT8X1x4WqBmRy752I7BTL/Tru7h+I0EAPvLerUOooRES/Csv9OuRyGVKG98Sxkiqcu3RF6jhERDeN5X4D00cEQaWU490dZ6WOQkR001juNxDo6YLfjNBiw3/O826RRGR3WO6/4MmY/nBWKrDy69NSRyEiuiks91/g667CrDHB2HbSiPMVdVLHISLqMJZ7O2bd2RtOCjnStp2ROgoRUYex3NvR08cV024PwhdHL6CitknqOEREHcJy74CZY4LR2NKKtQeKpI5CRNQhLPcOGKDxwoSwALydXYALlfVSxyEiahfLvYOWTx4CkxB49avvpI5CRNQulnsHaX3dcO/IXvj3MQMKy2qljkNE9ItY7jfhobF94KSQYeU3PO+diGwby/0m9PJzw29G9sKWvAsoKK2ROg4R0Q2x3G/S4xP6wUWpwNvbec8ZIrJdHSr33NxcxMXFISYmBunp6ddd58svv0RCQgISExOxaNEii4a0JX4ezkge1h1fHruIsiuNUschIrouZXsrmEwmLF++HB988AHUajWmTZsGnU6HkJAQ8zp6vR7p6elYu3YtvL29cfnyZauGltqsMb2x8VAJ3tl+FsuSB0kdh4joGu3uuefl5SE4OBharRYqlQqJiYnIyspqs866detw//33w9vbGwDg5+dnnbQ2YkhPb8QMVGPjofO4zL13IrJB7Za70WiERqMxv1er1TAajW3W0ev1KCwsxL333ot77rkHubm5lk9qYxbG9kdVfTM+3K2XOgoR0TUsckDVZDLh+++/xyeffILXX38dS5cuRXW1Y98Dvb/aExPCApCeew6Xarj3TkS2pd1yV6vVMBgM5vdGoxFqtfqadXQ6HZycnKDVatG7d2/o9XqLh7U1S5MGocnUivRcnjlDRLal3XIPDw+HXq9HcXExmpqakJmZCZ1O12ad6Oho7N+/HwBQXl4OvV4PrVZrncQ2pG+ABxLCu+O9XYX4/jKvWiUi29FuuSuVSixbtgxz5sxBQkIC4uPjERoairS0NPOB1XHjxsHHxwcJCQmYPXs2Fi9ejG7dulk9vC34Q9IgKBVyrPjqFIQQUschIgIAyIREjZSamoqMjAwpNm1xK78+hb9mF2DNrBGIHqRu/zcQEf1KHe1OXqFqAfOiQtHTxxV/216A1lbuvROR9FjuFuCkkGN+VAiOFlfiqxOG9n8DEZGVsdwtJPW2IISpPbFo3VGU8IEeRCQxlruFOCnkeO9/RsDUKvC3LD5Mm4ikxXK3oKBubrhvVC+s/895FJRekToOEXVhLHcLe3xCCNxVCjyXcYynRhKRZFjuFhbg6YwlCQOxX1+OnNOXpI5DRF0Uy90Kpt0ehJ4+rkjbdoZ770QkCZa7FTgp5JirC8GR4krknOLeOxF1Ppa7lUy7PQhaX1f8ftNxFJfXSR2HiLoYlruVOCnkePu+21B2pRHPbMyTOg4RdTEsdysaGuSDBdGh2H32Mg7qy6WOQ0RdCMvdymaN6Q1/D2csXHcUVXXNUschoi6C5W5lHs5K/GX6UBRX1OHNrNNSxyGiLoLl3gkmhAUiJaInPt1bxPvOEFGnYLl3kkWx/aFUyLBo3RGe+05EVsdy7yRB3dzwXMJA7D1XznPficjqWO6d6J4RWvTydcMfM/PR1NIqdRwicmAs906kUsrx4uTBOHepFn/feU7qOETkwFjunWxCWCDih2jw16wzKCyrlToOETkolrsE/pA8GEq5DMs+P45mE6dniMjyWO4S0Hi7YEnCQOw8U4YPvi2UOg4ROSCWu0QeGB2McaH+eCu7AKU1DVLHISIHw3KX0FOxYahvNuGBNftQ19QidRwiciAsdwkN0/ogfeYInDZeQXouz54hIsthuUtswoBAxAxS453tZ2Go4vQMEVkGy90GPBndH82trVi8MY+3JiAii2C524BBPbzw4qTByD19Ce/t4tkzRHTrWO42YuboYEQNCMTLX57EtwVlUschIjvHcrcRMpkMaTOGI9jXDUs/P46GZpPUkYjIjrHcbYiHsxJ/mHT13jPPf3ac8+9E9Kt1qNxzc3MRFxeHmJgYpKen33C9rVu3IiwsDMeOHbNYwK5mQlggFkSFYuOh8/jn/iKp4xCRnWq33E0mE5YvX441a9YgMzMTW7ZsQUFBwTXrXblyBR9//DGGDRtmlaBdyYKoUESG+OOVL79DcXmd1HGIyA61W+55eXkIDg6GVquFSqVCYmIisrKyrlkvLS0NjzzyCJydna0StCuRy2V4KWUIGk2tmPPRQc6/E9FNa7fcjUYjNBqN+b1arYbRaGyzzokTJ2AwGHD33XdbPGBX1dvfHX+eEo5Txhos35IvdRwisjO3fEC1tbUVr7zyCp555hlL5KGfmHp7EGbcocU/9xUh9zQfzUdEHdduuavVahgMBvN7o9EItVptfl9bW4vTp09j1qxZ0Ol0OHLkCB577DEeVLWQ5xMHoZevGxZvyEN5bZPUcYjITrRb7uHh4dDr9SguLkZTUxMyMzOh0+nMn3t6emLfvn3Izs5GdnY2IiIisGrVKoSHh1s1eFfh4azEH1OG4NKVRjy1/igf7kFEHdJuuSuVSixbtgxz5sxBQkIC4uPjERoairS0tOseWCXLu6t/AJYlDUL2d6V4/evTUschIjsgExJdKZOamoqMjAwpNm23ZqTvxd7Cy9g8NxJDenpLHYeIJNDR7uQVqnbkrfuGw8fVCY98fJC3ByaiX8RytyN+Hs54677bYKxuwJyPD/D2BER0Qyx3OzM2xB/Pxg/A8ZJqPLWe938noutTSh2Abt6cyL6orGvGOzlnEaH1xswxvaWOREQ2hnvudkgul+HpuDDc1T8AL2WexP7CcqkjEZGNYbnbKZlMhtemD4O/hzMeWLMPJy9WSx2JiGwIy92OBXg6Y/1vx8DL1Qnz1x5GBa9gJaIfsNztXA8fV7zxm2EoLKvFvLWHYWrlAVYiYrk7hHGhAXhh0mDsKijDwnVHeAYNEfFsGUfxwOhgGKoa8Nb2AvRXe+LxCSFSRyIiCXHP3YHMiwrBhLAA/GXrKaw/WCx1HCKSEMvdgTgrFVg9cwTu6OOLJRnHkHOqVOpIRCQRlruDUSnl+PvMEQhVe+KhDw9g15kyqSMRkQRY7g7I280Jn84ZBX8PZyxcdwSXahqljkREnYzl7qB83VVYM3sEKuuaMXXVbpTW8C6SRF0Jy92BDQ3ywaoHbkNpTQMeWLMPVxpbpI5ERJ2E5e7gogaqsWbWSBSUXsGCtYfR2GKSOhIRdQKWexcQGeqP5ZOHIOu7UixYewQtfA4rkcNjuXcRD4wOxrPxA/DVCQOeWn8UDc3cgydyZLxCtQv57V39UF1/9T7wVxpNePv+4XBWKqSORURWwD33LmbxxAH44+TB2HbSiDkfHUQtD7ISOSSWexc0c0xvrJg2FN8WlGH2+/tR38QpGiJHw3Lvou4ZocXfZtyG/xRV4L41e1FV1yx1JCKyIJZ7F5Y4tDtW3X8bjpdU4Tfpe6Avq5U6EhFZCMu9i5s4pDvS7h2Oc2W1eHLdEdQ0cA+eyBGw3AkJ4d3x2vRhOHa+Cvev2YeSynqpIxHRLWK5EwBg0rAeePv+25B/oRqT39qFvPOVUkciolvAciezuMEabHjsTjgrFZiRvhefHT4vdSQi+pVY7tRGhNYHGb+7EwO7e2HhuqP4e+45tPKh20R2h+VO11B7ueCTh0chakAgXv7yJB7+6ACaeT8aIrvSoXLPzc1FXFwcYmJikJ6efs3nH3zwARISEpCcnIzZs2ejpKTE4kGpc7mqFPj7rBFYEBWK7acu4aEPD6C8tknqWETUQe2Wu8lkwvLly7FmzRpkZmZiy5YtKCgoaLPOwIEDsXHjRmzevBlxcXH4y1/+YrXA1HlkMhmejOmPpUmDsK+wHA+s2YczxhqpYxFRB7Rb7nl5eQgODoZWq4VKpUJiYiKysrLarDN69Gi4uroCACIiImAwGKyTliTxcGQf/G3GcFysqse0d/dgW75R6khE1I52y91oNEKj0Zjfq9VqGI03/nJv2LAB48ePt0w6shlxgzX4Ym4kAjydMefjg/jX/iKpIxHRL7DoAdXPP/8cx48fx5w5cyz5Y8lGaH3dkPG7OzG8lw+ezTiGld+c5oM/iGxUu+WuVqvbTLMYjUao1epr1tu9ezfeffddrFq1CiqVyrIpyWZ4uThh7SOjETNIjb9mnUHyW9+iuLxO6lhE9DPtlnt4eDj0ej2Ki4vR1NSEzMxM6HS6Nuvk5+dj2bJlWLVqFfz8/KwWlmyDi9PVM2lemz4MJy9WY8o7u5F10ggheD48ka1ot9yVSiWWLVuGOXPmICEhAfHx8QgNDUVaWpr5wOqKFStQV1eHBQsWYPLkyfjtb39r9eAkvWm3B+Hzx8fCxUmOhz86iGc25vHxfUQ2QiYk2t1KTU1FRkaGFJsmC6tvMuG1r0/hvV2FGKDxxOqZtyPYz13qWEQOqaPdyStU6Za5qhRYmjQIb/4mAhcq65GQthMvZ+bDxNsWEEmG5U4WkzK8Jz6fG4k7Q/zx952FmPz2LhSUXpE6FlGXxHIni+rj7470mbdjxdShKLpch4S/7sSn+77nKZNEnYzlThYnk8lwz0gtvpgbiYEaTzz/2XFMe3cP7xFP1IlY7mQ1vf3dsenxsUi7NwLfX67F5Le/xZKMY6is4w3IiKyN5U5WJZPJMDmiJ3IXT8DDY/tg7f4iRK/MxZfHLvK8eCIrYrlTp/B0ccLvkwZh89xIqL2c8btPD2Hqqt04d4kHXImsgeVOnSo8yBufPz4WL04ajNPGK4hP24mVX59CXVOL1NGIHArLnTqdUiHH7Dt7I3vRXZgQFoi/Zhfgrr/k4N0dZ3mFK5GFsNxJMoFeLnh35u1Y+8hohAR44JV/f4c7X8nGugPFnI8nukVKqQMQjennhzH9/LDn7GW8se00Fm/Mw9oDRbhnhBb3jNBCIZdJHZHI7nDPnWzGmH5+WPvIaLw4aTCuNLRgScYxxL2Zi7X7izhdQ3STWO5kUxRyGWbf2RtfPzkeb993G5yVcizJOIY7X8nGyq9PobSmQeqIRHaB0zJkk2QyGRKHdkdCuAZ7z5XjvV2F+Nv2Ary74xwmRfTAw5F9MLC7l9QxiWwWy51smkwmM8/JF5bV4oNvC7H+4Hls+M95RIb44+HIPrirfwDknJcnaoPTMmQ3+vi7Y/nkIdizRIfFE8NwprQGD354ADFv7MA/93FenuinWO5kd3zcVPjd3SHYuViHN38TAVeVAs99dgxj/pyF1zkvTwSA0zJkx1RKOVKG98TkiB7YX3h1Xv6t7QV4d8dZxA7W4J4RWowL8eeUDXVJLHeyezKZDKP6+mFUXz/oy2rx4W49vjh6AZl5FxHs54a4wRrMGhOMoG5uUkcl6jQsd3Iovf3d8cKkwViSMABfHTdg46ESvLerEOm55zAiuBuShnbHxCHdofF2kToqkVWx3MkhOSsVmBzRE5MjekJfVovNRy9gS95FvLA5Hy9szse4UH/EDlIjbogGgZ4senI8LHdyeL393TEvKhTzokJxxliDL45ewOdHLmDp5yew7IsTGNnbFwlDNNyjJ4fCcqcuJVTtiUWxYVgUG4ZThhp8eewivjpuMO/RR2h9cFf/AIzvH4BhQd5QKnhCGdknljt1WWEaT4RpPPFkTH+cvXQF/z52Ed+cLMVfs88gLesMvFyUiAz1x7jQAESG+EPrywOyZD9Y7kQA+gV4YK4uFHN1oaisa8KugjLknr6E3NNl+PKYAQDQ28/NXPYje/vC110lcWqiG2O5E/2Mj5sKSUN7IGloDwghcPbSFew8U4ZdZ8qQcagE/9hbBAAI6uaKO3r7YnhwN4zs3Q2hgZ68PTHZDJY70S+QyWQICfRESKAnHhzbB00trThSXIkjxRU4UlyJ3DOXkHG4BADgplJgSE9vRGh9EKH1wTCtD3p4u0AmY+FT52O5E90ElVKOO/r44o4+vgAAIQSKyutwqKgCR4urcKS4Eh9+q0eTqRUA4O/hjKFB3uiv9kR/tQfCNJ4ICfSAs1Ih5R+DugCWO9EtkMlkCPZzR7CfO6YMDwIANLW04jtD9Q97+JU4UVKNnWcuodl09dGBchnQy9cNIYGe6Bfojj5+7ujt744+/u4I9HTmnj5ZBMudyMJUSjmGBvlgaJAPZo25uqzZ1Ap9WS1OGmpQUHoFZ0uv4ExpDXacLjWXPnB1aqe339Wi7+3vBm03N/TydUNQNzeovZ25x08dxnIn6gROCjlC1Z4IVXu2WW5qFbhQWY/CslroL9defS2rRf7Famw9YUBLa9sHhfu5q6D2ckF3bxeovV3Q3euHV28XaLxcoPF2gaeLU2f+0chGdajcc3Nz8fLLL6O1tRXTp0/Ho48+2ubzpqYmLF68GCdOnICPjw/eeOMNBAUFWSUwkSNRyGXQ+rpB6+uG8Qho81mLqRUXqxpQVF6Hksp6GKoaYKhugKGqARerGnC4uBLltU3X/Ex3lQL+ns7wcVPBx9UJPm5O8HF1gvdP3ndzU8H7h+U+bip4uSh5wZaDabfcTSYTli9fjg8++ABqtRrTpk2DTqdDSEiIeZ3169fDy8sL33zzDTIzM/Haa6/hzTfftGZuIoenVMjNxX8jDc0mlFY34mJVfZviL69tQmV9MyrrmqC/XIvKumZUNzRDiBv+KHi6KOHj5gRPZye4OyvgqlLCXaWAm0oJN5UCbs4KuCgVcFUp4KKUX311+u8vVycFnBQyKOVyKOQyKBWyq6/yq68//jJ/Lm/7OY81WFa75Z6Xl4fg4GBotVoAQGJiIrKystqUe3Z2NubOnQsAiIuLw/LlyyGE4F8WkZW5OCnQy88Nvfzav3rW1CpQXd9sLv3K+mZU1f33vyt/+O8rjSbUNbWgqr4Zhqp61DaaUN9sQm1jCxpbWq32Z1H8rOyvvsrb/M9BKZdBLpfBnpvF2UmOlfdEoP/Ppugsrd1yNxqN0Gg05vdqtRp5eXnXrNO9e/erP1CphKenJyoqKuDr62vhuET0aynkMnRzV6GbuwqA+6/6Ga2tAo0trahvNqGh2WR+bWg2ob6pFc2trTCZBFpaBUytAi2trT+8iv++mlphEoCptfWH9z/7/Mfl5vX/u/zH32fPnJUKuDtb/3AnD6gSUYfJ5TK4qq5OzZBta/cIilqthsFgML83Go1Qq9XXrHPx4kUAQEtLC2pqatCtWzcLRyUioo5qt9zDw8Oh1+tRXFyMpqYmZGZmQqfTtVlHp9Phs88+AwBs3boVo0eP5nw7EZGE2p2WUSqVWLZsGebMmQOTyYSpU6ciNDQUaWlpGDJkCKKiojBt2jQ8/fTTiImJgbe3N954443OyE5ERDcgE+KXTo6yntTUVGRkZEixaSIiu9XR7uRVC0REDojlTkTkgFjuREQOiOVOROSAJLuIqaSkBKmpqVJtnojILpWUlHRoPcnOliEiIuvhtAwRkQNiuRMROSCWOxGRA2K5ExE5IJY7EZEDYrkTETkguyv33NxcxMXFISYmBunp6Z267YsXL2LmzJlISEhAYmIiPvroIwBAZWUlHnzwQcTGxuLBBx9EVVUVAEAIgZdeegkxMTFITk7GiRMnrJ7RZDIhJSUF//u//wsAKC4uxvTp0xETE4MnnngCTU1XH6jc1NSEJ554AjExMZg+fTrOnz9v1VzV1dWYP38+Jk6ciPj4eBw+fNhmxu3DDz9EYmIikpKSsHDhQjQ2Nko2bkuWLMGYMWOQlJRkXvZrxumzzz5DbGwsYmNjzbfjtka2V199FRMnTkRycjIef/xxVFdXmz9bvXo1YmJiEBcXh507d5qXW+M7fL1sP3r//fcRFhaG8vJyAJ07bjfK9cknn2DixIlITEzEihUrzMstOmbCjrS0tIioqChRVFQkGhsbRXJysjhz5kynbd9oNIrjx48LIYSoqakRsbGx4syZM+LVV18Vq1evFkIIsXr1arFixQohhBA5OTni4YcfFq2treLw4cNi2rRpVs/4/vvvi4ULF4pHH31UCCHE/PnzxZYtW4QQQixdulR8+umnQggh/vGPf4ilS5cKIYTYsmWLWLBggVVzLV68WKxbt04IIURjY6OoqqqyiXEzGAxiwoQJor6+Xghxdbw2btwo2bjt379fHD9+XCQmJpqX3ew4VVRUCJ1OJyoqKkRlZaXQ6XSisrLSKtl27twpmpubhRBCrFixwpztzJkzIjk5WTQ2NoqioiIRFRUlWlparPYdvl42IYS4cOGCeOihh8Tdd98tLl++LITo3HG7Xq49e/aI2bNni8bGRiGEEGVlZUIIy4+ZXe25//Rh3SqVyvyw7s4SGBiIwYMHAwA8PDzQt29fGI1GZGVlISUlBQCQkpKCbdu2AYB5uUwmQ0REBKqrq1FaWmq1fAaDATk5OZg2bRqAq3soe/fuRVxcHABgypQp5vHKzs7GlClTAFx9qPmePXsgrHQ9W01NDQ4cOGDOpVKp4OXlZTPjZjKZ0NDQgJaWFjQ0NCAgIECycRs5ciS8vb3bLLvZcdq1axfGjh0LHx8feHt7Y+zYsW32Ai2ZLTIyEkrl1QvdIyIizE9ty8rKQmJiIlQqFbRaLYKDg5GXl2e17/D1sgHAn//8Zzz99NNtHh7UmeN2vVxr167Fo48+CpVKBQDw8/Mz57LkmNlVuV/vYd1Go1GSLOfPn8fJkycxbNgwXL58GYGBgQCAgIAAXL58+bp5NRqNVfP+6U9/wtNPPw25/Opfa0VFBby8vMxfvp9u/0YPNbeG8+fPw9fXF0uWLEFKSgqef/551NXV2cS4qdVqPPTQQ5gwYQIiIyPh4eGBwYMH28S4/ehmx0mq78nGjRsxfvz462b7MUNnZtu2bRsCAwMxYMCANsulHje9Xo+DBw9i+vTpeOCBB5CXl3fdXLc6ZnZV7raitrYW8+fPx3PPPQcPD482n8lkMkkeMbh9+3b4+vpiyJAhnb7t9rS0tCA/Px8zZszApk2b4Orqes28oVTjVlVVhaysLGRlZWHnzp2or6+3yF6utUg1Tu1ZtWoVFAoFJk2aJHUUAEB9fT1Wr16NBQsWSB3lGiaTCVVVVVi3bh0WL16MJ554wir/ararcu/Iw7qtrbm5GfPnz0dycjJiY2MBXP1n1Y/TBqWlpfD19b1uXoPBYLW8hw4dQnZ2NnQ6HRYuXIi9e/fi5ZdfRnV1NVpaWq7Zfmc+1Fyj0UCj0WDYsGEAgIkTJyI/P98mxm337t0ICgqCr68vnJycEBsbi0OHDtnEuP3oZseps78nGRkZyMnJwWuvvWb+H8+NMnRWtqKiIpw/fx6TJ0+GTqeDwWBAamoqLl26JPm4qdVqxMTEQCaTYejQoZDL5aioqLD4mNlVuXfkYd3WJITA888/j759++LBBx80L9fpdNi0aRMAYNOmTYiKimqzXAiBI0eOwNPT0/zPa0tbtGgRcnNzkZ2djZUrV2L06NF4/fXXMWrUKGzduhXA1TMBfhyvznyoeUBAADQaDc6dOwcA2LNnD/r162cT49ajRw8cPXoU9fX1EEJgz549CAkJsYlx+9HNjlNkZCR27dqFqqoqVFVVYdeuXYiMjLRKttzcXKxZswarVq2Cq6trm8yZmZloampCcXEx9Ho9hg4d2mnf4bCwMOzZswfZ2dnIzs6GRqNBRkYGAgICJB+36Oho7Nu3DwBQWFiI5uZmdOvWzfJjdkuHgiWQk5MjYmNjRVRUlHjnnXc6ddsHDhwQ/fv3F0lJSWLSpEli0qRJIicnR5SXl4tZs2aJmJgYMXv2bFFRUSGEEKK1tVW88MILIioqSiQlJYm8vLxOybl3717z2TJFRUVi6tSpIjo6WsybN898hL6hoUHMmzdPREdHi6lTp4qioiKrZsrPzxdTpkwRSUlJ4rHHHhOVlZU2M25paWkiLi5OJCYmiqeeesp8toIU4/bkk0+KsWPHikGDBolx48aJdevW/apxWr9+vYiOjhbR0dFiw4YNVssWHR0txo8fb/4+/HgmkRBCvPPOOyIqKkrExsaKnJwc83JrfIevl+2nJkyYYD5bpjPH7Xq5GhsbxaJFi0RiYqJISUkRu3fvNq9vyTHjLX+JiByQXU3LEBFRx7DciYgcEMudiMgBsdyJiBwQy52IyAGx3ImIHBDLnYjIAf0/4AZ+VR7eGtIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating results\n",
      "task 1 accuracy: tensor(99.8800, device='cuda:0')\n",
      "Task 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 4992309.488567816\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 1/2 [00:17<00:17, 17.41s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.005999604846698612\n",
      "Train loss: 1000.4617664198886\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:34<00:00, 17.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.0054905967881727314\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating results\n",
      "task 1 accuracy: tensor(99.8200, device='cuda:0')\n",
      "task 2 accuracy: tensor(98.5100, device='cuda:0')\n",
      "Task 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 7154329.393117095\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 1/2 [00:17<00:17, 17.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.00943462468482032\n",
      "Train loss: 497.89716583121816\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:34<00:00, 17.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.007939638715099461\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating results\n",
      "task 1 accuracy: tensor(99.8500, device='cuda:0')\n",
      "task 2 accuracy: tensor(99.8000, device='cuda:0')\n",
      "task 3 accuracy: tensor(98.8100, device='cuda:0')\n",
      "Task 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 8578933.104944127\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 1/2 [00:17<00:17, 17.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.015329166275547717\n",
      "Train loss: 216.61464559396447\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:34<00:00, 17.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.011036374496172218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating results\n",
      "task 1 accuracy: tensor(99.8500, device='cuda:0')\n",
      "task 2 accuracy: tensor(99.8200, device='cuda:0')\n",
      "task 3 accuracy: tensor(99.2800, device='cuda:0')\n",
      "task 4 accuracy: tensor(98.5200, device='cuda:0')\n",
      "Task 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 9946950.021980643\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 1/2 [00:17<00:17, 17.41s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.009110842108471425\n",
      "Train loss: 122.17234107426235\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:34<00:00, 17.41s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.007514236919870333\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating results\n",
      "task 1 accuracy: tensor(99.8100, device='cuda:0')\n",
      "task 2 accuracy: tensor(99.8000, device='cuda:0')\n",
      "task 3 accuracy: tensor(98.6400, device='cuda:0')\n",
      "task 4 accuracy: tensor(97.1700, device='cuda:0')\n",
      "task 5 accuracy: tensor(99.2200, device='cuda:0')\n",
      "Task 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 12947130.456122197\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 1/2 [00:17<00:17, 17.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.044243805923137314\n",
      "Train loss: 79.80158750233112\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:34<00:00, 17.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test/validation loss: 0.03022664572130058\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAm50lEQVR4nO3deVyUdeIH8M8DwwzXAA7HDAKBCp4QpnkfJYgohyKi1bZqpmvb5pW1bv5c3bLsXHVpdzXJtcNOK7VVKitQaRWvxBDBAxEFlEEBuW++vz/YKNYDjxmemeHzfr18yczzMM+nZvj48H2e5/tIQggBIiIye1ZyByAiIsNgoRMRWQgWOhGRhWChExFZCBY6EZGFUMi14SFDhsDLy0uuzRMRmaWCggIcPHjwustkK3QvLy9s3bpVrs0TEZml2NjYGy7jkAsRkYVgoRMRWQgWOhGRhWChExFZCBY6EZGFaLfQly5dimHDhiEqKuq6y4UQeOmllxAWFobo6GicOHHC4CGJiKh97RZ6bGwsNm7ceMPlKSkpyM3NxbfffosXX3wRzz//vCHzERHRLWq30AcNGgRnZ+cbLk9KSkJMTAwkSUL//v1RXl6OoqIig4b8tcsVddj0n3P4PlOPi1drjLYdIiJzc9cXFun1euh0utbHOp0Oer0eHh4ed/vS13VGX4GXEjPR/N9Z3O/37YK1D/WHj8beKNsjIjIXZndQdLi/G9KfD8cXTw7D0gm9caqwAlPW70d5bYPc0YiIZHXXha7ValFYWNj6uLCwEFqt9m5f9qYcVQoM9NXgiQd6YPOcISiuqsdDGw6gqq7RqNslIjJld13oISEh2L59O4QQOHbsGNRqtdGGW66nv48LEqYPRNalcszYdAj1jc0dtm0iIlPS7hj64sWLcejQIZSWlmL06NGYP38+Ghtb9oQfeeQRPPDAA9i7dy/CwsJgZ2eHl19+2eih/1doHy1eignEn7dn4InNR7DpsUGQJKnDcxARyandQl+zZs1Nl0uShL/85S8GC3SnfjvUF5V1jXj165P413/OYc6o7nJHIiLqUGZ3UPRmHhvuh/4+LngpMQuf/5gvdxwiog5lUYVua2ONj343BP4ejli3JxtCCLkjERF1GIsqdACwVyowa4Qfci5X4eiFUrnjEBF1GIsrdACIDPKExkGJZdsyuJdORJ2GRRa6i70Sz47rhZOFFXgzKVvuOEREHcIiCx0AHh7kg5H+bohPOo3dJ403twwRkamw2EK3spIQ/3B/dHd3xKtfn5Q7DhGR0VlsoQOAq6MKjw65B6f0FThfXCV3HCIio7LoQgeAUQFuAIAdP12UOQkRkXFZfKH3cHfEqAA3vJmUjeyiSrnjEBEZjcUXuiRJWDOtP+yU1vi/bcd5GiMRWSyLL3QAcFer8Oy4njh0rgQHckrkjkNEZBSdotABIHaANzydbbHwkzTklVTLHYeIyOA6TaE7qBR4d9Zg1DQ0Ycnn6Rx6ISKL02kKHQB66dR4JqwnUnOKsef0ZbnjEBEZVKcqdAD4zRBf+Lra49WvTqKpmXvpRGQ5Ol2hKxVWWBzWE6f0FUg5w710IrIcna7QAWB8oA5ujiqsSszijaWJyGJ0ykJXKayx9qFgZBdVYltagdxxiIgMolMWOgCM9HeDr6s9/n3sIs94ISKL0GkLXZIkzB7ZDYdyS/DBgfNyxyEiumudttAB4LdDfDG6pzue35GJExfL5I5DRHRXOnWhW1lJWDMtGNZWEv666xSHXojIrHXqQgcAN0cVnnygB3afuozvMvVyxyEiumOdvtAB4A9jeqCXVo2nPz2G/FLO80JE5omFjpbTGDfOvB+1jc3YzAOkRGSmWOj/5aOxx9g+Hvj0cB7KqhvkjkNEdNtY6L8yPyQAV6sbsG5vttxRiIhuGwv9VwK9nDG2jxYJKTnIKOBpjERkXljo/+ONuHthb2ON+KQzckchIrotLPT/0cVBiadC/PFdph4pnDOdiMzILRV6SkoKwsPDERYWhoSEhGuWX7x4EdOnT0dMTAyio6Oxd+9egwftSLNHdsM9Gnv8YzfH0onIfLRb6E1NTVi5ciU2btyIxMRE7Ny5E9nZbYtu/fr1mDBhArZv3461a9fihRdeMFrgjqBSWCOmf1ccyS3B/rNX5I5DRHRL2i309PR0+Pr6wsfHB0qlEpGRkUhKSmqzjiRJqKysBABUVFTAw8PDOGk70PRhftA4qDDvozTe2YiIzEK7ha7X66HT6Vofa7Va6PVtL5GfN28eduzYgdGjR2Pu3Ln485//bPikHcxdrcLyqD4oqarHP5I59EJEps8gB0UTExMxefJkpKSkICEhAUuWLEFzc7MhXlpWEUGeGN7DFev2ZKO8lhcbEZFpa7fQtVotCgsLWx/r9Xpotdo263z++eeYMGECAOC+++5DXV0dSktLDRy149lYt9x/tK6xGclZRXLHISK6qXYLPSgoCLm5ucjLy0N9fT0SExMREhLSZh1PT0+kpqYCAM6ePYu6ujpoNBrjJO5gA+7pAl9Xe7yXmit3FCKim2q30BUKBVasWIE5c+YgIiICEyZMQEBAAOLj41sPjj733HPYsmULJk6ciMWLF+PVV1+FJElGD98RrKwkPD6iG9IuXMW6PRxLJyLTJQmZ7uoQGxuLrVu3yrHp29bY1IzH3zuCw+dK8O95IxCgVcsdiYg6qZt1J68UvQUKayu8PuVeOKissWx7htxxiIiui4V+i3TOtpgxzA+Hc0twoZg3wSAi08NCvw3T7veBSmGFP32RzvuPEpHJYaHfBp2zLZZF9kVqTjF2n+JpjERkWljot+nhQT64R2OPF3ZkoqyGFxsRkelgod8mG2srrJkWjILSGizbdlzuOERErVjod+B+Pw1+M+QefJ+l58RdRGQyWOh36F5vF9Q2NCPncqXcUYiIALDQ79iQbhpYScDmA+fljkJEBICFfsd8NPaYMcwP76eex/a0ArnjEBGx0O/G0oje6O/jgkWfHkNSlr79byAiMiIW+l1QKazx4Zwh6ObmgNXfnkZtQ5PckYioE2Oh3yUHlQJPh/VEVmE5Zr93mGe9EJFsWOgGMDG4K16ZHIR92cV4n/OmE5FMWOgG8tAgH9zv2wWbU89znhcikgUL3UAkScJDg3yQc6UKu04Utv8NREQGxkI3oOjgruipdcTru05xL52IOhwL3YBsbawxa0Q35FyuQtalCrnjEFEnw0I3sNDeHrCSgFe+zpI7ChF1Mix0A/NwssXC0J744cwVHL1QKnccIupEWOhGMHtUN6htFfhHcjbH0omow7DQjcBRpcC8Mf5IPlmE1d+eljsOEXUSLHQjmTu6O6YM8Ma6Pdk4o+cBUiIyPha6kUiShGWRfeCgVGDVV1lo5pQARGRkLHQj0jgosSisJ/acuoyVOzPljkNEFo6FbmSPj/DDjGG+eHd/LtJ41gsRGREL3cgkScKS8b2hdVJh+ZcZaGhqljsSEVkoFnoHcFQp8Hx0P2QUlOPZz36SOw4RWSgWegeZEOSJBSH++PLYRRzPL5M7DhFZIBZ6B5o9sjuU1lZ4j3OmE5ER3FKhp6SkIDw8HGFhYUhISLjuOl999RUiIiIQGRmJZ555xqAhLYWzvQ2i7vXE5z/m48OD5+WOQ0QWRtHeCk1NTVi5ciXeeecdaLVaxMXFISQkBP7+/q3r5ObmIiEhAR9//DGcnZ1RXFxs1NDmbNXkIJzSV+DP2zMwoocb/Nwc5I5ERBai3T309PR0+Pr6wsfHB0qlEpGRkUhKSmqzzpYtW/Doo4/C2dkZAODq6mqctBbATmmNf80cBGtJwt++P825XojIYNotdL1eD51O1/pYq9VCr9e3WSc3Nxfnzp3Dww8/jGnTpiElJcXwSS2IztkWE/t3xfZjF7H7VJHccYjIQhjkoGhTUxPOnz+PzZs3Y/Xq1Vi+fDnKy8sN8dIW69XYe+GhVmHZtgzUN/LcdCK6e+0WularRWHhL/fI1Ov10Gq116wTEhICGxsb+Pj4wM/PD7m5uQYPa0mUCiu8EhuES2W1PEBKRAbRbqEHBQUhNzcXeXl5qK+vR2JiIkJCQtqsM3bsWBw6dAgAUFJSgtzcXPj4+BgnsQUZ08sDg/002LA3h5N3EdFda7fQFQoFVqxYgTlz5iAiIgITJkxAQEAA4uPjWw+Ojho1Ci4uLoiIiMDMmTOxZMkSdOnSxejhzZ2VlYTpw3xRWF6Lf+7OljsOEZk5Sch0mkVsbCy2bt0qx6ZNihAC8z9Ow64ThfhqwSgEaNVyRyIiE3az7uSVojKTJAnPT+wHB5UCz209zqEXIrpjLHQT4OaowvLIvvjxfCk2/idH7jhEZKZY6CYidoAXRgW44eWvTmL/2StyxyEiM8RCNxGSJGHdowOgcVBi5Y5MzptORLeNhW5C1LY2eHlyIE4WVmDLkTy54xCRmWGhm5jwfjoM9O2CF/6dia+PX5I7DhGZERa6iZEkCQnTB6KXTo2nPjqKH8/zPqREdGtY6CbI1VGFj+cOhbtahbXfnZY7DhGZCRa6iXJUKfCbwb7Yd/YK99KJ6Jaw0E3YY8P9cI/GHvM+Oorahia54xCRiWOhmzBnexusimmZkfH7LH3730BEnRoL3cQN7a6Bo0qBTw/ncS+diG6KhW7iFNZWeGy4H344cwXLtmXIHYeITBgL3Qw8G94Ljw33wxdH85Gef1XuOERkoljoZuKZcT3h5qjCkx8cRUlVvdxxiMgEsdDNhNrWBut/OwCXymowY9NB1DVyPJ2I2mKhm5FBfhq8EReMjIJyvLAjU+44RGRiWOhmZspAb0wf6otPD+ch53Kl3HGIyISw0M3QgtAA2Cut8eJO7qUT0S9Y6GbIXa3C7x/ogd2nLmPD3rOcO52IALDQzdbjI7phSDcNXvn6JBJSeNs6ImKhmy07pTU+mTsUD/R0x4a9Z1FW3SB3JCKSGQvdjEmShOcm9EZFXSPW7z0rdxwikhkL3cz18XTCpOCueGvvWXx6+ILccYhIRix0C7BkfG8EejnhT18cxwbuqRN1Wix0C9DVxQ7b/jACkUGeeO2bk/gmo1DuSEQkAxa6hbCxtsKrU4LQr6szntuajiuVdXJHIqIOxkK3IGpbG6yZFoyqukYs/CQNZTU884WoM2GhW5gArRqrYoJw6FwJVnyZASGE3JGIqIMo5A5AhjdtkA/Ol1Thn7vPIsDDEfNCAuSOREQdgHvoFuqZsF6IDPJEfNIZHMgpljsOEXWAWyr0lJQUhIeHIywsDAkJCTdcb9euXejVqxeOHz9usIB0Z6ysJLwYEwg3RxXmfZSG/NJquSMRkZG1W+hNTU1YuXIlNm7ciMTEROzcuRPZ2dnXrFdZWYn3338fwcHBRglKt0/joMTqqcGorm/Ego/TOIkXkYVrt9DT09Ph6+sLHx8fKJVKREZGIikp6Zr14uPj8bvf/Q4qlcooQenODPd3wyuxQTh64SoeTjjAOV+ILFi7ha7X66HT6Vofa7Va6PX6NuucOHEChYWFePDBBw0ekO7epP5eWD01GMfzy/DI2yx1Ikt11wdFm5ub8eqrr+JPf/qTIfKQkUwZ6I2EGQOReakcm/adkzsOERlBu4Wu1WpRWPjLpeR6vR5arbb1cVVVFU6fPo0ZM2YgJCQEx44dw5NPPskDoybowV4eGNvHA+v3nsXRC6VyxyEiA2u30IOCgpCbm4u8vDzU19cjMTERISEhrcvVajUOHjyI5ORkJCcno3///li/fj2CgoKMGpzuzBtxwdA6qTDnvSPYe/qy3HGIyIDaLXSFQoEVK1Zgzpw5iIiIwIQJExAQEID4+PjrHhwl09bFQYlNMwdB46DEM1uO4eLVGrkjEZGBSEKma8NjY2OxdetWOTZNADIvluOhDalwcbDBR3OGwkdjL3ckIroFN+tOXinaSfXt6oQP5gxBWXUDHtqQirwSXnhEZO5Y6J1YsI8LPvrdUFypqscLOzLR1MyJvIjMGQu9kwv0csbvR3fH91l6LPgkDXWNTXJHIqI7xNkWCU+H9YTC2gprvjsNfVkt3p89GPZKfjSIzA330AmSJGFBaABejAnEkfOl+PhQntyRiOgOsNCp1fShvhjSTYO/fXcaX/yYz5tjEJkZFjq1sXpaMHp7qvHMZz/h9x/8iMq6RrkjEdEtYqFTG95d7PHJ3GF4YnR37Dqhxz93XztVMhGZJh75omtYW0lYGtEHlyvrsH7PWeReqcKqyUHQOCjljkZEN8E9dLqhlycHYfbIbkg6WYQnNh/hKY1EJo6FTjdka2ON5VF9sXpqMA7nluLZz9JR38i7HhGZKg65ULuig7sir7Qar39zCpeu1mDR2J4YGeAmdywi+h/cQ6db8ocH/fFG3L04U1SJ6ZsOcj51IhPEQqdbNvV+H/znT2Ogc7LFkx/8iJzLlXJHIqJfYaHTbVHb2uDtGfejoUng0Y0HkVFQJnckIvovFjrdtkAvZ2x6bBCEAH7z9gHsOVUkdyQiAgud7lB/Hxd8MGcwXOyVmPPeEazfc1buSESdHgud7pi/hxrb/jAcYX21eO2bkyx1Ipmx0OmuuDqqEP/wfQjt7YHXvjmJ1d+e4qReRDJhodNdUyqs8OYj9yEiSIe/J2dj/sdpuFTGm08TdTQWOhmEg0qBfzwyAE+P7YlvM/WYEP8DzhdXyR2LqFNhoZPBWFlJWDg2AFufHI7quiZMXrcf6flX5Y5F1Gmw0MngAr2csf2pEbCzsUbMP/fhw4Pn5Y5E1Cmw0Mko+nZ1wvanRmBkgDuWbcvA058ew9XqerljEVk0FjoZjbtahfWPDsATo7sjMf0SHtpwgHPAEBkRC52MykGlwNKIPvjXY/ejpLoesev2Y/n2DNQ2cG51IkNjoVOHGBXgjj3PPojZI7th84HziF23H6cKK+SORWRRWOjUYRxUCiyP6ou1DwXjTFEFov7+A3amX0RzMy9EIjIEFjp1uMn3eePA0lAEejlj3kdpCFu7F/ml1XLHIjJ7LHSShaujCh/OGYJVkwNxuaIOU9bvx7cnCjltANFduKVCT0lJQXh4OMLCwpCQkHDN8nfeeQcRERGIjo7GzJkzUVBQYPCgZHnslQo8OsQXnz4xDGpbG8zd/CMmr9vPaQOI7lC7hd7U1ISVK1di48aNSExMxM6dO5Gdnd1mnT59+uCLL77Ajh07EB4ejjfeeMNogcny9PF0wtcLR+H1Kfciu6gS49akYP2esyivbZA7GpFZabfQ09PT4evrCx8fHyiVSkRGRiIpKanNOkOHDoWdnR0AoH///igsLDROWrJYNtZWmDbIB9ufGoEBvl3w2jcn8fCGAyit4sVIRLeq3ULX6/XQ6XStj7VaLfR6/Q3X//zzzzF69GjDpKNOx9/DEe/OGoT4h/vjlL4CQ19JwitfZaGCe+tE7VIY8sW+/PJLZGRk4IMPPjDky1InI0kSJvX3Qk+tGv9IzsaGlBzsOlGIJx7ogYcH+UCSJLkjEpmkdvfQtVptmyEUvV4PrVZ7zXr79+/HW2+9hfXr10OpVBo2JXVKfTyd8M9HB2Dz7MGwtbHG0q3H8fi7h3H2cqXc0YhMUruFHhQUhNzcXOTl5aG+vh6JiYkICQlps05mZiZWrFiB9evXw9XV1WhhqXMaFeCOrxeOwtIJvbH71GWErdmLDXvPorKuUe5oRCal3SEXhUKBFStWYM6cOWhqasKUKVMQEBCA+Ph4BAYGIjQ0FK+//jqqq6uxcOFCAICnpyfeeusto4enzkOSJDzxQA+M7avFM1t+witfn8Q7+3KxOKwnpgz0hrUVh2GIJCHTlRyxsbHYunWrHJsmMyeEwI/nS/H8jhPIKCiHh1qFmcP9MH2YL5xsbeSOR2RUN+tOXilKZkeSJNzvp8GOeSOx/tEB8HSxwxu7TiF09V4kn9RzbhjqtFjoZLYkScKEIE98+dQIfPb7YXC2s8Hj7x5BzLp9+C7zxqfWElkqFjpZhEF+Gvx73ggsj+qLCyXV+N37RzBz0yFkXiyXOxpRh2Ghk8WwVyowe2Q3HFk2FovGBiDtQiki//4Dpr2ViuP5ZXLHIzI6FjpZHIW1FRaN7YmvF43GwtAA5JVWY9qGVKxKzERhWa3c8YiMhoVOFsvLxQ6LxvbEl0+NQFhfLf71n3MY9XoyFn96DPvPXpE7HpHBGfTSfyJT5OFkizcfuQ/PjuuFt3/IwWc/5mFrWgF8Xe3x1IP+GNdPCxd7Xt1M5o976NRp3ONqjxdjAnFsxTi8GBMIJ1sbLPkiHUNeTsLa706jup5XnpJ54x46dTq2NtaYPtQXjw6+B2l5pXgzKRvxSWeQkJKDB3q649Gh92CkvxsnASOzw0KnTsvKSsJAXw3ee3wwfjxfgu1pF/F1xiV8c6IQ93o7Y/bIbgjvp4OtjbXcUYluCQudCMBAXw0G+mrw56g++OxIPjb95xwWfnIMKoUVRvi7YXygDpFBnnBQ8UeGTBc/nUS/olJY47dDfTHtfh/sy76CvacvI+mkHsmfF2HNt6fx+Eg/jOurg6+rPYdkyOSw0ImuQ6mwwpjeHhjT2wN/ie6L1LPFWLkzEy9/dRIvf3USPbWOmDncD+P76eDqqJI7LhEAFjpRuyRJwnB/N3yzaDTySqrxbaYem1NzsWxbBpZty0CAhyPiBnojtI8W/h6OcselToyFTnQbfDT2mD2yGx4f4YcTF8uRcuYydmUU4pWvT+LVb07ift8uGOSnwfhAHQK7OsOK87RTB2KhE90BSZIQ6OWMQC9nPPlAD+SX1uDDgxdw8FwxElJysG7PWdjZWGNS/66ICPLEkO4aqBQ8W4aMi4VOdJckSYKPxh7PTegNALhaXY+krCIcyCnGtrQCfHI4Dw5Ka4wKcEdIHw+M6eUBdzXH3cnwWOhEBuZir8SUgd6YMtAbKycFIjXnCpKyipB8sgjfnGi54XqwjwtCe3tgcDcNgr1dYKfk3jvdPRY6kRHZKa0R0luLkN5aCCGQdakCSVl6JJ0swtrvT0MIwM7GGmN6uyMiyBNjennwXHe6Y/zkEHUQSZLQt6sT+nZ1wvzQAJRW1ePguWLsyy7G1xmF+Op4IWysJfTSqRHk5YzB3TQI76eDvZI/pnRr+EkhkkkXByXGB3pifKAnnp/YDz+eL8XuU0U4nl+Gr44X4uNDeXBUncDQ7q4Y3sMVw3q4opdWzTNn6IZY6EQmwNpKwuBuGgzupgEACCFwOLcU29LysS+7GN9ntdwjVW2rQGBXZ9zr7Yx7vV1wr7czvLvY8apVAsBCJzJJktS24Auu1iD1bDGOXihFRkEZ3tmXi/qmZgCAq4MSQf8t+OD//s2zaDonFjqRGfBysUPcQG/EDfQGANQ3NiPrUjnSC8qQnncV6fllSDl9Bs2iZf2uzrYte/A+zuijc0KA1hFeLtyTt3QsdCIzpFRYIdjHBcE+LsBQXwBAVV0jTlwsR3r+VfyUX4b0/Kutp0kCgNZJhWBvF/h7OMLfwxE93B3R3d0Balsbmf4ryNBY6EQWwkGlaDNMA7Rc5HSmqBJZl8pxJLcUJy6WIflkERp/3pVHy968v1aN7m4OuNfbGfdo7NHNzQEaByX36M0MC53IgrnYKzHIT4NBfhrMGOYHAGhoasb54mqcvVyJ7KJKnNZXIOdyFbbkluDd/bmt32trYwV/D0f09FDD19UBgV5OCPBQw8NJxZt+mCgWOlEnY2Nt1TrsEt7vl+ebmgXOXq5EQWkNzl6uxKWyWmRdKm+ZwuBYAcQvO/Vwc1TC19UBvhp79PBwhHcXO+icbNHVxQ5eLnY8tVImLHQiAtBy6mRPrRo9tWqM6e3RZllVXSMyL5Uj90oV9OW1yC+tQW5xFfafLcbWtII269orreHn6gA/N3tonWyhc7KFp4sdvFxs4elsBw+1Cgpr3p/eGFjoRNQuB5Widejmf1XWNaKwrAaXylqK/uchnJOFFdh76jKq6pvarG9tJcFDrUJXl5a9ene1qqX4nVXwUNtC66SCu9oWTrYKjuHfJhY6Ed0VR5UC/h5q+Huor7u8vLYBl67W4mJZTcvfV2tav84qLMfe03WorGu85vtUCiu4OargplbBzUEJN0cVXB1/+dvdUQVXRxXcHJVwsVfCmsM8t1boKSkpWLVqFZqbmzF16lTMnTu3zfL6+nosWbIEJ06cgIuLC9auXQtvb2+jBCYi8+JkawMnnQ166a5f+EDLkE5heS2KyutQVFGLyxV10JfXoriyHpcr63CprBbHC8pQXFWPpl+dofMzSQKc7WzgYmcDF3slnO1s4GRnAydbxa++toGT3X8f2/6y3MnOBjYWMgTUbqE3NTVh5cqVeOedd6DVahEXF4eQkBD4+/u3rvPZZ5/ByckJ3333HRITE/HXv/4Vf/vb34yZm4gsiINKgR7uLefG30xzs0BZTQOKq+pwuaIeVyrrUFxZh5KqelytaUBpdQOuVtfjanU9LpRUo7ymAWU1DW1O07wee6U11LYKOKgUcFQpoLZVtJS+rQ2c7W1a/1H4+R8N51/9cbKzMZnfDtot9PT0dPj6+sLHxwcAEBkZiaSkpDaFnpycjHnz5gEAwsPDsXLlSgghOP5FRAZlZSWhi4MSXRyU8Pdof32gZV6cmoYmlNc0ory2obXkW75ubH1cUduIyvpGVNY2orKuEUXlla3r1TY03/D1bawleKhtYae0xq00nsrGCmum9UdP7Y1/Y7lT7Ra6Xq+HTqdrfazVapGenn7NOp6eni0vqFBArVajtLQUGs21B1CIiDqSJEmwVypgr1RA52x7R69R29DUWvxXaxpQVv3L1z8PEdU2NLX/QgBUCmujzXnPg6JERO2wtbGGrY01PJzu7B+EjtLukQCtVovCwl/mg9Dr9dBqtdesc+nSJQBAY2MjKioq0KVLFwNHJSKim2m30IOCgpCbm4u8vDzU19cjMTERISEhbdYJCQnBtm3bAAC7du3C0KFDOX5ORNTB2h1yUSgUWLFiBebMmYOmpiZMmTIFAQEBiI+PR2BgIEJDQxEXF4c//vGPCAsLg7OzM9auXdsR2YmI6FckIcTNz+cxktjYWGzdulWOTRMRma2bdadlnE1PREQsdCIiS8FCJyKyECx0IiILIduFRQUFBYiNjZVr80REZqmgoOCGy2Q7y4WIiAyLQy5ERBaChU5EZCFY6EREFoKFTkRkIVjoREQWgoVORGQhzK7QU1JSEB4ejrCwMCQkJHT49pcuXYphw4YhKiqq9bmrV69i1qxZGDduHGbNmoWysjIALbe+eumllxAWFobo6GicOHHCaLkuXbqE6dOnIyIiApGRkXjvvfdMJltdXR3i4uIwceJEREZG4s033wQA5OXlYerUqQgLC8OiRYtQX18PoOWm44sWLUJYWBimTp2K/Px8o2X7WVNTE2JiYvDEE0+YVLaQkBBER0dj0qRJrddtmMJ7CgDl5eVYsGABxo8fjwkTJiAtLU32bDk5OZg0aVLrnwEDBuDdd9+VPdfP3n33XURGRiIqKgqLFy9GXV2dYT9rwow0NjaK0NBQceHCBVFXVyeio6PFmTNnOjTDoUOHREZGhoiMjGx97rXXXhMbNmwQQgixYcMG8frrrwshhNizZ4+YPXu2aG5uFmlpaSIuLs5oufR6vcjIyBBCCFFRUSHGjRsnzpw5YxLZmpubRWVlpRBCiPr6ehEXFyfS0tLEggULxM6dO4UQQixfvlx8+OGHQgghPvjgA7F8+XIhhBA7d+4UCxcuNFq2n23atEksXrxYzJ07VwghTCbbmDFjRHFxcZvnTOE9FUKIJUuWiC1btgghhKirqxNlZWUmk02Ilr4YPny4yM/PN4lchYWFYsyYMaKmpkYI0fIZ++KLLwz6WTOrPfRf37BaqVS23rC6Iw0aNAjOzs5tnktKSkJMTAwAICYmBt9//32b5yVJQv/+/VFeXo6ioiKj5PLw8EC/fv0AAI6OjujevTv0er1JZJMkCQ4ODgBa7mjV2NgISZJw4MABhIeHAwAmT57c+l4mJydj8uTJAFpuOp6amgphxOvfCgsLsWfPHsTFxQFo2WszlWzXYwrvaUVFBQ4fPtz6/0ypVMLJyckksv0sNTUVPj4+8PLyMplcTU1NqK2tRWNjI2pra+Hu7m7Qz5pZFfr1blit1+tlTNSiuLgYHh4ttyB3d3dHcXExgGvz6nS6Dsmbn5+PrKwsBAcHm0y2pqYmTJo0CcOHD8fw4cPh4+MDJycnKBSKa7Z/o5uOG8vLL7+MP/7xj7CyavlxKC0tNZlsADB79mzExsbi008/BWAan7f8/HxoNBosXboUMTExWLZsGaqrq00i288SExNbh0ZNIZdWq8Xjjz+OMWPGYOTIkXB0dES/fv0M+lkzq0I3B5IkyXr7vaqqKixYsAD/93//B0dHxzbL5MxmbW2NL7/8Env37kV6ejpycnJkyfG/du/eDY1Gg8DAQLmjXNfHH3+Mbdu24e2338aHH36Iw4cPt1ku13va2NiIzMxMPPLII9i+fTvs7OyuOaYl5+etvr4eycnJGD9+/DXL5MpVVlaGpKQkJCUl4YcffkBNTQ1++OEHg27DrAr9Vm5YLQdXV9fWX9OKioqg0WgAXJu3sLDQqHkbGhqwYMECREdHY9y4cSaV7WdOTk4YMmQIjh07hvLycjQ2Nl6z/Y686fjRo0eRnJyMkJAQLF68GAcOHMCqVatMItvP2wNa3sewsDCkp6ebxHuq0+mg0+kQHBwMABg/fjwyMzNNIhvQcvJEv3794ObmBsA0fg72798Pb29vaDQa2NjYYNy4cTh69KhBP2tmVei3csNqOYSEhGD79u0AgO3btyM0NLTN80IIHDt2DGq1uvXXPkMTQmDZsmXo3r07Zs2aZVLZSkpKUF5eDgCora3F/v370aNHDwwZMgS7du0CAGzbtq31vezIm44/88wzSElJQXJyMtasWYOhQ4di9erVJpGturoalZWVrV/v27cPAQEBJvGeuru7Q6fTtf6mlZqaih49ephENqBluCUyMrL1sSnk6tq1K3766SfU1NRACIHU1FT4+/sb9rNmwIO4HWLPnj1i3LhxIjQ0VKxbt67Dt//000+LESNGiL59+4pRo0aJLVu2iJKSEjFjxgwRFhYmZs6cKUpLS4UQLWd3PP/88yI0NFRERUWJ9PR0o+U6fPiw6Nmzp4iKihITJ04UEydOFHv27DGJbFlZWWLSpEkiKipKREZGir///e9CCCEuXLggpkyZIsaOHSvmz58v6urqhBBC1NbWivnz54uxY8eKKVOmiAsXLhgt268dOHCg9SwXU8h24cIFER0dLaKjo0VERETr590U3lMhhMjMzBSTJ08WUVFR4sknnxRXr141iWxVVVVi8ODBory8vPU5U8glhBDx8fEiPDxcREZGimeffVbU1dUZ9LPG6XOJiCyEWQ25EBHRjbHQiYgsBAudiMhCsNCJiCwEC52IyEKw0ImILAQLnYjIQvw/t1PXuIg4TSkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating results\n",
      "task 1 accuracy: tensor(99.8800, device='cuda:0')\n",
      "task 2 accuracy: tensor(99.8100, device='cuda:0')\n",
      "task 3 accuracy: tensor(99.2400, device='cuda:0')\n",
      "task 4 accuracy: tensor(99.2400, device='cuda:0')\n",
      "task 5 accuracy: tensor(99.6700, device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:Internal Python error in the inspect module.\n",
      "Below is the traceback from this internal error.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Traceback (most recent call last):\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/interactiveshell.py\", line 3343, in run_code\n",
      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "  File \"<ipython-input-14-064c303ffba4>\", line 101, in <module>\n",
      "    acc = task_accuracy(j)\n",
      "  File \"<ipython-input-13-50c9dafc92ce>\", line 6, in task_accuracy\n",
      "    for x,y in testloader:\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/torch/utils/data/dataloader.py\", line 355, in __iter__\n",
      "    return self._get_iterator()\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/torch/utils/data/dataloader.py\", line 301, in _get_iterator\n",
      "    return _MultiProcessingDataLoaderIter(self)\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/torch/utils/data/dataloader.py\", line 914, in __init__\n",
      "    w.start()\n",
      "  File \"/usr/lib64/python3.6/multiprocessing/process.py\", line 105, in start\n",
      "    self._popen = self._Popen(self)\n",
      "  File \"/usr/lib64/python3.6/multiprocessing/context.py\", line 223, in _Popen\n",
      "    return _default_context.get_context().Process._Popen(process_obj)\n",
      "  File \"/usr/lib64/python3.6/multiprocessing/context.py\", line 277, in _Popen\n",
      "    return Popen(process_obj)\n",
      "  File \"/usr/lib64/python3.6/multiprocessing/popen_fork.py\", line 19, in __init__\n",
      "    self._launch(process_obj)\n",
      "  File \"/usr/lib64/python3.6/multiprocessing/popen_fork.py\", line 66, in _launch\n",
      "    self.pid = os.fork()\n",
      "KeyboardInterrupt\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2044, in showtraceback\n",
      "    stb = value._render_traceback_()\n",
      "AttributeError: 'KeyboardInterrupt' object has no attribute '_render_traceback_'\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\", line 1169, in get_records\n",
      "    return _fixed_getinnerframes(etb, number_of_lines_of_context, tb_offset)\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\", line 316, in wrapped\n",
      "    return f(*args, **kwargs)\n",
      "  File \"/home/s2967057/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\", line 350, in _fixed_getinnerframes\n",
      "    records = fix_frame_records_filenames(inspect.getinnerframes(etb, context))\n",
      "  File \"/usr/lib64/python3.6/inspect.py\", line 1490, in getinnerframes\n",
      "    frameinfo = (tb.tb_frame,) + getframeinfo(tb, context)\n",
      "  File \"/usr/lib64/python3.6/inspect.py\", line 1448, in getframeinfo\n",
      "    filename = getsourcefile(frame) or getfile(frame)\n",
      "  File \"/usr/lib64/python3.6/inspect.py\", line 696, in getsourcefile\n",
      "    if getattr(getmodule(object, filename), '__loader__', None) is not None:\n",
      "  File \"/usr/lib64/python3.6/inspect.py\", line 739, in getmodule\n",
      "    f = getabsfile(module)\n",
      "  File \"/usr/lib64/python3.6/inspect.py\", line 709, in getabsfile\n",
      "    return os.path.normcase(os.path.abspath(_filename))\n",
      "  File \"/usr/lib64/python3.6/posixpath.py\", line 385, in abspath\n",
      "    return normpath(path)\n",
      "  File \"/usr/lib64/python3.6/posixpath.py\", line 364, in normpath\n",
      "    if (comp != dotdot or (not initial_slashes and not new_comps) or\n",
      "KeyboardInterrupt\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "object of type 'NoneType' has no len()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "    \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n",
      "\u001b[0;32m<ipython-input-14-064c303ffba4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    100\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 101\u001b[0;31m             \u001b[0macc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtask_accuracy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mj\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    102\u001b[0m             \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"task\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mj\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"accuracy:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0macc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-13-50c9dafc92ce>\u001b[0m in \u001b[0;36mtask_accuracy\u001b[0;34m(task)\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mtotal\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtestloader\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      7\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    354\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 355\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_iterator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    356\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_get_iterator\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    300\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_worker_number_rationality\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 301\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0m_MultiProcessingDataLoaderIter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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    302\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, loader)\u001b[0m\n\u001b[1;32m    913\u001b[0m             \u001b[0;31m#     AssertionError: can only join a started process.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 914\u001b[0;31m             \u001b[0mw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    915\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_index_queues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex_queue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib64/python3.6/multiprocessing/process.py\u001b[0m in \u001b[0;36mstart\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    104\u001b[0m         \u001b[0m_cleanup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_popen\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_Popen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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    106\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sentinel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_popen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msentinel\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib64/python3.6/multiprocessing/context.py\u001b[0m in \u001b[0;36m_Popen\u001b[0;34m(process_obj)\u001b[0m\n\u001b[1;32m    222\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_Popen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocess_obj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 223\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_default_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mProcess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_Popen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocess_obj\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    224\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib64/python3.6/multiprocessing/context.py\u001b[0m in \u001b[0;36m_Popen\u001b[0;34m(process_obj)\u001b[0m\n\u001b[1;32m    276\u001b[0m             \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0mpopen_fork\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mPopen\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 277\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mPopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocess_obj\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    278\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib64/python3.6/multiprocessing/popen_fork.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, process_obj)\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreturncode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_launch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocess_obj\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     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib64/python3.6/multiprocessing/popen_fork.py\u001b[0m in \u001b[0;36m_launch\u001b[0;34m(self, process_obj)\u001b[0m\n\u001b[1;32m     65\u001b[0m         \u001b[0mparent_r\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchild_w\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpipe\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfork\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     67\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpid\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: ",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mshowtraceback\u001b[0;34m(self, exc_tuple, filename, tb_offset, exception_only, running_compiled_code)\u001b[0m\n\u001b[1;32m   2043\u001b[0m                         \u001b[0;31m# in the engines. This should return a list of strings.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2044\u001b[0;31m                         \u001b[0mstb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_render_traceback_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2045\u001b[0m                     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'KeyboardInterrupt' object has no attribute '_render_traceback_'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "    \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mshowtraceback\u001b[0;34m(self, exc_tuple, filename, tb_offset, exception_only, running_compiled_code)\u001b[0m\n\u001b[1;32m   2045\u001b[0m                     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2046\u001b[0m                         stb = self.InteractiveTB.structured_traceback(etype,\n\u001b[0;32m-> 2047\u001b[0;31m                                             value, tb, tb_offset=tb_offset)\n\u001b[0m\u001b[1;32m   2048\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2049\u001b[0m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_showtraceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0metype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\u001b[0m in \u001b[0;36mstructured_traceback\u001b[0;34m(self, etype, value, tb, tb_offset, number_of_lines_of_context)\u001b[0m\n\u001b[1;32m   1434\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1435\u001b[0m         return FormattedTB.structured_traceback(\n\u001b[0;32m-> 1436\u001b[0;31m             self, etype, value, tb, tb_offset, number_of_lines_of_context)\n\u001b[0m\u001b[1;32m   1437\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1438\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\u001b[0m in \u001b[0;36mstructured_traceback\u001b[0;34m(self, etype, value, tb, tb_offset, number_of_lines_of_context)\u001b[0m\n\u001b[1;32m   1334\u001b[0m             \u001b[0;31m# Verbose modes need a full traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1335\u001b[0m             return VerboseTB.structured_traceback(\n\u001b[0;32m-> 1336\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0metype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtb_offset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumber_of_lines_of_context\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1337\u001b[0m             )\n\u001b[1;32m   1338\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mmode\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Minimal'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\u001b[0m in \u001b[0;36mstructured_traceback\u001b[0;34m(self, etype, evalue, etb, tb_offset, number_of_lines_of_context)\u001b[0m\n\u001b[1;32m   1191\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1192\u001b[0m         formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n\u001b[0;32m-> 1193\u001b[0;31m                                                                tb_offset)\n\u001b[0m\u001b[1;32m   1194\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1195\u001b[0m         \u001b[0mcolors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mColors\u001b[0m  \u001b[0;31m# just a shorthand + quicker name lookup\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\u001b[0m in \u001b[0;36mformat_exception_as_a_whole\u001b[0;34m(self, etype, evalue, etb, number_of_lines_of_context, tb_offset)\u001b[0m\n\u001b[1;32m   1148\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1149\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1150\u001b[0;31m         \u001b[0mlast_unique\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrecursion_repeat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfind_recursion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0morig_etype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrecords\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   1151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1152\u001b[0m         \u001b[0mframes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_records\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecords\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlast_unique\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrecursion_repeat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/MasterThesis/env/lib64/python3.6/site-packages/IPython/core/ultratb.py\u001b[0m in \u001b[0;36mfind_recursion\u001b[0;34m(etype, value, records)\u001b[0m\n\u001b[1;32m    449\u001b[0m     \u001b[0;31m# first frame (from in to out) that looks different.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    450\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mis_recursion_error\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0metype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrecords\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 451\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecords\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    452\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    453\u001b[0m     \u001b[0;31m# Select filename, lineno, func_name to track frames with\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()"
     ]
    }
   ],
   "source": [
    "# time.sleeps are there to prevent tqdm from messing up the output formatting, can be removed\n",
    "epochs = 2\n",
    "weight_decay = 9 * 10e-6 # lambda in paper\n",
    "c_decay = 10e1 # gamma in paper\n",
    "results = []\n",
    "for i in range(num_tasks):\n",
    "    results.append([])\n",
    "    print(\"Task\", i+1)\n",
    "    time.sleep(0.25)\n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        train_loss = []\n",
    "        test_loss = []\n",
    "        for x, y in trainloader:\n",
    "            x, y = x.to(device), y.to(device)\n",
    "            y = F.one_hot(y,10)\n",
    "            # We are only interested in label of current task\n",
    "            y = y[:,i]\n",
    "            optimizer.zero_grad()\n",
    "            out = model(x.float())\n",
    "            # Training process for first task is normal, after that use conceptor regularization\n",
    "            if i != 0:\n",
    "                loss = ce_loss(out.float(), y.float()) + weight_decay * l2_loss(model.weights) + c_decay * c_loss(model, A1, A2, A3)\n",
    "            else:\n",
    "                loss = ce_loss(out.float(), y.float()) + weight_decay * l2_loss(model.weights)\n",
    "            train_loss.append(loss.item())\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        print(\"Train loss:\",statistics.mean(train_loss))\n",
    "\n",
    "        for x, y in testloader:\n",
    "            x, y = x.to(device), y.to(device)\n",
    "            y = F.one_hot(y,10)\n",
    "            y = y[:,i]\n",
    "            optimizer.zero_grad()\n",
    "            out = model(x.float())\n",
    "            loss = ce_loss(out.float(), y.float())\n",
    "            test_loss.append(loss.item())\n",
    "        print(\"Test/validation loss:\",statistics.mean(test_loss))\n",
    "    \n",
    "    time.sleep(0.25)\n",
    "        \n",
    "    # Collect activation batches to compute conceptors\n",
    "    col1 = []\n",
    "    col2 = []\n",
    "    col3 = []\n",
    "    for _ in range(20):\n",
    "        x,y = next(iter(trainloader))\n",
    "        model(x.to(device))\n",
    "        col1.append(model.x1)\n",
    "        col2.append(model.x2)\n",
    "        col3.append(model.x3)\n",
    "        \n",
    "    '''\n",
    "    Compute the actual conceptors.\n",
    "    For conv. layer (C1) this is done by taking patches of the activation map and computing the autocorrelation matrix \n",
    "    from those patches. But we want to do this over multiple images. Therefore, input patches are concatenated into \n",
    "    one big matrix\n",
    "    For the linear layers (C2, C3) it's simpler, just take the activation vectors and put them as columns in an array.\n",
    "    '''\n",
    "    C1, _, _ = conceptor(torch.cat([torch.cat(list(c)) for c in col1], dim=0).cpu().detach().numpy())\n",
    "    C2, _, _ = conceptor(torch.cat(col2, dim=0).cpu().detach().numpy())\n",
    "    C3, _, _ = conceptor(torch.cat(col3, dim=0).cpu().detach().numpy())\n",
    "\n",
    "    # Do the OR operation after every task to compute subspace used for all tasks currently trained on\n",
    "    if i == 0:\n",
    "        A1 = torch.zeros(C1.shape)\n",
    "        A2 = torch.zeros(C2.shape)\n",
    "        A3 = torch.zeros(C3.shape)\n",
    "        A1 = OR(C1, A1.numpy())\n",
    "        A2 = OR(C2, A2.numpy())\n",
    "        A3 = OR(C3, A3.numpy())\n",
    "\n",
    "    else:\n",
    "        A1 = OR(C1, A1.cpu().detach().numpy())\n",
    "        A2 = OR(C2, A2.cpu().detach().numpy())\n",
    "        A3 = OR(C3, A3.cpu().detach().numpy())\n",
    "        \n",
    "    \n",
    "    # Conceptors are calculated using numpy, because their linalg library was (is?) more advanced, not sure if it still is, so\n",
    "    # could be changed to torch code for minor speed up\n",
    "    A1 = torch.from_numpy(A1).to(device).float()\n",
    "    A2 = torch.from_numpy(A2).to(device).float()\n",
    "    A3 = torch.from_numpy(A3).to(device).float()\n",
    "        \n",
    "    # The incremental weights and old weights are added and will now be the old weights\n",
    "    if i < num_tasks - 1:\n",
    "        old1 = copy.deepcopy(model.w1.data) + copy.deepcopy(model.w1_old.data)\n",
    "        old2 = copy.deepcopy(model.w2.data) + copy.deepcopy(model.w2_old.data)\n",
    "        old3 = copy.deepcopy(model.w3.data) + copy.deepcopy(model.w3_old.data)\n",
    "        old4 = copy.deepcopy(model.w4.data) + copy.deepcopy(model.w4_old.data)\n",
    "\n",
    "        model.w1_old = nn.Parameter(old1)\n",
    "        model.w2_old = nn.Parameter(old2)\n",
    "        model.w3_old = nn.Parameter(old3)\n",
    "        model.w4_old = nn.Parameter(old4)\n",
    "        \n",
    "        model.head.append(old4)\n",
    "        \n",
    "        print(\"Generating results\")\n",
    "        for j in range(i+1):\n",
    "            acc = task_accuracy(j)\n",
    "            print(\"task\", j+1, \"accuracy:\", acc)\n",
    "            results[j].append(acc)\n",
    "        \n",
    "        model.initialise()\n",
    "    else:\n",
    "        old4 = copy.deepcopy(model.w4.data) + copy.deepcopy(model.w4_old.data)\n",
    "        model.head.append(old4)\n",
    "        print(\"Generating results\")\n",
    "        for j in range(i+1):\n",
    "            acc = task_accuracy(j)\n",
    "            print(\"task\", j+1, \"accuracy:\", acc)\n",
    "            results[j].append(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(97.5900, device='cuda:0')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "overall_accuracy()"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}