testing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1280, 720)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "#Sandesh\n",
    "import os\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "def LoadSceneAndLabel(dirnameScene, dirnameLabel, numImages):\n",
    "    count = 0\n",
    "    sceneX = []\n",
    "    sceneY = []\n",
    "    for sceneName in os.listdir(dirnameScene):\n",
    "        scene = Image.open(os.path.join(dirnameScene, sceneName))\n",
    "        sceneLabel = Image.open(os.path.join(dirnameLabel, sceneName[:-4]+\"_drivable_color.png\"))\n",
    "        #scene.show()\n",
    "        #sceneLabel.show()\n",
    "        #print(scene.size)\n",
    "        #print(sceneLabel.size)\n",
    "        sceneX.append(scene)\n",
    "        sceneY.append(sceneLabel)\n",
    "        count += 1\n",
    "        if count >= numImages:\n",
    "          break\n",
    "    return sceneX, sceneY\n",
    "\n",
    "dataX, dataY = LoadSceneAndLabel(dirnameScene=\"bdd100k/images/100k/train\", dirnameLabel=\"bdd100k/drivable_maps/color_labels/train\", numImages=800)\n",
    "valX, valY = LoadSceneAndLabel(dirnameScene=\"bdd100k/images/100k/val\", dirnameLabel=\"bdd100k/drivable_maps/color_labels/val\", numImages=50)\n",
    "\n",
    "dataX[0].size\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1280, 720)\n",
      "(1280, 720)\n",
      "(128, 72)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def compress(x, y, rate=0.5):\n",
    "    global xSize\n",
    "    global ySize\n",
    "    print((x[0].size))\n",
    "    xSize = math.floor(((x[0].size)[0])*rate)\n",
    "    ySize = math.floor(((y[0].size)[1])*rate)\n",
    "#     print(xSize)\n",
    "#     print(ySize)\n",
    "    sceneX = [img.resize([xSize, ySize]) for img in x]  \n",
    "    sceneY = [img.resize([xSize, ySize]) for img in y]  \n",
    "    #sceneX[0].show()\n",
    "    #sceneY[0].show()\n",
    "    return sceneX, sceneY\n",
    "\n",
    "# #print(SceneLabelPair[0][0].size)\n",
    "dataX, dataY = compress(dataX, dataY, rate=0.1)\n",
    "# print(SceneLabelPair[0][0].size)\n",
    "valX, valY = compress(valX, valY, rate=0.1)\n",
    "\n",
    "print(dataX[0].size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torchvision.transforms.functional as TF\n",
    "\n",
    "# import random\n",
    "\n",
    "# #list is pass by reference so copy isn't made\n",
    "\n",
    "# def transformImages(image, mask):\n",
    "\n",
    "#     for n in range(len(image)):\n",
    "# #         # Resize\n",
    "# #         resize = transforms.Resize(size=(520, 520))\n",
    "# #         image = resize(image)\n",
    "# #         mask = resize(mask)\n",
    "\n",
    "# #         # Random crop\n",
    "# #         i, j, h, w = transforms.RandomCrop.get_params(\n",
    "# #             image, output_size=(512, 512))\n",
    "# #         image = TF.crop(image, i, j, h, w)\n",
    "# #         mask = TF.crop(mask, i, j, h, w)\n",
    "\n",
    "#         # Random horizontal flipping\n",
    "#         if random.random() > 0.5:\n",
    "#             image[n] = TF.hflip(image[n])\n",
    "#             mask[n] = TF.hflip(mask[n])\n",
    "\n",
    "#         # Random vertical flipping\n",
    "#         if random.random() > 0.5:\n",
    "#             image[n] = TF.vflip(image[n])\n",
    "#             mask[n] = TF.vflip(mask[n])\n",
    "\n",
    "# #         # Transform to tensor\n",
    "# #         image = TF.to_tensor(image)\n",
    "# #         mask = TF.to_tensor(mask)\n",
    "# #     return image, mask\n",
    "\n",
    "    \n",
    "# #transform dataX and dataY, doesn't return anything since passed by reference\n",
    "# transformImages(dataX, dataY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=128x72 at 0x7F5C5D743EB0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = 0\n",
    "dataX[img]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAABICAIAAACx52pFAAAEQUlEQVR4nO3aX2iVdRzH8ZdzZ85tZv7rz6w0/5TlJDXBaBqJFSuDbiy9CLIuDIoKIgrrKogkgyiowCuDKP+EJdSF9geKkgpEMVIpbdOpbcpc1pzzLNfp4uzsnGVjf85zzrPs9+ZzsfOc3/P7fX6f77bneb7nEAgEAoFAIBAIBAKBQCAQCAQCgUAgEAgEAoFAIBAIBAKBQCAQCAQCgUDejIjbQLRM4B4eIsFnfMle2v5t5B100MhJkkV2mcvFVIBaNjO598EGdrKDnTRkDk7nAAmSNHKIg+zjZxpp5mzRTF9MBRjN26zq49029vIFn3OY67mVJdzMJTnDztLMYQ6xj584wq/8USDTF1MBkOA97u9vWD1fsZ1dnGM6tSxhHpMuGJzkJEeoZz8HOMxxWknl73j4FuA2HiCRc6Si9+8qKqnMebmed1SxhbsHtsgZ9rCDT9lPKbOp5XbmUt3HWedp4Sj17OH1eK8i0XMlb5EkNUidYRFM5JvBn93Au6zMXEXKWcgzbKOx77MOUhZnWNFSwiM0DD683DyqYTI/DHWOdr7jJWoz4ZaxgKf5kHq6cga/H2tgkbKA7XlE36PtjIJp/JL3ZEfZzMNMydgsZR5PsIVDPBVfYNExnrW0R5F+Wq92TzyH4xFN2c73rGUpVRnjCUbHlFl0LOdAdNGn1cWD3dMvoiXq6Y+xldVcN5zvYvrnRrZGnU2PTrOge51ltBVmkQ52sY47GR9nlIOliuf5rWDpp7Uve1e/ks4Cr3aMj3iMGkpjTbc/6thT4DB6tC0bxupirXmO3bxGHRPjDPpCprKh901cEfRidv1ni7tyiia2Zf4sEn3FUgzKeJzmogeQ4jzLs0ZeicNCiiR7eYN7uazY6S/i65j2nVYLNVk762P1kuIEH/Mkcwr+FH0Fbw6pqRC5djOu21SCjXHbSSvJj4WKvoRV+TUVItdGSrrdVfFJ3HZ6VADmR9RUiFzPZT1OiPv/YmEKMI61BXvsyV9JlmXNVufRsBuWBVjO/rh306+amZm1HEnDbhgUYBYfxL2PgetbxmS9R9iwi6MAFazhVNyZDlYbem2iEA27gSqvZl4dLzOvj3dTJGmngw7aSNJKF6f4k05OZQafo3Vgi5YyKdOEHJnz8wQSjGIsGEspoymnLKOSnHnWsI6/ul8tY1NOn7l4DKUAI7iBF1hBFydpoYlmmjhBE638zmna6KCTzuxui0E67nTu6TJUUs5YRjGRFJvoyJ6xgkdpI5F5ZiinijFUUtG7fJExlAKM4z7Oc5ATtHKmuOEWi3QFKxnDpVzONcxgCtO4mkmMzHON//LnCXEygvFcxSxuYg41VA+htRAKEBVVTGUuC7mFmZmLUT+EAhSCEiYzn8UsZnbvry/1IhSg0JQwjYUspZYZ/7iYhwIUkwpquIO7mJ9+HAwFiItrWUxd3DYCgUAgEAgEAoFA4H/H3wOq3TSx875FAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=128x72 at 0x7F5C22DE34C0>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataY[img]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## maybe flatten y?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \n",
    "#convert non zero label to be the same number so it's not different based on different lane categorization\n",
    "\n",
    "def convert_to_array(x, y):\n",
    "    sceneX = []\n",
    "    sceneY = []\n",
    "    count = 0\n",
    "    for img in x:\n",
    "        #img = img.convert('LA')  # convert to grayscale\n",
    "        #img = np.squeeze(np.array(img)[:,:,:])\n",
    "        img = np.array(img)\n",
    "        #divide by 255.0\n",
    "        img = np.divide(img, 255.0)\n",
    "        sceneX.append(img)\n",
    "    for img in y:\n",
    "        img = img.convert('LA')  # convert to grayscale\n",
    "        if count == 0:\n",
    "            img.show()\n",
    "        count = 1\n",
    "        img = np.squeeze(np.array(img)[:,:,0])\n",
    "        img = np.where(img > 0, 1, 0)\n",
    "        sceneY.append(img)\n",
    "#     img = np.squeeze(np.array(img)[:, :, 0]) #squeeze to remove the unnecessary dimension after conversion to grayscale\n",
    "#     label_img = np.squeeze(np.array(label_img)[:, :, 0])\n",
    "    return np.array(sceneX), np.array(sceneY)\n",
    "\n",
    "dataX, dataY = convert_to_array(dataX, dataY)\n",
    "valX, valY = convert_to_array(valX, valY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "800\n",
      "800\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(800, 72, 128, 3)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(len(dataX))\n",
    "print(len(dataY))\n",
    "\n",
    "\n",
    "dataX.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2857142857142857\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "split = 2/7.0\n",
    "print(split)\n",
    "\n",
    "trainX, testX, trainY, testY = train_test_split(dataX, dataY, test_size=split) \n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_num = trainX.shape[0]\n",
    "test_num = testX.shape[0]\n",
    "x_dim = trainX.shape[2]\n",
    "y_dim = trainX.shape[1]\n",
    "val_num = valX.shape[0]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pytorch CNN Model\n",
    "\n",
    "Module is the baseclass for all NN module:\n",
    "https://pytorch.org/docs/stable/generated/torch.nn.Module.html\n",
    "\n",
    "### Conv2D -> \n",
    "Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')\n",
    "https://cs231n.github.io/convolutional-networks/\n",
    "out_channels = number of kernels (filters) used, so dim in the 3rd dim\n",
    "\n",
    "\n",
    "### BatchNorm2d ->\n",
    "BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
    "Batch normalization normalizes the activations of the network between layers in batches so that the batches have a mean of 0 and a variance of 1.\n",
    "param = num of channels\n",
    "\n",
    "### nn.Linear ->\n",
    "Linear(in_features, out_features, bias=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert to PyTorch types\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1.         1.         1.         ... 0.26666667 0.44705882 0.43529412]\n",
      "  [0.39215686 0.36862745 0.34901961 ... 0.27843137 0.2745098  0.42352941]\n",
      "  [0.43137255 0.42745098 0.7372549  ... 0.2745098  0.27058824 0.29019608]\n",
      "  ...\n",
      "  [0.22745098 0.21568627 0.2        ... 0.16078431 0.20392157 0.2       ]\n",
      "  [0.17647059 0.18039216 0.17647059 ... 0.12941176 0.11372549 0.10588235]\n",
      "  [0.1254902  0.10980392 0.10588235 ... 0.2627451  0.2745098  0.29411765]]\n",
      "\n",
      " [[0.22352941 0.21960784 0.2        ... 0.16078431 0.17254902 0.16470588]\n",
      "  [0.15294118 0.17254902 0.16470588 ... 0.11764706 0.10196078 0.09411765]\n",
      "  [0.11764706 0.10196078 0.11372549 ... 0.26666667 0.28235294 0.29411765]\n",
      "  ...\n",
      "  [0.16862745 0.14901961 0.16470588 ... 0.18823529 0.18431373 0.17647059]\n",
      "  [0.18039216 0.18039216 0.17254902 ... 0.59607843 0.54509804 0.71764706]\n",
      "  [0.60784314 0.55294118 0.68235294 ... 0.36862745 0.34901961 0.36470588]]\n",
      "\n",
      " [[0.1372549  0.13333333 0.15294118 ... 0.22745098 0.21176471 0.21176471]\n",
      "  [0.21960784 0.20784314 0.20784314 ... 0.43137255 0.43921569 0.50588235]\n",
      "  [0.45882353 0.45490196 0.49411765 ... 0.36078431 0.35294118 0.37254902]\n",
      "  ...\n",
      "  [0.2        0.19215686 0.19607843 ... 0.2        0.17254902 0.17647059]\n",
      "  [0.19607843 0.17254902 0.17647059 ... 0.16862745 0.18431373 0.16470588]\n",
      "  [0.16862745 0.18431373 0.16862745 ... 0.55294118 0.54509804 0.6       ]]]\n",
      "(571, 3, 72, 128)\n",
      "torch.Size([571, 1, 72, 128])\n",
      "[[[0.47843137 0.41176471 0.38039216 ... 0.8        0.19607843 0.50588235]\n",
      "  [0.8        0.19607843 0.50588235 ... 0.49019608 0.78431373 0.18039216]\n",
      "  [0.49411765 0.78039216 0.17254902 ... 0.01568627 0.03137255 0.04313725]\n",
      "  ...\n",
      "  [0.44313725 0.44313725 0.37254902 ... 0.39215686 0.50196078 0.44705882]\n",
      "  [0.39607843 0.40784314 0.38039216 ... 0.61176471 0.77647059 0.38823529]\n",
      "  [0.60784314 0.76078431 0.4        ... 0.39607843 0.72941176 0.95294118]]\n",
      "\n",
      " [[0.45882353 0.47058824 0.39607843 ... 0.31764706 0.44705882 0.41176471]\n",
      "  [0.38039216 0.38039216 0.34117647 ... 0.58039216 0.70588235 0.40392157]\n",
      "  [0.55686275 0.64705882 0.34901961 ... 0.40392157 0.7372549  0.95294118]\n",
      "  ...\n",
      "  [0.32156863 0.38823529 0.37647059 ... 0.39607843 0.45882353 0.52941176]\n",
      "  [0.46666667 0.51372549 0.58039216 ... 0.45098039 0.44313725 0.3254902 ]\n",
      "  [0.41568627 0.40784314 0.29019608 ... 0.14117647 0.18039216 0.15686275]]\n",
      "\n",
      " [[0.50980392 0.59215686 0.58039216 ... 0.56862745 0.53333333 0.6       ]\n",
      "  [0.54901961 0.49411765 0.56078431 ... 0.5372549  0.52941176 0.43529412]\n",
      "  [0.52156863 0.51372549 0.41960784 ... 0.21176471 0.25490196 0.23921569]\n",
      "  ...\n",
      "  [0.01176471 0.03529412 0.03529412 ... 0.37254902 0.29803922 0.37647059]\n",
      "  [0.37254902 0.29411765 0.36470588 ... 0.42745098 0.44705882 0.32941176]\n",
      "  [0.41176471 0.43137255 0.33333333 ... 0.30196078 0.35686275 0.38823529]]]\n",
      "(50, 3, 72, 128)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "# train\n",
    "\n",
    "trainX = trainX.reshape(train_num, 3, y_dim, x_dim).astype(float)\n",
    "print(trainX[0])\n",
    "print(trainX.shape)\n",
    "trainX  = torch.from_numpy(trainX).type(torch.FloatTensor)\n",
    "\n",
    "# trainY = trainY.reshape(train_num, 1, x_dim, y_dim).astype(float)\n",
    "# trainY  = torch.from_numpy(trainY)\n",
    "# print(trainY.shape)\n",
    "\n",
    "trainY = trainY.reshape(train_num, 1, y_dim, x_dim).astype(float)\n",
    "#trainY  = torch.from_numpy(trainY).type(torch.LongTensor)\n",
    "trainY  = torch.from_numpy(trainY).type(torch.FloatTensor)\n",
    "print(trainY.shape)\n",
    "\n",
    "\n",
    "\n",
    "# val\n",
    "valX = valX.reshape(val_num, 3, y_dim, x_dim).astype(float)\n",
    "print(valX[0])\n",
    "print(valX.shape)\n",
    "valX  = torch.from_numpy(valX).type(torch.FloatTensor)\n",
    "\n",
    "# valY = valY.reshape(val_num, 1, x_dim, y_dim).astype(float)\n",
    "# valY  = torch.from_numpy(valY)\n",
    "\n",
    "\n",
    "valY = valY.reshape(val_num, 1, y_dim, x_dim).astype(float)\n",
    "#valY  = torch.from_numpy(valY).type(torch.LongTensor)\n",
    "valY  = torch.from_numpy(valY).type(torch.FloatTensor)\n",
    "# //TODO Test\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([571, 3, 72, 128]), torch.Size([571, 1, 72, 128]))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainX.shape, trainY.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torch\n",
    "\n",
    "# torch.cuda.current_device()\n",
    "# torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 3, 72, 128])\n",
      "conv\n",
      "torch.Size([1, 2, 72, 128])\n",
      "max pool\n",
      "torch.Size([1, 2, 70, 126])\n",
      "conv2\n",
      "torch.Size([1, 1, 68, 124])\n",
      "batch norm\n",
      "torch.Size([1, 1, 68, 124])\n",
      "max pool\n",
      "torch.Size([1, 1, 64, 120])\n",
      "conv transpose\n",
      "torch.Size([1, 2, 68, 124])\n",
      "conv transpose\n",
      "torch.Size([1, 1, 70, 126])\n",
      "conv transpose\n",
      "torch.Size([1, 1, 72, 128])\n"
     ]
    }
   ],
   "source": [
    "from torch.nn import Conv2d\n",
    "from torch.nn import Linear, ReLU, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout, Flatten\n",
    "\n",
    "import torch.nn as nn\n",
    "\n",
    "# calculating the size of output from convolution layers\n",
    "dat = trainX[:1].type(torch.FloatTensor)\n",
    "print(dat.size())\n",
    "#x = dat.to(device=device, dtype=torch.float)\n",
    "conv = Conv2d(3, 2, kernel_size=3, stride=1, padding=1)\n",
    "out = conv(dat)\n",
    "print('conv')\n",
    "print(out.size())\n",
    "mp = MaxPool2d(kernel_size=3, stride=1)\n",
    "out = mp(out)\n",
    "print('max pool')\n",
    "print(out.size())\n",
    "conv2 = Conv2d(2, 1, kernel_size=5, stride=1, padding=1)\n",
    "out = conv2(out)\n",
    "print('conv2')\n",
    "print(out.size())\n",
    "bN = BatchNorm2d(1)\n",
    "out = bN(out)\n",
    "print('batch norm')\n",
    "print(out.size())\n",
    "mp2 = MaxPool2d(kernel_size=5, stride=1)\n",
    "out = mp2(out)\n",
    "print('max pool')\n",
    "print(out.size())\n",
    "tp = nn.ConvTranspose2d(1,2,kernel_size=5, stride=1, bias=False)\n",
    "print('conv transpose')\n",
    "out = tp(out)\n",
    "print(out.size())\n",
    "tp1 = nn.ConvTranspose2d(2,1,kernel_size=3, stride=1, bias=False)\n",
    "out = tp1(out)\n",
    "print('conv transpose')\n",
    "print(out.size())\n",
    "tp2 = nn.ConvTranspose2d(1,1,kernel_size=3, stride=1, bias=False)\n",
    "out = tp2(out)\n",
    "print('conv transpose')\n",
    "print(out.size())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PyTorch libraries and modules\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "from torch.nn import Linear, Softmax, Sigmoid, ReLU, NLLLoss, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout, Flatten\n",
    "from torch.optim import Adam, SGD\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import optim\n",
    "\n",
    "class CNN(Module):\n",
    "    def __init__(self):\n",
    "        super(CNN,self).__init__() #base class for all neural network modules\n",
    "        out_chan_1 = 5\n",
    "        out_chan_2 = 7\n",
    "        out_chan_3 = 3\n",
    "        k_s_1 = 3\n",
    "        k_s_2 = 3\n",
    "#         k_s_1_mp = 2 #mp = max pool\n",
    "#         k_s_2_mp = 2\n",
    "        \n",
    "        num_neurons_1 = 10\n",
    "        \n",
    "        output_size = 9216 #depending on num of pixels\n",
    "        \n",
    "        self.cnn_1 = Sequential(\n",
    "            # Defining a 2D convolution layer\n",
    "            Conv2d(3, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "            BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "            ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_1, stride=1),\n",
    "            # Defining another 2D convolution layer\n",
    "            Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_1, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "        )\n",
    "        \n",
    "        self.cnn_2 = Sequential(\n",
    "            MaxPool2d(kernel_size=k_s_1, stride=2), #downscale\n",
    "            Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "            Conv2d(out_chan_1, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "            #MaxPool2d(kernel_size=k_s_2, stride=1),\n",
    "        )\n",
    "        \n",
    "        \n",
    "        self.cnn_3 = Sequential(\n",
    "            MaxPool2d(kernel_size=k_s_2, stride=2), #downscale\n",
    "            Conv2d(out_chan_2, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "            Conv2d(out_chan_2, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "            #MaxPool2d(kernel_size=k_s_2, stride=1),\n",
    "        )\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "#         self.up_2 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "#             #nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "        \n",
    "        \n",
    "        self.up_1 = Sequential(\n",
    "            #Conv2d(out_chan_3, 1, kernel_size=1, stride=1, padding=1),\n",
    "            #nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "            #Sigmoid(),\n",
    "            nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=2), #upscale\n",
    "            Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "            Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "            \n",
    "#             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=2),\n",
    "#             nn.ConvTranspose2d(out_chan_1,1,kernel_size=k_s_1, stride=1)\n",
    "        )\n",
    "        \n",
    "        \n",
    "        self.up_2 = Sequential(\n",
    "            #Conv2d(out_chan_3, 1, kernel_size=1, stride=1, padding=1),\n",
    "            #nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "            #Sigmoid(),\n",
    "            nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_1, stride=2), #upscale\n",
    "            \n",
    "            Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            ReLU(inplace=True),\n",
    "            Conv2d(out_chan_1, 1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(1),\n",
    "            ReLU(inplace=True),\n",
    "            \n",
    "#             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=2),\n",
    "#             nn.ConvTranspose2d(out_chan_1,1,kernel_size=k_s_1, stride=1)\n",
    "        )\n",
    "        \n",
    "        self.set_chan = Sequential(\n",
    "            Conv2d(5, 1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(1),\n",
    "            ReLU(inplace=True)\n",
    "        )\n",
    "        \n",
    "        self.out_conv = Sequential(\n",
    "            Conv2d(1, 1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(1),\n",
    "            ReLU(inplace=True),\n",
    "        )\n",
    "        \n",
    "        \n",
    "        \n",
    "#         self.up_3 = Sequential(\n",
    "#             #Conv2d(out_chan_3, 1, kernel_size=1, stride=1, padding=1),\n",
    "#             #nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             #Sigmoid(),\n",
    "#             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_1, stride=2),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "            \n",
    "# #             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=2),\n",
    "# #             nn.ConvTranspose2d(out_chan_1,1,kernel_size=k_s_1, stride=1)\n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         self.linear_layers = Sequential(\n",
    "#             Linear(out_chan_2 * 31 * 17, num_neurons_1),\n",
    "#             Softmax(dim=1),\n",
    "#             #ReLU(inplace=True),\n",
    "#             Linear(num_neurons_1,output_size),\n",
    "#             Sigmoid() # map from 0 to 1\n",
    "#             #Softmax(dim=1)\n",
    "#             #Sign()\n",
    "#             #ReLU(inplace=True)\n",
    "            \n",
    "#         )\n",
    "        \n",
    "    # Defining the forward pass    \n",
    "    def forward(self, x):\n",
    "        \n",
    "        print(\"Start: \")\n",
    "        print(x.size())\n",
    "        \n",
    "        x1 = self.cnn_1(x)\n",
    "        \n",
    "        print(\"1st Conv: \")\n",
    "        print(x1.size())\n",
    "        \n",
    "        x2 = self.cnn_2(x1)\n",
    "        \n",
    "        print(\"2nd Conv: \")\n",
    "        print(x2.size())\n",
    "        \n",
    "        \n",
    "        x3 = self.cnn_3(x2)\n",
    "        print(\"3rd Conv: \")\n",
    "        print(x3.size())\n",
    "        \n",
    "#         x1 = x2+x1\n",
    "        \n",
    "        x4 = self.up_1(x3)\n",
    "        \n",
    "        print(\"Upscale 1: \")\n",
    "        print(x4.size())\n",
    "        \n",
    "        #x4 = x4+x2\n",
    "        \n",
    "        x5 = self.up_2(x4)\n",
    "        \n",
    "        print(\"Upscale 2: \")\n",
    "        print(x5.size())\n",
    "\n",
    "        diffY = x1.size()[2] - x5.size()[2]\n",
    "        diffX = x1.size()[3] - x5.size()[3]\n",
    "        x5 = F.pad(x5, [diffX//2, diffX - diffX//2,\n",
    "                       diffY//2, diffY - diffY//2])\n",
    "        x5 = torch.cat([x1, x5], dim=1)\n",
    "        \n",
    "        x5 = self.set_chan(x5)\n",
    "        #x5 = x5 + x1\n",
    "        \n",
    "        x6 = self.out_conv(x5)\n",
    "        print(\"Out: \")\n",
    "        print(x6.size())\n",
    "        \n",
    "#         x3 = self.up_1(x2)\n",
    "#         print(x3.size())\n",
    "        \n",
    "        #x2 = x1 + x2\n",
    "        \n",
    "        #x1 = x3 + x1\n",
    "        #print(x2.size())\n",
    "#         x = self.output(x)\n",
    "        #x=x.long()\n",
    "        #x = x.view(x.size(0), -1)\n",
    "        \n",
    "        #x = self.linear_layers(x)\n",
    "        #x = x.float()\n",
    "        return x6\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.001\n",
    "# defining the model\n",
    "model = CNN()\n",
    "# defining the optimizer\n",
    "#optimizer =  torch.optim.SGD(model.parameters(), lr=lr, momentum=0.5, weight_decay=0.0005)\n",
    "optimizer = optim.RMSprop(model.parameters(), lr=lr, weight_decay=1e-8, momentum=0.9)\n",
    "#optimizer = optim.RMSprop(model.parameters(), lr=lr, momentum=0.9)\n",
    "#optimizer = Adam(model.parameters(), lr=0.03)\n",
    "\n",
    "\n",
    "#scheduler - not used\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', patience=2) #changes the learning rate based on epoch\n",
    "\n",
    "\n",
    "# defining the loss function\n",
    "#criterion = MSELoss()\n",
    "#criterion = CrossEntropyLoss()\n",
    "#criterion = nn.BCEWithLogitsLoss()\n",
    "#criterion = nn.BCELoss()\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "# checking if GPU is available\n",
    "# if torch.cuda.is_available():\n",
    "#     model = model.cuda()\n",
    "#     criterion = criterion.cuda()\n",
    "    \n",
    "# print(model)\n",
    "\n",
    "# trainX = trainX[:2].cuda()\n",
    "\n",
    "# output = model(Variable(trainX))\n",
    "# output\n",
    "\n",
    "\n",
    "\n",
    "def train(epoch, train_x, train_y, val_x, val_y):\n",
    "    model.train()\n",
    "    tr_loss = 0\n",
    "    # getting the training set\n",
    "    x_train, y_train = Variable(train_x), Variable(train_y)\n",
    "    # getting the validation set\n",
    "    x_val, y_val = Variable(val_x), Variable(val_y)\n",
    "    # converting the data into GPU format\n",
    "#     if torch.cuda.is_available():\n",
    "#         x_train = x_train.cuda()\n",
    "#         y_train = y_train.cuda()\n",
    "#         x_val = x_val.cuda()\n",
    "#         y_val = y_val.cuda()\n",
    "\n",
    "    # clearing the Gradients of the model parameters\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    # prediction for training and validation set\n",
    "    output_train = model(x_train)\n",
    "    output_val = model(x_val)\n",
    "\n",
    "    # computing the training and validation loss\n",
    "    print(output_train.shape)\n",
    "    print(y_train.shape)\n",
    "    loss_train = criterion(output_train, y_train)\n",
    "    loss_val = criterion(output_val, y_val)\n",
    "    train_losses.append(loss_train)\n",
    "    val_losses.append(loss_val)\n",
    "\n",
    "    # computing the updated weights of all the model parameters\n",
    "    loss_train.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    tr_loss = loss_train.item()\n",
    "    \n",
    "    #scheduler.step(tr_loss) #decreases the learning rate as we go\n",
    "    \n",
    "    if epoch%2 == 0:\n",
    "        # printing the validation loss\n",
    "        print('Epoch : ',epoch+1, '\\t', 'loss :', loss_val)\n",
    "     \n",
    "    # delete this things that aren't necessary for the next iteration\n",
    "    del loss_train\n",
    "    del loss_val\n",
    "    del output_train\n",
    "    del output_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start: \n",
      "torch.Size([571, 3, 72, 128])\n",
      "1st Conv: \n",
      "torch.Size([571, 5, 72, 128])\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "running_mean should contain 7 elements not 5",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-92-4f64b38b35af>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# training the model\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[0;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_epochs\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----> 9\u001b[0;31m     \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalY\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-91-e732300d74f5>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(epoch, train_x, train_y, val_x, val_y)\u001b[0m\n\u001b[1;32m     52\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m     \u001b[0;31m# prediction for training and validation set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m     \u001b[0moutput_train\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_train\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     55\u001b[0m     \u001b[0moutput_val\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_val\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    725\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    726\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--> 727\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    728\u001b[0m         for hook in itertools.chain(\n\u001b[1;32m    729\u001b[0m                 \u001b[0m_global_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[0;32m<ipython-input-90-2802d8844d09>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    155\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\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    156\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 157\u001b[0;31m         \u001b[0mx2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcnn_2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx1\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    158\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    159\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"2nd Conv: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    725\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    726\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--> 727\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    728\u001b[0m         for hook in itertools.chain(\n\u001b[1;32m    729\u001b[0m                 \u001b[0m_global_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[0;32m~/.local/lib/python3.8/site-packages/torch/nn/modules/container.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    115\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[1;32m    116\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mmodule\u001b[0m \u001b[0;32min\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[0;32m--> 117\u001b[0;31m             \u001b[0minput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodule\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    118\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    725\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    726\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--> 727\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    728\u001b[0m         for hook in itertools.chain(\n\u001b[1;32m    729\u001b[0m                 \u001b[0m_global_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[0;32m~/.local/lib/python3.8/site-packages/torch/nn/modules/batchnorm.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    129\u001b[0m         \u001b[0mused\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mnormalization\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0;32min\u001b[0m \u001b[0meval\u001b[0m \u001b[0mmode\u001b[0m \u001b[0mwhen\u001b[0m \u001b[0mbuffers\u001b[0m \u001b[0mare\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\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    130\u001b[0m         \"\"\"\n\u001b[0;32m--> 131\u001b[0;31m         return F.batch_norm(\n\u001b[0m\u001b[1;32m    132\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    133\u001b[0m             \u001b[0;31m# If buffers are not to be tracked, ensure that they won't be updated\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.8/site-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mbatch_norm\u001b[0;34m(input, running_mean, running_var, weight, bias, training, momentum, eps)\u001b[0m\n\u001b[1;32m   2054\u001b[0m         \u001b[0m_verify_batch_size\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\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   2055\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2056\u001b[0;31m     return torch.batch_norm(\n\u001b[0m\u001b[1;32m   2057\u001b[0m         \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrunning_mean\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrunning_var\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2058\u001b[0m         \u001b[0mtraining\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmomentum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackends\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcudnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menabled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: running_mean should contain 7 elements not 5"
     ]
    }
   ],
   "source": [
    "# defining the number of epochs\n",
    "n_epochs = 50\n",
    "# empty list to store training losses\n",
    "train_losses = []\n",
    "# empty list to store validation losses\n",
    "val_losses = []\n",
    "# training the model\n",
    "for epoch in range(n_epochs):\n",
    "    train(epoch, trainX, trainY, valX, valY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "plt.plot(train_losses, label='Training loss')\n",
    "plt.plot(val_losses, label='Validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#discussion with Chau\n",
    "\n",
    "should label data be 0 and 1 per pixel rather than whatever it currently is?\n",
    "should we normalize all the images to be closer to 1 rather than such large numbers?\n",
    "should just discussion on loss function -> i think mseloss would be best for pixel by pixel comparison?\n",
    "should final output be filtered using something other than nerual network?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start: \n",
      "torch.Size([1, 3, 72, 128])\n",
      "1st Conv: \n",
      "torch.Size([1, 5, 72, 128])\n",
      "2nd Conv: \n",
      "torch.Size([1, 5, 35, 63])\n",
      "3rd Conv: \n",
      "torch.Size([1, 5, 17, 31])\n",
      "Upscale 1: \n",
      "torch.Size([1, 5, 35, 63])\n",
      "Upscale 2: \n",
      "torch.Size([1, 1, 71, 127])\n",
      "Out: \n",
      "torch.Size([1, 1, 72, 128])\n",
      "(1, 72, 128)\n",
      "6.0999623e-06\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "imNum = 5\n",
    "\n",
    "testSingle = valX[imNum:imNum+1]\n",
    "#testSingle = testSingle.cuda()\n",
    "testSingle = testSingle\n",
    "y_pred = model(testSingle)\n",
    "\n",
    "\n",
    "out = y_pred.cpu().detach().numpy()\n",
    "\n",
    "print(valY[imNum].numpy().shape)\n",
    "\n",
    "# print(out)\n",
    "# print(\"Max:\")\n",
    "# print(np.max(out))\n",
    "avg = np.mean(out)\n",
    "print(avg)\n",
    "\n",
    "\n",
    "final = np.where(out > avg, 1, 0)\n",
    "\n",
    "\n",
    "final = np.reshape(final, (ySize,xSize))*255.0\n",
    "\n",
    "out = np.reshape(out, (ySize,xSize))\n",
    "\n",
    "actual = ((np.reshape(valY[imNum].numpy(), (ySize, xSize)))*255)\n",
    "\n",
    "print(actual)\n",
    "\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# im = Image.fromarray((final).astype(np.uint8))\n",
    "# im.show()\n",
    "\n",
    "# im2 = Image.fromarray(actual.astype(np.uint8))\n",
    "# im2.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f5b9da4e730>"
      ]
     },
     "execution_count": 77,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.imshow(actual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f5b9e831490>"
      ]
     },
     "execution_count": 78,
     "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.imshow(out, cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f5b9e809550>"
      ]
     },
     "execution_count": 79,
     "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.imshow(final, cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f5b9e763460>"
      ]
     },
     "execution_count": 80,
     "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.imshow(np.reshape(valX[imNum].numpy(), (ySize,xSize,3)), cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PyTorch libraries and modules\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "from torch.nn import Linear, Softmax, LogSoftmax, Sigmoid, ReLU, NLLLoss, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout2d, Flatten\n",
    "from torch.optim import Adam, SGD, RMSprop\n",
    "import torch.nn as nn\n",
    "\n",
    "class CNN(Module):\n",
    "    def __init__(self):\n",
    "        super(CNN,self).__init__() #base class for all neural network modules\n",
    "        \n",
    "# #         out_chan_1 = 64\n",
    "# #         out_chan_2 = 128\n",
    "# #         out_chan_3 = 256\n",
    "# #         out_chan_4 = 512\n",
    "# #         out_chan_5 = 512\n",
    "        \n",
    "        out_chan_1 = 3\n",
    "        out_chan_2 = 5\n",
    "#         out_chan_1 = 2\n",
    "#         out_chan_2 = 2\n",
    "#         out_chan_3 = 4\n",
    "#         out_chan_4 = 8\n",
    "#         out_chan_5 = 8\n",
    "        \n",
    "# #         out_fc_6 = 4096\n",
    "# #         out_fc_7 = 4096\n",
    "\n",
    "#         out_fc_6 = 32\n",
    "#         out_fc_7 = 32\n",
    "        \n",
    "#         n_class = 2\n",
    "        \n",
    "#         #k_s_1 = 3\n",
    "#         #k_s_2 = 3\n",
    "        k_s = 3\n",
    "        \n",
    "#         #k_s_1_mp = 2 #mp = max pool\n",
    "#         #k_s_2_mp = 2\n",
    "        k_s_mp = 2\n",
    "        \n",
    "#         num_neurons_1 = 10\n",
    "        \n",
    "#         output_size = 1 #9216 #depending on num of pixels\n",
    "        \n",
    "        self.cnn_layers = Sequential(\n",
    "            # Defining a 2D convolution layer\n",
    "            Conv2d(1, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "            BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "            ReLU(inplace=True),\n",
    "            MaxPool2d(kernel_size=k_s_1_mp, stride=2),\n",
    "      \n",
    "            # Defining another 2D convolution layer\n",
    "            Conv2d(out_chan_1, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            BatchNorm2d(out_chan_2),\n",
    "            ReLU(inplace=True),\n",
    "            MaxPool2d(kernel_size=k_s_2_mp, stride=2)\n",
    "        )\n",
    "        \n",
    "#         self.cnn_layer1 = Sequential(\n",
    "#             # Defining a 2D convolution layer\n",
    "#             Conv2d(1, out_chan_1, kernel_size=k_s, padding=100), \n",
    "#             BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s, padding=1), \n",
    "#             BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "#             ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_mp, stride=2, ceil_mode=True)\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_layer2 = Sequential(\n",
    "#             # Defining another 2D convolution layer\n",
    "#             Conv2d(out_chan_1, out_chan_2, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_2),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_2, out_chan_2, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_2),\n",
    "#             ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_mp, stride=2, ceil_mode=True)\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_layer3 = Sequential(\n",
    "#             # Defining another 2D convolution layer\n",
    "#             Conv2d(out_chan_2, out_chan_3, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_3),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_3, out_chan_3, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_3),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_3, out_chan_3, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_3),\n",
    "#             ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_mp, stride=2, ceil_mode=True)\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_layer4 = Sequential(\n",
    "#             # Defining another 2D convolution layer\n",
    "#             Conv2d(out_chan_3, out_chan_4, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_4),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_4, out_chan_4, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_4),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_4, out_chan_4, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_4),\n",
    "#             ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_mp, stride=2, ceil_mode=True)\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_layer5 = Sequential(\n",
    "#             # Defining another 2D convolution layer\n",
    "#             Conv2d(out_chan_4, out_chan_5, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_5),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_5, out_chan_5, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_5),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_5, out_chan_5, kernel_size=k_s, padding=1),\n",
    "#             BatchNorm2d(out_chan_5),\n",
    "#             ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_mp, stride=2, ceil_mode=True)\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_fc6 = Sequential(\n",
    "#             Conv2d(out_chan_5, out_fc_6, kernel_size=7),\n",
    "#             BatchNorm2d(out_fc_6),\n",
    "#             ReLU(inplace=True),\n",
    "#             Dropout2d()\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_fc7 = Sequential(\n",
    "#             Conv2d(out_fc_6, out_fc_7, kernel_size=1),\n",
    "#             BatchNorm2d(out_fc_7),\n",
    "#             ReLU(inplace=True),\n",
    "#             Dropout2d()\n",
    "#         )\n",
    "        \n",
    "#         self.score_fr = nn.Conv2d(out_fc_6, output_size, 1)\n",
    "#         self.score_pool3 = nn.Conv2d(out_chan_3, output_size, 1)\n",
    "#         self.score_pool4 = nn.Conv2d(out_chan_5, output_size, 1)\n",
    "\n",
    "#         self.upscore2 = nn.ConvTranspose2d(\n",
    "#             output_size, output_size, 4, stride=2, bias=False)\n",
    "#         self.upscore8 = nn.ConvTranspose2d(\n",
    "#             output_size, output_size, 16, stride=8, bias=False)\n",
    "#         self.upscore_pool4 = nn.ConvTranspose2d(\n",
    "#             output_size, output_size, 4, stride=2, bias=False)\n",
    "        \n",
    "#         self.sigmoid = Sequential(\n",
    "#             Sigmoid()\n",
    "#         )\n",
    "        \n",
    "        \n",
    "# #         self.linear_layers = Sequential(\n",
    "# #             Linear(out_chan_2 * 31 * 17, num_neurons_1),\n",
    "# #             Softmax(dim=1),\n",
    "# #             #ReLU(inplace=True),\n",
    "# #             Linear(num_neurons_1,output_size),\n",
    "# #             Sigmoid() # map from 0 to 1\n",
    "# #             #LogSoftmax(dim=1)\n",
    "# #             #Softmax(dim=1)\n",
    "# #             #Sign()\n",
    "# #             #ReLU(inplace=True)\n",
    "            \n",
    "# #         )\n",
    "        \n",
    "#     # Defining the forward pass    \n",
    "#     def forward(self, x):\n",
    "#         h = self.cnn_layer1(x)\n",
    "#         h = self.cnn_layer2(h)\n",
    "        \n",
    "#         h = self.cnn_layer3(h)\n",
    "#         pool3 = h\n",
    "        \n",
    "#         h = self.cnn_layer4(h)\n",
    "#         pool4 = h\n",
    "        \n",
    "#         h = self.cnn_layer5(h)\n",
    "        \n",
    "#         h = self.cnn_fc6(h)\n",
    "#         h = self.cnn_fc7(h)\n",
    "        \n",
    "#         h = self.score_fr(h)\n",
    "#         h = self.upscore2(h)\n",
    "#         upscore2 = h  # 1/16\n",
    "\n",
    "#         h = self.score_pool4(pool4 * 0.01)  # XXX: scaling to train at once\n",
    "#         h = h[:, :, 5:5 + upscore2.size()[2], 5:5 + upscore2.size()[3]]\n",
    "#         score_pool4c = h  # 1/16\n",
    "\n",
    "#         h = upscore2 + score_pool4c  # 1/16\n",
    "#         h = self.upscore_pool4(h)\n",
    "#         upscore_pool4 = h  # 1/8\n",
    "\n",
    "#         h = self.score_pool3(pool3 * 0.0001)  # XXX: scaling to train at once\n",
    "#         h = h[:, :,\n",
    "#               9:9 + upscore_pool4.size()[2],\n",
    "#               9:9 + upscore_pool4.size()[3]]\n",
    "#         score_pool3c = h  # 1/8\n",
    "\n",
    "#         h = upscore_pool4 + score_pool3c  # 1/8\n",
    "\n",
    "#         print(h.shape)\n",
    "#         h = self.upscore8(h)\n",
    "#         h = h[:, :, 31:31 + x.size()[2], 31:31 + x.size()[3]].contiguous()\n",
    "        \n",
    "#         h = self.sigmoid(h)\n",
    "\n",
    "#         return h\n",
    "        \n",
    "    \n",
    "# #         x = self.cnn_layers(x)\n",
    "# #         print(x.size())\n",
    "# #         #x=x.long()\n",
    "# #         x = x.view(x.size(0), -1)\n",
    "# #         x = self.linear_layers(x)\n",
    "# #         #x = x.float()\n",
    "# #         return x\n",
    "    \n",
    "\n",
    "# # defining the model\n",
    "# model = CNN()\n",
    "# # defining the optimizer\n",
    "# # optimizer = SGD(model.parameters(), lr=0.05, momentum=0.5, weight_decay=0.0005)\n",
    "# # optimizer = RMSprop(model.parameters(), lr=0.01, weight_decay=1e-8, momentum=0.9)\n",
    "# optimizer = Adam(model.parameters(), lr=0.05)\n",
    "\n",
    "# # defining the loss function\n",
    "# #criterion = MSELoss()\n",
    "# #criterion = CrossEntropyLoss()\n",
    "# criterion = nn.BCEWithLogitsLoss()\n",
    "# #criterion = nn.BCELoss()\n",
    "\n",
    "\n",
    "# #checking if GPU is available\n",
    "# # if torch.cuda.is_available():\n",
    "# #    model = model.cuda()\n",
    "# #    criterion = criterion.cuda()\n",
    "    \n",
    "# # print(model)\n",
    "\n",
    "# # trainX = trainX[:2].cuda()\n",
    "\n",
    "# # output = model(Variable(trainX))\n",
    "# # output\n",
    "\n",
    "\n",
    "\n",
    "# def train(epoch, train_x, train_y, val_x, val_y):\n",
    "#     model.train()\n",
    "#     tr_loss = 0\n",
    "#     # getting the training set\n",
    "#     x_train, y_train = Variable(train_x), Variable(train_y)\n",
    "#     # getting the validation set\n",
    "#     x_val, y_val = Variable(val_x), Variable(val_y)\n",
    "#     # converting the data into GPU format\n",
    "# #     if torch.cuda.is_available():\n",
    "# #         x_train = x_train.cuda()\n",
    "# #         y_train = y_train.cuda()\n",
    "# #         x_val = x_val.cuda()\n",
    "# #         y_val = y_val.cuda()\n",
    "\n",
    "#     # clearing the Gradients of the model parameters\n",
    "#     optimizer.zero_grad()\n",
    "    \n",
    "#     # prediction for training and validation set\n",
    "#     output_train = model(x_train)\n",
    "#     output_val = model(x_val)\n",
    "\n",
    "#     # computing the training and validation loss\n",
    "#     print(output_train.shape)\n",
    "#     print(y_train.shape)\n",
    "#     loss_train = criterion(output_train, y_train)\n",
    "#     loss_val = criterion(output_val, y_val)\n",
    "#     train_losses.append(loss_train)\n",
    "#     val_losses.append(loss_val)\n",
    "\n",
    "#     # computing the updated weights of all the model parameters\n",
    "#     loss_train.backward()\n",
    "#     optimizer.step()\n",
    "#     tr_loss = loss_train.item()\n",
    "#     if epoch%2 == 0:\n",
    "#         # printing the validation loss\n",
    "#         print('Epoch : ',epoch+1, '\\t', 'loss :', loss_val)\n",
    "    \n",
    "#     del loss_train\n",
    "#     del loss_val\n",
    "#     del output_train\n",
    "#     del output_val\n",
    "#     #torch.cuda.empty_cache()"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}