BLOCK_20_MODEL_FOR_IMAGE_SR - Copy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 269
    },
    "id": "GOeD3dP8DeIG",
    "outputId": "9a4e55c9-9826-481b-8583-fa05b0247d9b"
   },
   "outputs": [],
   "source": [
    "#!wget http://data.vision.ee.ethz.ch/cvl/DIV2K/DIV2K_train_HR.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 118
    },
    "id": "fD9dGwVA9Ghr",
    "outputId": "d2a53d4c-fb01-435a-9f2b-3c10bb58c8f1"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "fatal: destination path 'SRCNN-Keras' already exists and is not an empty directory.\n"
     ]
    }
   ],
   "source": [
    "!git clone https://github.com/niazwazir/SRCNN-Keras.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "DGaooD6C9olO",
    "outputId": "64198e46-bec4-4f27-f711-ac9fc4b8e17c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\Desktop\\ABC\\SRCNN-Keras\n"
     ]
    }
   ],
   "source": [
    "cd SRCNN-Keras/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 151
    },
    "id": "BXJ_SDhF9tM1",
    "outputId": "62c48edd-e9e1-454b-83a2-eaaa548c9143"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image_Super_Resolution.ipynb\n",
      "MOUNT_SRCNN_37_PSNR.ipynb\n",
      "PSNR_SSIM_MSE_SRCNN_Super_Resolution_.ipynb\n",
      "SRCNNMODIFIEDPYTHON2.ipynb\n",
      "SRCNN_COLOR_IMAGE_GENERATED.ipynb\n",
      "SRCNN_KERAS.ipynb\n",
      "SRCNN_KERAS_2nd.ipynb\n",
      "SRCNN_KERAS_IN_Python3.ipynb\n",
      "SRCNN_KERAS_IN_Python3_Curves.ipynb\n",
      "baby_GT.bmp\n",
      "baby_x2_GT.png\n",
      "bird_GT.bmp\n",
      "butterfly_GT.bmp\n",
      "head_GT.bmp\n",
      "prepare_data.py\n",
      "project.gif\n",
      "subpixel.py\n",
      "text\n",
      "woman_GT.bmp\n",
      "yang91\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "qkqRdZec9t3a",
    "outputId": "71c916e5-63f8-48c3-eae6-852bfd055716"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "unzip:  cannot find or open yang91.zip, yang91.zip.zip or yang91.zip.ZIP.\n"
     ]
    }
   ],
   "source": [
    "!unzip yang91.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 168
    },
    "id": "B2Rg2BGtoDSl",
    "outputId": "ca10f16e-95a1-43d3-8054-03d37da3c65b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image_Super_Resolution.ipynb\n",
      "MOUNT_SRCNN_37_PSNR.ipynb\n",
      "PSNR_SSIM_MSE_SRCNN_Super_Resolution_.ipynb\n",
      "SRCNNMODIFIEDPYTHON2.ipynb\n",
      "SRCNN_COLOR_IMAGE_GENERATED.ipynb\n",
      "SRCNN_KERAS.ipynb\n",
      "SRCNN_KERAS_2nd.ipynb\n",
      "SRCNN_KERAS_IN_Python3.ipynb\n",
      "SRCNN_KERAS_IN_Python3_Curves.ipynb\n",
      "baby_GT.bmp\n",
      "baby_x2_GT.png\n",
      "bird_GT.bmp\n",
      "butterfly_GT.bmp\n",
      "head_GT.bmp\n",
      "prepare_data.py\n",
      "project.gif\n",
      "subpixel.py\n",
      "text\n",
      "woman_GT.bmp\n",
      "yang91\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "aaLOFe3soDi6"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "rm: cannot remove '*.zip': No such file or directory\n"
     ]
    }
   ],
   "source": [
    "!rm -r *.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 151
    },
    "id": "f0sw_I9YoDe9",
    "outputId": "fd0ac6da-c0e9-4041-e9c7-2379372ef1d0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image_Super_Resolution.ipynb\n",
      "MOUNT_SRCNN_37_PSNR.ipynb\n",
      "PSNR_SSIM_MSE_SRCNN_Super_Resolution_.ipynb\n",
      "SRCNNMODIFIEDPYTHON2.ipynb\n",
      "SRCNN_COLOR_IMAGE_GENERATED.ipynb\n",
      "SRCNN_KERAS.ipynb\n",
      "SRCNN_KERAS_2nd.ipynb\n",
      "SRCNN_KERAS_IN_Python3.ipynb\n",
      "SRCNN_KERAS_IN_Python3_Curves.ipynb\n",
      "baby_GT.bmp\n",
      "baby_x2_GT.png\n",
      "bird_GT.bmp\n",
      "butterfly_GT.bmp\n",
      "head_GT.bmp\n",
      "prepare_data.py\n",
      "project.gif\n",
      "subpixel.py\n",
      "text\n",
      "woman_GT.bmp\n",
      "yang91\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "-_to1Cbz9t8R",
    "outputId": "0e60f7c7-ecb7-4a51-f6e5-68eef0164646"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\Desktop\\ABC\n"
     ]
    }
   ],
   "source": [
    "cd .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "8ZwIhMYY9t0u",
    "outputId": "61fce2ce-b6c9-4423-bc55-90d22326aa4c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FSRCNN_Experimental.ipynb\n",
      "SRCNN-Keras\n",
      "best_model_improved.h5\n",
      "model.png\n",
      "model2_FCN_FSRCNN.h5\n",
      "pytorch-LapSRN\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "FLFuW18UEMXi",
    "outputId": "050e32da-87f9-404d-b82f-81da6b6bec2d"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "unzip:  cannot find or open DIV2K_train_HR.zip, DIV2K_train_HR.zip.zip or DIV2K_train_HR.zip.ZIP.\n"
     ]
    }
   ],
   "source": [
    "!unzip \"DIV2K_train_HR.zip\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "p6VyDPRsoQZJ"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "rm: cannot remove '*.zip': No such file or directory\n"
     ]
    }
   ],
   "source": [
    "!rm -r *.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "fYHIjuWpukaS",
    "outputId": "d762d282-265b-421d-dce9-973c288768d7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FSRCNN_Experimental.ipynb\n",
      "SRCNN-Keras\n",
      "best_model_improved.h5\n",
      "model.png\n",
      "model2_FCN_FSRCNN.h5\n",
      "pytorch-LapSRN\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "2w9fURjBP0Ov"
   },
   "outputs": [],
   "source": [
    "DATADIR = \"SRCNN-Keras/yang91\"\n",
    "DATADIR2 = \"SRCNN-Keras/yang91\"\n",
    "#DATADIR2 = \"DIV2K_train_HR\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "6_Xvzi4fj1R2"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import keras\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "#from google.colab.patches import cv2_imshow\n",
    "from keras.callbacks import ModelCheckpoint\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.models import Model, Sequential\n",
    "from tensorflow.keras.layers import Dense, Conv2D, Dropout, BatchNormalization, Input,Conv2DTranspose, add, Activation, LeakyReLU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "ZxBdm7j4fLw7"
   },
   "outputs": [],
   "source": [
    "scale = 2\n",
    "req_size = 20\n",
    "inp_size = int(req_size/scale)\n",
    "stride = 15\n",
    "\n",
    "X=[]\n",
    "labels=[]\n",
    "\n",
    "for filera in os.listdir(DATADIR):\n",
    "    readpath = os.path.join(DATADIR,filera)\n",
    "    img = cv2.imread(readpath)\n",
    "    img = np.asarray(img)\n",
    "    shapes = img.shape\n",
    "    for i in range(0, shapes[0]-req_size+1, stride):\n",
    "        for j in range(0, shapes[1]-req_size+1,stride):\n",
    "            subimage_HR = img[i:i+req_size, j:j+req_size]\n",
    "            #cv2_imshow(subimage_HR)\n",
    "            subimage_LR = cv2.resize(subimage_HR,(inp_size,inp_size))\n",
    "            X.append(subimage_LR)\n",
    "            labels.append(subimage_HR)\n",
    "\n",
    "counta=0\n",
    "for filera in os.listdir(DATADIR2):\n",
    "    counta=counta+1\n",
    "    if(counta==300):\n",
    "        break\n",
    "        readpath = os.path.join(DATADIR2,filera)\n",
    "        img = cv2.imread(readpath)\n",
    "        img = np.asarray(img)\n",
    "        shapes = img.shape\n",
    "        for i in range(0, shapes[0]-req_size+1, stride):\n",
    "            for j in range(0, shapes[1]-req_size+1,stride):\n",
    "                subimage_HR = img[i:i+req_size, j:j+req_size]\n",
    "                #cv2_imshow(subimage_HR)\n",
    "                subimage_LR = cv2.resize(subimage_HR,(inp_size,inp_size))\n",
    "                X.append(subimage_LR)\n",
    "                labels.append(subimage_HR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "GK3LFglUm6rY",
    "outputId": "bf5d0e4f-abdc-4acc-e8cd-812978c3314a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(18849, 20, 20, 3)\n",
      "(18849, 10, 10, 3)\n"
     ]
    }
   ],
   "source": [
    "X = np.asarray(X)\n",
    "labels = np.asarray(labels)\n",
    "print(labels.shape)\n",
    "print(X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "lXm7CzkdPKwp"
   },
   "outputs": [],
   "source": [
    "alpha = 0.85\n",
    "def basic_mse(y_true, y_pred):\n",
    "    pred = tf.image.sobel_edges(y_pred)\n",
    "    true = tf.image.sobel_edges(y_true)\n",
    "    lossmse = tf.reduce_mean(tf.square(y_pred-y_true))\n",
    "    lossedge = tf.reduce_mean(tf.square(pred-true))\n",
    "    return alpha*lossmse + (1-alpha)*lossedge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Res_block():\n",
    "    _input = Input(shape=(None, None, 3))\n",
    "\n",
    "    conv1 = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu')(_input)\n",
    "    conv2 = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='linear')(conv1)\n",
    "    conv3 = Conv2D(filters=3, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='linear')(conv2)\n",
    "\n",
    "    out = add(inputs=[_input, conv3])\n",
    "    out = Activation('relu')(out)\n",
    "\n",
    "    model1 = Model(inputs=_input, outputs=out)\n",
    "\n",
    "    return model1\n",
    "model1 = Res_block()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, None, None,  0           []                               \n",
      "                                 3)]                                                              \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)                (None, None, None,   1792        ['input_1[0][0]']                \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv2d_1 (Conv2D)              (None, None, None,   36928       ['conv2d[0][0]']                 \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv2d_2 (Conv2D)              (None, None, None,   1731        ['conv2d_1[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " add (Add)                      (None, None, None,   0           ['input_1[0][0]',                \n",
      "                                3)                                'conv2d_2[0][0]']               \n",
      "                                                                                                  \n",
      " activation (Activation)        (None, None, None,   0           ['add[0][0]']                    \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 40,451\n",
      "Trainable params: 40,451\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model1.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.keras.utils.plot_model(\n",
    "    model1, to_file='model.png', show_shapes=False, show_layer_names=True, rankdir='LR', expand_nested=False, dpi=96\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 87
    },
    "id": "EyfVm2oJk26g",
    "outputId": "2fcf0d89-cbfe-48b5-9524-c5dd327d6211"
   },
   "outputs": [],
   "source": [
    "inputlayer = tf.keras.layers.Input(shape=(None,None,3))\n",
    "C1 = Conv2D(64, (3,3), padding=\"same\")(inputlayer)\n",
    "L1 = LeakyReLU(alpha=0.2)(C1)\n",
    "C2 = Conv2D(12, (3,3),padding=\"same\")(L1)\n",
    "L2 = LeakyReLU(alpha=0.2)(C2)\n",
    "C3 = Conv2D(3, (3,3),padding=\"same\")(L2)\n",
    "B1 = Res_block()(C3)\n",
    "B2 = Res_block()(B1)\n",
    "sum1 = add(inputs=[inputlayer, B2])\n",
    "B3 = Res_block()(sum1)\n",
    "B4 = Res_block()(B3)\n",
    "sum2 = add(inputs=[inputlayer, B4])\n",
    "B5 = Res_block()(sum2)\n",
    "B6 = Res_block()(B5)\n",
    "B7 = Res_block()(B6)\n",
    "B8 = Res_block()(B7)\n",
    "B9 = Res_block()(B8)\n",
    "B10 = Res_block()(B9)\n",
    "sum3 = add(inputs=[inputlayer,sum2, B10])\n",
    "B11 = Res_block()(sum3)\n",
    "B12 = Res_block()(B11)\n",
    "B13 = Res_block()(B12)\n",
    "B14 = Res_block()(B13)\n",
    "B15 = Res_block()(B14)\n",
    "B16 = Res_block()(B15)\n",
    "B17 = Res_block()(B16)\n",
    "B18 = Res_block()(B17)\n",
    "B19 = Res_block()(B18)\n",
    "B20= Res_block()(B19)\n",
    "sumf = add(inputs=[inputlayer,sum3, B20])\n",
    "CL = Conv2D(64,(1, 1), padding=\"same\")(sumf)\n",
    "LL = LeakyReLU(alpha=0.1)(CL)\n",
    "\n",
    "#final expanding layer of the model 3 channels for RGB\n",
    "y = Conv2DTranspose(3,(9,9), strides = (scale,scale), padding=\"same\",activation=None)(LL)\n",
    "model = Model(inputs=inputlayer , outputs = y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 638
    },
    "id": "AXTCMeqxP411",
    "outputId": "7bb07015-b91c-479f-e93a-4371d4dd7af5",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_21\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_2 (InputLayer)           [(None, None, None,  0           []                               \n",
      "                                 3)]                                                              \n",
      "                                                                                                  \n",
      " conv2d_3 (Conv2D)              (None, None, None,   1792        ['input_2[0][0]']                \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " leaky_re_lu (LeakyReLU)        (None, None, None,   0           ['conv2d_3[0][0]']               \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv2d_4 (Conv2D)              (None, None, None,   6924        ['leaky_re_lu[0][0]']            \n",
      "                                12)                                                               \n",
      "                                                                                                  \n",
      " leaky_re_lu_1 (LeakyReLU)      (None, None, None,   0           ['conv2d_4[0][0]']               \n",
      "                                12)                                                               \n",
      "                                                                                                  \n",
      " conv2d_5 (Conv2D)              (None, None, None,   327         ['leaky_re_lu_1[0][0]']          \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_1 (Functional)           (None, None, None,   40451       ['conv2d_5[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_2 (Functional)           (None, None, None,   40451       ['model_1[0][0]']                \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " add_3 (Add)                    (None, None, None,   0           ['input_2[0][0]',                \n",
      "                                3)                                'model_2[0][0]']                \n",
      "                                                                                                  \n",
      " model_3 (Functional)           (None, None, None,   40451       ['add_3[0][0]']                  \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_4 (Functional)           (None, None, None,   40451       ['model_3[0][0]']                \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " add_6 (Add)                    (None, None, None,   0           ['input_2[0][0]',                \n",
      "                                3)                                'model_4[0][0]']                \n",
      "                                                                                                  \n",
      " model_5 (Functional)           (None, None, None,   40451       ['add_6[0][0]']                  \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_6 (Functional)           (None, None, None,   40451       ['model_5[0][0]']                \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_7 (Functional)           (None, None, None,   40451       ['model_6[0][0]']                \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_8 (Functional)           (None, None, None,   40451       ['model_7[0][0]']                \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_9 (Functional)           (None, None, None,   40451       ['model_8[0][0]']                \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_10 (Functional)          (None, None, None,   40451       ['model_9[0][0]']                \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " add_13 (Add)                   (None, None, None,   0           ['input_2[0][0]',                \n",
      "                                3)                                'add_6[0][0]',                  \n",
      "                                                                  'model_10[0][0]']               \n",
      "                                                                                                  \n",
      " model_11 (Functional)          (None, None, None,   40451       ['add_13[0][0]']                 \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_12 (Functional)          (None, None, None,   40451       ['model_11[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_13 (Functional)          (None, None, None,   40451       ['model_12[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_14 (Functional)          (None, None, None,   40451       ['model_13[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_15 (Functional)          (None, None, None,   40451       ['model_14[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_16 (Functional)          (None, None, None,   40451       ['model_15[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_17 (Functional)          (None, None, None,   40451       ['model_16[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_18 (Functional)          (None, None, None,   40451       ['model_17[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_19 (Functional)          (None, None, None,   40451       ['model_18[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " model_20 (Functional)          (None, None, None,   40451       ['model_19[0][0]']               \n",
      "                                3)                                                                \n",
      "                                                                                                  \n",
      " add_24 (Add)                   (None, None, None,   0           ['input_2[0][0]',                \n",
      "                                3)                                'add_13[0][0]',                 \n",
      "                                                                  'model_20[0][0]']               \n",
      "                                                                                                  \n",
      " conv2d_66 (Conv2D)             (None, None, None,   256         ['add_24[0][0]']                 \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " leaky_re_lu_2 (LeakyReLU)      (None, None, None,   0           ['conv2d_66[0][0]']              \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv2d_transpose (Conv2DTransp  (None, None, None,   15555      ['leaky_re_lu_2[0][0]']          \n",
      " ose)                           3)                                                                \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 833,874\n",
      "Trainable params: 833,874\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss='mse',optimizer='adam',metrics=['accuracy'])\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.keras.utils.plot_model(\n",
    "    model, to_file='model.png', show_shapes=False, show_layer_names=True, rankdir='LR', expand_nested=False, dpi=96\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "4l2qU6Acj1W-"
   },
   "outputs": [],
   "source": [
    "checkpoint = ModelCheckpoint('best_model_improved.h5',  # model filename\n",
    "                             monitor='val_loss', # quantity to monitor\n",
    "                             verbose=0, # verbosity - 0 or 1\n",
    "                             save_best_only= True, # The latest best model will not be overwritten\n",
    "                             mode='auto') # The decision to overwrite model is made \n",
    "                                          # automatically depending on the quantity to monitor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "KFTza99ToCtg",
    "outputId": "923ddd9b-a223-4d45-e59c-78ec64533069"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "584/584 [==============================] - ETA: 0s - loss: 462.2988 - accuracy: 0.8818"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\anaconda3\\envs\\cuda_tf\\lib\\site-packages\\keras\\engine\\functional.py:1410: CustomMaskWarning: Custom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.\n",
      "  layer_config = serialize_layer_fn(layer)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "584/584 [==============================] - 28s 41ms/step - loss: 462.2988 - accuracy: 0.8818 - val_loss: 35.6915 - val_accuracy: 1.0000\n",
      "Epoch 2/5\n",
      "584/584 [==============================] - 24s 40ms/step - loss: 113.4656 - accuracy: 0.9396 - val_loss: 31.3332 - val_accuracy: 1.0000\n",
      "Epoch 3/5\n",
      "584/584 [==============================] - 23s 40ms/step - loss: 103.8800 - accuracy: 0.9400 - val_loss: 33.3586 - val_accuracy: 1.0000\n",
      "Epoch 4/5\n",
      "584/584 [==============================] - 22s 39ms/step - loss: 97.0136 - accuracy: 0.9426 - val_loss: 26.3001 - val_accuracy: 1.0000\n",
      "Epoch 5/5\n",
      "584/584 [==============================] - 24s 40ms/step - loss: 93.1429 - accuracy: 0.9437 - val_loss: 36.1604 - val_accuracy: 1.0000\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(X,labels,batch_size=32,shuffle=True,validation_split=0.01 ,epochs=5,callbacks=[checkpoint],\n",
    "                    verbose=1 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "qsuVLb6riEvt"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 428
    },
    "id": "kswhJaz8huEY",
    "outputId": "8ff40869-147d-4195-91a5-7100b9abee55"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Loss Curves')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Loss Curves\n",
    "plt.figure(figsize=[8,6])\n",
    "plt.plot(history.history['loss'],'r',linewidth=3.0)\n",
    "plt.plot(history.history['val_loss'],'b',linewidth=3.0)\n",
    "plt.legend(['Training loss', 'Validation Loss'],fontsize=18)\n",
    "plt.xlabel('Epochs ',fontsize=16)\n",
    "plt.ylabel('Loss',fontsize=16)\n",
    "plt.title('Loss Curves',fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 428
    },
    "id": "PAe-oncliIsD",
    "outputId": "8f42eebf-f2ba-4ba9-f219-2200f510788f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Accuracy Curves')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Accuracy Curves\n",
    "plt.figure(figsize=[8,6])\n",
    "plt.plot(history.history['accuracy'],'r',linewidth=3.0)\n",
    "plt.plot(history.history['val_accuracy'],'b',linewidth=3.0)\n",
    "plt.legend(['Training Accuracy', 'Validation Accuracy'],fontsize=18)\n",
    "plt.xlabel('Epochs ',fontsize=16)\n",
    "plt.ylabel('Accuracy',fontsize=16)\n",
    "plt.title('Accuracy Curves',fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "IBOspcO-msge"
   },
   "outputs": [],
   "source": [
    "def psnr_calc():\n",
    "    testimg = []\n",
    "    GT = cv2.imread(\"SRCNN-Keras/baby_x2_GT.png\")\n",
    "    GT = np.asarray(GT)\n",
    "    h = GT.shape[0]\n",
    "    l = GT.shape[1]\n",
    "    img1 = cv2.resize(GT,(int(l/2),int(h/2)),interpolation = cv2.INTER_CUBIC)\n",
    "    img1 = np.asarray(img1)\n",
    "    testimg.append(img1)\n",
    "    testimg = np.asarray(testimg)\n",
    "    print(testimg.shape)\n",
    "    fin =(model.predict(testimg)[0])\n",
    "    inp = cv2.resize(img1,(l,h),interpolation = cv2.INTER_CUBIC)\n",
    "    GT = GT[0:fin.shape[0],0:fin.shape[1],:]\n",
    "    mse = np.square(np.subtract(GT, fin)).mean()\n",
    "    #cv2_imshow(inp)\n",
    "    #cv2_imshow(fin)\n",
    "    #cv2_imshow(GT)\n",
    "    import math\n",
    "    psnr = 20*math.log(255.0,10) - 10*(math.log(mse,10))\n",
    "    return psnr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "cgs0qUdwWuln",
    "outputId": "2ca744a1-13d1-4085-dea4-6d98cf2e0f17"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 256, 256, 3)\n",
      "30.54473668609\n"
     ]
    }
   ],
   "source": [
    "ps1 = psnr_calc()\n",
    "print(ps1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "4QjSLa-WWm7a"
   },
   "outputs": [],
   "source": [
    "#35.27103087889881"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GIZfQITtqRJ9"
   },
   "outputs": [],
   "source": [
    "model.save(\"model2_FCN_FSRCNN.h5\")"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "FSRCNN_Experimental.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "cuda_tf",
   "language": "python",
   "name": "cuda_tf"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}