SumNet_Final_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "GXzCvqKSqnWY"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Oubln6I9-xXy",
    "outputId": "a4d0efee-b16b-4792-c461-b76beac591ec"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object `# import torch` not found.\n"
     ]
    }
   ],
   "source": [
    "?# import torch\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73,
     "resources": {
      "http://localhost:8080/nbextensions/google.colab/files.js": {
       "data": "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",
       "headers": [
        [
         "content-type",
         "application/javascript"
        ]
       ],
       "ok": true,
       "status": 200,
       "status_text": ""
      }
     }
    },
    "id": "5ZxAbJMoq9Rm",
    "outputId": "aee45394-51cf-4cd6-a208-5d6e8ca24338"
   },
   "outputs": [],
   "source": [
    "# from google.colab import files\n",
    "# uploaded = files.upload()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "W7YroGIrsgU_",
    "outputId": "c0a0be61-c484-473e-91da-931148a5e366"
   },
   "outputs": [],
   "source": [
    "# !unzip akshit_sum.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "5gI7czRFqnWt"
   },
   "outputs": [],
   "source": [
    "data1 = np.load('akshit_sum/data0.npy')\n",
    "data2 = np.load('akshit_sum/data1.npy')\n",
    "data3 = np.load('akshit_sum/data2.npy')\n",
    "lab1 = np.load('akshit_sum/lab0.npy')\n",
    "lab2 = np.load('akshit_sum/lab1.npy')\n",
    "lab3 = np.load('akshit_sum/lab2.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "W-PJDNOJwdo7"
   },
   "outputs": [],
   "source": [
    "X = np.concatenate((data1,data2,data3))\n",
    "Y = np.concatenate((lab1,lab2,lab3))\n",
    "X = (X-0)/(255-0)\n",
    "X = np.expand_dims(X, 1)      # if numpy array\n",
    "# indices = np.arange(len(X))\n",
    "# random.shuffle(indices)\n",
    "train_x = X[:int(0.8*len(X))]\n",
    "val_x = X[int(0.8*len(X)):]\n",
    "\n",
    "train_y = Y[:int(0.8*len(Y))]\n",
    "val_y = Y[int(0.8*len(Y)):]\n",
    "\n",
    "train_x = torch.tensor(train_x)\n",
    "val_x = torch.tensor(val_x)\n",
    "\n",
    "train_y = torch.LongTensor(train_y)\n",
    "val_y = torch.LongTensor(val_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "D1jrQz5WyNRw",
    "outputId": "ec7af339-ea8d-4844-faea-5970aa5838b6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(30000, 1, 40, 168)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SkHUY_JwHgvI",
    "outputId": "1018f801-2db6-4f40-b7b0-aca5b7884936"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "24XDHC1XwcIa"
   },
   "outputs": [],
   "source": [
    "class SumNet(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SumNet, self).__init__()\n",
    "        self.conv1 = torch.nn.Conv2d(1,2,3,1)\n",
    "        self.conv2 = torch.nn.Conv2d(2,4,3,1,padding=1)\n",
    "        self.conv_bn_2 = torch.nn.BatchNorm2d(4)\n",
    "        self.conv3 = torch.nn.Conv2d(4,8,3,1,padding=1)\n",
    "        self.conv4 = torch.nn.Conv2d(8,16,3,1,padding=1)\n",
    "        self.conv_bn_4 = torch.nn.BatchNorm2d(16)\n",
    "        self.conv5 = torch.nn.Conv2d(16,32,3,1,padding=1)\n",
    "        self.conv6 = torch.nn.Conv2d(32,64,3,1,padding=1)\n",
    "        self.conv_bn_6 = torch.nn.BatchNorm2d(64)\n",
    "        self.conv7 = torch.nn.Conv2d(64,64,3,1,padding=1)\n",
    "        self.conv8 = torch.nn.Conv2d(64,128,3,1,padding=1)\n",
    "        self.conv_bn_8 = torch.nn.BatchNorm2d(128)\n",
    "        self.conv9 = torch.nn.Conv2d(128,128,3,1,padding=1)\n",
    "        self.conv10 = torch.nn.Conv2d(128,256,3,1,padding=1)\n",
    "        self.conv_bn_10 = torch.nn.BatchNorm2d(256)\n",
    "        self.conv11 = torch.nn.Conv2d(256,256,3,1,padding=0)\n",
    "        self.conv12 = torch.nn.Conv2d(256,512,3,1,padding=0)\n",
    "        self.conv_bn_12 = torch.nn.BatchNorm2d(512)\n",
    "\n",
    "        self.fc1 = torch.nn.Linear(512,256)\n",
    "        self.dropout1 = torch.nn.Dropout(0.5)\n",
    "        self.fc2 = torch.nn.Linear(256,37)\n",
    "#         self.dropout2 = torch.nn.Dropout(0.6)\n",
    "#         self.fc3 = torch.nn.Linear(64, 37)\n",
    "#         self.dropout3 = torch.nn.Dropout(0.8)\n",
    "#         self.fc4 = torch.nn.Linear(128, 37)\n",
    "\n",
    "\n",
    "\n",
    "    def forward(self,x):\n",
    "        x=self.conv1(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=self.conv2(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x = self.conv_bn_2(x)\n",
    "        x=torch.nn.functional.max_pool2d(x,kernel_size = [1,2],stride=[1,2],padding=[0,1])\n",
    "        x=self.conv3(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=self.conv4(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x = self.conv_bn_4(x)\n",
    "        x=torch.nn.functional.max_pool2d(x,kernel_size = [1,2],stride=[1,2],padding=[0,1])\n",
    "        # print(x.shape)\n",
    "        x=self.conv5(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=self.conv6(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x = self.conv_bn_6(x)\n",
    "        x=torch.nn.functional.max_pool2d(x,kernel_size = [2,2],stride=[2,2],padding=[1,0])\n",
    "        x=self.conv7(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=self.conv8(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=torch.nn.functional.max_pool2d(x,kernel_size = [2,2],stride=[2,2],padding=[1,0])\n",
    "        x = self.conv_bn_8(x)\n",
    "        # # print(x.shape)\n",
    "        x=self.conv9(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=self.conv10(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=torch.nn.functional.max_pool2d(x,kernel_size = [2,2],stride=[2,2])\n",
    "        x = self.conv_bn_10(x)\n",
    "        x=self.conv11(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "        x=self.conv12(x)\n",
    "        x=torch.nn.functional.relu(x)\n",
    "#         x=torch.nn.functional.max_pool2d(x,kernel_size = [2,2],stride=[2,2])\n",
    "        x = self.conv_bn_12(x)\n",
    "#         print(x.shape)\n",
    "        x = torch.flatten(x, 1)\n",
    "#         print(\"Size\",x.shape)\n",
    "        x = self.fc1(x)\n",
    "        x = torch.nn.functional.relu(x)\n",
    "        x = self.dropout1(x)\n",
    "        x = self.fc2(x)\n",
    "#         x = torch.nn.functional.relu(x)\n",
    "#         x = self.dropout2(x)\n",
    "#         x = self.fc3(x)\n",
    "#         x = torch.nn.functional.relu(x)\n",
    "#         x = self.dropout3(x)\n",
    "#         x = self.fc4(x)\n",
    "\n",
    "        # output = F.log_softmax(x, dim=1)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "P62JUhmL0ANv",
    "outputId": "0f6db1ba-197c-4426-855c-5e93676b4479"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SumNet(\n",
      "  (conv1): Conv2d(1, 2, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (conv2): Conv2d(2, 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv_bn_2): BatchNorm2d(4, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (conv3): Conv2d(4, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv4): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv_bn_4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (conv5): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv6): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv_bn_6): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (conv7): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv8): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv_bn_8): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (conv9): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv_bn_10): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (conv11): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (conv12): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (conv_bn_12): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc1): Linear(in_features=512, out_features=256, bias=True)\n",
      "  (dropout1): Dropout(p=0.5, inplace=False)\n",
      "  (fc2): Linear(in_features=256, out_features=37, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "model = SumNet()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "loss = torch.nn.CrossEntropyLoss()\n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min',verbose=True,patience=240)\n",
    "if torch.cuda.is_available():\n",
    "    model = model.cuda()\n",
    "    loss = loss.cuda()\n",
    "    train_y = train_y.cuda()\n",
    "    train_x = train_x.cuda()\n",
    "    val_y = val_y.cuda()\n",
    "    val_x = val_x.cuda()\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "JubYSK0ZWbVM"
   },
   "outputs": [],
   "source": [
    "def get_accuracy(pred,y):\n",
    "    accu_sum=0\n",
    "    for i in range(len(y)):\n",
    "        maxi=-100000\n",
    "        maxind=-1\n",
    "        for j in range(37):\n",
    "          # print(pred[i][j])\n",
    "          if pred[i][j] >= maxi:\n",
    "              maxind = j\n",
    "              maxi=pred[i][j]\n",
    "        if(maxind==y[i]):\n",
    "            accu_sum+=1\n",
    "        \n",
    "    return accu_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1C0RL-0l0G6k",
    "outputId": "c656bd8c-00b6-4cb3-f145-0056ab014c70"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch # 0 Completed\n",
      "2.842319965362549 2.8668627738952637\n",
      "0.07133333333333333 0.071375\n",
      "Epoch # 1 Completed\n",
      "2.5261292457580566 2.524479866027832\n",
      "0.121125 0.11255\n",
      "Epoch # 2 Completed\n",
      "2.2371721267700195 2.302424907684326\n",
      "0.16554166666666667 0.159925\n",
      "Epoch # 3 Completed\n",
      "2.062661647796631 2.0926098823547363\n",
      "0.20441666666666666 0.19025\n",
      "Epoch # 4 Completed\n",
      "2.0755865573883057 2.013603925704956\n",
      "0.24358333333333335 0.22525\n",
      "Epoch # 5 Completed\n",
      "1.8730725049972534 1.8063042163848877\n",
      "0.281375 0.257575\n",
      "Epoch # 6 Completed\n",
      "1.6587549448013306 1.9023109674453735\n",
      "0.30783333333333335 0.285675\n",
      "Epoch # 7 Completed\n",
      "1.597712755203247 1.777189016342163\n",
      "0.336 0.31295\n",
      "Epoch # 8 Completed\n",
      "1.4269031286239624 1.8110798597335815\n",
      "0.355375 0.322525\n",
      "Epoch # 9 Completed\n",
      "1.4998295307159424 1.6369822025299072\n",
      "0.4154583333333333 0.354275\n",
      "Epoch # 10 Completed\n",
      "1.518065333366394 1.622853398323059\n",
      "0.435875 0.3778\n",
      "Epoch # 11 Completed\n",
      "1.5229274034500122 1.524061679840088\n",
      "0.46166666666666667 0.398425\n",
      "Epoch # 12 Completed\n",
      "1.1496915817260742 1.4924421310424805\n",
      "0.466625 0.403375\n",
      "Epoch # 13 Completed\n",
      "1.268006682395935 1.6786555051803589\n",
      "0.49654166666666666 0.414775\n",
      "Epoch # 14 Completed\n",
      "0.9456402659416199 1.693528413772583\n",
      "0.5089583333333333 0.422025\n",
      "Epoch # 15 Completed\n",
      "0.9922736883163452 1.55180823802948\n",
      "0.5204166666666666 0.44415\n",
      "Epoch # 16 Completed\n",
      "0.9866721630096436 1.5939795970916748\n",
      "0.5651666666666667 0.453725\n",
      "Epoch  1427: reducing learning rate of group 0 to 1.0000e-04.\n",
      "Epoch # 17 Completed\n",
      "0.8813112378120422 1.4321409463882446\n",
      "0.541875 0.441425\n",
      "Epoch # 18 Completed\n",
      "0.7461456060409546 1.4468050003051758\n",
      "0.6574583333333334 0.51615\n",
      "Epoch # 19 Completed\n",
      "0.6420111656188965 1.58318030834198\n",
      "0.6909166666666666 0.525875\n",
      "Epoch # 20 Completed\n",
      "0.6400637626647949 1.6668965816497803\n",
      "0.6908333333333333 0.55\n",
      "Epoch # 21 Completed\n",
      "0.6431359052658081 1.4363670349121094\n",
      "0.7442916666666667 0.54155\n",
      "Epoch # 22 Completed\n",
      "0.6290462017059326 1.707265853881836\n",
      "0.7639583333333333 0.5468\n",
      "Epoch  1911: reducing learning rate of group 0 to 1.0000e-05.\n",
      "Epoch # 23 Completed\n",
      "0.7087494134902954 1.350293755531311\n",
      "0.7703333333333333 0.540075\n",
      "Epoch # 24 Completed\n",
      "0.4476761817932129 1.6549382209777832\n",
      "0.7835416666666667 0.557225\n",
      "Epoch # 25 Completed\n",
      "0.9662656784057617 1.798094391822815\n",
      "0.7900416666666666 0.5633\n",
      "Epoch  2152: reducing learning rate of group 0 to 1.0000e-06.\n",
      "Epoch # 26 Completed\n",
      "0.5504209995269775 1.51406729221344\n",
      "0.7950416666666666 0.561975\n",
      "Epoch # 27 Completed\n",
      "0.47091904282569885 1.2654489278793335\n",
      "0.776125 0.562025\n",
      "Epoch # 28 Completed\n",
      "0.7018250823020935 1.4729011058807373\n",
      "0.7864166666666667 0.554825\n",
      "Epoch  2393: reducing learning rate of group 0 to 1.0000e-07.\n",
      "Epoch # 29 Completed\n",
      "0.5162415504455566 1.7928736209869385\n",
      "0.809 0.5565\n",
      "Epoch # 30 Completed\n",
      "0.6021323800086975 1.6906931400299072\n",
      "0.7995 0.551075\n",
      "Epoch # 31 Completed\n",
      "0.6677266955375671 1.4515626430511475\n",
      "0.781375 0.5655\n",
      "Epoch  2634: reducing learning rate of group 0 to 1.0000e-08.\n"
     ]
    }
   ],
   "source": [
    "index_list = np.arange(24000)\n",
    "val_index_list = np.arange(6000)\n",
    "\n",
    "train_losses= []\n",
    "val_losses = []\n",
    "\n",
    "train_accs = []\n",
    "val_accs = []\n",
    "\n",
    "batch_size = 300\n",
    "cnt=-1\n",
    "for epochs in range(100):\n",
    "  acc_sum_ep_val = 0\n",
    "  acc_sum_ep_trn = 0\n",
    "\n",
    "  random.shuffle(index_list)\n",
    "  for batch_no in range(int(len(train_x)/batch_size)):\n",
    "    cnt+=1\n",
    "    # print(index_list[batch_size*batch_no:batch_size*(batch_no+1)])\n",
    "    train_batch_x = train_x[index_list[batch_size*batch_no:batch_size*(batch_no+1)]] \n",
    "    train_batch_y = train_y[index_list[batch_size*batch_no:batch_size*(batch_no+1)]]\n",
    "\n",
    "    output_train = model(train_batch_x.float())\n",
    "    loss_train = loss(output_train, train_batch_y)\n",
    "    train_losses.append(loss_train.item())\n",
    "    optimizer.zero_grad()\n",
    "    loss_train.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    if(cnt%1==0):\n",
    "      random.shuffle(val_index_list)\n",
    "      val_batch_x = val_x[val_index_list[:500]]\n",
    "      val_batch_y = val_y[val_index_list[:500]]\n",
    "\n",
    "      output_val = model(val_batch_x.float())\n",
    "      loss_val = loss(output_val, val_batch_y)\n",
    "      val_losses.append(loss_val.item())\n",
    "      scheduler.step(loss_val.item())\n",
    "    else:\n",
    "      val_losses.append(val_losses[-1])\n",
    "\n",
    "    if(cnt%1==0):\n",
    "      acc_tmp = get_accuracy(output_val.cpu().detach().numpy(),val_batch_y.cpu().detach().numpy())\n",
    "      acc_sum_ep_val+=acc_tmp\n",
    "      val_accs.append(acc_tmp/500)\n",
    "      acc_tmp = get_accuracy(output_train.cpu().detach().numpy(),train_batch_y.cpu().detach().numpy())\n",
    "      acc_sum_ep_trn+=acc_tmp\n",
    "      train_accs.append(acc_tmp/batch_size)\n",
    "\n",
    "  for param_group in optimizer.param_groups:\n",
    "        lr = param_group['lr']\n",
    "\n",
    "  if(lr<0.0000001):\n",
    "    break\n",
    "\n",
    "  print(\"Epoch #\",epochs,\"Completed\")\n",
    "  print(train_losses[-1],val_losses[-1])\n",
    "  print(acc_sum_ep_trn/len(train_x),acc_sum_ep_val/(500*int(len(train_x)/batch_size)))\n",
    "  # if(epochs>=5):\n",
    "  #   inp = input()\n",
    "  #   if(inp == \"s\"):\n",
    "  #     break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 299
    },
    "id": "Q-v8L7RPZyM-",
    "outputId": "6f7197f0-e855-4aab-9483-62f6e5e1b49d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x15525297ea90>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_losses,label=\"Training Loss\")\n",
    "plt.plot(val_losses,label=\"Validation Loss\")\n",
    "plt.title(\"Loss Vs Iterations\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 299
    },
    "id": "qRtrSSUh9lV_",
    "outputId": "4c2ddb71-0398-43d1-c819-a1939452e359"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1552529175d0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_accs,label=\"Training Acc\")\n",
    "plt.plot(val_accs,label=\"Validation Acc\")\n",
    "plt.title(\"Accuracies Vs Iterations\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "xBLBEz3yZBc4"
   },
   "outputs": [],
   "source": [
    "# Accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xO0_8QiH5M_b"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FbAfJaTwWBZH",
    "outputId": "c1cd94eb-c175-494e-91b4-da41fa2ff767"
   },
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "CUDA out of memory. Tried to allocate 54.00 MiB (GPU 0; 10.92 GiB total capacity; 9.94 GiB already allocated; 45.00 MiB free; 427.81 MiB cached)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-be68cce843c7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mtrain_batch_x\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_x\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mbatch_no\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_no\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[1;32m      5\u001b[0m     \u001b[0mtrain_batch_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_y\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mbatch_no\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_no\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----> 6\u001b[0;31m     \u001b[0moutput_train\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_batch_x\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\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      7\u001b[0m     \u001b[0mcorrect_preds\u001b[0m\u001b[0;34m+=\u001b[0m\u001b[0mget_accuracy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtrain_batch_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\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[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Overall Train Accuracy: \"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mcorrect_preds\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_x\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~/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    539\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\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--> 541\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    542\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\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[1;32m    543\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\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-18f3cf4a1428>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     61\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv10\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_pool2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mkernel_size\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mstride\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\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[1;32m     65\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv_bn_10\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mrelu\u001b[0;34m(input, inplace)\u001b[0m\n\u001b[1;32m    912\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    913\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--> 914\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\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[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    916\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: CUDA out of memory. Tried to allocate 54.00 MiB (GPU 0; 10.92 GiB total capacity; 9.94 GiB already allocated; 45.00 MiB free; 427.81 MiB cached)"
     ]
    }
   ],
   "source": [
    "batch_size = 500\n",
    "correct_preds=0\n",
    "for batch_no in range(int(len(train_x)/batch_size)):\n",
    "    train_batch_x = train_x[batch_size*batch_no:batch_size*(batch_no+1)] \n",
    "    train_batch_y = train_y[batch_size*batch_no:batch_size*(batch_no+1)]\n",
    "    output_train = model(train_batch_x.float())\n",
    "    correct_preds+=get_accuracy(output_train.cpu().detach().numpy(),train_batch_y.cpu().detach().numpy())\n",
    "print(\"Overall Train Accuracy: \",100*correct_preds/len(train_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jf1c4C1QXapL",
    "outputId": "a335bc38-825d-4390-f52b-0cf24fb963d9"
   },
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "CUDA out of memory. Tried to allocate 20.00 MiB (GPU 0; 10.92 GiB total capacity; 10.08 GiB already allocated; 5.00 MiB free; 325.18 MiB cached)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-af999e9291c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mval_batch_x\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval_x\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mbatch_no\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_no\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[1;32m      5\u001b[0m     \u001b[0mval_batch_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval_y\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mbatch_no\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_no\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----> 6\u001b[0;31m     \u001b[0moutput_val\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval_batch_x\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\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      7\u001b[0m     \u001b[0mcorrect_preds\u001b[0m\u001b[0;34m+=\u001b[0m\u001b[0mget_accuracy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput_val\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mval_batch_y\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\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[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Overall Validation Accuracy: \"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mcorrect_preds\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval_x\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~/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    539\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\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--> 541\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    542\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\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[1;32m    543\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\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-18f3cf4a1428>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     45\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_pool2d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mkernel_size\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mstride\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpadding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\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[1;32m     46\u001b[0m         \u001b[0;31m# print(x.shape)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv5\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     48\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     49\u001b[0m         \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv6\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    539\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\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--> 541\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    542\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\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[1;32m    543\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\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/tf-gpu-cuda/lib/python3.7/site-packages/torch/nn/modules/conv.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    343\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    344\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\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--> 345\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv2d_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\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    346\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    347\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mConv3d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_ConvNd\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~/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/nn/modules/conv.py\u001b[0m in \u001b[0;36mconv2d_forward\u001b[0;34m(self, input, weight)\u001b[0m\n\u001b[1;32m    340\u001b[0m                             _pair(0), self.dilation, self.groups)\n\u001b[1;32m    341\u001b[0m         return F.conv2d(input, weight, self.bias, self.stride,\n\u001b[0;32m--> 342\u001b[0;31m                         self.padding, self.dilation, self.groups)\n\u001b[0m\u001b[1;32m    343\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    344\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\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;31mRuntimeError\u001b[0m: CUDA out of memory. Tried to allocate 20.00 MiB (GPU 0; 10.92 GiB total capacity; 10.08 GiB already allocated; 5.00 MiB free; 325.18 MiB cached)"
     ]
    }
   ],
   "source": [
    "batch_size = 100\n",
    "correct_preds=0\n",
    "for batch_no in range(int(len(val_x)/batch_size)):\n",
    "    val_batch_x = val_x[batch_size*batch_no:batch_size*(batch_no+1)] \n",
    "    val_batch_y = val_y[batch_size*batch_no:batch_size*(batch_no+1)]\n",
    "    output_val = model(val_batch_x.float())\n",
    "    correct_preds+=get_accuracy(output_val.cpu().detach().numpy(),val_batch_y.cpu().detach().numpy())\n",
    "print(\"Overall Validation Accuracy: \",100*correct_preds/len(val_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "4OFniI72ZUw1"
   },
   "outputs": [],
   "source": [
    "#saving and loading the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "mRN-4VHxbVBI"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jashn.arora/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/serialization.py:292: UserWarning: Couldn't retrieve source code for container of type SumNet. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jashn.arora/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/serialization.py:292: UserWarning: Couldn't retrieve source code for container of type Conv2d. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jashn.arora/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/serialization.py:292: UserWarning: Couldn't retrieve source code for container of type BatchNorm2d. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jashn.arora/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/serialization.py:292: UserWarning: Couldn't retrieve source code for container of type Linear. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jashn.arora/anaconda3/envs/tf-gpu-cuda/lib/python3.7/site-packages/torch/serialization.py:292: UserWarning: Couldn't retrieve source code for container of type Dropout. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "torch.save(model,\"SumNet_final_model_2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 17
    },
    "id": "tXXLk6AjcN-8",
    "outputId": "130ea159-f878-4299-e4d0-3bd6a73627da"
   },
   "outputs": [],
   "source": [
    "from google.colab import files\n",
    "files.download('SumNet_inital_model_2') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "bblHIvM2Zf45"
   },
   "outputs": [],
   "source": [
    "saved_model = torch.load(\"SumNet_final_model_2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dVj0Y1j6ctmk",
    "outputId": "9bca7beb-7a43-483d-9885-b16727de86af"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SumNet(\n",
       "  (conv1): Conv2d(1, 2, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (conv2): Conv2d(2, 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv_bn_2): BatchNorm2d(4, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (conv3): Conv2d(4, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv4): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv_bn_4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (conv5): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv6): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv_bn_6): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (conv7): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv8): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv_bn_8): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (conv9): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv_bn_10): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (conv11): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (conv12): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (conv_bn_12): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (fc1): Linear(in_features=512, out_features=256, bias=True)\n",
       "  (dropout1): Dropout(p=0.5, inplace=False)\n",
       "  (fc2): Linear(in_features=256, out_features=37, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "saved_model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZcUHBigPcwBa",
    "outputId": "01ae0006-7d5c-4cdc-d7ef-d784e9c4e0f8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall Train Accuracy:  96.28333333333333\n"
     ]
    }
   ],
   "source": [
    "batch_size = 500\n",
    "correct_preds=0\n",
    "for batch_no in range(int(len(train_x)/batch_size)):\n",
    "    train_batch_x = train_x[batch_size*batch_no:batch_size*(batch_no+1)] \n",
    "    train_batch_y = train_y[batch_size*batch_no:batch_size*(batch_no+1)]\n",
    "    output_train = saved_model(train_batch_x.float())\n",
    "    correct_preds+=get_accuracy(output_train.cpu().detach().numpy(),train_batch_y.cpu().detach().numpy())\n",
    "print(\"Overall Train Accuracy: \",100*correct_preds/len(train_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "apQYRCY6f0lG",
    "outputId": "975cf002-6b70-4f01-8e3a-a6658dd1f551"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall Validation Accuracy:  61.916666666666664\n"
     ]
    }
   ],
   "source": [
    "batch_size = 500\n",
    "correct_preds=0\n",
    "for batch_no in range(int(len(val_x)/batch_size)):\n",
    "    val_batch_x = val_x[batch_size*batch_no:batch_size*(batch_no+1)] \n",
    "    val_batch_y = val_y[batch_size*batch_no:batch_size*(batch_no+1)]\n",
    "    output_val = saved_model(val_batch_x.float())\n",
    "    correct_preds+=get_accuracy(output_val.cpu().detach().numpy(),val_batch_y.cpu().detach().numpy())\n",
    "print(\"Overall Validation Accuracy: \",100*correct_preds/len(val_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "Bq0-53kyrBwV"
   },
   "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": [
      "8 8\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 26\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14 14\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28 29\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22 22\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAByCAYAAABKpoqAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmvElEQVR4nO3deZAb133g8e+vDzRuYO6bc3CGpKibki0qsnXZimRZPmQ7jr0+4+w6SVWSzVHZ2El2a7OV2sTZVBKnditZJU7W2Th2ZFu2tPIh27JkydZFiaTEmxzODDkn5wYwwABodL/9AyDFczgkh3OQ71PFItA4+oeH6V8/vH6HKKXQNE3T1h5jpQPQNE3TLo5O4JqmaWuUTuCapmlrlE7gmqZpa5RO4JqmaWuUTuCapmlr1CUlcBF5QEQOiEiviHxuqYLSNE3Tzk8uth+4iJjAQeA+YAjYBnxUKbV36cLTNE3TzuVSauBvBXqVUn1KqSLwNeB9SxOWpmmadj7WJby2BRg86f4QcNtCLwiIo4JELmGXmqZpV58MM5NKqbrTt19KAl8UEfks8FmAIGFuk3dc7l1qmqZdUX6kvnHkbNsvpQllGGg76X5rZdsplFKPKKVuVUrdauNcwu40TdO0k11KAt8G9IhIp4gEgI8ATyxNWJqmadr5XHQTilKqJCK/DjwFmMA/KqX2LFlkmqZp2oIuqQ1cKfVd4LtLFIumaZp2AfRITE3TtDXqsvdCWa2MYBBpbwVDwC0h+SKlkTHwvcW9gQhi2RjRCKqlAfF9JDuPyuXxJidBL5ShadpldtUmcHVdN5P/tUjUKXB0rBq7L0TXX+fwZmYW9XrDcTCaG5l5SyMdv3mA6UKY3h1txA4bNP6fLH4ud5k/gaZpV7urNoH7jsWW+sM0OmleMLrozTSBufgWJQk6uI0Jso0GH67fxlQpyhfTcbLFJEYiXt6HTuKapl1GV20CPy5sFOmITtMXrwXTXPwL62sZvC+CuzHHFmeMcFC46cajfKH2XYxu6yYymEN27EOVSpcveE3TrmpX5UVMsQP4AYOQ6RI2ioTMIoZxAW3WhokfC5JvcWmrmyEmBgkjyDU2dEcmKMQMShH78n0ATdM0rsIauDgOZnMj6YYAb4n202LNMJCvWfzrLQsjFiPTHuV37vg+t4V7iRoOBoIjFlV2lkJSKM5aWHJVnh81TVsmV12GERFUwMYLCEkzS9go4GGglCz+TUwDLyBsDg7RZRUxePO1JgplgjKk3MNF0zTtMrnqEjimiQoFKAWhzswQE5eMG8QrGuAvohlFDBAD34Q6M0vCCF7+mDVN087i6kvghoGyTZQJAXxcDIZzCSRngfIX8XpBnAC+Jdj4p9S+NU3TltPV1wZuGpTCFl5QMETR59bSu6ONZK+gCsXzvt4IBXHbasnXCKbowTqapq2ctZfADRMzHi13+fMVeB5eJrP4kY+WRTFu44bL7dVpL4gzZRCc8cFbxChMO0CxKkApUn69pmnaSllzCdysSpC+p4dSUBAPnLRH+PkDeHPZxQ2DT8YZe6uJ6s4SMzyGijXU7ioR7k+jiuevgVMVZ/xmm8KGecK69UTTtBW0thK4CBIOk243cSsrszkzBpG9VZiG4KXS56+J2xbFGo/G5Bw24CoTK+dh5PKUFnERUwVsitU+8fg8ppyawX0Ued/GzINZ8Bd3UVTTNO0irZ0ELoIRjeKuq2XTwwd4e1UvG50Rnpy9iZfSt5IYqMZ6eR9+Pr/g2/jRIN0bR7mn7iBh4wJGXlZ4cYfaaya5o6GPsLz5+hIeE16B/dkGqg4WCA6n8RbTJKNpmnaR1kwCl0AAo66GuQaH+5ID3BU5QJcFA5FhXjRvXeSbCL5tUBPMUmtnKCifnB9APAX+InqgAMo2aIxkaAtOY5zUicdTioKCOdfBTheRTG5xvVquVoaJ2BZimmCaSDgE8SgEbPzgm3+WRnoeZlKo+Tx+NruCAWva6rNmErhZW8PQe5vJdHvcG9lHu6U45nnszTVTtT+HdXgUr+ie+w1EMEIhikGL2kCWoBTZWUiyL92IPTOPyswtKuGWgiZ31x7g7eGD2CfVwF08Mr7NdD5CZHACb0JPKbsQsyoB9TX4EQc37jB5o0N+6xwbG8f5UMOrAPgYfGHX/UR+0EDVvnmMn+5c2aA1bZVZGwlcBBVyyDUpgo1ZkkYRXxm8Vmhh32wjZrqAmssunIDFQCwLZQkRq0DQcJn1w2SKDqFiCbVQ8j+JMoSkmSMsJcoryZWZlf7gIqrcQ0YPoz9VpcZthMNIIkapPkG2LYwbNijGhMx6j7va+3ln1V4+FpsCwFM+P2oZ5LWmzURGA+ghU5p2qtWfwCtt36WGBNdu7eOBut3Umia7iw6///wvED4coP3YIbxcbsEar5gmEotSjJlcExqh0Urxcm49U9kwbZk03tzcJdWYDQyqzSJN4TTj3Z0EQg7e4SOLXyDiCmdWJaChlpmbqjm2VZFoT/GJ9T+k2pqjzkpTY2RptuaJiYGn3kzVb0seYu+tDaSna3QC17TTrPoELpaNUVdDti7AzfFjbHJGAZjw4gRGbCIjCgqF8yZfMQ1UyMFzhJiRx8TnyHwt2bkgyp265OYOU4SgCBGriBuzsCM63UB58rDyqkX1zHUnSHUZ1HRNckdTHw/FdhEWRcwwsTGxJYSrPGb8eYJi4ohNo52iu3qSvdHFTzimaVeLVZ/Azdpqhh9qJt3t8XDiNTbaBUZK8Hx6Ay3PuwT7pha1cIIEHYqtVeTqDVqsGab8CN/dcx3BQ075BHCJLEyqjCCdoUlebbdARQntMVFXeQ3c6FrH9JYaJrfAQ3e/yubwCG8P9Z54/JgX4IAbotnM0G2b9Jc8Xppfz7XOMLc4cJszRnPL9/loQ88KfgpNW51WbwI3TMxoBL8uSbZVEWzOUmfO40iAnIJ0KYSVLa9laYTDqEoNWkTAtsptrkGnvMqOYeBVRUh1Osw3KmJGkTEvgczYOCmWrL+2gRA0XLwA+PbVORuhEYthVCfLk4ZZJtnuKtKdBva6DO9PbqfBnKPZEnYXHV7I9TDpxpgsRFkXmubm8ABjpSQD+VrqrDSQIa9g2osipQssS5E3e7hYld4utgWWhdj2ieec75eXioRQoQBScJF8ERVy8EMXPte7OTaDNz6J8jzdrKYtmVWbwM14lOzbNzLbbfGLP/88d0b302QGKKgSg6V6Um6QYtJG3Gq87gaUIShL8G0hX2WWL4x1ghfyIVYiHM/zwfXPsSE4Rqdl8tJ8lFifQaLfXdwITG1hlYuUhds3cuRdFn6sRLhqnraqYT5e28t1oUFudrJMej4v56v4nTc+TOJrMeyMR2C2yMHGa/lW293MrfOJ9cxitCveFd7JP8++lS+/vpWafYuMQwTEwIxHkWgUPxmjVBWimLApJAzm6wzm6xWnzEG2QA6PXjfNR7te5rHBmxgbaGDDhhE+3PzqGc8zxcfAx8fAU2dewP6Lr32Azq+GYGJ60euuatr5rNoEjuMw12SSa1LcGulnc2Cm3EaKR1Bcap0shzptAjUWbrjcO0SZ4NtQTEAp4uN0ZogEizRGM7SGZ3l3fCeNZgFHwrjKxJ5TWDnvRO1du0gimIk4NNaSbreJd81QH52jJz5BW3Ca60KDRKTIAddiV76TF1Ld5PtjtB1IYaRzqJlZYqkGzEICN2JjbfKZ8xz2uS7bZtoJ9AcJTS1uaTojGsVIxPEakuQbwhTjJoW44EYFNwaFOg+rdp6TB9Eu9PXf13aATyXewPUtvivX8sHm7XwyPnzmfhFMMfCUj3+WM8KfNJVwm+IE5gugE7i2RFZvAk/GydyT47b2I2xxxmgwQxgIUXF4WzDFjQ0/4vXf2kFRmZjin5hYysAnaLgE8EgYBUxR2CiCAgkjgCkOABk/SGjGw56eL/+s1S6OYWIEbLJv6+Howz7Xdg3whY7HCIqHIzBUCrG/2MSXJ69n24FOIocCNL04z4bxKfy+o3i+QpVcDLdEeGoWub6bT3a+zPbMOj6+85dQP6ti/deOojIZFvMtlW7qZuz2EKW3ZPijGx7DlhIBKZ/0bSkRFJeIuBgnzSTpL7CYR4PpkjAcfin5Gg/Hd1BjKjhLfxgfBedI3j4+G3pG6HuwjbYfNmAPDi2mZDXtvFZvAgeUEkrKwFPgKg9TBAODkAQImQHuC82f8vyCOr2WVv54tphnzNvtKwPDVYjrLW5OQcPECAXxgga2eAREj7IEMAI2RjJBrs5kQ/sId9UeZIMdIOXnOeYZ7Cm08PT0NewcbCV8OEDisIe9fxiVm0cdv3gsgoSCUFuFG1f0OGPszLSRnQtSNavwRscWfZLN1wWY6ypxb1s/H4qOnSvqU0bR+pz7uzQIAVBrhqg2/XM+38A4kbzP9rhp+CiDq/K6iHb5rN4EPp0i8XQd29dv5IcPb+CW4AB1ZoGgCFVG8IyEXFAlDrqK4skHpjIISolWK09QTEISOPHcvG8jHuAtLhGb8SjudZ2kOk067AmqDUMv5gAYTQ1kbmxgaovPP69/9EQN9fG59XzxwD3k9yVpfq5E12Qec/AwKp/HS7856lUsCwkESN/dzch7XO7auJvbg7NsD0/wvNWFMkCVFtd8AjB5ncm/3f9FGs0C4FyeD30R9g820vKiT3BgZlG/JDRtMVZvAneLREdL+AGLb45sYXeihRZnlrBRpNmewZZTD+pZL8z2bAdFv/yRvMrP4rrAHO9NbKfOKNBq2bjKY9QrMlJIYOY9pOiiFtMLxbJw4zalMETExZHVW3TLToGRF7bl1xExithS4jsT15PtS5Dsh/ChSUjNUZqYOOOlZm0NXls9qS6T6zqOsCV2FBuTlBfCTTtY82fZ30IMiEl5VG3GL2IiGCJkfI+Mf+rFRVPUib+T0x3zokx5UbyTTtL+WS5OHnejM0y3feYJw1UeeeWh5iyCE0Ukt/Bka5p2IVZtFvJSaULP7yf8SgCereZgcANvNIbxggbz1QbqtIkE7ZwiuX8OKZbKk1NV7NmUZPuvt3FX7SF+teoNjnk+fzr6Ln5yoIdrDo/jjY0vqluXOA7ztRbFpE/CcHEkvNQfeU3yj00QezlP99FaHnnpgxQjBsWEEB322LRjDJXN4U/PntkEUum1cuzdXaz7VC+frH6BD8VexweGPOE7/dey7gkhPDCzQAPHmSKDil858DFuqhni3sQ+guISNgp8P3UDzx3rfnP352kDH91bT9U+wXDBKFWeu8B53vzEOM9e//Uztve6wmG3idCoRaBvCH82dQGfRtMWtmoTOErhZzKQASanEDtAZLoBFXQI1UZR1qkHnZl1kd29+KeNyowGr2UmHyJVCuErRca32T9Tj0wHUPPzKHeRXQgNA98CZYJ5lkqbj6KgXKZLkRO9W66G+cD9fLkd21CKeMHFizoUq4MER+fwBkfO3u9ZBLM6CXXVZNuEDzZspycwRp1psbto83xuA7nRKK2jcxizmQtK4KFpn8H+OqazYcYbYoRMl4BRYtvYOmaGE6fFwTmTcvKwQdX+eaTkY7jeObuqKNvEtwyG5049obvKw1U+r+S7eW5mA840qGz2gpqDNO18Vm8CP41yi3jDo+U+voMWnLaYAp53RvI+mwG3lunt9VQfZlFrYC7WnF9gezHGM2M9NDw7DuOTeIs9Oaxlvoc/Pw/5AjKbwhAhaNvgumc9OYplIaHQiTbvn+vZy4PhQTLKp69k8Zv7PoL6Zi3rD+eRPYfxLjDhxZ7ex+btCfxYhOl4W3kiNIGGdJ6m1Oii30fl8qjj09cuMNWw0dlGqTmOYZw6GdqRkuKwW8uf/fg9tH1f0bR/bHELjmjaBThvAheRNuCfgQbK9ZVHlFJfFJFq4N+ADmAA+LBS6rJ2cD1ee1l0rVkEDAPH9HCM8mszfpDAjBCc9Ra3BuY5mKfNNphRPq/PtzMxGyWRGitfqLtaKAXKQxUqPXoWWFTDiMWgvoZMS7nN+7ZEP1HDYcwtsDPfysSxBN2H8tijs3jnWZzjbLx0GtJpjGAQKxQ60etDZXOULuL9zkXsAGJbuLVRUh0BaqNTGMiJnih7io08l9pEaMgkcnAcpmd18taW3GJq4CXgd5VS20UkBrwmIj8EPg08rZT6MxH5HPA54PcvX6gXSATDcXCjNtdVjXJj+CguiqFiNck+j0j/HMpdup+zOwv1/M9X7yG830Hl5vVw6dNVRki6N3QweG+I2C2T/FXHN0gYAgT5ZnoLX3r1bVS/ZGNt34e/yOl9z8UvFODk91jixTXMlkbc5ip6/53N5+9+nK2hPkwJUlIurvL4410PEXwqTtuODH7fUT3WQLsszpvAlVKjwGjldkZE9gEtwPuAuytP+zLwLKsqgRtI0MFzTOoCGZJGjilPGC/GCKRKGJncki55llc2zFlYWS6pZn+lMhNxqK1mpiOI2zXPDbUjrLNCzPh59hRLvDTdSXAgQORYaWlW3qn8KlhylYuvXm2cubYQ8aYU74kcJGaUD6WhUoGBUoL50SgNfUXMiRSlq6EpTVsRF9QGLiIdwM3Ay0BDJbkDjFFuYlk1jIANDXXk6ixujxyizUrz3blr+dloJ419k3hDo7qWvIxyt2/gyPuEDT2D/G3XY9SZRSDEv6Su5+92vZ3QKxG6Hh1AZeZWdT9ps6YaqhMM3RmnuDXDx7t2kDDK4wvm/DyfH3wf295YT8sz4Ly4H28JZrrUtHNZdAIXkSjwTeC3lFJpOekiolJKichZG/hE5LPAZwGCLGPXO9umVBOhGC+voGMAh/N1pDNhGudTi29HPwdPr3d5pkqzlUQjUHTx5rIYQQcJh8g1WDSsm+AtNUe4xoZpH14rwHNTPUhfmNigR2l4ZKU/wblVmoCorybXESfX4nNT0ygbgqOYIkx4BaZ9i73jjUT7LMKjWb2Gp3bZLSqBi4hNOXl/RSn1WGXzMRFpUkqNikgTMH621yqlHgEeAYhL9bJdxTGSCYZvj5DpKZE0iox4YZ7quwajP4RyL619VTuLStOCumY9E7fGiQ6VCG8/Qml9E9PXhpm6xeN32rfRHphgyHP5m/F38J3tN1C106L7u0Oo9OqueUsggBEKMvhgDc0PHOXXG3fznujuSht+gG9lruXJseuxn07Q9I1eVGbugro/atrFWEwvFAG+BOxTSv3lSQ89AXwK+LPK/49flggvlm1RqFbYyTw2iqzvkJ8OEk3JxbVRK4V4IB54ujPBqSr9ulVjHenuKKn14IZtDLeNzLoAqW4I12WxpcS0F2Vnwea1yVYifTbxoy7e8Ojqvch3fHra5kbcxiTZdR73N+xla+gwrZZDyi9ypFTk+ZluDvY30jri4R07a11G05bcYmrgdwCfAHaJyM7Ktj+gnLgfFZFfBo4AH74sEV4kPxxErc9ya9sgEUMYdGtIvmGX5//OX3i7pCoUCU172BmLjLIoqJIeTk+5O50RCpK+u5uJX5jnxpZe/rT5aTJ+kIlSnJiRp85Ks32+gx9MbmZkLsHEVIzYthDtjx7Gz+bwV/HgFiMcRqIRBj7SwrXvPsB/qd3Fg5F+HDEAi69nNvH/xm5g9Il2Nn97CDU9u6p/SWhXlsX0QvkpnHPWpncsbThLRATlmNQl5+iKTGIvxaRTpRJ2poSdsdhVaMFkiA22ias8jnlFevPXYKUN7KxacODHFaMyjaxRlcRvqCbdbnLbugHuSh7kdsfDJ4On0idmkNybdzkwUU9uKowzZhEd9iiNHVv0fpRS4KtlW9FG7AASsJGmekp1cXLrSnygbjvXOyMkjAApv8gxr8jzMz0c6G+i9ahHaeDoZY9L00525VUhKxfSClVBfqXjKe4LDxA1QrTZU8xeX6IUsml7wVlwsMnZeKk09rYDNBa7+c83vJ8N68b4as/XOVIy+W+DD7Pj8Dq6n8pjj2XwLrEP81pg1lTjtzdw7OYYqXvmeUv7Pv64+bvEKv26DYxTZk795ugWEo/GaB4rEOgdRmWzi6qpmjXVqKYajJIPJQ9m0nhnmRRrqZktjbgt1QzfGcbfkuGTG37GO8NDBKU8Cc/xmvfIk+1s/vYIalrPMqgtvysvgVeYBZ/nUxvJ+Q6GKF7LtGPOGVh5Lm6OEt/Dz2axprI4/fUc8Jp4pO5GhgtJdva3ETziYI+Nw3RqyQeNrCrH15qsijPXHiGzDm5pP8qdVQdptUJnPP1oaZ5dxUb6RmtZP1QeYblgb5PK+xuxGJKM4zZXMdcWxHAVZlERPhpAZmbKM0herpq4CF5VjMy6IPOtHne1DXBz+AgJI8ikN8+EDz+b6ebg0UaaBj1K/Uf0KEttRVx5CVwp/EIBa/tBhj/TypDdDoC4HhvTQ6h8AS+Tuei39/uO0vXIHAQdno3fCp7imuwU5At4k9Pln/hX8MFshEIY1VVMbq2n+MEZ7mvu53frnz5R8z6Zj89vD3yIkX/ppL2/iLXr0Hn7RRvhMEZVkuk72xi7y6OtY5JPr/sBo8UkI4UEz/7gJrqnG8sr9FyGmf2Oz09+7LY4pQdm+UTnG/xq1cuEDRMI8KXZW3ls4Ebc52voeX4Oa3CU0hX8fWur25WXwKGcxLNZ2HNg6d/aLVIaPXWllyu4vn2CWBbiOEhTPbn1NaQ7hDubjvDW2OGz1rzn/AITvqJvqoamg3ns0TTeXPacv07EcTCiEaivYb4lTqrToKNrlPsa9vP+6CEGSzb7i038MH4DmEa5T/aSf0jBrKvFr0uSbYGfaxzilnA/TVaUOT/PjJ9nZ6qV2aNJGoZ8rIFj+JmraM4bbdW5MhO4tuTMuloKm5oZeVuQ93/gp1wbHuau0BEiYnC2lW9eKFTzT6Nvo7QrgbV9V3na2QWaPIzuDqZvrmLyJnjr7Qd4b7KfB6N7SBrltUwHUcx6YYyCgcrOo4pLOzxdHAcjFOTYg53M3pvnwY2v8tt1z5A0DDwVZHsxyIvZHl7/WQ/dj+ewh6YojU9e2c1l2qqnE7h2fiKo6gSz3Q7zHUU+nNxGrenSYJ5Z8z5uzE1yaKoOZxb8ubkzmpWON1VIKIiEQmQ74qTWGzidKd5ft5319gTNpkleeRzzCryW38BTE9fiTAu4xaWbb6YyAMlsaqBUnyDTATetG+S2WB/NlkPGLzJQyvHc3K38aGwTkRHBHppCpdJ6KgZtxekEri2s0o1vfGs17/+NZ7g5PEC3rbBl4fUmd8y1U3gjSe3g2a8JmA31uB31pLpCzG4C59pZ/mTzd2izp+iyiuSUote1eSXfw4up9Tz/s2vp/HaB9tHR8rzaS8SsTkJNFUcerqfuHcN8pvElPhTfcWKE5eNz6/nOxPXsfbab1mcKtBwZuaBFljXtctIJXFuQEXQwqqvI1wrvir1Bg1nEkTdr3j4+XiVBH+/zDTDv2ZjzglkoPyaOgxGLIo4DToBiWxWzXUHm2gXVleW2pqPcFRol4yuOlALsKTTz6lwn+1KNHBmvJjpgEDg0gp/NLclF4uO/AKivYb4tTq7N4z1Nu7gt3Eur5TDtFeh1S/xkdgM7+9uoGQCndxyVSutVdbRVQydwbUHS3sL41lqymwp0WSXCxqk174xfZMQziUiJmCE4YhCWwJnv09PJxFuryDYL+e4CzY0zPNz8Al3OOJudUaqNEjHD4Uuzm/n7XXcQ2hGm9XvT2G6JHjeFyoxQmppesjZns6kRt7WG0TsiFG7J8vCG7Xw0/kalt4nFV9M38PXBm8k91cA1jw+j0hm8VFrXvLVVRSdw7ewqc4CUkmGyrUK8Kocj1oka9vGad18pwI8y11FrZ+iwJ2izUnTbUB3IUqjxmWs2CV+3icymBOn1UGwucH3nMLckj/JQ/HWqjRINZogZ32Nf0efF6S7MvhDJXg9/9/4l/1hGOIzEohQ76pjtDpLt8NjSOsyW6BGqTYeRUoERz+HHkxsZ668pj7DsP7LkcWjaUtAJXDsrw3GQRJyJa8Jcd/8B7qo+iF0ZhQhv1rx/v/cXyTzaTK5BKGyc547uw/z9uqf5DzU/5fqHBukv1LPvk43cHN7L1mgvNeYczWaOiCFExcbHIqeK/MPMFv5p9+2Et4Xp/tYQKpW5LCMbvZt6mNgSYe7ncvzezY+zPnCMDit1os37T0Yf4MfbN1Oz3eSaF6dhfFqPsNRWLZ3AtQUpAyJWkaCUpwfIqSLTnsdet5YfpzYz0F/P+t4ChutQqHEYbS6v/F5nCHeEBtjklJezazRTdNt5bDEIisOEV+AN12TKjzNRivP90c0YfSFigx7e0MiSN1WIHUCCDpmmIOkunxtbh3lP5GCl3V6Y9uGAa7JjvIXIEYvYYBEGR/Hnl24dTU1bajqBa2flFwowMUX86DqefX0TU5sifDw+yKuFKF8au5OXXttAz7/Oc83UFGrkGMliD/P1YcY6YgBEDQdHPBpMj432BCaCLQFc5ZHyi/zVxJ08tu1WgiMWyV6fyGiR7oNHynOkXIaLhEZ7C/mOaobfqfird36FjfY49WaY/W6B/cUGHhm8k4MHmqnZYdL28jTG+AylTOaKHlWrrX06gWtnV1lT0k4XCY5GOVxbw+51ihezPewYaSVy1MTYdRi/6KLcItbsPM50iOlUiCOlIkkDqowgUG52cZVHxi/S6wZ5Ld/DM8M9RPssokM+iX0ZzMnUZVmR53jN221JMtsTINk8w23OGLYI86rIzkIr35u6noNHGokdtogOuRjjM+URljp5a6ucTuDagswDg3Rm6pk4Ws0n1Gdw+2I0P+8RGkrh597s0qcGhmiYy+FbrXyu6/3cU3OQX032nXifI6US2/Lt/Pc33kX1NyPUjBQIHDqMKhRR8/OXpdYNYHS0Mr++hiPvNvjNe7/HltAACSNAf8njkFvLHz33Adq/DRtHchgjR1G5eUrZnB5hqa0JOoFrC/JzOYxjk0SHY8wejhE9KoSPZjCm0qdM4qQKBfzJaSLHmtnZ38Z0PoItbyblw/l69qSa8PuiJPbPYkymFjcf+EU6XvMutiSZ7baJts1wf2QvNabClADDpTivzHURGLMIHxqHqRm8qenLFo+mXQ46gWsLUoUCnlsi+MIBNuyJowpF/HQa77SLjKpUQnkesaf3cc3OKlTA5vHQXW8+oeQjnkdP5ijexOQZr19qJ2reDxr82r1P8ZZQP22WcaIb5Fcnt/KTVzbT/LqP3z+o+3dra5JO4Nr5+R5+JoN/vml4lcJLpyG9dEPdL5YfDzHXZGE3ZLk/uoc6o3TK8P9UMYidNrByJZS7tBNjadpy0QlcuyKlu2NM3V3gwa4DdFlgcOboUE1b63QC165IXkAIxwrUBOZOGYA0VCowUErQP1NDICVY87rpRFu7dALXriqfH3wfr/9kA9W7FVXbRmEmpUdaamuWTuDaFSmQ9Rkfj/BMZAP19ptt8q/1r6O6F2JH86hjk6j8wku8adpqphO4dkWK/Wgfm19LoIIOTwbfdmL7psxMeUrY+Tz+/LwerKOtaTqBa1ekc/WG0cNztCvJZVgZVtM0TVsOOoFrmqatUTqBa5qmrVE6gWuapq1ROoFrmqatUTqBa5qmrVE6gWuapq1ROoFrmqatUTqBa5qmrVE6gWuapq1RopZxLggRmQCywOSy7fTC1aLju1irOTbQ8V0qHd+luZT42pVSdadvXNYEDiAiryqlbl3WnV4AHd/FW82xgY7vUun4Ls3liE83oWiapq1ROoFrmqatUSuRwB9ZgX1eCB3fxVvNsYGO71Lp+C7Nkse37G3gmqZp2tLQTSiapmlr1LIlcBF5QEQOiEiviHxuufa7QDxtIvKMiOwVkT0i8h8r26tF5Icicqjyf9UKx2mKyA4RebJyv1NEXq6U47+JSGAFY0uKyDdEZL+I7BOR21dT+YnIb1e+290i8lURCa5k+YnIP4rIuIjsPmnbWctLyv6mEucbIrJlheL7H5Xv9w0R+ZaIJE967POV+A6IyP0rEd9Jj/2uiCgRqa3cX9byO1dsIvIblfLbIyJ/ftL2pSk7pdRl/weYwGGgCwgArwObl2PfC8TUBGyp3I4BB4HNwJ8Dn6ts/xzwhRWO83eAfwWerNx/FPhI5fbfAb+2grF9Gfj3ldsBILlayg9oAfqB0Enl9umVLD/gTmALsPukbWctL+BB4HuAAFuBl1covp8HrMrtL5wU3+bKcewAnZXj21zu+Crb24CngCNA7UqU3znK7h7gR4BTuV+/1GW3XH+4twNPnXT/88Dnl2PfFxDj48B9wAGgqbKtCTiwgjG1Ak8D9wJPVv4YJ086oE4p12WOLVFJkHLa9lVRfpUEPghUU1779Ung/pUuP6DjtIP8rOUF/G/go2d73nLGd9pjDwNfqdw+5RiuJNDbVyI+4BvAjcDASQl82cvvLN/to8A7z/K8JSu75WpCOX4wHTdU2bYqiEgHcDPwMtCglBqtPDQGNKxUXMBfA/+JN9firQFmlVKlyv2VLMdOYAL4p0oTzz+ISIRVUn5KqWHgL4CjwCiQAl5j9ZTfcecqr9V4zHyGcq0WVkl8IvI+YFgp9fppD62G+DYAb6802f1ERN6y1LFd9RcxRSQKfBP4LaXUKcuYq/LpcUW66YjIQ8C4Uuq1ldj/IliUfzL+rVLqZspTJJxybWOFy68KeB/lE00zEAEeWIlYFmsly+t8ROQPgRLwlZWO5TgRCQN/APyXlY7lHCzKvwC3Ar8HPCoispQ7WK4EPky5neq41sq2FSUiNuXk/RWl1GOVzcdEpKnyeBMwvkLh3QG8V0QGgK9Rbkb5IpAUEavynJUsxyFgSCn1cuX+Nygn9NVSfu8E+pVSE0opF3iMcpmulvI77lzltWqOGRH5NPAQ8LHKSQZWR3zrKZ+gX68cJ63AdhFpXCXxDQGPqbJXKP+Srl3K2JYrgW8Deio9AALAR4AnlmnfZ1U5E34J2KeU+suTHnoC+FTl9qcot40vO6XU55VSrUqpDsrl9WOl1MeAZ4APrYL4xoBBEdlY2fQOYC+rpPwoN51sFZFw5bs+Ht+qKL+TnKu8ngA+WelNsRVIndTUsmxE5AHKzXjvVUrlTnroCeAjIuKISCfQA7yynLEppXYppeqVUh2V42SIcseEMVZH+X2b8oVMRGQD5Qv9kyxl2V3uiw4nNdQ/SLmnx2HgD5drvwvE8zbKP1ffAHZW/j1IuZ35aeAQ5SvI1asg1rt5sxdKV+XL7gW+TuUK9wrFdRPwaqUMvw1UrabyA/4Y2A/sBv4v5av+K1Z+wFcpt8e7lJPNL5+rvChfsP5fleNlF3DrCsXXS7m99vgx8ncnPf8PK/EdAN61EvGd9vgAb17EXNbyO0fZBYB/qfz9bQfuXeqy0yMxNU3T1qir/iKmpmnaWqUTuKZp2hqlE7imadoapRO4pmnaGqUTuKZp2hqlE7imadoapRO4pmnaGqUTuKZp2hr1/wGkYol2/KGdewAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14 14\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 8\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13 13\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27 27\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16 16\n"
     ]
    }
   ],
   "source": [
    "# for i in range(10):\n",
    "\n",
    "output_first_10 = saved_model(val_x[:10].float())\n",
    "for i in range(len(output_first_10)):\n",
    "    plt.imshow(val_x[i].cpu().detach().numpy().reshape(40,168))\n",
    "    plt.show()\n",
    "\n",
    "    maxi = 0\n",
    "    for j in range(len(output_first_10[0])):\n",
    "        if output_first_10[i][maxi] <= output_first_10[i][j]: \n",
    "            maxi = j\n",
    "    print(maxi,val_y[i].cpu().detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "SUM_overfitted_2.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}