diff --git "a/models/SRGAN/srgan-cvprj.ipynb" "b/models/SRGAN/srgan-cvprj.ipynb"
new file mode 100644--- /dev/null
+++ "b/models/SRGAN/srgan-cvprj.ipynb"
@@ -0,0 +1,1942 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b402e39f",
+   "metadata": {
+    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
+    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
+    "execution": {
+     "iopub.execute_input": "2024-01-03T17:17:02.328327Z",
+     "iopub.status.busy": "2024-01-03T17:17:02.32768Z",
+     "iopub.status.idle": "2024-01-03T17:17:02.34062Z",
+     "shell.execute_reply": "2024-01-03T17:17:02.338685Z",
+     "shell.execute_reply.started": "2024-01-03T17:17:02.328289Z"
+    },
+    "papermill": {
+     "duration": 0.009625,
+     "end_time": "2024-03-22T08:37:49.261849",
+     "exception": false,
+     "start_time": "2024-03-22T08:37:49.252224",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "<h3>DATA PREPROCESSING</h3>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bfea6d6c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:37:49.282185Z",
+     "iopub.status.busy": "2024-03-22T08:37:49.281821Z",
+     "iopub.status.idle": "2024-03-22T08:37:56.950132Z",
+     "shell.execute_reply": "2024-03-22T08:37:56.949152Z"
+    },
+    "papermill": {
+     "duration": 7.681323,
+     "end_time": "2024-03-22T08:37:56.952633",
+     "exception": false,
+     "start_time": "2024-03-22T08:37:49.271310",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import gc\n",
+    "import random\n",
+    "import time\n",
+    "from tqdm import tqdm\n",
+    "import numpy as np\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torch.utils.data import Dataset, DataLoader, ConcatDataset\n",
+    "from torchvision import transforms\n",
+    "from torchvision.transforms import Compose\n",
+    "from torchvision.models import vgg19\n",
+    "from torchmetrics.functional.image import structural_similarity_index_measure as ssim\n",
+    "import wandb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "10afb6e0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:37:56.972310Z",
+     "iopub.status.busy": "2024-03-22T08:37:56.971969Z",
+     "iopub.status.idle": "2024-03-22T08:37:56.983851Z",
+     "shell.execute_reply": "2024-03-22T08:37:56.982949Z"
+    },
+    "papermill": {
+     "duration": 0.024012,
+     "end_time": "2024-03-22T08:37:56.985835",
+     "exception": false,
+     "start_time": "2024-03-22T08:37:56.961823",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class DF2KDataset(Dataset):\n",
+    "    def __init__(self, hr_images_path, random_crop:bool=True, transforms:Compose=None, output_size:tuple=(256, 256), seed:int=1989):\n",
+    "        super(DF2KDataset, self).__init__()\n",
+    "        \n",
+    "        self.hr_images_path = hr_images_path\n",
+    "        \n",
+    "        hr_images_list = os.listdir(hr_images_path)\n",
+    "        \n",
+    "        self.hr_images_list = [hr_images_path + image_name for image_name in hr_images_list]\n",
+    "        \n",
+    "        self.random_crop = random_crop\n",
+    "        self.transforms = transforms\n",
+    "        self.output_size = output_size\n",
+    "        self.seed = seed\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        hr_image_path = self.hr_images_list[idx]\n",
+    "        lr_image_path = hr_image_path.replace('.png', 'x4.png').replace('HR', 'LR_bicubic_X4')\n",
+    "        \n",
+    "        hr_image = Image.open(hr_image_path)\n",
+    "        lr_image = Image.open(lr_image_path)\n",
+    "        \n",
+    "        # -------------------- RANDOM CROP -------------------- #\n",
+    "        if self.random_crop:\n",
+    "            w, h = hr_image.size\n",
+    "            th, tw = self.output_size\n",
+    "            random.seed(self.seed + idx)\n",
+    "            i = random.choice(list(range(0, h-th+1, 4)))\n",
+    "            j = random.choice(list(range(0, w-tw+1, 4)))\n",
+    "\n",
+    "            hr_image = transforms.functional.crop(hr_image, i, j, th, tw)\n",
+    "            lr_image = transforms.functional.crop(lr_image, i//4, j//4, th//4, tw//4)\n",
+    "            \n",
+    "        # -------------------- TO TENSOR -------------------- #\n",
+    "        hr_image = transforms.functional.to_tensor(hr_image)\n",
+    "        lr_image = transforms.functional.to_tensor(lr_image)\n",
+    "        \n",
+    "        # -------------------- OTHER TRANSFORMATIONS -------------------- #\n",
+    "        if self.transforms:\n",
+    "            torch.manual_seed(seed=self.seed)\n",
+    "            hr_image = self.transforms(hr_image)\n",
+    "            torch.manual_seed(seed=self.seed)\n",
+    "            lr_image = self.transforms(lr_image)\n",
+    "        \n",
+    "        return hr_image, lr_image\n",
+    "        \n",
+    "    def __len__(self):\n",
+    "        return len(self.hr_images_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "66cb8b72",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:37:57.004156Z",
+     "iopub.status.busy": "2024-03-22T08:37:57.003866Z",
+     "iopub.status.idle": "2024-03-22T08:37:57.012298Z",
+     "shell.execute_reply": "2024-03-22T08:37:57.011534Z"
+    },
+    "papermill": {
+     "duration": 0.019689,
+     "end_time": "2024-03-22T08:37:57.014084",
+     "exception": false,
+     "start_time": "2024-03-22T08:37:56.994395",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class DF2KDataLoader(DataLoader):\n",
+    "    def __init__(self, hr_images_path, \n",
+    "                 random_crop:bool=True, transforms:Compose=None, output_size:tuple=(256, 256), seed:int=1989,\n",
+    "                 batch_size:int=16, shuffle:bool=True, num_crops:int=1):\n",
+    "        \"\"\"\n",
+    "        - hr_images_path: str\n",
+    "            Path to the high-resolution images\n",
+    "        - random_crop: bool\n",
+    "            Whether to crop the images. Default is True. You might want to crop on the training set, but not on the validation set.\n",
+    "        - transforms: Compose\n",
+    "            A Compose of transformations, applied similarly on both high-res and low-res images.\n",
+    "            >> NOTE: Some transformations might worsen the quality of image, so consider carefully.\n",
+    "        - output_size: tuple\n",
+    "            Size of the random crop applied to an image. Default is 256x256.\n",
+    "            >> NOTE: Only meaningful when `random_crop` is True.\n",
+    "        - seed: int\n",
+    "            A random number, meant to keep all transformations the same for high-res and low-res images\n",
+    "        - num_crops: int\n",
+    "            The number of random crops applied to an image. Size of dataset is multiplied accordingly. Default is 1.\n",
+    "            >> NOTE: Only meaningful when `random_crop` is True.\n",
+    "        \"\"\"\n",
+    "        if random_crop and num_crops > 1:\n",
+    "            random.seed(1989)\n",
+    "            sub_datasets = [DF2KDataset(hr_images_path, random_crop=random_crop, transforms=transforms, output_size=output_size, seed=seed+int(random.random()*10)) \n",
+    "                            for _ in range(num_crops)]\n",
+    "            self.dataset = ConcatDataset(sub_datasets)\n",
+    "        else:\n",
+    "            self.dataset = DF2KDataset(hr_images_path, random_crop=random_crop, transforms=transforms, output_size=output_size, seed=seed)\n",
+    "        super().__init__(self.dataset, batch_size=batch_size, shuffle=shuffle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21b8caaf",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00861,
+     "end_time": "2024-03-22T08:37:57.031223",
+     "exception": false,
+     "start_time": "2024-03-22T08:37:57.022613",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### EXAMPLE USAGE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "dd5c4a41",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:37:57.049844Z",
+     "iopub.status.busy": "2024-03-22T08:37:57.049544Z",
+     "iopub.status.idle": "2024-03-22T08:37:57.292076Z",
+     "shell.execute_reply": "2024-03-22T08:37:57.291289Z"
+    },
+    "papermill": {
+     "duration": 0.254649,
+     "end_time": "2024-03-22T08:37:57.294531",
+     "exception": false,
+     "start_time": "2024-03-22T08:37:57.039882",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "HR_IMAGES_PATH_TRAIN = \"/kaggle/input/df2k-with-bicubic-x4/dataset/DF2K_train_HR/\"\n",
+    "HR_IMAGES_PATH_VALID = \"/kaggle/input/df2k-with-bicubic-x4/dataset/DIV2K_valid_HR/\"\n",
+    "\n",
+    "class RandomRotation(object):\n",
+    "    def __call__(self, img):\n",
+    "        rotation_angle = torch.randint(0,3,(1,)).item()* 90\n",
+    "        return transforms.functional.rotate(img, rotation_angle)\n",
+    "\n",
+    "TRANSFORMS = Compose([\n",
+    "    transforms.RandomHorizontalFlip(),\n",
+    "    RandomRotation()\n",
+    "])\n",
+    "# NOTE: Refer to the source code above to navigate the paramters when initializing a DataLoader for this dataset.\n",
+    "train_dataloader = DF2KDataLoader(hr_images_path=HR_IMAGES_PATH_TRAIN,\n",
+    "                                  random_crop=True, transforms=TRANSFORMS, output_size=(256, 256),seed=1989,\n",
+    "                                  batch_size=16, shuffle=True, num_crops=1)\n",
+    "# NOTE: For the validation dataloader, batch_size should always be 1, because the dimensions of each picture are \n",
+    "# different, making them unstackable in the dataloader. In the case you do not want to do so, let random_crop be \n",
+    "# True and add an output_size, and num_crops if you would like to have multiple crops per validation image.\n",
+    "valid_dataloader = DF2KDataLoader(hr_images_path=HR_IMAGES_PATH_VALID,\n",
+    "                                  random_crop=False, transforms=None, seed=1989,\n",
+    "                                  batch_size = 1, shuffle=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "92f9445b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:37:57.313612Z",
+     "iopub.status.busy": "2024-03-22T08:37:57.313286Z",
+     "iopub.status.idle": "2024-03-22T08:38:01.678493Z",
+     "shell.execute_reply": "2024-03-22T08:38:01.677539Z"
+    },
+    "papermill": {
+     "duration": 4.377402,
+     "end_time": "2024-03-22T08:38:01.681008",
+     "exception": false,
+     "start_time": "2024-03-22T08:37:57.303606",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Length of train_dataloader: 216\n",
+      ">> Size of high-res image: torch.Size([256, 256, 3])\n",
+      ">> Size of low-res image: torch.Size([64, 64, 3])\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"Length of train_dataloader: {}\".format(len(train_dataloader)))\n",
+    "hrs, lrs = next(iter(train_dataloader))\n",
+    "\n",
+    "hr = hrs[0].permute((1, 2, 0))\n",
+    "lr = lrs[0].permute((1, 2, 0))\n",
+    "\n",
+    "print(\">> Size of high-res image:\", hr.size())\n",
+    "print(\">> Size of low-res image:\", lr.size())\n",
+    "fig, axs = plt.subplots(1, 2)\n",
+    "\n",
+    "axs[0].imshow(hr)\n",
+    "axs[0].set_title('High Resolution')\n",
+    "axs[1].imshow(lr)\n",
+    "axs[1].set_title('Low Resolution')\n",
+    "\n",
+    "for ax in axs.flat:\n",
+    "    ax.axis('off')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "416310cb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:01.702926Z",
+     "iopub.status.busy": "2024-03-22T08:38:01.702624Z",
+     "iopub.status.idle": "2024-03-22T08:38:02.694790Z",
+     "shell.execute_reply": "2024-03-22T08:38:02.693890Z"
+    },
+    "papermill": {
+     "duration": 1.006677,
+     "end_time": "2024-03-22T08:38:02.697980",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:01.691303",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Length of valid_dataloader: 100\n",
+      ">> Size of high-res image: torch.Size([1416, 2040, 3])\n",
+      ">> Size of low-res image: torch.Size([354, 510, 3])\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"Length of valid_dataloader: {}\".format(len(valid_dataloader)))\n",
+    "hrs, lrs = next(iter(valid_dataloader))\n",
+    "\n",
+    "hr = hrs[0].permute((1, 2, 0))\n",
+    "lr = lrs[0].permute((1, 2, 0))\n",
+    "\n",
+    "print(\">> Size of high-res image:\", hr.size())\n",
+    "print(\">> Size of low-res image:\", lr.size())\n",
+    "fig, axs = plt.subplots(1, 2)\n",
+    "\n",
+    "axs[0].imshow(hr)\n",
+    "axs[0].set_title('High Resolution')\n",
+    "axs[1].imshow(lr)\n",
+    "axs[1].set_title('Low Resolution')\n",
+    "\n",
+    "for ax in axs.flat:\n",
+    "    ax.axis('off')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d296bac8",
+   "metadata": {
+    "papermill": {
+     "duration": 0.011539,
+     "end_time": "2024-03-22T08:38:02.721392",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.709853",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "<h3>MODEL</h3>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "34547a64",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:02.745768Z",
+     "iopub.status.busy": "2024-03-22T08:38:02.745467Z",
+     "iopub.status.idle": "2024-03-22T08:38:02.751654Z",
+     "shell.execute_reply": "2024-03-22T08:38:02.750791Z"
+    },
+    "papermill": {
+     "duration": 0.020499,
+     "end_time": "2024-03-22T08:38:02.753425",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.732926",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class ResidualBlock(nn.Module):\n",
+    "    def __init__(self, in_features):\n",
+    "        super(ResidualBlock, self).__init__()\n",
+    "        self.conv_block = nn.Sequential(\n",
+    "            nn.Conv2d(in_features, in_features, kernel_size=3, stride=1, padding=1),\n",
+    "            nn.BatchNorm2d(in_features, 0.8),\n",
+    "            nn.PReLU(),\n",
+    "            nn.Conv2d(in_features, in_features, kernel_size=3, stride=1, padding=1),\n",
+    "            nn.BatchNorm2d(in_features, 0.8),\n",
+    "        )\n",
+    "    \n",
+    "    def forward(self, x):\n",
+    "        return x + self.conv_block(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d8e5600b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:02.777812Z",
+     "iopub.status.busy": "2024-03-22T08:38:02.777525Z",
+     "iopub.status.idle": "2024-03-22T08:38:02.788061Z",
+     "shell.execute_reply": "2024-03-22T08:38:02.787358Z"
+    },
+    "papermill": {
+     "duration": 0.02514,
+     "end_time": "2024-03-22T08:38:02.790053",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.764913",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class GeneratorResnet(nn.Module):\n",
+    "    def __init__(self, in_channels=3, out_channels=3, n_residual_blocks=16):\n",
+    "        super(GeneratorResnet, self).__init__()\n",
+    "        #first layer\n",
+    "        self.conv1 = nn.Sequential(nn.Conv2d(in_channels, 64, kernel_size=9, stride=1, padding=4), nn.PReLU())\n",
+    "        \n",
+    "        #Residual blocks\n",
+    "        res_blocks=[]\n",
+    "        for _ in range(n_residual_blocks):\n",
+    "            res_blocks.append(ResidualBlock(64))\n",
+    "        self.res_blocks = nn.Sequential(*res_blocks)\n",
+    "        \n",
+    "        #second conv layer after res blocks\n",
+    "        self.conv2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(64, 0.8))\n",
+    "        upsampling=[]\n",
+    "        for _ in range(2):\n",
+    "            upsampling+=[\n",
+    "                nn.Conv2d(64, 256, kernel_size=3, stride=1, padding=1),\n",
+    "                nn.BatchNorm2d(256),\n",
+    "                nn.PixelShuffle(upscale_factor=2),\n",
+    "                nn.PReLU(),\n",
+    "            ]\n",
+    "        self.upsampling = nn.Sequential(*upsampling)\n",
+    "        \n",
+    "        self.conv3 = nn.Conv2d(64, out_channels, kernel_size=9, stride=1, padding=4)\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        out1 = self.conv1(x)\n",
+    "        out = self.res_blocks(out1)\n",
+    "        out2 = self.conv2(out)\n",
+    "        out = torch.add(out1, out2)\n",
+    "        out = self.upsampling(out)\n",
+    "        out = self.conv3(out)\n",
+    "        return out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4311c5fb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:02.814581Z",
+     "iopub.status.busy": "2024-03-22T08:38:02.814239Z",
+     "iopub.status.idle": "2024-03-22T08:38:02.826058Z",
+     "shell.execute_reply": "2024-03-22T08:38:02.825237Z"
+    },
+    "papermill": {
+     "duration": 0.026351,
+     "end_time": "2024-03-22T08:38:02.827924",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.801573",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class Discriminator(nn.Module):\n",
+    "    def __init__(self, input_shape):\n",
+    "        super(Discriminator, self).__init__()\n",
+    "        \n",
+    "        self.input_shape = input_shape\n",
+    "        in_channels, in_height, in_width = self.input_shape\n",
+    "        patch_h, patch_w = int(in_height / 2**4), int(in_width / 2**4)\n",
+    "        self.output_shape = (1, patch_h, patch_w)\n",
+    "        \n",
+    "        def discriminator_block(in_filters, out_filters, first_block=False):\n",
+    "            layers=[]\n",
+    "            layers.append(nn.Conv2d(in_filters, out_filters, kernel_size=3, stride=1, padding=1))\n",
+    "            if not first_block:\n",
+    "                layers.append(nn.BatchNorm2d(out_filters))\n",
+    "            layers.append(nn.LeakyReLU(0.2, inplace=True))\n",
+    "            layers.append(nn.Conv2d(out_filters, out_filters, kernel_size=3, stride=2, padding=1))\n",
+    "            layers.append(nn.BatchNorm2d(out_filters))\n",
+    "            layers.append(nn.LeakyReLU(0.2, inplace=True))\n",
+    "            return layers\n",
+    "        \n",
+    "        layers=[]\n",
+    "        in_filters = in_channels\n",
+    "        for i, out_filters in enumerate([64, 128, 256, 512]):\n",
+    "            layers.extend(discriminator_block(in_filters, out_filters, first_block=(i==0)))\n",
+    "            in_filters = out_filters\n",
+    "        layers.append(nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1))\n",
+    "        layers.append(nn.BatchNorm2d(512))\n",
+    "        layers.append(nn.LeakyReLU(0.2))\n",
+    "        output_layers=[nn.AdaptiveAvgPool2d(1),\n",
+    "            nn.Conv2d(512, 1024, kernel_size=1),\n",
+    "            nn.LeakyReLU(0.2),\n",
+    "            nn.Conv2d(1024, 1, kernel_size=1)]\n",
+    "        layers.extend(output_layers)\n",
+    "        self.model = nn.Sequential(*layers)\n",
+    "        \n",
+    "    def forward(self, img):\n",
+    "        batch_size = img.size(0)\n",
+    "        return torch.sigmoid(self.model(img).view(batch_size))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "87183a41",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:02.852636Z",
+     "iopub.status.busy": "2024-03-22T08:38:02.852370Z",
+     "iopub.status.idle": "2024-03-22T08:38:02.864066Z",
+     "shell.execute_reply": "2024-03-22T08:38:02.863389Z"
+    },
+    "papermill": {
+     "duration": 0.025986,
+     "end_time": "2024-03-22T08:38:02.865823",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.839837",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class GeneratorLoss(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(GeneratorLoss, self).__init__()\n",
+    "        vgg = vgg19(pretrained=True)\n",
+    "        loss_network = nn.Sequential(*list(vgg.features)[:31]).eval()\n",
+    "        for param in loss_network.parameters():\n",
+    "            param.requires_grad=False\n",
+    "        self.loss_network = loss_network\n",
+    "        self.mse_loss = nn.MSELoss()\n",
+    "        self.tv_loss = TVLoss()\n",
+    "        \n",
+    "    def forward(self, out_labels, out_img, target_img):\n",
+    "        #adversarial loss\n",
+    "        adversarial_loss = torch.mean(1-out_labels)\n",
+    "        #perception loss\n",
+    "        perception_loss = self.mse_loss(self.loss_network(out_img), self.loss_network(target_img))\n",
+    "        #image loss\n",
+    "        image_loss = self.mse_loss(out_img, target_img)\n",
+    "        #tv loss\n",
+    "        tv_loss = self.tv_loss(out_img)\n",
+    "        return image_loss + 0.001*adversarial_loss + 0.006*perception_loss + 2e-8*tv_loss\n",
+    "    \n",
+    "class TVLoss(nn.Module):\n",
+    "    def __init__(self, tv_loss_weight=1):\n",
+    "        super(TVLoss, self).__init__()\n",
+    "        self.tv_loss_weight = tv_loss_weight\n",
+    "        \n",
+    "    def forward(self, img):\n",
+    "        batch_size = img.size()[0]\n",
+    "        h = img.size()[2]\n",
+    "        w = img.size()[3]\n",
+    "        count_h = self.tensor_size(img[:,:,1:,:])\n",
+    "        count_w = self.tensor_size(img[:,:,:,1:])\n",
+    "        h_tv = torch.pow(img[:,:,1:,:] - img[:,:,:h-1,:], 2).sum()\n",
+    "        w_tv = torch.pow(img[:,:,:,1:] - img[:,:,:,:w-1], 2).sum()\n",
+    "        return self.tv_loss_weight * 2 * (h_tv/count_h + w_tv/count_w)/batch_size\n",
+    "        \n",
+    "    def tensor_size(self, x):\n",
+    "        return x.size()[1]*x.size()[2]*x.size()[3]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "459736c0",
+   "metadata": {
+    "papermill": {
+     "duration": 0.011533,
+     "end_time": "2024-03-22T08:38:02.888907",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.877374",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "<h3>TRAINING</h3>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "d08c5a81",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:02.912924Z",
+     "iopub.status.busy": "2024-03-22T08:38:02.912655Z",
+     "iopub.status.idle": "2024-03-22T08:38:02.966905Z",
+     "shell.execute_reply": "2024-03-22T08:38:02.966063Z"
+    },
+    "papermill": {
+     "duration": 0.068429,
+     "end_time": "2024-03-22T08:38:02.968800",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.900371",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#settings\n",
+    "N_EPOCHS = 40\n",
+    "BATCH_SIZE = 16\n",
+    "G_LR = 0.001\n",
+    "D_LR = 1e-5\n",
+    "b1 = 0.9\n",
+    "b2 = 0.999\n",
+    "BETAS = (b1, b2)\n",
+    "STEP_SIZE=10\n",
+    "EPS = 1e-08\n",
+    "GAMMA = 0.67\n",
+    "CHANNELS = 3\n",
+    "hr_img_shape = (256,256)\n",
+    "DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "105b1986",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:02.993678Z",
+     "iopub.status.busy": "2024-03-22T08:38:02.993392Z",
+     "iopub.status.idle": "2024-03-22T08:38:02.999204Z",
+     "shell.execute_reply": "2024-03-22T08:38:02.998370Z"
+    },
+    "papermill": {
+     "duration": 0.020357,
+     "end_time": "2024-03-22T08:38:03.001101",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:02.980744",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "device(type='cuda')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "DEVICE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "5484def3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:03.025948Z",
+     "iopub.status.busy": "2024-03-22T08:38:03.025674Z",
+     "iopub.status.idle": "2024-03-22T08:38:03.063867Z",
+     "shell.execute_reply": "2024-03-22T08:38:03.063147Z"
+    },
+    "papermill": {
+     "duration": 0.052816,
+     "end_time": "2024-03-22T08:38:03.065667",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:03.012851",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class Network:\n",
+    "    def __init__(self, for_inference=False, train_dataloader=train_dataloader, valid_dataloader=valid_dataloader,\n",
+    "                 g_lr=G_LR, d_lr = D_LR, betas = BETAS, step_size = STEP_SIZE, device = DEVICE,\n",
+    "                 num_epochs = N_EPOCHS,eps = EPS, gamma = GAMMA, run_id=None):\n",
+    "        self.for_inference = for_inference\n",
+    "        self.generator = GeneratorResnet().to(device)\n",
+    "        self.discriminator = Discriminator(input_shape = (CHANNELS,*hr_img_shape)).to(device)\n",
+    "        self.device = device\n",
+    "        if not self.for_inference:\n",
+    "            self.generator_loss = GeneratorLoss().to(device)\n",
+    "            self.optimizer_G = torch.optim.Adam(self.generator.parameters(), lr=g_lr, betas=BETAS, eps=eps)\n",
+    "            self.optimizer_D = torch.optim.Adam(self.discriminator.parameters(), lr=d_lr, betas=BETAS, eps=eps)\n",
+    "            self.scheduler_G =  torch.optim.lr_scheduler.StepLR(self.optimizer_G, step_size=step_size, gamma=gamma)\n",
+    "            self.scheduler_D =  torch.optim.lr_scheduler.StepLR(self.optimizer_D, step_size=step_size, gamma=gamma)\n",
+    "            self.train_dataloader = train_dataloader\n",
+    "            self.valid_dataloader = valid_dataloader\n",
+    "            self.num_epochs = num_epochs\n",
+    "\n",
+    "            self.run_id = run_id\n",
+    "    \n",
+    "    def save_network(self, epoch, G_train_loss, G_valid_loss, D_train_loss, D_valid_loss, checkpoint_path):\n",
+    "        checkpoint = {\n",
+    "            'epoch': epoch,\n",
+    "            'G_train_loss': G_train_loss,\n",
+    "            'G_valid_loss': G_valid_loss,\n",
+    "            'D_train_loss': D_train_loss,\n",
+    "            'D_valid_loss': D_valid_loss,\n",
+    "            'generator': self.generator.state_dict(),\n",
+    "            'discriminator': self.discriminator.state_dict(),\n",
+    "            'G_optimizer': self.optimizer_G.state_dict(),\n",
+    "            'D_optimizer': self.optimizer_D.state_dict(),\n",
+    "            'G_lr_scheduler': self.scheduler_G.state_dict(),\n",
+    "            'D_lr_scheduler': self.scheduler_D.state_dict(),\n",
+    "            'network': self\n",
+    "        }\n",
+    "        torch.save(checkpoint, checkpoint_path)\n",
+    "    \n",
+    "    def load_network(self, checkpoint_path):\n",
+    "        checkpoint = torch.load(checkpoint_path)\n",
+    "        self.generator.load_state_dict(checkpoint['generator'])\n",
+    "        if not self.for_inference:\n",
+    "            self.optimizer_G.load_state_dict(checkpoint['G_optimizer'])\n",
+    "            self.scheduler_G.load_state_dict(checkpoint['G_lr_scheduler'])\n",
+    "            self.optimizer_D.load_state_dict(checkpoint['D_optimizer'])\n",
+    "            self.scheduler_D.load_state_dict(checkpoint['D_lr_scheduler'])\n",
+    "            self.train_dataloader = train_dataloader\n",
+    "            self.valid_dataloader = valid_dataloader\n",
+    "        return checkpoint['epoch'], checkpoint['G_train_loss'], checkpoint['G_valid_loss'], checkpoint['D_train_loss'], checkpoint['D_valid_loss']\n",
+    "    \n",
+    "    def train_step(self, lr_img, hr_img):\n",
+    "        lr_img, hr_img = lr_img.to(self.device), hr_img.to(self.device)\n",
+    "        \n",
+    "        #-----------------\n",
+    "        # train generator\n",
+    "        #-----------------\n",
+    "        \n",
+    "        self.generator.train()\n",
+    "        self.optimizer_G.zero_grad()\n",
+    "        #generate hr img\n",
+    "        gen_hr = self.generator(lr_img).to(self.device)\n",
+    "        fake_out = self.discriminator(gen_hr).mean()\n",
+    "        loss_G = self.generator_loss(fake_out, gen_hr, hr_img)\n",
+    "\n",
+    "        loss_G.backward()\n",
+    "        self.optimizer_G.step()\n",
+    "        \n",
+    "        #-----------------------------\n",
+    "        # train discriminator\n",
+    "        #-----------------------------\n",
+    "        self.discriminator.train()\n",
+    "        self.optimizer_D.zero_grad()\n",
+    "        \n",
+    "        real_out = self.discriminator(hr_img).mean()\n",
+    "        fake_out = self.discriminator(self.generator(lr_img)).mean()\n",
+    "        loss_D = 1 - real_out + fake_out\n",
+    "        loss_D.backward()\n",
+    "        self.optimizer_D.step()\n",
+    "        del gen_hr, lr_img, hr_img, real_out, fake_out\n",
+    "        gc.collect()\n",
+    "        torch.cuda.empty_cache()\n",
+    "        return loss_G.item(), loss_D.item()\n",
+    "    \n",
+    "    def valid_step(self, lr_img, hr_img):\n",
+    "        lr_img, hr_img = lr_img.to(self.device), hr_img.to(self.device)\n",
+    "        gen_hr = self.generator(lr_img).to(self.device)\n",
+    "        #loss of generator\n",
+    "        fake_out = self.discriminator(gen_hr).mean()\n",
+    "        loss_G = self.generator_loss(fake_out, gen_hr, hr_img)\n",
+    "        \n",
+    "        #loss of discriminator\n",
+    "        real_out = self.discriminator(hr_img).mean()\n",
+    "        fake_out = self.discriminator(gen_hr).mean()\n",
+    "        loss_D = 1 - real_out + fake_out\n",
+    "        \n",
+    "        del lr_img, hr_img, gen_hr, fake_out, real_out\n",
+    "        gc.collect()\n",
+    "        torch.cuda.empty_cache()\n",
+    "        \n",
+    "        return loss_G.item(), loss_D.item()\n",
+    "    \n",
+    "    def train_GAN(self):\n",
+    "        last_valid_loss = float('inf')\n",
+    "        wandb.init(project='SRGAN ver2',\n",
+    "                  resume='allow',\n",
+    "                  config={\n",
+    "                      'generator_lr':G_LR,\n",
+    "                      'discriminator_lr': D_LR,\n",
+    "                      'num_epochs':N_EPOCHS\n",
+    "                  },\n",
+    "                  id = self.run_id)\n",
+    "        wandb.watch(self.generator)\n",
+    "        for epoch in range(self.num_epochs):\n",
+    "            start = time.time()\n",
+    "            \n",
+    "            #---------TRAIN------------\n",
+    "            G_train_epoch_loss = 0\n",
+    "            D_train_epoch_loss = 0\n",
+    "            for hr_img, lr_img in tqdm(self.train_dataloader, desc=f'Epoch {epoch+1}/{self.num_epochs}'):\n",
+    "                G_loss, D_loss = self.train_step(lr_img, hr_img)\n",
+    "                G_train_epoch_loss += G_loss\n",
+    "                D_train_epoch_loss += D_loss\n",
+    "            \n",
+    "            G_train_epoch_loss /= len(self.train_dataloader)\n",
+    "            D_train_epoch_loss /= len(self.train_dataloader)\n",
+    "            end = time.time()\n",
+    "            \n",
+    "            #---------VALID-----------\n",
+    "            self.generator.eval()\n",
+    "            self.discriminator.eval()\n",
+    "            with torch.no_grad():\n",
+    "                G_valid_epoch_loss = 0\n",
+    "                D_valid_epoch_loss = 0\n",
+    "                for hr_img, lr_img in tqdm(self.valid_dataloader, desc=f'Epoch {epoch+1}/{self.num_epochs}'):\n",
+    "                    G_loss, D_loss = self.valid_step(lr_img, hr_img)\n",
+    "                    G_valid_epoch_loss+=G_loss\n",
+    "                    D_valid_epoch_loss+=D_loss\n",
+    "                \n",
+    "                G_valid_epoch_loss /= len(self.valid_dataloader)\n",
+    "                D_valid_epoch_loss /= len(self.valid_dataloader)\n",
+    "                \n",
+    "            #------------LOG----------------\n",
+    "            wandb.log({\n",
+    "                'G_train_loss': G_train_epoch_loss,\n",
+    "                'G_valid_loss': G_valid_epoch_loss,\n",
+    "                'G_lr': self.optimizer_G.param_groups[0]['lr'],\n",
+    "                'D_train_loss': D_train_epoch_loss,\n",
+    "                'D_valid_loss': D_valid_epoch_loss,\n",
+    "                'D_lr': self.optimizer_D.param_groups[0]['lr']\n",
+    "            })\n",
+    "            self.scheduler_G.step()\n",
+    "            self.scheduler_D.step()\n",
+    "            \n",
+    "            #---------------VERBOSE-------------\n",
+    "            print(f'Epoch {epoch+1}/{self.num_epochs} | Generator train Loss: {G_train_epoch_loss:.4f} | Generator valid Loss: {G_valid_epoch_loss:.4f}')\n",
+    "            print(f'                                  | Discriminator train Loss: {D_train_epoch_loss:.4f} | Discriminator valid Loss: {D_valid_epoch_loss:.4f} | Time: {end-start:.2f}s')\n",
+    "            #-------------CHECKPOINT------------\n",
+    "            self.save_network(epoch, G_train_epoch_loss, G_valid_epoch_loss, D_train_epoch_loss, D_valid_epoch_loss, 'model_checkpoint_latest.pth')\n",
+    "            if G_valid_epoch_loss < last_valid_loss:\n",
+    "                last_valid_loss = G_valid_epoch_loss\n",
+    "                self.save_network(epoch, G_train_epoch_loss, G_valid_epoch_loss, D_train_epoch_loss, D_valid_epoch_loss, 'model_checkpoint_best.pth')\n",
+    "                print(\"New best checkpoint saved!\")\n",
+    "        \n",
+    "        wandb.finish()\n",
+    "    def inference(self, lr_image, hr_image=None):\n",
+    "        lr_image = lr_image.unsqueeze(0).to(self.device)\n",
+    "        with torch.no_grad():\n",
+    "            sr_image = self.generator(lr_image)\n",
+    "        \n",
+    "        lr_image = lr_image.squeeze(0)\n",
+    "        sr_image = sr_image.squeeze(0)\n",
+    "        \n",
+    "        print(\">> Size of low-res image:\", lr_image.size())\n",
+    "        print(\">> Size of super-res image:\", sr_image.size())\n",
+    "        if hr_image != None:\n",
+    "            print(\">> Size of high-res image:\", hr_image.size())\n",
+    "        \n",
+    "        if hr_image != None:\n",
+    "            fig, axes = plt.subplots(1, 3, figsize=(10, 6))\n",
+    "            axes[0].imshow(lr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "            axes[0].set_title('Low Resolution')\n",
+    "            axes[1].imshow(sr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "            axes[1].set_title('Super Resolution')\n",
+    "            axes[2].imshow(hr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "            axes[2].set_title('High Resolution')\n",
+    "            for ax in axes.flat:\n",
+    "                ax.axis('off')\n",
+    "        else:\n",
+    "            fig, axes = plt.subplots(1, 2, figsize=(10, 6))\n",
+    "            axes[0].imshow(lr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "            axes[0].set_title('Low Resolution')\n",
+    "            axes[1].imshow(sr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "            axes[1].set_title('Super Resolution')\n",
+    "            for ax in axes.flat:\n",
+    "                ax.axis('off')\n",
+    "        \n",
+    "        plt.tight_layout()        \n",
+    "        plt.show()\n",
+    "        \n",
+    "        return sr_image \n",
+    "        \n",
+    "    def train_model_continue(self, checkpoint_path):\n",
+    "        \n",
+    "        start_epoch, G_train_loss, G_valid_loss, D_train_loss, D_valid_loss = self.load_network(checkpoint_path)\n",
+    "        print(\"Generator previous train loss: \", G_train_loss)\n",
+    "        print(\"Generator previous valid loss: \", G_valid_loss)\n",
+    "        print(\"Discriminator previous train loss: \", D_train_loss)\n",
+    "        print(\"Discriminator previous valid loss: \", D_valid_loss)\n",
+    "        print()\n",
+    "        print(\"------------------- Resuming training -------------------\")\n",
+    "        self.num_epochs -= start_epoch\n",
+    "        self.train_GAN()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "9edbacd2",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:03.090580Z",
+     "iopub.status.busy": "2024-03-22T08:38:03.090294Z",
+     "iopub.status.idle": "2024-03-22T08:38:03.094139Z",
+     "shell.execute_reply": "2024-03-22T08:38:03.093226Z"
+    },
+    "papermill": {
+     "duration": 0.018605,
+     "end_time": "2024-03-22T08:38:03.096291",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:03.077686",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#srgan = Network(run_id='srgan_cvprj_7')\n",
+    "#num_params = sum(p.numel() for p in srgan.generator.parameters() if p.requires_grad) + sum(p.numel() for p in srgan.discriminator.parameters() if p.requires_grad)\n",
+    "#print('Number of learnable params: ',num_params)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "9c462372",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T08:38:03.121170Z",
+     "iopub.status.busy": "2024-03-22T08:38:03.120910Z",
+     "iopub.status.idle": "2024-03-22T13:32:58.120993Z",
+     "shell.execute_reply": "2024-03-22T13:32:58.120248Z"
+    },
+    "papermill": {
+     "duration": 17695.014755,
+     "end_time": "2024-03-22T13:32:58.123104",
+     "exception": false,
+     "start_time": "2024-03-22T08:38:03.108349",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34m\u001b[1mwandb\u001b[0m: W&B API key is configured. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[33mWARNING\u001b[0m If you're specifying your api key in code, ensure this code is not shared publicly.\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[33mWARNING\u001b[0m Consider setting the WANDB_API_KEY environment variable, or running `wandb login` from the command line.\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Appending key for api.wandb.ai to your netrc file: /root/.netrc\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mphamquangtung0606\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: wandb version 0.16.4 is available!  To upgrade, please run:\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m:  $ pip install wandb --upgrade\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.16.0\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m/kaggle/working/wandb/run-20240322_083806-srgan_cvprj_7\u001b[0m\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Resuming run \u001b[33msrgan_cvprj_7\u001b[0m\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/phamquangtung0606/SRGAN%20ver2\u001b[0m\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/phamquangtung0606/SRGAN%20ver2/runs/srgan_cvprj_7\u001b[0m\n",
+      "Epoch 1/25: 100%|██████████| 216/216 [17:47<00:00,  4.94s/it]\n",
+      "Epoch 1/25: 100%|██████████| 100/100 [01:50<00:00,  1.11s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/25 | Generator train Loss: 0.0135 | Generator valid Loss: 0.0181\n",
+      "                                  | Discriminator train Loss: 0.0008 | Discriminator valid Loss: 1.2184 | Time: 1067.42s\n",
+      "New best checkpoint saved!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/25: 100%|██████████| 216/216 [09:39<00:00,  2.68s/it]\n",
+      "Epoch 2/25: 100%|██████████| 100/100 [01:44<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/25 | Generator train Loss: 0.0134 | Generator valid Loss: 0.0200\n",
+      "                                  | Discriminator train Loss: 0.0006 | Discriminator valid Loss: 1.1946 | Time: 579.65s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/25: 100%|██████████| 216/216 [09:41<00:00,  2.69s/it]\n",
+      "Epoch 3/25: 100%|██████████| 100/100 [01:45<00:00,  1.06s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/25 | Generator train Loss: 0.0134 | Generator valid Loss: 0.0156\n",
+      "                                  | Discriminator train Loss: 0.0005 | Discriminator valid Loss: 1.1598 | Time: 581.08s\n",
+      "New best checkpoint saved!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/25: 100%|██████████| 216/216 [09:44<00:00,  2.71s/it]\n",
+      "Epoch 4/25: 100%|██████████| 100/100 [01:44<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/25 | Generator train Loss: 0.0134 | Generator valid Loss: 0.0166\n",
+      "                                  | Discriminator train Loss: 0.0004 | Discriminator valid Loss: 1.1621 | Time: 584.56s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/25: 100%|██████████| 216/216 [09:46<00:00,  2.72s/it]\n",
+      "Epoch 5/25: 100%|██████████| 100/100 [01:45<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/25 | Generator train Loss: 0.0134 | Generator valid Loss: 0.0196\n",
+      "                                  | Discriminator train Loss: 0.0003 | Discriminator valid Loss: 1.1444 | Time: 586.87s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/25: 100%|██████████| 216/216 [09:43<00:00,  2.70s/it]\n",
+      "Epoch 6/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/25 | Generator train Loss: 0.0134 | Generator valid Loss: 0.0178\n",
+      "                                  | Discriminator train Loss: 0.0003 | Discriminator valid Loss: 1.1135 | Time: 583.76s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/25: 100%|██████████| 216/216 [09:44<00:00,  2.71s/it]\n",
+      "Epoch 7/25: 100%|██████████| 100/100 [01:45<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/25 | Generator train Loss: 0.0134 | Generator valid Loss: 0.0199\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1378 | Time: 584.69s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/25: 100%|██████████| 216/216 [09:41<00:00,  2.69s/it]\n",
+      "Epoch 8/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/25 | Generator train Loss: 0.0133 | Generator valid Loss: 0.0265\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1232 | Time: 581.41s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/25: 100%|██████████| 216/216 [09:40<00:00,  2.69s/it]\n",
+      "Epoch 9/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/25 | Generator train Loss: 0.0133 | Generator valid Loss: 0.0236\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1369 | Time: 580.88s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/25: 100%|████████���█| 216/216 [09:41<00:00,  2.69s/it]\n",
+      "Epoch 10/25: 100%|██████████| 100/100 [01:44<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/25 | Generator train Loss: 0.0133 | Generator valid Loss: 0.0274\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1355 | Time: 581.55s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 11/25: 100%|██████████| 216/216 [09:39<00:00,  2.68s/it]\n",
+      "Epoch 11/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 11/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0171\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1697 | Time: 579.67s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 12/25: 100%|██████████| 216/216 [09:38<00:00,  2.68s/it]\n",
+      "Epoch 12/25: 100%|██████████| 100/100 [01:43<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 12/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0163\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1458 | Time: 578.96s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 13/25: 100%|██████████| 216/216 [09:37<00:00,  2.67s/it]\n",
+      "Epoch 13/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 13/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0162\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1523 | Time: 577.71s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 14/25: 100%|██████████| 216/216 [09:38<00:00,  2.68s/it]\n",
+      "Epoch 14/25: 100%|██████████| 100/100 [01:44<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 14/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0168\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1501 | Time: 578.48s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 15/25: 100%|██████████| 216/216 [09:37<00:00,  2.67s/it]\n",
+      "Epoch 15/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 15/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0160\n",
+      "                                  | Discriminator train Loss: 0.0002 | Discriminator valid Loss: 1.1429 | Time: 577.28s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 16/25: 100%|██████████| 216/216 [09:39<00:00,  2.68s/it]\n",
+      "Epoch 16/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 16/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0176\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1294 | Time: 579.38s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 17/25: 100%|██████████| 216/216 [09:39<00:00,  2.68s/it]\n",
+      "Epoch 17/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 17/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0171\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1475 | Time: 579.58s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 18/25: 100%|██████████| 216/216 [09:40<00:00,  2.69s/it]\n",
+      "Epoch 18/25: 100%|██████████| 100/100 [01:44<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 18/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0166\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1462 | Time: 581.00s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 19/25: 100%|██████████| 216/216 [09:44<00:00,  2.70s/it]\n",
+      "Epoch 19/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 19/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0172\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1465 | Time: 584.27s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20/25: 100%|██████████| 216/216 [09:47<00:00,  2.72s/it]\n",
+      "Epoch 20/25: 100%|██████████| 100/100 [01:44<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0158\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1373 | Time: 587.01s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 21/25: 100%|██████████| 216/216 [09:50<00:00,  2.73s/it]\n",
+      "Epoch 21/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 21/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0157\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1265 | Time: 590.25s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 22/25: 100%|██████████| 216/216 [09:44<00:00,  2.71s/it]\n",
+      "Epoch 22/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 22/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0158\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1295 | Time: 584.61s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 23/25: 100%|██████████| 216/216 [09:46<00:00,  2.71s/it]\n",
+      "Epoch 23/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 23/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0157\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1260 | Time: 586.39s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 24/25: 100%|██████████| 216/216 [09:46<00:00,  2.72s/it]\n",
+      "Epoch 24/25: 100%|██████████| 100/100 [01:43<00:00,  1.04s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 24/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0158\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1235 | Time: 586.71s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 25/25: 100%|██████████| 216/216 [09:48<00:00,  2.72s/it]\n",
+      "Epoch 25/25: 100%|██████████| 100/100 [01:44<00:00,  1.05s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 25/25 | Generator train Loss: 0.0132 | Generator valid Loss: 0.0159\n",
+      "                                  | Discriminator train Loss: 0.0001 | Discriminator valid Loss: 1.1280 | Time: 588.26s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "wandb: WARNING No requirements.txt found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m:                                                                                \n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: \n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Run history:\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m:         D_lr ██████████▂▂▂▂▂▂▂▂▂▂▁▁▁▁▁\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: D_train_loss █▆▅▄▃▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: D_valid_loss █▆▄▄▃▁▃▂▃▂▅▃▄▃▃▂▃▃▃▃▂▂▂▂▂\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m:         G_lr ██████████▂▂▂▂▂▂▂▂▂▂▁▁▁▁▁\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: G_train_loss █▆▆▅▅▅▅▄▄▄▂▂▂▂▂▂▂▁▁▁▁▁▁▁▁\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: G_valid_loss ▂▄▁▂▃▂▄▇▆█▂▁▁▂▁▂▂▂▂▁▁▁▁▁▁\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: \n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Run summary:\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m:         D_lr 0.0\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: D_train_loss 0.00014\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: D_valid_loss 1.12798\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m:         G_lr 0.0\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: G_train_loss 0.01318\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: G_valid_loss 0.0159\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: \n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run \u001b[33msrgan_cvprj_7\u001b[0m at: \u001b[34m\u001b[4mhttps://wandb.ai/phamquangtung0606/SRGAN%20ver2/runs/srgan_cvprj_7\u001b[0m\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Synced 3 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Find logs at: \u001b[35m\u001b[1m./wandb/run-20240322_083806-srgan_cvprj_7/logs\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "checkpoint = torch.load('/kaggle/input/srgan3/model_checkpoint_latest.pth')\n",
+    "srgan = checkpoint['network']\n",
+    "srgan.num_epochs = 25\n",
+    "srgan.optimizer_G = torch.optim.Adam(srgan.generator.parameters(), lr=1e-04, betas=BETAS)\n",
+    "srgan.optimizer_D = torch.optim.Adam(srgan.discriminator.parameters(), lr=2e-06, betas=BETAS)\n",
+    "srgan.scheduler_G =  torch.optim.lr_scheduler.StepLR(srgan.optimizer_G, step_size=STEP_SIZE)\n",
+    "srgan.scheduler_D =  torch.optim.lr_scheduler.StepLR(srgan.optimizer_D, step_size=STEP_SIZE)\n",
+    "wandb.login(key='372e034db319c23a6f5b110e14401540f2152e95')\n",
+    "srgan.train_GAN()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12ddadbe",
+   "metadata": {
+    "papermill": {
+     "duration": 0.664769,
+     "end_time": "2024-03-22T13:32:59.447274",
+     "exception": false,
+     "start_time": "2024-03-22T13:32:58.782505",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "<h1>TEST</h1>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ab76eacc",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:00.749064Z",
+     "iopub.status.busy": "2024-03-22T13:33:00.748106Z",
+     "iopub.status.idle": "2024-03-22T13:33:00.755556Z",
+     "shell.execute_reply": "2024-03-22T13:33:00.754760Z"
+    },
+    "papermill": {
+     "duration": 0.65982,
+     "end_time": "2024-03-22T13:33:00.757682",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:00.097862",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class TestDataset(Dataset):\n",
+    "    def __init__(self, hr_images_path):\n",
+    "        super(TestDataset, self).__init__()\n",
+    "        hr_images_list = os.listdir(hr_images_path)\n",
+    "        self.hr_images_list = [hr_images_path + image_name for image_name in hr_images_list if image_name.endswith('HR.png')]\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        hr_image_path = self.hr_images_list[idx]\n",
+    "        lr_image_path = hr_image_path.replace('HR', 'LR')\n",
+    "        \n",
+    "        hr_image = Image.open(hr_image_path)\n",
+    "        lr_image = Image.open(lr_image_path)\n",
+    "        \n",
+    "        hr_image = transforms.functional.to_tensor(hr_image)\n",
+    "        lr_image = transforms.functional.to_tensor(lr_image)\n",
+    "        \n",
+    "        return hr_image, lr_image\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.hr_images_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "60717741",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:02.192097Z",
+     "iopub.status.busy": "2024-03-22T13:33:02.191334Z",
+     "iopub.status.idle": "2024-03-22T13:33:02.196890Z",
+     "shell.execute_reply": "2024-03-22T13:33:02.195727Z"
+    },
+    "papermill": {
+     "duration": 0.789983,
+     "end_time": "2024-03-22T13:33:02.198994",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:01.409011",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#SET5_PATH = \"/kaggle/input/super-resolution-hust/Super Resolution HUST/Set5/image_SRF_4/\"\n",
+    "#SET14_PATH = \"/kaggle/input/super-resolution-hust/Super Resolution HUST/Set14/image_SRF_4/\"\n",
+    "#URBAN100_PATH = \"/kaggle/input/super-resolution-hust/Super Resolution HUST/Urban100/image_SRF_4/\"\n",
+    "#BSD100_PATH = \"/kaggle/input/super-resolution-hust/Super Resolution HUST/BSD100/image_SRF_4/\"\n",
+    "\n",
+    "#set5_dataset = TestDataset(hr_images_path=SET5_PATH)\n",
+    "#set14_dataset = TestDataset(hr_images_path=SET14_PATH)\n",
+    "#urban100_dataset = TestDataset(hr_images_path=URBAN100_PATH)\n",
+    "#bsd100_dataset = TestDataset(hr_images_path=BSD100_PATH)\n",
+    "\n",
+    "#print(len(set5_dataset), len(set14_dataset), len(urban100_dataset), len(bsd100_dataset))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98104ffe",
+   "metadata": {
+    "papermill": {
+     "duration": 0.654559,
+     "end_time": "2024-03-22T13:33:03.539624",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:02.885065",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "<h1>Test metrics</h1>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "701d55bb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:04.852416Z",
+     "iopub.status.busy": "2024-03-22T13:33:04.852053Z",
+     "iopub.status.idle": "2024-03-22T13:33:04.863654Z",
+     "shell.execute_reply": "2024-03-22T13:33:04.862889Z"
+    },
+    "papermill": {
+     "duration": 0.672654,
+     "end_time": "2024-03-22T13:33:04.865651",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:04.192997",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def inference(model, lr_image, hr_image=None):\n",
+    "    lr_image = lr_image.unsqueeze(0).to(DEVICE)\n",
+    "    with torch.no_grad():\n",
+    "        sr_image = model(lr_image)\n",
+    "\n",
+    "    lr_image = lr_image.squeeze(0)\n",
+    "    sr_image = sr_image.squeeze(0)\n",
+    "\n",
+    "    print(\">> Size of low-res image:\", lr_image.size())\n",
+    "    print(\">> Size of super-res image:\", sr_image.size())\n",
+    "    if hr_image != None:\n",
+    "        print(\">> Size of high-res image:\", hr_image.size())\n",
+    "\n",
+    "    if hr_image != None:\n",
+    "        fig, axes = plt.subplots(1, 3, figsize=(10, 6))\n",
+    "        axes[0].imshow(lr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "        axes[0].set_title('Low Resolution')\n",
+    "        axes[1].imshow(sr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "        axes[1].set_title('Super Resolution')\n",
+    "        axes[2].imshow(hr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "        axes[2].set_title('High Resolution')\n",
+    "        for ax in axes.flat:\n",
+    "            ax.axis('off')\n",
+    "\n",
+    "    else:\n",
+    "        fig, axes = plt.subplots(1, 2, figsize=(10, 6))\n",
+    "        axes[0].imshow(lr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "        axes[0].set_title('Low Resolution')\n",
+    "        axes[1].imshow(sr_image.cpu().detach().permute((1, 2, 0)))\n",
+    "        axes[1].set_title('Super Resolution')\n",
+    "        for ax in axes.flat:\n",
+    "            ax.axis('off')\n",
+    "\n",
+    "    plt.tight_layout()        \n",
+    "    plt.show()\n",
+    "\n",
+    "    return sr_image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "eb5793bd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:06.258765Z",
+     "iopub.status.busy": "2024-03-22T13:33:06.258417Z",
+     "iopub.status.idle": "2024-03-22T13:33:06.267836Z",
+     "shell.execute_reply": "2024-03-22T13:33:06.266968Z"
+    },
+    "papermill": {
+     "duration": 0.753649,
+     "end_time": "2024-03-22T13:33:06.269692",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:05.516043",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def test(model, hr_images, lr_images, show_image=True, idx=0):\n",
+    "    hr_images = hr_images.cuda()\n",
+    "    lr_images = lr_images.cuda()\n",
+    "    \n",
+    "    def calculate_psnr(original_images, reconstructed_images):\n",
+    "        if original_images.shape != reconstructed_images.shape:\n",
+    "            raise ValueError(\"Images must have the same shape\")\n",
+    "\n",
+    "        mse = F.mse_loss(original_images, reconstructed_images, reduction='mean')\n",
+    "        max_pixel_value = 1.0\n",
+    "        psnr_value = 10 * torch.log10((max_pixel_value ** 2) / mse)\n",
+    "        return psnr_value.item()\n",
+    "    \n",
+    "    def calculate_ssim(original_images, reconstructed_images):\n",
+    "\n",
+    "        if original_images.shape != reconstructed_images.shape:\n",
+    "            raise ValueError(\"Images in the batch must have the same shape\")\n",
+    "\n",
+    "        ssim_value = ssim(original_images, reconstructed_images) \n",
+    "        return ssim_value.item()\n",
+    "    \n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        sr_images = model(lr_images)\n",
+    "    \n",
+    "    loss_func = nn.L1Loss(reduction='mean')\n",
+    "    l1_loss = loss_func(hr_images.cpu(), sr_images.cpu()).item()\n",
+    "    psnr_value = calculate_psnr(hr_images.cpu(), sr_images.cpu())\n",
+    "    ssim_value = calculate_ssim(hr_images.cpu(), sr_images.cpu())\n",
+    "    \n",
+    "    if show_image:\n",
+    "        inference(model, lr_images[idx], hr_images[idx])\n",
+    "    \n",
+    "    return l1_loss, psnr_value, ssim_value"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "90ce6e64",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:07.571919Z",
+     "iopub.status.busy": "2024-03-22T13:33:07.571061Z",
+     "iopub.status.idle": "2024-03-22T13:33:07.579557Z",
+     "shell.execute_reply": "2024-03-22T13:33:07.578579Z"
+    },
+    "papermill": {
+     "duration": 0.659811,
+     "end_time": "2024-03-22T13:33:07.581584",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:06.921773",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def test_on_dataset(model, dataset, IDX):\n",
+    "    l1_batch_loss = 0\n",
+    "    psnr_batch_value = 0\n",
+    "    ssim_batch_value = 0\n",
+    "    for i in range(len(dataset)):\n",
+    "        hr_image, lr_image = dataset[i]\n",
+    "        if hr_image.shape[0] != 3:\n",
+    "            hr_image = hr_image.expand(3, -1, -1)\n",
+    "            lr_image = lr_image.expand(3, -1, -1)\n",
+    "        hr_image = hr_image.unsqueeze(0)\n",
+    "        lr_image = lr_image.unsqueeze(0)\n",
+    "\n",
+    "        if i in IDX:\n",
+    "            l1_loss, psnr_value, ssim_value = test(model, hr_image, lr_image, show_image=True)\n",
+    "        else:\n",
+    "            l1_loss, psnr_value, ssim_value = test(model, hr_image, lr_image, show_image=False)\n",
+    "\n",
+    "        l1_batch_loss += l1_loss\n",
+    "        psnr_batch_value += psnr_value\n",
+    "        ssim_batch_value += ssim_value\n",
+    "        \n",
+    "    print(\"Metrics across \" + str(len(dataset)) + \" images:\")\n",
+    "    print(f\"> L1 Loss: {l1_batch_loss/len(dataset):.4f}\")\n",
+    "    print(f\"> PSNR: {psnr_batch_value/len(dataset):.4f}\")\n",
+    "    print(f\"> SSIM: {ssim_batch_value/len(dataset):.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2e1d0e7",
+   "metadata": {
+    "papermill": {
+     "duration": 0.656931,
+     "end_time": "2024-03-22T13:33:08.888502",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:08.231571",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "<h1>TEST MODELS<h1>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "768d8c73",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:10.337552Z",
+     "iopub.status.busy": "2024-03-22T13:33:10.336546Z",
+     "iopub.status.idle": "2024-03-22T13:33:10.341251Z",
+     "shell.execute_reply": "2024-03-22T13:33:10.340280Z"
+    },
+    "papermill": {
+     "duration": 0.811421,
+     "end_time": "2024-03-22T13:33:10.343368",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:09.531947",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#model = Network(for_inference=True)\n",
+    "#model.load_network('/kaggle/input/srgan2/model_checkpoint_best.pth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "83afc85f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:11.648791Z",
+     "iopub.status.busy": "2024-03-22T13:33:11.648429Z",
+     "iopub.status.idle": "2024-03-22T13:33:11.652670Z",
+     "shell.execute_reply": "2024-03-22T13:33:11.651756Z"
+    },
+    "papermill": {
+     "duration": 0.653152,
+     "end_time": "2024-03-22T13:33:11.654840",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:11.001688",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#generator = model.generator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "95b466e9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:12.983505Z",
+     "iopub.status.busy": "2024-03-22T13:33:12.983137Z",
+     "iopub.status.idle": "2024-03-22T13:33:12.987389Z",
+     "shell.execute_reply": "2024-03-22T13:33:12.986484Z"
+    },
+    "papermill": {
+     "duration": 0.684113,
+     "end_time": "2024-03-22T13:33:12.989233",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:12.305120",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#-------------------- SET5 -------------------- #\n",
+    "#IDX = list(range(5))\n",
+    "#test_on_dataset(generator, set5_dataset, IDX)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "abdb6366",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:14.374088Z",
+     "iopub.status.busy": "2024-03-22T13:33:14.373188Z",
+     "iopub.status.idle": "2024-03-22T13:33:14.377483Z",
+     "shell.execute_reply": "2024-03-22T13:33:14.376643Z"
+    },
+    "papermill": {
+     "duration": 0.66121,
+     "end_time": "2024-03-22T13:33:14.379395",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:13.718185",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#random.seed(1989)\n",
+    "#IDX = random.choices(list(range(14)), k=5)\n",
+    "#test_on_dataset(generator, set14_dataset, IDX)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "53beaf3d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-22T13:33:15.690929Z",
+     "iopub.status.busy": "2024-03-22T13:33:15.690095Z",
+     "iopub.status.idle": "2024-03-22T13:33:15.694046Z",
+     "shell.execute_reply": "2024-03-22T13:33:15.693176Z"
+    },
+    "papermill": {
+     "duration": 0.663925,
+     "end_time": "2024-03-22T13:33:15.695889",
+     "exception": false,
+     "start_time": "2024-03-22T13:33:15.031964",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#random.seed(1989)\n",
+    "#IDX = random.choices(list(range(100)), k=5)\n",
+    "#test_on_dataset(generator, urban100_dataset, IDX)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "gpu",
+   "dataSources": [
+    {
+     "datasetId": 4029616,
+     "sourceId": 7009068,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 4120526,
+     "sourceId": 7139628,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 4648227,
+     "sourceId": 7911972,
+     "sourceType": "datasetVersion"
+    }
+   ],
+   "dockerImageVersionId": 30588,
+   "isGpuEnabled": true,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "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.10.12"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 17733.37832,
+   "end_time": "2024-03-22T13:33:19.013845",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "__notebook__.ipynb",
+   "output_path": "__notebook__.ipynb",
+   "parameters": {},
+   "start_time": "2024-03-22T08:37:45.635525",
+   "version": "2.4.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}