SwinIr.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SwinIr.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/wanifarooq/SwinIr/blob/main/SwinIr.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This block ofcode is used to mount the **Google Drive**\n"
      ],
      "metadata": {
        "id": "TqZf2zNJEMlG"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Oz-ULTEDE6_x",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "847cceac-e61b-4fcf-909e-a98b70623822"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Weights & Biases** is the machine learning platform for developers to build better models faster. Use ***W&B's*** lightweight, interoperable tools to quickly track experiments, version and iterate on datasets, evaluate model performance, reproduce models, visualize results and spot regressions, and share findings with colleagues."
      ],
      "metadata": {
        "id": "8t01JNk7Efh6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install wandb"
      ],
      "metadata": {
        "id": "l-JlHr0WNGCn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bc7b072d-8108-4e3e-cb3f-96b6b0cf9513"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Installing collected packages: smmap, gitdb, shortuuid, setproctitle, sentry-sdk, pathtools, GitPython, docker-pycreds, wandb\n",
            "Successfully installed GitPython-3.1.27 docker-pycreds-0.4.0 gitdb-4.0.9 pathtools-0.1.2 sentry-sdk-1.5.10 setproctitle-1.2.3 shortuuid-1.0.8 smmap-5.0.0 wandb-0.12.15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**`timm`** is a deep-learning library created by ***Ross Wightman*** and is a collection of SOTA computer vision models, layers, utilities, optimizers, schedulers, data-loaders, augmentations and also training/validating scripts with ability to reproduce ImageNet training results."
      ],
      "metadata": {
        "id": "qhmQCRLRFgEm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install timm"
      ],
      "metadata": {
        "id": "mFwEXltgNRXE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Importing different libraries"
      ],
      "metadata": {
        "id": "VyVfkDuwGey3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import argparse\n",
        "import sys\n",
        "import random\n",
        "import numpy as np\n",
        "import wandb\n",
        "import logging\n",
        "import json\n",
        "import re\n",
        "import glob\n",
        "import cv2\n",
        "import os\n",
        "import functools\n",
        "import math\n",
        "from torch.nn.parallel import DataParallel, DistributedDataParallel\n",
        "from torch.utils.data import DataLoader\n",
        "from torch.utils.data.distributed import DistributedSampler\n",
        "from timm.models.layers import DropPath, to_2tuple, trunc_normal_\n",
        "import torch\n",
        "import torch.utils.checkpoint as checkpoint\n",
        "from datetime import datetime\n",
        "import torch.distributed as workDist\n",
        "import torch.multiprocessing as mp\n",
        "from collections import OrderedDict\n",
        "from torch.optim import lr_scheduler\n",
        "import torch.utils.data as data\n",
        "from torch.optim import Adam\n",
        "import torch.nn as nn\n",
        "import warnings"
      ],
      "metadata": {
        "id": "tjKxY8RdRpCR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "1.   First line is being written to supress the **warnings**\n",
        "2.   The second line of code is introduced to include different **image extension**.\n",
        "\n"
      ],
      "metadata": {
        "id": "Ffw3PL3_Gssf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "warnings.filterwarnings(\"ignore\")\n",
        "checkExtension = ['.jpg', '.JPG', '.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', '.tif']"
      ],
      "metadata": {
        "id": "FqlS_EPPiUlv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**This blocks checks for the file type, whether it is image or not**"
      ],
      "metadata": {
        "id": "DqcGMzlGHSpv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def checkFileType(image):\n",
        "    return any(image.endswith(extension) for extension in checkExtension)"
      ],
      "metadata": {
        "id": "VSUm1bW3icSg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "\n",
        "1.   Returns the list of image paths from the directory(folder).\n",
        "2.  The function argument is the path of the directory and the return is list of image paths."
      ],
      "metadata": {
        "id": "bEq5UJqQNtxO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getImagePaths(path):\n",
        "    assert os.path.isdir(path), '{:s} is not valid directory so check it again'.format(path)\n",
        "    images = []\n",
        "    for dirpath, _, fnames in sorted(os.walk(path)):\n",
        "        for fname in sorted(fnames):\n",
        "            if checkFileType(fname):\n",
        "                img_path = os.path.join(dirpath, fname)\n",
        "                images.append(img_path)\n",
        "    assert images, '{:s} doesnot contain any valid images'.format(path)\n",
        "    return images"
      ],
      "metadata": {
        "id": "AkmZPCFFihQb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sorts the image paths, same for every dataset"
      ],
      "metadata": {
        "id": "Uw9Pum1rTBv3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def imagePaths(dataroot):\n",
        "    paths = None  \n",
        "    if dataroot is not None:\n",
        "        paths = sorted(getImagePaths(dataroot))\n",
        "    return paths"
      ],
      "metadata": {
        "id": "QMM8Rs6_ihVD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Converts uint to float "
      ],
      "metadata": {
        "id": "0GBiFx-mwl_G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def uint2single(img):\n",
        "    return np.float32(img / 255.)"
      ],
      "metadata": {
        "id": "O3qWDPs_ihaL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Loads the image from the image path as \n",
        "\n",
        "\n",
        "1.  **H*W*1**  for **grayscale**\n",
        "2.  **H*W*2** **GGG** for **ndim =2**\n",
        "3.  **H*W*3** **RGB** for **ndim =3**\n",
        "\n"
      ],
      "metadata": {
        "id": "eR7Rickyx1lB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def imreadFromPath(path, n_channels=3):\n",
        "    if n_channels == 1:\n",
        "        img = cv2.imread(path, 0)  \n",
        "        img = np.expand_dims(img, axis=2)  \n",
        "    elif n_channels == 3:\n",
        "        img = cv2.imread(path, cv2.IMREAD_UNCHANGED)  \n",
        "        if img.ndim == 2:\n",
        "            img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)  \n",
        "        else:\n",
        "            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  \n",
        "    return img"
      ],
      "metadata": {
        "id": "SxX49mBiihky"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This function is used to **Augment** the images **to artificially expand the dataset** for different variations "
      ],
      "metadata": {
        "id": "2j8aKBLL07De"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def imageAugmentation(img, mode=0):\n",
        "    if mode == 0:\n",
        "        return img\n",
        "    elif mode == 1:\n",
        "        return np.flipud(np.rot90(img))\n",
        "    elif mode == 2:\n",
        "        return np.flipud(img)\n",
        "    elif mode == 3:\n",
        "        return np.rot90(img, k=3)\n",
        "    elif mode == 4:\n",
        "        return np.flipud(np.rot90(img, k=2))\n",
        "    elif mode == 5:\n",
        "        return np.rot90(img)\n",
        "    elif mode == 6:\n",
        "        return np.rot90(img, k=2)\n",
        "    elif mode == 7:\n",
        "        return np.flipud(np.rot90(img, k=3))"
      ],
      "metadata": {
        "id": "81Crz9EQjHF7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It shaves off the **extra pixels(remainder)** which exceed after the **scale** division"
      ],
      "metadata": {
        "id": "MSSSAAzs43zX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def modCrop(img_in, scale):\n",
        "    img = np.copy(img_in)\n",
        "    if img.ndim == 2:\n",
        "        H, W = img.shape\n",
        "        H_r, W_r = H % scale, W % scale\n",
        "        img = img[:H - H_r, :W - W_r]\n",
        "    elif img.ndim == 3:\n",
        "        H, W, C = img.shape\n",
        "        H_r, W_r = H % scale, W % scale\n",
        "        img = img[:H - H_r, :W - W_r, :]\n",
        "    else:\n",
        "        raise ValueError('the image dimensions are wrong: [{:d}].'.format(img.ndim))\n",
        "    return img\n"
      ],
      "metadata": {
        "id": "e2906nIbjKZv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Converts single numpy Tensor"
      ],
      "metadata": {
        "id": "fdDk1vZA8sXK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def single2tensor3(img):\n",
        "    return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float()"
      ],
      "metadata": {
        "id": "LTSK1Jcr8rGJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To Load the dataset from the directory.\n",
        "\n",
        "* It has inherited  **data.Dataset class** and uses the super function loaded with current class and the instance of the class.\n",
        "* Stores the path of the both **L** and **H** images \n",
        "* Loads the images from the directory of the provided index \n",
        "* Does the random crop of the Low and high level images\n",
        "* Augmentaion of images by many different variations\n",
        "* **L/H** pairs, **HWC** to **CHW**, numpy to tensor\n",
        "* Returns **L** , **H** and **L path **and **H path**\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "k1Xmn_wa9CgF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class DatasetSR(data.Dataset):\n",
        "    def __init__(self, jsonDetails):\n",
        "        super(DatasetSR, self).__init__()\n",
        "        self.jsonDetails = jsonDetails\n",
        "        self.n_channels = jsonDetails['n_channels'] if jsonDetails['n_channels'] else 3\n",
        "        self.sf = jsonDetails['scale'] if jsonDetails['scale'] else 4\n",
        "        self.patch_size = self.jsonDetails['H_size'] if self.jsonDetails['H_size'] else 96\n",
        "        self.L_size = self.patch_size // self.sf\n",
        "        self.paths_H = imagePaths(jsonDetails['dataroot_H'])\n",
        "        self.paths_L = imagePaths(jsonDetails['dataroot_L'])\n",
        "        \n",
        "        # To check for the number of the L paths is equal to the number of H paths\n",
        "        assert self.paths_H, 'Does not contain any images'\n",
        "        if self.paths_L and self.paths_H:\n",
        "            assert len(self.paths_L) == len(self.paths_H), 'L/H mismatch - {}, {}.'.format(len(self.paths_L),len(self.paths_H))\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "\n",
        "        L_path = None\n",
        "        \n",
        "        # gets the High resolution images\n",
        "        H_path = self.paths_H[index]\n",
        "        img_H = imreadFromPath(H_path, self.n_channels)\n",
        "\n",
        "        # cropping the required part\n",
        "        start = random.randrange(0, 360,4)\n",
        "        end = start+120\n",
        "        img_H = img_H[start:end,start:end]\n",
        "        # img_H = img_H[60:420,60:420]\n",
        "        \n",
        "        img_H = uint2single(img_H)\n",
        "        img_H = modCrop(img_H, self.sf)\n",
        "\n",
        "        # get the Low resolution images\n",
        "        if self.paths_L:\n",
        "            L_path = self.paths_L[index]\n",
        "            img_L = imreadFromPath(L_path, self.n_channels)\n",
        "            start = int(start/4)\n",
        "            end =start+30\n",
        "            img_L = img_L[start:end,start:end]\n",
        "            # img_L = img_L[15:105,15:105]\n",
        "            img_L = uint2single(img_L)\n",
        "\n",
        "        if self.jsonDetails['phase'] == 'train':\n",
        "            H, W, C = img_L.shape\n",
        "\n",
        "            # randomly crop the L patch\n",
        "            rnd_h = random.randint(0, max(0, H - self.L_size))\n",
        "            rnd_w = random.randint(0, max(0, W - self.L_size))\n",
        "            img_L = img_L[rnd_h:rnd_h + self.L_size, rnd_w:rnd_w + self.L_size, :]\n",
        "\n",
        "            # crop corresponding H patch\n",
        "            rnd_h_H, rnd_w_H = int(rnd_h * self.sf), int(rnd_w * self.sf)\n",
        "            img_H = img_H[rnd_h_H:rnd_h_H + self.patch_size, rnd_w_H:rnd_w_H + self.patch_size, :]\n",
        "\n",
        "            # augmentation - flip and/or rotate\n",
        "            mode = random.randint(0, 7)\n",
        "            img_L, img_H = imageAugmentation(img_L, mode=mode), imageAugmentation(img_H, mode=mode)\n",
        "        \n",
        "        # L/H pairs, HWC to CHW, numpy to tensor\n",
        "        img_H, img_L = single2tensor3(img_H), single2tensor3(img_L)\n",
        "        if L_path is None:\n",
        "            L_path = H_path\n",
        "\n",
        "        return {'L': img_L, 'H': img_H, 'L_path': L_path, 'H_path': H_path}\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.paths_H)\n"
      ],
      "metadata": {
        "id": "A6isgnV4jKwx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "*  Setting up the **Log handler** , giving the log **handler name** and the **location** to store the log file\n",
        "\n",
        "*   Checking if the handler already exist or create the new one \n",
        "*   overwriting the logger print to simultaneously **print and log** the logs\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "BCrwEWA7HQN8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def loggerSetup(logger_name, log_path='default_logger.log'):\n",
        "    log = logging.getLogger(logger_name)\n",
        "    if log.hasHandlers():\n",
        "        print('Handler already exist!')\n",
        "    else:\n",
        "        print('Setting up the new handler!')\n",
        "        level = logging.INFO\n",
        "        formatter = logging.Formatter('%(asctime)s.%(msecs)03d : %(message)s', datefmt='%y-%m-%d %H:%M:%S')\n",
        "        fh = logging.FileHandler(log_path, mode='a')\n",
        "        fh.setFormatter(formatter)\n",
        "        log.setLevel(level)\n",
        "        log.addHandler(fh)\n",
        "        sh = logging.StreamHandler()\n",
        "        sh.setFormatter(formatter)\n",
        "        log.addHandler(sh)\n",
        "\n",
        "class logger_print(object):\n",
        "    def __init__(self, log_path=\"default.log\"):\n",
        "        self.terminal = sys.stdout\n",
        "        self.log = open(log_path, 'a')\n",
        "    def write(self, message):\n",
        "        self.terminal.write(message)\n",
        "        self.log.write(message)  \n",
        "    def flush(self):\n",
        "        pass\n"
      ],
      "metadata": {
        "id": "skHoz8g6jK9-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "*   Checks whether paths is single or multiple (then iterates them) \n",
        "*   Makes **directory** for each of the path if it doesn't exist already\n",
        "\n"
      ],
      "metadata": {
        "id": "131OaSNTJPZX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def makeSingleDir(path):\n",
        "    if not os.path.exists(path):\n",
        "        os.makedirs(path)\n",
        "\n",
        "\n",
        "def makeTheDir(paths):\n",
        "    if isinstance(paths, str):\n",
        "        makeSingleDir(paths)\n",
        "    else:\n",
        "        for path in list(paths):\n",
        "            makeSingleDir(path)\n"
      ],
      "metadata": {
        "id": "L9Ep8lA0wOMQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Loads The **configuration JSON** from directory given as opt_path\n",
        "\n",
        "\n",
        "> Modifies the **dataset block** and checks for different parameters                 \n",
        "> Creates the paths for different folders and adds them to configuration json      \n",
        "> Network paramaters   \n",
        ">  Default setting for **distributed dataparallel **   \n",
        ">  Default setting for **optimizer**                              \n",
        "> Default setting of **strict** for **model loading**        \n",
        ">  **Exponential Moving Average** decay\n"
      ],
      "metadata": {
        "id": "-dfPEcgEKCGH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def loadTheJson(opt_path, is_train=True):\n",
        "    json_str = ''\n",
        "    with open(opt_path, 'r') as f:\n",
        "        for line in f:\n",
        "            line = line.split('//')[0] + '\\n'\n",
        "            json_str += line\n",
        "    jsonDetails = json.loads(json_str, object_pairs_hook=OrderedDict)\n",
        "    jsonDetails['opt_path'] = opt_path\n",
        "    jsonDetails['is_train'] = is_train\n",
        "    if 'scale' not in jsonDetails:\n",
        "        jsonDetails['scale'] = 1\n",
        "\n",
        "    # for dataset loader and checker\n",
        "    for phase, dataset in jsonDetails['datasets'].items():\n",
        "        phase = phase.split('_')[0]\n",
        "        dataset['phase'] = phase\n",
        "        dataset['scale'] = jsonDetails['scale']  # broadcast\n",
        "        dataset['n_channels'] = jsonDetails['n_channels']  # broadcast\n",
        "        if 'dataroot_H' in dataset and dataset['dataroot_H'] is not None:\n",
        "            dataset['dataroot_H'] = os.path.expanduser(dataset['dataroot_H'])\n",
        "        if 'dataroot_L' in dataset and dataset['dataroot_L'] is not None:\n",
        "            dataset['dataroot_L'] = os.path.expanduser(dataset['dataroot_L'])\n",
        "\n",
        "    # path checker and modifiers\n",
        "    for key, path in jsonDetails['path'].items():\n",
        "        if path and key in jsonDetails['path']:\n",
        "            jsonDetails['path'][key] = os.path.expanduser(path)\n",
        "\n",
        "    path_task = os.path.join(jsonDetails['path']['root'], jsonDetails['task'])\n",
        "    jsonDetails['path']['task'] = path_task\n",
        "    jsonDetails['path']['log'] = path_task\n",
        "    jsonDetails['path']['options'] = os.path.join(path_task, 'options')\n",
        "\n",
        "    if is_train:\n",
        "        jsonDetails['path']['models'] = os.path.join(path_task, 'models')\n",
        "        jsonDetails['path']['images'] = os.path.join(path_task, 'images')\n",
        "    else:  \n",
        "        jsonDetails['path']['images'] = os.path.join(path_task, 'test_images')\n",
        "\n",
        "    \n",
        "    # network\n",
        "    jsonDetails['netG']['scale'] = jsonDetails['scale'] if 'scale' in jsonDetails else 1\n",
        "\n",
        "    \n",
        "    # GPU devices\n",
        "    gpu_list = ','.join(str(x) for x in jsonDetails['gpu_ids'])\n",
        "    os.environ['CUDA_VISIBLE_DEVICES'] = gpu_list\n",
        "    print('export CUDA_VISIBLE_DEVICES=' + gpu_list)\n",
        "\n",
        "    \n",
        "    # default setting for distributeddataparallel\n",
        "    if 'find_unused_parameters' not in jsonDetails:\n",
        "        jsonDetails['find_unused_parameters'] = True\n",
        "    if 'workDist' not in jsonDetails:\n",
        "        jsonDetails['workDist'] = False\n",
        "    jsonDetails['num_gpu'] = len(jsonDetails['gpu_ids'])\n",
        "    print('number of GPUs is: ' + str(jsonDetails['num_gpu']))\n",
        "\n",
        "    \n",
        "    # default setting for optimizer\n",
        "    if 'G_optimizer_reuse' not in jsonDetails['train']:\n",
        "        jsonDetails['train']['G_optimizer_reuse'] = False\n",
        "    if 'netD' in jsonDetails and 'D_optimizer_reuse' not in jsonDetails['train']:\n",
        "        jsonDetails['train']['D_optimizer_reuse'] = False\n",
        "\n",
        "    # default setting of strict for model loading\n",
        "    if 'G_param_strict' not in jsonDetails['train']:\n",
        "        jsonDetails['train']['G_param_strict'] = True\n",
        "    if 'E_param_strict' not in jsonDetails['path']:\n",
        "        jsonDetails['train']['E_param_strict'] = True\n",
        "\n",
        "    # Exponential Moving Average\n",
        "    if 'E_decay' not in jsonDetails['train']:\n",
        "        jsonDetails['train']['E_decay'] = 0\n",
        "\n",
        "    return jsonDetails\n"
      ],
      "metadata": {
        "id": "izp1AByEwOQW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "*   The **Multiprocessing** is intialized \n",
        "*  The **CUDA** runtime does not support the fork start method; either the spawn or forkserver start method are required to use CUDA in subprocesses.\n",
        "* The server for multiprocessing is choosed\n",
        "* It enables  to easily **parallelize** their computations across processes and clusters of machines\n",
        "* The package is initialized using the **torch.distributed.init_process_group()** function before calling any other methods. This blocks until all processes have joined.\n",
        "*Communication channel is given **GLOO** which support both **CPU** and **GPU** tensor communication, we can use **NCCL** for Gpu commuication only\n",
        "* if distribution intilaization returns the **False**  it will **not allow** anyother API to get expose.\n",
        "* **Rank** gives the number of current process and **world_size** gives number of processes participating in the job.\n",
        "\n"
      ],
      "metadata": {
        "id": "TBiYjRv9nsQ5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def decTheLauncher(serverFrame, backend='gloo', **kwargs):\n",
        "    if mp.get_start_method(allow_none=True) is None:\n",
        "        mp.set_start_method('spawn')\n",
        "    if serverFrame == 'pytorch':\n",
        "        intializePytorch(backend, **kwargs)\n",
        "\n",
        "    else:\n",
        "        raise ValueError(f'Invalid serverFrame type: {serverFrame}')\n",
        "\n",
        "\n",
        "def intializePytorch(backend, **kwargs):\n",
        "    rank = int(os.environ['RANK'])\n",
        "    num_gpus = torch.cuda.device_count()\n",
        "    torch.cuda.set_device(rank % num_gpus)\n",
        "    workDist.init_process_group(backend=backend, **kwargs)\n",
        "\n",
        "\n",
        "def getDistributionInfo():\n",
        "    if workDist.is_available():\n",
        "        initialized = workDist.is_initialized()\n",
        "    else:\n",
        "        initialized = False\n",
        "    if initialized:\n",
        "        rank = workDist.get_rank()\n",
        "        world_size = workDist.get_world_size()\n",
        "    else:\n",
        "        rank = 0\n",
        "        world_size = 1\n",
        "    return rank, world_size"
      ],
      "metadata": {
        "id": "ZL_v09ngwOUQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Load the **path** and **iteration** number of the last **checkpoint** for different net types or optimizers.\n",
        "* If nothing is present in model folder then simply returns the **zeroth** iteration with **None** path\n"
      ],
      "metadata": {
        "id": "1tBuKj5dvRDm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def loadFromLastCheckpoint(save_dir, net_type='G'):\n",
        "    file_list = glob.glob(os.path.join(save_dir, '*_{}.pth'.format(net_type)))\n",
        "    if file_list:\n",
        "        iter_exist = []\n",
        "        for file_ in file_list:\n",
        "            iter_current = re.findall(r\"(\\d+)_{}.pth\".format(net_type), file_)\n",
        "            iter_exist.append(int(iter_current[0]))\n",
        "        init_iter = max(iter_exist)\n",
        "        init_path = os.path.join(save_dir, '{}_{}.pth'.format(init_iter, net_type))\n",
        "    else:\n",
        "        init_iter = 0\n",
        "        init_path = None\n",
        "    return init_iter, init_path\n"
      ],
      "metadata": {
        "id": "ifdEEHU6w-Ao"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Writing back the configured json in the models/option folder for using in future checking 🐜"
      ],
      "metadata": {
        "id": "Yx3XrYMByVeR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def currentTimeFormatted():\n",
        "    return datetime.now().strftime('_%y%m%d_%H%M%S')\n",
        "\n",
        "\n",
        "def save(jsonDetails):\n",
        "    opt_path = jsonDetails['opt_path']\n",
        "    opt_path_copy = jsonDetails['path']['options']\n",
        "    dirname, filename_ext = os.path.split(opt_path)\n",
        "    filename, ext = os.path.splitext(filename_ext)\n",
        "    dump_path = os.path.join(opt_path_copy, filename + currentTimeFormatted() + ext)\n",
        "    with open(dump_path, 'w') as dump_file:\n",
        "        json.dump(jsonDetails, dump_file, indent=2)\n"
      ],
      "metadata": {
        "id": "9xMsho3_w-EI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* It Just creates the useful form of the **Dictionary** from the **configured json** and if the some key is called which is not present in the dictionary then rather throwing the exception **key not found** , we have **overloaded** the parent dict() class function of **missing**  to return **None** .\n",
        "* Simply converts the **Dict** object to **Str** object for **messages** and **logs**"
      ],
      "metadata": {
        "id": "YGduBn6Oz2Uf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def DictToNoneDict(jsonDetails):\n",
        "    if isinstance(jsonDetails, dict):\n",
        "        new_opt = dict()\n",
        "        for key, sub_opt in jsonDetails.items():\n",
        "            new_opt[key] = DictToNoneDict(sub_opt)\n",
        "        return NoneDict(**new_opt)\n",
        "    elif isinstance(jsonDetails, list):\n",
        "        return [DictToNoneDict(sub_opt) for sub_opt in jsonDetails]\n",
        "    else:\n",
        "        return jsonDetails\n",
        "\n",
        "\n",
        "class NoneDict(dict):\n",
        "    def __missing__(self, key):\n",
        "        return None\n",
        "\n",
        "\n",
        "def dict2str(jsonDetails, indent_l=1):\n",
        "    msg = ''\n",
        "    for k, v in jsonDetails.items():\n",
        "        if isinstance(v, dict):\n",
        "            msg += ' ' * (indent_l * 2) + k + ':[\\n'\n",
        "            msg += dict2str(v, indent_l + 1)\n",
        "            msg += ' ' * (indent_l * 2) + ']\\n'\n",
        "        else:\n",
        "            msg += ' ' * (indent_l * 2) + k + ': ' + str(v) + '\\n'\n",
        "    return msg\n",
        "\n"
      ],
      "metadata": {
        "id": "zTFQ-7qsw-JZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Call for DatasetSR with super resolution dataset configuration"
      ],
      "metadata": {
        "id": "V31tq5435TgA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def loadDataPath(data_item):\n",
        "    dataset_type = data_item['dataset_type'].lower()\n",
        "    \n",
        "    if dataset_type in ['sr', 'super-resolution']:\n",
        "          \n",
        "        return DatasetSR(data_item)\n",
        "    else:\n",
        "        raise NotImplementedError('no implemenation found for'.format(dataset_type))"
      ],
      "metadata": {
        "id": "Z3ySDjPExICl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Making the Multi layer perceptron with two fully connected layers**\n",
        "> Taking the number of inputs features equal to number of input channels here **180** \n",
        "> The hidden channels equal to mlp ratio times the input channels  **360**\n",
        "> The output feature size here is equal to number of the input channels that is **180**\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "hUW1JT-O51If"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Using the GELU activation layer and dropout custom percantage\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "x9yNb6yuMm9m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "class Mlp(nn.Module):\n",
        "    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):\n",
        "        super().__init__()\n",
        "        out_features = out_features or in_features\n",
        "        hidden_features = hidden_features or in_features\n",
        "        self.fc1 = nn.Linear(in_features, hidden_features)\n",
        "        self.act = act_layer()\n",
        "        self.fc2 = nn.Linear(hidden_features, out_features)\n",
        "        self.drop = nn.Dropout(drop)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.fc1(x)\n",
        "        x = self.act(x)\n",
        "        x = self.drop(x)\n",
        "        x = self.fc2(x)\n",
        "        x = self.drop(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "ytT0QHr2xIHa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The first function just partitions the image into the size of window\n",
        "\n",
        "\n",
        "1.   the input argument is the (B,H,W,C) and window_size\n",
        "2.   The return of the function is (number of windows ✖ B, window_size,Wondow_size,C)           \n",
        "\n",
        "The role of second function is exactly the reverse of the first function.\n",
        "\n"
      ],
      "metadata": {
        "id": "og_dv3F0NSNH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def windowPartition(x, window_size):\n",
        "    \n",
        "    B, H, W, C = x.shape\n",
        "    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)\n",
        "    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)\n",
        "    return windows\n",
        "\n",
        "\n",
        "def reverseWindow(windows, window_size, H, W):\n",
        "    B = int(windows.shape[0] / (H * W / window_size / window_size))\n",
        "    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)\n",
        "    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)\n",
        "    return x\n"
      ],
      "metadata": {
        "id": "eDUu97_oxIQg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Window based multi-head self attention (W-MSA) module with relative position bias.It supports both of shifted and non-shifted window.\n",
        "\n",
        "\n",
        "* ### It has number of input argument:\n",
        "\n",
        "\n",
        ">1.  dim (int): Number of input channels.\n",
        ">2.  window_size (tuple[int]): The height and width of the window.\n",
        ">3. num_heads (int): Number of attention heads.\n",
        ">4. qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True\n",
        ">5. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set\n",
        ">6. attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0\n",
        ">7. proj_drop (float, optional): Dropout ratio of output. Default: 0.0\n",
        "\n",
        "\n",
        "\n",
        "*   ### Define a parameter table of relative position bias\n",
        "* ### It calculates the self attention on each window by just breaking it into key,query and value \n",
        "* ### The argument of the forward are:\n",
        ">1. x: input features with shape of (num_windows*B, N, C)\n",
        ">2. mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None\n",
        "* ### Calculate flops for 1 window with token length of N\n",
        "\n"
      ],
      "metadata": {
        "id": "7sp5ECtRgmzO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class WindowAttention(nn.Module):\n",
        "    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):\n",
        "\n",
        "        super().__init__()\n",
        "        self.dim = dim\n",
        "        self.window_size = window_size  \n",
        "        self.num_heads = num_heads\n",
        "        head_dim = dim // num_heads\n",
        "        self.scale = qk_scale or head_dim ** -0.5\n",
        "\n",
        "        # relative position bias\n",
        "        self.relative_position_bias_table = nn.Parameter(\n",
        "            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  \n",
        "\n",
        "        # get pair-wise relative position index for each token inside the window\n",
        "        coords_h = torch.arange(self.window_size[0])\n",
        "        coords_w = torch.arange(self.window_size[1])\n",
        "        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  \n",
        "        coords_flatten = torch.flatten(coords, 1) \n",
        "        relative_coords: object = coords_flatten[:, :, None] - coords_flatten[:, None, :] \n",
        "        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  \n",
        "        relative_coords[:, :, 0] += self.window_size[0] - 1  \n",
        "        relative_coords[:, :, 1] += self.window_size[1] - 1\n",
        "        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1\n",
        "        relative_position_index = relative_coords.sum(-1)  \n",
        "        self.register_buffer(\"relative_position_index\", relative_position_index)\n",
        "        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)\n",
        "        self.attn_drop = nn.Dropout(attn_drop)\n",
        "        self.proj = nn.Linear(dim, dim)\n",
        "        self.proj_drop = nn.Dropout(proj_drop)\n",
        "        trunc_normal_(self.relative_position_bias_table, std=.02)\n",
        "        self.softmax = nn.Softmax(dim=-1)\n",
        "\n",
        "    def forward(self, x, mask=None):\n",
        "        B_, N, C = x.shape\n",
        "        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)\n",
        "        q, k, v = qkv[0], qkv[1], qkv[2]  \n",
        "\n",
        "        q = q * self.scale\n",
        "        attn = (q @ k.transpose(-2, -1))\n",
        "\n",
        "        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(\n",
        "            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  \n",
        "        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  \n",
        "        attn = attn + relative_position_bias.unsqueeze(0)\n",
        "\n",
        "        if mask is not None:\n",
        "            nW = mask.shape[0]\n",
        "            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)\n",
        "            attn = attn.view(-1, self.num_heads, N, N)\n",
        "            attn = self.softmax(attn)\n",
        "        else:\n",
        "            attn = self.softmax(attn)\n",
        "\n",
        "        attn = self.attn_drop(attn)\n",
        "\n",
        "        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)\n",
        "        x = self.proj(x)\n",
        "        x = self.proj_drop(x)\n",
        "        return x\n",
        "\n",
        "    def extra_repr(self) -> str:\n",
        "        return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'\n",
        "\n",
        "    def flops(self, N):\n",
        "        flops = 0\n",
        "        # qkv = self.qkv(x)\n",
        "        flops += N * self.dim * 3 * self.dim\n",
        "        # attn = (q @ k.transpose(-2, -1))\n",
        "        flops += self.num_heads * N * (self.dim // self.num_heads) * N\n",
        "        #  x = (attn @ v)\n",
        "        flops += self.num_heads * N * N * (self.dim // self.num_heads)\n",
        "        # x = self.proj(x)\n",
        "        flops += N * self.dim * self.dim\n",
        "        return flops"
      ],
      "metadata": {
        "id": "p-xc9xhuxk3H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Swin transformer\n",
        "* ### The Arguments are:\n",
        "        dim (int): Number of input channels.\n",
        "        input_resolution (tuple[int]): Input resulotion.\n",
        "        num_heads (int): Number of attention heads.\n",
        "        window_size (int): Window size.\n",
        "        shift_size (int): Shift size for SW-MSA.\n",
        "        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.\n",
        "        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n",
        "        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.\n",
        "        drop (float, optional): Dropout rate. Default: 0.0\n",
        "        attn_drop (float, optional): Attention dropout rate. Default: 0.0\n",
        "        drop_path (float, optional): Stochastic depth rate. Default: 0.0\n",
        "        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU\n",
        "        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "bu-AU2qxlY8r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SwinTransformerBlock(nn.Module):\n",
        "    def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,\n",
        "                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,\n",
        "                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):\n",
        "        super().__init__()\n",
        "        self.dim = dim\n",
        "        self.input_resolution = input_resolution\n",
        "        self.num_heads = num_heads\n",
        "        self.window_size = window_size\n",
        "        self.shift_size = shift_size\n",
        "        self.mlp_ratio = mlp_ratio\n",
        "        if min(self.input_resolution) <= self.window_size:\n",
        "\n",
        "            # if window size is larger than input resolution, we don't partition windows\n",
        "            self.shift_size = 0\n",
        "            self.window_size = min(self.input_resolution)\n",
        "        assert 0 <= self.shift_size < self.window_size, \"shift_size must in 0-window_size\"\n",
        "\n",
        "        self.norm1 = norm_layer(dim)\n",
        "        self.attn = WindowAttention(\n",
        "            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,\n",
        "            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)\n",
        "\n",
        "        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()\n",
        "        self.norm2 = norm_layer(dim)\n",
        "        mlp_hidden_dim = int(dim * mlp_ratio)\n",
        "        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)\n",
        "\n",
        "        if self.shift_size > 0:\n",
        "            attn_mask = self.calculateMask(self.input_resolution)\n",
        "        else:\n",
        "            attn_mask = None\n",
        "\n",
        "        self.register_buffer(\"attn_mask\", attn_mask)\n",
        "\n",
        "    def calculateMask(self, x_size):\n",
        "\n",
        "        # calculate attention mask for SW-MSA\n",
        "        H, W = x_size\n",
        "        img_mask = torch.zeros((1, H, W, 1))  # 1 H W 1\n",
        "        h_slices = (slice(0, -self.window_size),\n",
        "                    slice(-self.window_size, -self.shift_size),\n",
        "                    slice(-self.shift_size, None))\n",
        "        w_slices = (slice(0, -self.window_size),\n",
        "                    slice(-self.window_size, -self.shift_size),\n",
        "                    slice(-self.shift_size, None))\n",
        "        cnt = 0\n",
        "        for h in h_slices:\n",
        "            for w in w_slices:\n",
        "                img_mask[:, h, w, :] = cnt\n",
        "                cnt += 1\n",
        "        # nW, window_size, window_size, 1\n",
        "        mask_windows = windowPartition(img_mask, self.window_size)  \n",
        "        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)\n",
        "        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)\n",
        "        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))\n",
        "\n",
        "        return attn_mask\n",
        "\n",
        "    def forward(self, x, x_size):\n",
        "        H, W = x_size\n",
        "        B, L, C = x.shape\n",
        "       \n",
        "\n",
        "        shortcut = x\n",
        "        x = self.norm1(x)\n",
        "        x = x.view(B, H, W, C)\n",
        "\n",
        "        # cyclic shift\n",
        "        if self.shift_size > 0:\n",
        "            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))\n",
        "        else:\n",
        "            shifted_x = x\n",
        "\n",
        "        # partition windows\n",
        "        # nW*B, window_size, window_size, C\n",
        "        x_windows = windowPartition(shifted_x, self.window_size)\n",
        "        # nW*B, window_size*window_size, C  \n",
        "        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  \n",
        "\n",
        "        # W-MSA (to be compatible for testing on images whose shapes are the multiple of window size\n",
        "        if self.input_resolution == x_size:\n",
        "             # nW*B, window_size*window_size, C\n",
        "            attn_windows = self.attn(x_windows, mask=self.attn_mask)  \n",
        "        else:\n",
        "            attn_windows = self.attn(x_windows, mask=self.calculateMask(x_size).to(x.device))\n",
        "\n",
        "        # merge windows\n",
        "        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)\n",
        "        shifted_x = reverseWindow(attn_windows, self.window_size, H, W)  # B H' W' C\n",
        "\n",
        "        # reverse cyclic shift\n",
        "        if self.shift_size > 0:\n",
        "            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))\n",
        "        else:\n",
        "            x = shifted_x\n",
        "        x = x.view(B, H * W, C)\n",
        "\n",
        "        # FFN\n",
        "        x = shortcut + self.drop_path(x)\n",
        "        x = x + self.drop_path(self.mlp(self.norm2(x)))\n",
        "\n",
        "        return x\n",
        "\n",
        "    def extra_repr(self) -> str:\n",
        "        return f\"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, \" \\\n",
        "               f\"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}\"\n",
        "\n",
        "    def flops(self):\n",
        "        flops = 0\n",
        "        H, W = self.input_resolution\n",
        "        # norm1\n",
        "        flops += self.dim * H * W\n",
        "        # W-MSA/SW-MSA\n",
        "        nW = H * W / self.window_size / self.window_size\n",
        "        flops += nW * self.attn.flops(self.window_size * self.window_size)\n",
        "        # mlp\n",
        "        flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio\n",
        "        # norm2\n",
        "        flops += self.dim * H * W\n",
        "        return flops"
      ],
      "metadata": {
        "id": "ND_gb05wxk6R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##A basic Swin Transformer layer for one stage.\n",
        "* The Input arguments are:\n",
        "        dim (int): Number of input channels.\n",
        "        input_resolution (tuple[int]): Input resolution.\n",
        "        depth (int): Number of blocks.\n",
        "        num_heads (int): Number of attention heads.\n",
        "        window_size (int): Local window size.\n",
        "        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.\n",
        "        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n",
        "        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.\n",
        "        drop (float, optional): Dropout rate. Default: 0.0\n",
        "        attn_drop (float, optional): Attention dropout rate. Default: 0.0\n",
        "        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0\n",
        "        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm\n",
        "        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None\n",
        "        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "a1CW22ZHqDDa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class BasicLayer(nn.Module):\n",
        "    \n",
        "\n",
        "    def __init__(self, dim, input_resolution, depth, num_heads, window_size,\n",
        "                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,\n",
        "                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False):\n",
        "\n",
        "        super().__init__()\n",
        "        self.dim = dim\n",
        "        self.input_resolution = input_resolution\n",
        "        self.depth = depth\n",
        "        self.use_checkpoint = use_checkpoint\n",
        "\n",
        "        # build blocks\n",
        "        self.blocks = nn.ModuleList([\n",
        "            SwinTransformerBlock(dim=dim, input_resolution=input_resolution,\n",
        "                                 num_heads=num_heads, window_size=window_size,\n",
        "                                 shift_size=0 if (i % 2 == 0) else window_size // 2,\n",
        "                                 mlp_ratio=mlp_ratio,\n",
        "                                 qkv_bias=qkv_bias, qk_scale=qk_scale,\n",
        "                                 drop=drop, attn_drop=attn_drop,\n",
        "                                 drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,\n",
        "                                 norm_layer=norm_layer)\n",
        "            for i in range(depth)])\n",
        "\n",
        "        # patch merging layer\n",
        "        if downsample is not None:\n",
        "            self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)\n",
        "        else:\n",
        "            self.downsample = None\n",
        "\n",
        "    def forward(self, x, x_size):\n",
        "        for blk in self.blocks:\n",
        "            if self.use_checkpoint:\n",
        "                x = checkpoint.checkpoint(blk, x)\n",
        "            else:\n",
        "                x = blk(x, x_size)\n",
        "        if self.downsample is not None:\n",
        "            x = self.downsample(x)\n",
        "        return x\n",
        "\n",
        "    def extra_repr(self) -> str:\n",
        "        return f\"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}\"\n",
        "\n",
        "    def flops(self):\n",
        "        flops = 0\n",
        "        for blk in self.blocks:\n",
        "            flops += blk.flops()\n",
        "        if self.downsample is not None:\n",
        "            flops += self.downsample.flops()\n",
        "        return flops"
      ],
      "metadata": {
        "id": "9JqwyZ-1xk-e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Residual Swin Transformer Block (RSTB).\n",
        "* The input Arguments are:\n",
        "dim (int): Number of input channels.\n",
        "        input_resolution (tuple[int]): Input resolution.\n",
        "        depth (int): Number of blocks.\n",
        "        num_heads (int): Number of attention heads.\n",
        "        window_size (int): Local window size.\n",
        "        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.\n",
        "        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n",
        "        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.\n",
        "        drop (float, optional): Dropout rate. Default: 0.0\n",
        "        attn_drop (float, optional): Attention dropout rate. Default: 0.0\n",
        "        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0\n",
        "        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm\n",
        "        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None\n",
        "        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.\n",
        "        img_size: Input image size.\n",
        "        patch_size: Patch size.\n",
        "        resi_connection: The convolutional block before residual connection.\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "ETCIbqgavU6T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class RSTB(nn.Module):\n",
        "  \n",
        "\n",
        "    def __init__(self, dim, input_resolution, depth, num_heads, window_size,\n",
        "                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,\n",
        "                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False,\n",
        "                 img_size=224, patch_size=4, resi_connection='1conv'):\n",
        "        super(RSTB, self).__init__()\n",
        "\n",
        "        self.dim = dim\n",
        "        self.input_resolution = input_resolution\n",
        "\n",
        "        self.residual_group = BasicLayer(dim=dim,\n",
        "                                         input_resolution=input_resolution,\n",
        "                                         depth=depth,\n",
        "                                         num_heads=num_heads,\n",
        "                                         window_size=window_size,\n",
        "                                         mlp_ratio=mlp_ratio,\n",
        "                                         qkv_bias=qkv_bias, qk_scale=qk_scale,\n",
        "                                         drop=drop, attn_drop=attn_drop,\n",
        "                                         drop_path=drop_path,\n",
        "                                         norm_layer=norm_layer,\n",
        "                                         downsample=downsample,\n",
        "                                         use_checkpoint=use_checkpoint)\n",
        "\n",
        "        if resi_connection == '1conv':\n",
        "            self.conv = nn.Conv2d(dim, dim, 3, 1, 1)\n",
        "        elif resi_connection == '3conv':\n",
        "            # to save parameters and memory\n",
        "            self.conv = nn.Sequential(nn.Conv2d(dim, dim // 4, 3, 1, 1), nn.LeakyReLU(negative_slope=0.2, inplace=True),\n",
        "                                      nn.Conv2d(dim // 4, dim // 4, 1, 1, 0),\n",
        "                                      nn.LeakyReLU(negative_slope=0.2, inplace=True),\n",
        "                                      nn.Conv2d(dim // 4, dim, 3, 1, 1))\n",
        "\n",
        "        self.patch_embed = PatchEmbed(\n",
        "            img_size=img_size, patch_size=patch_size, in_chans=0, embed_dim=dim,\n",
        "            norm_layer=None)\n",
        "\n",
        "        self.patch_unembed = PatchUnEmbed(\n",
        "            img_size=img_size, patch_size=patch_size, in_chans=0, embed_dim=dim,\n",
        "            norm_layer=None)\n",
        "\n",
        "    def forward(self, x, x_size):\n",
        "        return self.patch_embed(self.conv(self.patch_unembed(self.residual_group(x, x_size), x_size))) + x\n",
        "\n",
        "    def flops(self):\n",
        "        flops = 0\n",
        "        flops += self.residual_group.flops()\n",
        "        H, W = self.input_resolution\n",
        "        flops += H * W * self.dim * self.dim * 9\n",
        "        flops += self.patch_embed.flops()\n",
        "        flops += self.patch_unembed.flops()\n",
        "\n",
        "        return flops"
      ],
      "metadata": {
        "id": "2mSOS_XYxlBe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Image to Patch Embedding\n",
        "* The input arguments are:\n",
        "        img_size (int): Image size.  Default: 224.\n",
        "        patch_size (int): Patch token size. Default: 4.\n",
        "        in_chans (int): Number of input image channels. Default: 3.\n",
        "        embed_dim (int): Number of linear projection output channels. Default: 96.\n",
        "        norm_layer (nn.Module, optional): Normalization layer. Default: None\n",
        "\n",
        "* The output of the forward will (B,number of pixels, channels)"
      ],
      "metadata": {
        "id": "Lngz6ng2wXWN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class PatchEmbed(nn.Module):\n",
        "    def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):\n",
        "        super().__init__()\n",
        "        img_size = to_2tuple(img_size)\n",
        "        patch_size = to_2tuple(patch_size)\n",
        "        patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]\n",
        "        self.img_size = img_size\n",
        "        self.patch_size = patch_size\n",
        "        self.patches_resolution = patches_resolution\n",
        "        self.num_patches = patches_resolution[0] * patches_resolution[1]\n",
        "\n",
        "        self.in_chans = in_chans\n",
        "        self.embed_dim = embed_dim\n",
        "\n",
        "        if norm_layer is not None:\n",
        "            self.norm = norm_layer(embed_dim)\n",
        "        else:\n",
        "            self.norm = None\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = x.flatten(2).transpose(1, 2)  # B Ph*Pw C\n",
        "        if self.norm is not None:\n",
        "            x = self.norm(x)\n",
        "        return x\n",
        "\n",
        "    def flops(self):\n",
        "        flops = 0\n",
        "        H, W = self.img_size\n",
        "        if self.norm is not None:\n",
        "            flops += H * W * self.embed_dim\n",
        "        return flops\n",
        "\n"
      ],
      "metadata": {
        "id": "B_yMc7r75UjH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Image to Patch Unembedding\n",
        "\n",
        "* The Input Arguments are:\n",
        "        img_size (int): Image size.  Default: 224.\n",
        "        patch_size (int): Patch token size. Default: 4.\n",
        "        in_chans (int): Number of input image channels. Default: 3.\n",
        "        embed_dim (int): Number of linear projection output channels. Default: 96.\n",
        "        norm_layer (nn.Module, optional): Normalization layer. Default: None\n",
        "  \n",
        "* The output is (B,C,H,W)"
      ],
      "metadata": {
        "id": "p6doWIKvw4Xi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class PatchUnEmbed(nn.Module):\n",
        "    def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):\n",
        "        super().__init__()\n",
        "        img_size = to_2tuple(img_size)\n",
        "        patch_size = to_2tuple(patch_size)\n",
        "        patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]\n",
        "        self.img_size = img_size\n",
        "        self.patch_size = patch_size\n",
        "        self.patches_resolution = patches_resolution\n",
        "        self.num_patches = patches_resolution[0] * patches_resolution[1]\n",
        "\n",
        "        self.in_chans = in_chans\n",
        "        self.embed_dim = embed_dim\n",
        "\n",
        "    def forward(self, x, x_size):\n",
        "        B, HW, C = x.shape\n",
        "        x = x.transpose(1, 2).view(B, self.embed_dim, x_size[0], x_size[1])  # B Ph*Pw C\n",
        "        return x\n",
        "\n",
        "    def flops(self):\n",
        "        flops = 0\n",
        "        return flops"
      ],
      "metadata": {
        "id": "JxVEQE3f5a0M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The Upsample module.\n",
        "This model upsamples or scale up the feature as much we need.\n",
        "![image.png](data:image/png;base64,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)\n",
        "\n",
        "* Pixel shuffle Rearranges elements in a tensor of shape (B, C*r^2, H, W) \n",
        " to a tensor of shape (B, C, H * r, W * r) where r is an upscale factor.\n"
      ],
      "metadata": {
        "id": "x7c_vWWjyKuN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Upsample(nn.Sequential):\n",
        "    \n",
        "    def __init__(self, scale, num_feat):\n",
        "        m = []\n",
        "        if (scale & (scale - 1)) == 0:  # scale = 2^n\n",
        "            for _ in range(int(math.log(scale, 2))):\n",
        "                m.append(nn.Conv2d(num_feat, 4 * num_feat, 3, 1, 1))\n",
        "                m.append(nn.PixelShuffle(2))\n",
        "        elif scale == 3:\n",
        "            m.append(nn.Conv2d(num_feat, 9 * num_feat, 3, 1, 1))\n",
        "            m.append(nn.PixelShuffle(3))\n",
        "        else:\n",
        "            raise ValueError(f'scale {scale} is not supported. ' 'Supported scales: 2^n and 3.')\n",
        "        super(Upsample, self).__init__(*m)\n",
        "\n"
      ],
      "metadata": {
        "id": "aND1C9Wc5l8J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## SwinIR\n",
        "* The Input Arguments are:\n",
        "        img_size (int | tuple(int)): Input image size. Default 64\n",
        "        patch_size (int | tuple(int)): Patch size. Default: 1\n",
        "        in_chans (int): Number of input image channels. Default: 3\n",
        "        embed_dim (int): Patch embedding dimension. Default: 96\n",
        "        depths (tuple(int)): Depth of each Swin Transformer layer.\n",
        "        num_heads (tuple(int)): Number of attention heads in different layers.\n",
        "        window_size (int): Window size. Default: 7\n",
        "        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4\n",
        "        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True\n",
        "        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None\n",
        "        drop_rate (float): Dropout rate. Default: 0\n",
        "        attn_drop_rate (float): Attention dropout rate. Default: 0\n",
        "        drop_path_rate (float): Stochastic depth rate. Default: 0.1\n",
        "        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.\n",
        "        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False\n",
        "        patch_norm (bool): If True, add normalization after patch embedding. Default: True\n",
        "        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False\n",
        "        upscale: Upscale factor. 2/3/4/8 for image SR, 1 for denoising and compress artifact reduction\n",
        "        img_range: Image range. 1. or 255.\n",
        "        upsampler: The reconstruction reconstruction module. 'pixelshuffle'/'pixelshuffledirect'/'nearest+conv'/None\n",
        "        resi_connection: The convolutional block before residual connection. '1conv'/'3conv'\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "_2lhEiya3XMm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SwinIR(nn.Module):\n",
        "  \n",
        "    def __init__(self, img_size=64, patch_size=1, in_chans=3,\n",
        "                 embed_dim=96, depths=[6, 6, 6, 6], num_heads=[6, 6, 6, 6],\n",
        "                 window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,\n",
        "                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,\n",
        "                 norm_layer=nn.LayerNorm, ape=False, patch_norm=True,\n",
        "                 use_checkpoint=False, upscale=2, img_range=1., upsampler='', resi_connection='1conv',\n",
        "                 **kwargs):\n",
        "        super(SwinIR, self).__init__()\n",
        "        num_in_ch = in_chans\n",
        "        num_out_ch = in_chans\n",
        "        num_feat = 64\n",
        "        self.img_range = img_range\n",
        "        if in_chans == 3:\n",
        "            rgb_mean = (0.4488, 0.4371, 0.4040)\n",
        "            self.mean = torch.Tensor(rgb_mean).view(1, 3, 1, 1)\n",
        "        else:\n",
        "            self.mean = torch.zeros(1, 1, 1, 1)\n",
        "        self.upscale = upscale\n",
        "        self.upsampler = upsampler\n",
        "\n",
        "        # 1, shallow feature extraction \n",
        "        self.conv_first_half = nn.Conv2d(num_in_ch, int(embed_dim/2), 3, 1, 1)\n",
        "        self.conv_first = nn.Conv2d(int(embed_dim/2), embed_dim, 3, 1, 1)\n",
        "\n",
        "        # 2, deep feature extraction \n",
        "        self.num_layers = len(depths)\n",
        "        self.embed_dim = embed_dim\n",
        "        self.ape = ape\n",
        "        self.patch_norm = patch_norm\n",
        "        self.num_features = embed_dim\n",
        "        self.mlp_ratio = mlp_ratio\n",
        "\n",
        "        # split image into non-overlapping patches\n",
        "        self.patch_embed = PatchEmbed(\n",
        "            img_size=img_size, patch_size=patch_size, in_chans=embed_dim, embed_dim=embed_dim,\n",
        "            norm_layer=norm_layer if self.patch_norm else None)\n",
        "        num_patches = self.patch_embed.num_patches\n",
        "        patches_resolution = self.patch_embed.patches_resolution\n",
        "        self.patches_resolution = patches_resolution\n",
        "\n",
        "        # merge non-overlapping patches into image\n",
        "        self.patch_unembed = PatchUnEmbed(\n",
        "            img_size=img_size, patch_size=patch_size, in_chans=embed_dim, embed_dim=embed_dim,\n",
        "            norm_layer=norm_layer if self.patch_norm else None)\n",
        "\n",
        "        # absolute position embedding\n",
        "        if self.ape:\n",
        "            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))\n",
        "            trunc_normal_(self.absolute_pos_embed, std=.02)\n",
        "\n",
        "        self.pos_drop = nn.Dropout(p=drop_rate)\n",
        "\n",
        "        # stochastic depth\n",
        "        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule\n",
        "\n",
        "        # build Residual Swin Transformer blocks (RSTB)\n",
        "        self.layers = nn.ModuleList()\n",
        "        for i_layer in range(self.num_layers):\n",
        "            layer = RSTB(dim=embed_dim,\n",
        "                         input_resolution=(patches_resolution[0],\n",
        "                                           patches_resolution[1]),\n",
        "                         depth=depths[i_layer],\n",
        "                         num_heads=num_heads[i_layer],\n",
        "                         window_size=window_size,\n",
        "                         mlp_ratio=self.mlp_ratio,\n",
        "                         qkv_bias=qkv_bias, qk_scale=qk_scale,\n",
        "                         drop=drop_rate, attn_drop=attn_drop_rate,\n",
        "                         drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],  # no impact on SR results\n",
        "                         norm_layer=norm_layer,\n",
        "                         downsample=None,\n",
        "                         use_checkpoint=use_checkpoint,\n",
        "                         img_size=img_size,\n",
        "                         patch_size=patch_size,\n",
        "                         resi_connection=resi_connection\n",
        "\n",
        "                         )\n",
        "            self.layers.append(layer)\n",
        "        self.norm = norm_layer(self.num_features)\n",
        "\n",
        "        # build the last conv layer in deep feature extraction\n",
        "        if resi_connection == '1conv':\n",
        "            self.conv_after_body = nn.Conv2d(embed_dim, embed_dim, 3, 1, 1)\n",
        "        elif resi_connection == '3conv':\n",
        "            raise NotImplementedError('no implemenation found for resi_connection of 3conv')\n",
        "\n",
        "        # 3, high quality image reconstruction\n",
        "        if self.upsampler == 'pixelshuffle':\n",
        "            \n",
        "            self.conv_before_upsample = nn.Sequential(nn.Conv2d(embed_dim, num_feat, 3, 1, 1),\n",
        "                                                      nn.LeakyReLU(inplace=True))\n",
        "            self.upsample = Upsample(upscale, num_feat)\n",
        "            self.conv_last = nn.Conv2d(num_feat, num_out_ch, 3, 1, 1)\n",
        "        else:\n",
        "             raise NotImplementedError('no implemenation found for upscaler')\n",
        "\n",
        "        self.apply(self.intializeWeights)\n",
        "\n",
        "    def intializeWeights(self, m):\n",
        "        if isinstance(m, nn.Linear):\n",
        "            trunc_normal_(m.weight, std=.02)\n",
        "            if isinstance(m, nn.Linear) and m.bias is not None:\n",
        "                nn.init.constant_(m.bias, 0)\n",
        "        elif isinstance(m, nn.LayerNorm):\n",
        "            nn.init.constant_(m.bias, 0)\n",
        "            nn.init.constant_(m.weight, 1.0)\n",
        "\n",
        "    @torch.jit.ignore\n",
        "    def no_weight_decay(self):\n",
        "        return {'absolute_pos_embed'}\n",
        "\n",
        "    @torch.jit.ignore\n",
        "    def no_weight_decay_keywords(self):\n",
        "        return {'relative_position_bias_table'}\n",
        "\n",
        "    def lowFreqFeatures(self, x):\n",
        "        x_size = (x.shape[2], x.shape[3])\n",
        "        x = self.patch_embed(x)\n",
        "        if self.ape:\n",
        "            x = x + self.absolute_pos_embed\n",
        "        x = self.pos_drop(x)\n",
        "\n",
        "        for layer in self.layers:\n",
        "            x = layer(x, x_size)\n",
        "\n",
        "        x = self.norm(x)  # B L C\n",
        "        x = self.patch_unembed(x, x_size)\n",
        "\n",
        "        return x\n",
        "\n",
        "    def forward(self, x):\n",
        "        self.mean = self.mean.type_as(x)\n",
        "        x = (x - self.mean) * self.img_range\n",
        "\n",
        "        if self.upsampler == 'pixelshuffle':\n",
        "            x = self.conv_first_half(x)\n",
        "            x=  self.conv_first(x)\n",
        "            x = self.conv_after_body(self.lowFreqFeatures(x)) + x\n",
        "            x = self.conv_before_upsample(x)\n",
        "            x = self.conv_last(self.upsample(x))\n",
        "        else:\n",
        "            x_first = self.conv_first_half(x)\n",
        "            x_first = self.conv_first(x_first)\n",
        "            res = self.conv_after_body(self.lowFreqFeatures(x_first)) + x_first\n",
        "            x = x + self.conv_last(res)\n",
        "\n",
        "        x = x / self.img_range + self.mean\n",
        "\n",
        "        return x\n",
        "\n",
        "    def flops(self):\n",
        "        flops = 0\n",
        "        H, W = self.patches_resolution\n",
        "        flops += H * W * 3 * self.embed_dim * 9\n",
        "        flops += self.patch_embed.flops()\n",
        "        for i, layer in enumerate(self.layers):\n",
        "            flops += layer.flops()\n",
        "        flops += H * W * 3 * self.embed_dim * self.embed_dim\n",
        "        flops += self.upsample.flops()\n",
        "        return flops\n"
      ],
      "metadata": {
        "id": "FSZGeM0I6IVT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "These are the regularization techniques taken from the official implementation"
      ],
      "metadata": {
        "id": "uuTwqWn98yaJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def regualrizerOrth(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        w = m.weight.data.clone()\n",
        "        c_out, c_in, f1, f2 = w.size()\n",
        "        # dtype = m.weight.data.type()\n",
        "        w = w.permute(2, 3, 1, 0).contiguous().view(f1 * f2 * c_in, c_out)\n",
        "        # self.netG.apply(svd_orthogonalization)\n",
        "        u, s, v = torch.svd(w)\n",
        "        s[s > 1.5] = s[s > 1.5] - 1e-4\n",
        "        s[s < 0.5] = s[s < 0.5] + 1e-4\n",
        "        w = torch.mm(torch.mm(u, torch.diag(s)), v.t())\n",
        "        m.weight.data = w.view(f1, f2, c_in, c_out).permute(3, 2, 0, 1)  # .type(dtype)\n",
        "    else:\n",
        "        pass\n",
        "\n",
        "\n",
        "def regularizerClip(m):\n",
        "    eps = 1e-4\n",
        "    c_min = -1.5\n",
        "    c_max = 1.5\n",
        "\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1 or classname.find('Linear') != -1:\n",
        "        w = m.weight.data.clone()\n",
        "        w[w > c_max] -= eps\n",
        "        w[w < c_min] += eps\n",
        "        m.weight.data = w\n",
        "\n",
        "        if m.bias is not None:\n",
        "            b = m.bias.data.clone()\n",
        "            b[b > c_max] -= eps\n",
        "            b[b < c_min] += eps\n",
        "            m.bias.data = b\n"
      ],
      "metadata": {
        "id": "tJfz-C_76ZvM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Base Model taken from official Implementation and anyother implementation is recommended to follow the same interface. "
      ],
      "metadata": {
        "id": "h6s3_avWDjtR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class ModelBase():\n",
        "    def __init__(self, jsonDetails):\n",
        "        self.jsonDetails = jsonDetails  # jsonDetails\n",
        "        self.save_dir = jsonDetails['path']['models']  # save models\n",
        "        self.device = torch.device('cuda' if jsonDetails['gpu_ids'] is not None else 'cpu')\n",
        "        self.is_train = jsonDetails['is_train']  # training or not\n",
        "        self.schedulers = []  # schedulers\n",
        "\n",
        "    \"\"\"\n",
        "    # ----------------------------------------\n",
        "    # Preparation before training with data\n",
        "    # Save model during training\n",
        "    # ----------------------------------------\n",
        "    \"\"\"\n",
        "\n",
        "    def initTrain(self):\n",
        "        pass\n",
        "\n",
        "    def load(self):\n",
        "        pass\n",
        "\n",
        "    def save(self, label):\n",
        "        pass\n",
        "\n",
        "    def defineLoss(self):\n",
        "        pass\n",
        "\n",
        "    def defineOptimizer(self):\n",
        "        pass\n",
        "\n",
        "    def defineSchedular(self):\n",
        "        pass\n",
        "\n",
        "    \"\"\"\n",
        "    # ----------------------------------------\n",
        "    # Optimization during training with data\n",
        "    # Testing/evaluation\n",
        "    # ----------------------------------------\n",
        "    \"\"\"\n",
        "\n",
        "    def loadDataToModel(self, data):\n",
        "        pass\n",
        "\n",
        "    def ParamOptimization(self):\n",
        "        pass\n",
        "\n",
        "    def currentVisuals(self):\n",
        "        pass\n",
        "\n",
        "    def currentLosses(self):\n",
        "        pass\n",
        "\n",
        "    def getTheLearningRate(self, n):\n",
        "        for scheduler in self.schedulers:\n",
        "            scheduler.step(n)\n",
        "\n",
        "    def CurrentLearningRate(self):\n",
        "        return self.schedulers[0].get_lr()[0]\n",
        "\n",
        "    def requires_grad(self, model, flag=True):\n",
        "        for p in model.parameters():\n",
        "            p.requires_grad = flag\n",
        "\n",
        "    \"\"\"\n",
        "    # ----------------------------------------\n",
        "    # Information of net\n",
        "    # ----------------------------------------\n",
        "    \"\"\"\n",
        "\n",
        "    def printNetwrok(self):\n",
        "        pass\n",
        "\n",
        "    def infoNetwork(self):\n",
        "        pass\n",
        "\n",
        "    def printParams(self):\n",
        "        pass\n",
        "\n",
        "    def infoParams(self):\n",
        "        pass\n",
        "\n",
        "    def getBareModel(self, network):\n",
        "        \"\"\"Get bare model, especially under wrapping with\n",
        "        DistributedDataParallel or DataParallel.\n",
        "        \"\"\"\n",
        "        if isinstance(network, (DataParallel, DistributedDataParallel)):\n",
        "            network = network.module\n",
        "        return network\n",
        "\n",
        "    def model2device(self, network):\n",
        "        \"\"\"Model to device. It also warps models with DistributedDataParallel\n",
        "        or DataParallel.\n",
        "        Args:\n",
        "            network (nn.Module)\n",
        "        \"\"\"\n",
        "        network = network.to(self.device)\n",
        "        if self.jsonDetails['workDist']:\n",
        "            find_unused_parameters = self.jsonDetails['find_unused_parameters']\n",
        "            network = DistributedDataParallel(network, device_ids=[torch.cuda.current_device()],\n",
        "                                              find_unused_parameters=find_unused_parameters)\n",
        "        else:\n",
        "            network = DataParallel(network)\n",
        "        return network\n",
        "\n",
        "    # ----------------------------------------\n",
        "    # network name and number of parameters\n",
        "    # ----------------------------------------\n",
        "    def explainNetworkChar(self, network):\n",
        "        network = self.getBareModel(network)\n",
        "        msg = '\\n'\n",
        "        msg += 'Networks name: {}'.format(network.__class__.__name__) + '\\n'\n",
        "        msg += 'Params number: {}'.format(sum(map(lambda x: x.numel(), network.parameters()))) + '\\n'\n",
        "        msg += 'Net structure:\\n{}'.format(str(network)) + '\\n'\n",
        "        return msg\n",
        "\n",
        "    # ----------------------------------------\n",
        "    # parameters description\n",
        "    # ----------------------------------------\n",
        "    def explainParams(self, network):\n",
        "        network = self.getBareModel(network)\n",
        "        msg = '\\n'\n",
        "        msg += ' | {:^6s} | {:^6s} | {:^6s} | {:^6s} || {:<20s}'.format('mean', 'min', 'max', 'std', 'shape',\n",
        "                                                                        'param_name') + '\\n'\n",
        "        for name, param in network.state_dict().items():\n",
        "            if not 'num_batches_tracked' in name:\n",
        "                v = param.data.clone().float()\n",
        "                msg += ' | {:>6.3f} | {:>6.3f} | {:>6.3f} | {:>6.3f} | {} || {:s}'.format(v.mean(), v.min(), v.max(),\n",
        "                                                                                          v.std(), v.shape, name) + '\\n'\n",
        "        return msg\n",
        "\n",
        "    \"\"\"\n",
        "    # ----------------------------------------\n",
        "    # Save prameters\n",
        "    # Load prameters\n",
        "    # ----------------------------------------\n",
        "    \"\"\"\n",
        "\n",
        "    # ----------------------------------------\n",
        "    # save the state_dict of the network\n",
        "    # ----------------------------------------\n",
        "    def saveNetwork(self, save_dir, network, network_label, iter_label):\n",
        "        save_filename = '{}_{}.pth'.format(iter_label, network_label)\n",
        "        save_path = os.path.join(save_dir, save_filename)\n",
        "        network = self.getBareModel(network)\n",
        "        state_dict = network.state_dict()\n",
        "        for key, param in state_dict.items():\n",
        "            state_dict[key] = param.cpu()\n",
        "        torch.save(state_dict, save_path)\n",
        "\n",
        "    # ----------------------------------------\n",
        "    # load the state_dict of the network\n",
        "    # ----------------------------------------\n",
        "    def loadNetwork(self, load_path, network, strict=True):\n",
        "        network = self.getBareModel(network)\n",
        "        if strict:\n",
        "            network.load_state_dict(torch.load(load_path), strict=strict)\n",
        "        else:\n",
        "            state_dict_old = torch.load(load_path)\n",
        "            state_dict = network.state_dict()\n",
        "            for ((key_old, param_old), (key, param)) in zip(state_dict_old.items(), state_dict.items()):\n",
        "                state_dict[key] = param_old\n",
        "            network.load_state_dict(state_dict, strict=True)\n",
        "            del state_dict_old, state_dict\n",
        "\n",
        "    # ----------------------------------------\n",
        "    # save the state_dict of the optimizer\n",
        "    # ----------------------------------------\n",
        "    def saveOptimzer(self, save_dir, optimizer, optimizer_label, iter_label):\n",
        "        save_filename = '{}_{}.pth'.format(iter_label, optimizer_label)\n",
        "        save_path = os.path.join(save_dir, save_filename)\n",
        "        torch.save(optimizer.state_dict(), save_path)\n",
        "\n",
        "    # ----------------------------------------\n",
        "    # load the state_dict of the optimizer\n",
        "    # ----------------------------------------\n",
        "    def loadOptimizer(self, load_path, optimizer):\n",
        "        optimizer.load_state_dict(\n",
        "            torch.load(load_path, map_location=lambda storage, loc: storage.cuda(torch.cuda.current_device())))\n",
        "\n",
        "    def updateEncod(self, decay=0.999):\n",
        "        netG = self.getBareModel(self.netG)\n",
        "        netG_params = dict(netG.named_parameters())\n",
        "        netE_params = dict(self.netE.named_parameters())\n",
        "        for k in netG_params.keys():\n",
        "            netE_params[k].data.mul_(decay).add_(netG_params[k].data, alpha=1 - decay)"
      ],
      "metadata": {
        "id": "ALlds1OV6asv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This block of the code is used to intialize the weights for the networks , If no argument is given network defination intialization is used "
      ],
      "metadata": {
        "id": "EzzZoTaBD9pZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def initWeights(net, init_type='xavier_uniform', init_bn_type='uniform', gain=1):\n",
        "    def customInit(m, init_type='xavier_uniform', init_bn_type='uniform', gain=1):\n",
        "        raise \"implementation error\"\n",
        "\n",
        "    if init_type not in ['default', 'none']:\n",
        "        print('Initialization method [{:s} + {:s}], gain is [{:.2f}]'.format(init_type, init_bn_type, gain))\n",
        "        fn = functools.partial(customInit, init_type=init_type, init_bn_type=init_bn_type, gain=gain)\n",
        "        net.apply(fn)\n",
        "    else:\n",
        "        print('Pass this initialization! Initialization was done during network defination!')\n"
      ],
      "metadata": {
        "id": "JsFW1Ejc6awa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define the Network and then Intalize the weights"
      ],
      "metadata": {
        "id": "k8FoGlZMEVIw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# get the network\n",
        "def defineNetworkArch(jsonDetails):\n",
        "    opt_net = jsonDetails['netG']\n",
        "    net_type = opt_net['net_type']\n",
        "    if net_type == 'swinir':\n",
        "        netG = SwinIR(upscale=opt_net['upscale'],\n",
        "                      in_chans=opt_net['in_chans'],\n",
        "                      img_size=opt_net['img_size'],\n",
        "                      window_size=opt_net['window_size'],\n",
        "                      img_range=opt_net['img_range'],\n",
        "                      depths=opt_net['depths'],\n",
        "                      embed_dim=opt_net['embed_dim'],\n",
        "                      num_heads=opt_net['num_heads'],\n",
        "                      mlp_ratio=opt_net['mlp_ratio'],\n",
        "                      upsampler=opt_net['upsampler'],\n",
        "                      resi_connection=opt_net['resi_connection'])\n",
        "\n",
        "    else:\n",
        "        raise NotImplementedError('netG [{:s}] is not found.'.format(net_type))\n",
        "\n",
        "    \n",
        "    # initialize weights\n",
        "    if jsonDetails['is_train']:\n",
        "        initWeights(netG,\n",
        "                    init_type=opt_net['init_type'],\n",
        "                    init_bn_type=opt_net['init_bn_type'],\n",
        "                    gain=opt_net['init_gain'])\n",
        "\n",
        "    return netG"
      ],
      "metadata": {
        "id": "zGxtRYbg60HP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The Generalized plain Model class for classical super resolution, which inherits the Model base class which can be implemented fro any type of resolution or noise removal by changing the implementation.\n",
        "Here we are using only the absolute pixel loss as loss function for training.\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "lV_Zgwme9L7C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class ModelPlain(ModelBase):\n",
        "    def __init__(self, jsonDetails):\n",
        "        super(ModelPlain, self).__init__(jsonDetails)\n",
        "        \n",
        "        \n",
        "        #get the training Json\n",
        "        self.opt_train = self.jsonDetails['train'] \n",
        "\n",
        "        # selective_network.py\n",
        "        self.netG = defineNetworkArch(jsonDetails)\n",
        "\n",
        "        # model to device (that is use the cuda)\n",
        "        self.netG = self.model2device(self.netG)\n",
        "        # Architecture for the encoder which we dont need here but is used for other reconstructions\n",
        "        if self.opt_train['E_decay'] > 0:\n",
        "            self.netE = defineNetworkArch(jsonDetails).to(self.device).eval()\n",
        "        \n",
        "\n",
        "    \n",
        "    \n",
        "    # initialize training\n",
        "    def initTrain(self):\n",
        "        # load model\n",
        "        self.load()\n",
        "\n",
        "        # set training mode,for BN  \n",
        "        self.netG.train()\n",
        "        # define loss  \n",
        "        self.defineLoss()  \n",
        "        # define optimizer\n",
        "        self.defineOptimizer()\n",
        "        # load optimizer  \n",
        "        self.loadOptimzers() \n",
        "        # define scheduler \n",
        "        self.defineSchedular()\n",
        "        #It is needed for logs  \n",
        "        self.log_dict = OrderedDict()  \n",
        "\n",
        "    \n",
        "    # Load pre-trained G model\n",
        "    def load(self):\n",
        "        load_path_G = self.jsonDetails['path']['pretrained_netG']\n",
        "        if load_path_G is not None:\n",
        "            print('Loading model for G [{:s}] ...'.format(load_path_G))\n",
        "            self.loadNetwork(load_path_G, self.netG, strict=self.opt_train['G_param_strict'])\n",
        "        load_path_E = self.jsonDetails['path']['pretrained_netE']\n",
        "        if self.opt_train['E_decay'] > 0:\n",
        "            if load_path_E is not None:\n",
        "                print('Loading model for E [{:s}] ...'.format(load_path_E))\n",
        "                self.loadNetwork(load_path_E, self.netE, strict=self.opt_train['E_param_strict'])\n",
        "            else:\n",
        "                print('Copying model for E ...')\n",
        "                self.updateEncod(0)\n",
        "            self.netE.eval()\n",
        "\n",
        "    #Load The optimizer\n",
        "    def loadOptimzers(self):\n",
        "        load_path_optimizerG = self.jsonDetails['path']['pretrained_optimizerG']\n",
        "        if load_path_optimizerG is not None and self.opt_train['G_optimizer_reuse']:\n",
        "            print('Loading optimizerG [{:s}] ...'.format(load_path_optimizerG))\n",
        "            self.loadOptimizer(load_path_optimizerG, self.G_optimizer)\n",
        "\n",
        "    # Save the Model and Optimizer \n",
        "    def save(self, iter_label):\n",
        "        self.saveNetwork(self.save_dir, self.netG, 'G', iter_label)\n",
        "        if self.opt_train['E_decay'] > 0:\n",
        "            self.saveNetwork(self.save_dir, self.netE, 'E', iter_label)\n",
        "        if self.opt_train['G_optimizer_reuse']:\n",
        "            self.saveOptimzer(self.save_dir, self.G_optimizer, 'optimizerG', iter_label)\n",
        "\n",
        "    def saveBetterModel(self, psnr, args, current_step):\n",
        "        dir = args.model_save_dir\n",
        "        model_name = str(self.opt_train['G_optimizer_lr']) + \"_\" + str(current_step) + \"_\" + str(psnr)\n",
        "        self.saveNetwork(dir, self.netG, 'G', psnr)\n",
        "        if self.opt_train['E_decay'] > 0:\n",
        "            self.saveNetwork(dir, self.netE, 'E', psnr)\n",
        "        if self.opt_train['G_optimizer_reuse']:\n",
        "            self.saveOptimzer(dir, self.G_optimizer, 'optimizerG', psnr)\n",
        "\n",
        "    # Define the loss function we are going to use\n",
        "    def defineLoss(self):\n",
        "        \n",
        "        G_lossfn_type = self.opt_train['G_lossfn_type']\n",
        "        if G_lossfn_type == 'l1':\n",
        "            self.G_lossfn = nn.L1Loss().to(self.device)\n",
        "        elif G_lossfn_type == 'l2':\n",
        "            self.G_lossfn = nn.MSELoss().to(self.device)\n",
        "        elif G_lossfn_type == 'l2sum':\n",
        "            self.G_lossfn = nn.MSELoss(reduction='sum').to(self.device)\n",
        "\n",
        "        else:\n",
        "            raise NotImplementedError('Loss type [{:s}] is not found.'.format(G_lossfn_type))\n",
        "        self.G_lossfn_weight = self.opt_train['G_lossfn_weight']  \n",
        "\n",
        "    #Define the Optimizer default is Adam\n",
        "    def defineOptimizer(self):\n",
        "        G_optim_params = []\n",
        "        for k, v in self.netG.named_parameters():\n",
        "            if v.requires_grad:\n",
        "                G_optim_params.append(v)\n",
        "            else:\n",
        "                print('Params [{:s}] will not optimize.'.format(k))\n",
        "        self.G_optimizer = Adam(G_optim_params, lr=self.opt_train['G_optimizer_lr'], weight_decay=0)\n",
        "\n",
        "    #Define the Schedular to use the multi step learning\n",
        "    def defineSchedular(self):\n",
        "       self.schedulers.append(lr_scheduler.MultiStepLR(self.G_optimizer,\n",
        "                                                        self.opt_train['G_scheduler_milestones'],\n",
        "                                                        self.opt_train['G_scheduler_gamma'], verbose=False\n",
        "                                                        ))\n",
        "\n",
        "    \n",
        "    # Feed the data from the  L/H dictionary\n",
        "    def loadDataToModel(self, data, need_H=True):\n",
        "        self.L = data['L'].to(self.device)\n",
        "        if need_H:\n",
        "            self.H = data['H'].to(self.device)\n",
        "\n",
        "    #Give the forward pass\n",
        "    def netForwardPass(self):\n",
        "        self.E = self.netG(self.L)\n",
        "\n",
        "    #give the forward pass\n",
        "    ##Get the loss \n",
        "    ### Do Backpropagation and Update the parameters\n",
        "    def ParamOptimization(self, current_step):\n",
        "        self.G_optimizer.zero_grad()\n",
        "        self.netForwardPass()\n",
        "        G_loss = self.G_lossfn_weight * self.G_lossfn(self.E, self.H)\n",
        "        G_loss.backward()\n",
        "        \n",
        "        # Regularizations\n",
        "\n",
        "        # `clip_grad_norm` helps prevent the exploding gradient problem.\n",
        "        G_optimizer_clipgrad = self.opt_train['G_optimizer_clipgrad'] if self.opt_train['G_optimizer_clipgrad'] else 0\n",
        "        if G_optimizer_clipgrad > 0:\n",
        "            torch.nn.utils.clip_grad_norm_(self.parameters(), max_norm=self.opt_train['G_optimizer_clipgrad'],\n",
        "                                           norm_type=2)\n",
        "\n",
        "        self.G_optimizer.step()\n",
        "\n",
        "        \n",
        "        # regularizer\n",
        "        G_regularizer_orthstep = self.opt_train['G_regularizer_orthstep'] if self.opt_train[\n",
        "            'G_regularizer_orthstep'] else 0\n",
        "        if G_regularizer_orthstep > 0 and current_step % G_regularizer_orthstep == 0 and current_step % \\\n",
        "                self.jsonDetails['train']['checkpoint_save'] != 0:\n",
        "            self.netG.apply(regualrizerOrth)\n",
        "        G_regularizer_clipstep = self.opt_train['G_regularizer_clipstep'] if self.opt_train[\n",
        "            'G_regularizer_clipstep'] else 0\n",
        "        if G_regularizer_clipstep > 0 and current_step % G_regularizer_clipstep == 0 and current_step % \\\n",
        "                self.jsonDetails['train']['checkpoint_save'] != 0:\n",
        "            self.netG.apply(regularizerClip)\n",
        "\n",
        "        \n",
        "        # Store the loss in log dictionary\n",
        "        self.log_dict['G_loss'] = G_loss.item()\n",
        "        \n",
        "        #update the E network\n",
        "        if self.opt_train['E_decay'] > 0:\n",
        "            self.updateEncod(self.opt_train['E_decay'])\n",
        "\n",
        "    #test to new images\n",
        "    def test(self):\n",
        "        self.netG.eval()\n",
        "        with torch.no_grad():\n",
        "            self.netForwardPass()\n",
        "        self.netG.train()\n",
        "\n",
        "    # Get the log dictionary\n",
        "    def getCurrentLog(self):\n",
        "        return self.log_dict\n",
        "\n",
        "    # Visualize the from G,E and H by detaching from tensor\n",
        "    def currentVisuals(self, need_H=True):\n",
        "        out_dict = OrderedDict()\n",
        "        out_dict['L'] = self.L.detach()[0].float().cpu()\n",
        "        out_dict['E'] = self.E.detach()[0].float().cpu()\n",
        "        if need_H:\n",
        "            out_dict['H'] = self.H.detach()[0].float().cpu()\n",
        "        return out_dict\n",
        "\n",
        "    \n",
        "    # get L, E, H batch images\n",
        "    def current_results(self, need_H=True):\n",
        "        out_dict = OrderedDict()\n",
        "        out_dict['L'] = self.L.detach().float().cpu()\n",
        "        out_dict['E'] = self.E.detach().float().cpu()\n",
        "        if need_H:\n",
        "            out_dict['H'] = self.H.detach().float().cpu()\n",
        "        return out_dict\n",
        "\n",
        "    \n",
        "    # print network\n",
        "    def printNetwrok(self):\n",
        "        msg = self.explainNetworkChar(self.netG)\n",
        "        print(msg)\n",
        "\n",
        "   \n",
        "    # print params\n",
        "    def printParams(self):\n",
        "        msg = self.explainParams(self.netG)\n",
        "        print(msg)\n",
        "\n",
        "    \n",
        "    # network information\n",
        "    def infoNetwork(self):\n",
        "        msg = self.explainNetworkChar(self.netG)\n",
        "        return msg\n",
        "\n",
        "    \n",
        "    # params information\n",
        "    def infoParams(self):\n",
        "        msg = self.explainParams(self.netG)\n",
        "        return msg\n"
      ],
      "metadata": {
        "id": "LZleEtLi60K9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def makeModel(jsonDetails):\n",
        "    model = jsonDetails['model']\n",
        "\n",
        "    if model == 'plain':\n",
        "         \n",
        "        return ModelPlain(jsonDetails)\n",
        "    else:\n",
        "        raise NotImplementedError('Model [{:s}] is not defined.'.format(model))"
      ],
      "metadata": {
        "id": "_GMkxx_360Ns"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# This section of the code is now for the automatic evaluation of the Set5.\n",
        "## This is taken directly from the official implementation with minor modifications"
      ],
      "metadata": {
        "id": "IdIqrBF_Fwxf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def convertInputRange(img):\n",
        "    \"\"\"Convert the type and range of the input image.\n",
        "    It converts the input image to np.float32 type and range of [0, 1].\n",
        "    It is mainly used for pre-processing the input image in colorspace\n",
        "    convertion functions such as rgb2ycbcr and ycbcr2rgb.\n",
        "    Args:\n",
        "        img (ndarray): The input image. It accepts:\n",
        "            1. np.uint8 type with range [0, 255];\n",
        "            2. np.float32 type with range [0, 1].\n",
        "    Returns:\n",
        "        (ndarray): The converted image with type of np.float32 and range of\n",
        "            [0, 1].\n",
        "    \"\"\"\n",
        "    img_type = img.dtype\n",
        "    img = img.astype(np.float32)\n",
        "    if img_type == np.float32:\n",
        "        pass\n",
        "    elif img_type == np.uint8:\n",
        "        img /= 255.\n",
        "    else:\n",
        "        raise TypeError('The img type should be np.float32 or np.uint8, ' f'but got {img_type}')\n",
        "    return img\n"
      ],
      "metadata": {
        "id": "DugjEg6n7IFe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def convertOuputRange(img, dst_type):\n",
        "    \"\"\"Convert the type and range of the image according to dst_type.\n",
        "    It converts the image to desired type and range. If `dst_type` is np.uint8,\n",
        "    images will be converted to np.uint8 type with range [0, 255]. If\n",
        "    `dst_type` is np.float32, it converts the image to np.float32 type with\n",
        "    range [0, 1].\n",
        "    It is mainly used for post-processing images in colorspace convertion\n",
        "    functions such as rgb2ycbcr and ycbcr2rgb.\n",
        "    Args:\n",
        "        img (ndarray): The image to be converted with np.float32 type and\n",
        "            range [0, 255].\n",
        "        dst_type (np.uint8 | np.float32): If dst_type is np.uint8, it\n",
        "            converts the image to np.uint8 type with range [0, 255]. If\n",
        "            dst_type is np.float32, it converts the image to np.float32 type\n",
        "            with range [0, 1].\n",
        "    Returns:\n",
        "        (ndarray): The converted image with desired type and range.\n",
        "    \"\"\"\n",
        "    if dst_type not in (np.uint8, np.float32):\n",
        "        raise TypeError('The dst_type should be np.float32 or np.uint8, ' f'but got {dst_type}')\n",
        "    if dst_type == np.uint8:\n",
        "        img = img.round()\n",
        "    else:\n",
        "        img /= 255.\n",
        "    return img.astype(dst_type)\n",
        "\n"
      ],
      "metadata": {
        "id": "YuPv7OnJ7M42"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def changeChannelOrder(img, input_order='HWC'):\n",
        "    \"\"\"Reorder images to 'HWC' order.\n",
        "    If the input_order is (h, w), return (h, w, 1);\n",
        "    If the input_order is (c, h, w), return (h, w, c);\n",
        "    If the input_order is (h, w, c), return as it is.\n",
        "    Args:\n",
        "        img (ndarray): Input image.\n",
        "        input_order (str): Whether the input order is 'HWC' or 'CHW'.\n",
        "            If the input image shape is (h, w), input_order will not have\n",
        "            effects. Default: 'HWC'.\n",
        "    Returns:\n",
        "        ndarray: reordered image.\n",
        "    \"\"\"\n",
        "\n",
        "    if input_order not in ['HWC', 'CHW']:\n",
        "        raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' \"'HWC' and 'CHW'\")\n",
        "    if len(img.shape) == 2:\n",
        "        img = img[..., None]\n",
        "    if input_order == 'CHW':\n",
        "        img = img.transpose(1, 2, 0)\n",
        "    return img\n",
        "\n"
      ],
      "metadata": {
        "id": "10B5usPe7M8W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def toYchannel(img):\n",
        "    \"\"\"Change to Y channel of YCbCr.\n",
        "    Args:\n",
        "        img (ndarray): Images with range [0, 255].\n",
        "    Returns:\n",
        "        (ndarray): Images with range [0, 255] (float type) without round.\n",
        "    \"\"\"\n",
        "    img = img.astype(np.float32) / 255.\n",
        "    if img.ndim == 3 and img.shape[2] == 3:\n",
        "        img = bgr2ycbcr(img, y_only=True)\n",
        "        img = img[..., None]\n",
        "    return img * 255.\n"
      ],
      "metadata": {
        "id": "e1xQ1UKB7VSm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def bgr2ycbcr(img, y_only=False):\n",
        "    \"\"\"Convert a BGR image to YCbCr image.\n",
        "    The bgr version of rgb2ycbcr.\n",
        "    It implements the ITU-R BT.601 conversion for standard-definition\n",
        "    television. See more details in\n",
        "    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.\n",
        "    It differs from a similar function in cv2.cvtColor: `BGR <-> YCrCb`.\n",
        "    In OpenCV, it implements a JPEG conversion. See more details in\n",
        "    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.\n",
        "    Args:\n",
        "        img (ndarray): The input image. It accepts:\n",
        "            1. np.uint8 type with range [0, 255];\n",
        "            2. np.float32 type with range [0, 1].\n",
        "        y_only (bool): Whether to only return Y channel. Default: False.\n",
        "    Returns:\n",
        "        ndarray: The converted YCbCr image. The output image has the same type\n",
        "            and range as input image.\n",
        "    \"\"\"\n",
        "    img_type = img.dtype\n",
        "    img = convertInputRange(img)\n",
        "    if y_only:\n",
        "        out_img = np.dot(img, [24.966, 128.553, 65.481]) + 16.0\n",
        "    else:\n",
        "        out_img = np.matmul(\n",
        "            img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786], [65.481, -37.797, 112.0]]) + [16, 128, 128]\n",
        "    out_img = convertOuputRange(out_img, img_type)\n",
        "    return out_img"
      ],
      "metadata": {
        "id": "_PLIAu0X7VVz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# ---------------for SwinIR set5 validation------------------------\n",
        "def calPsnrofImage(img1, img2, crop_border, input_order='HWC', test_y_channel=False):\n",
        "    \"\"\"Calculate PSNR (Peak Signal-to-Noise Ratio).\n",
        "    Ref: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio\n",
        "    Args:\n",
        "        img1 (ndarray): Images with range [0, 255].\n",
        "        img2 (ndarray): Images with range [0, 255].\n",
        "        crop_border (int): Cropped pixels in each edge of an image. These\n",
        "            pixels are not involved in the PSNR calculation.\n",
        "        input_order (str): Whether the input order is 'HWC' or 'CHW'.\n",
        "            Default: 'HWC'.\n",
        "        test_y_channel (bool): Test on Y channel of YCbCr. Default: False.\n",
        "    Returns:\n",
        "        float: psnr result.\n",
        "    \"\"\"\n",
        "\n",
        "    assert img1.shape == img2.shape, (f'Image shapes are differnet: {img1.shape}, {img2.shape}.')\n",
        "    if input_order not in ['HWC', 'CHW']:\n",
        "        raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' '\"HWC\" and \"CHW\"')\n",
        "    img1 = changeChannelOrder(img1, input_order=input_order)\n",
        "    img2 = changeChannelOrder(img2, input_order=input_order)\n",
        "    img1 = img1.astype(np.float64)\n",
        "    img2 = img2.astype(np.float64)\n",
        "\n",
        "    if crop_border != 0:\n",
        "        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]\n",
        "        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]\n",
        "\n",
        "    if test_y_channel:\n",
        "        img1 = toYchannel(img1)\n",
        "        img2 = toYchannel(img2)\n",
        "\n",
        "    mse = np.mean((img1 - img2) ** 2)\n",
        "    if mse == 0:\n",
        "        return float('inf')\n",
        "    return 20. * np.log10(255. / np.sqrt(mse))"
      ],
      "metadata": {
        "id": "dCU2N0cR7VYP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def calSSIMOfImage(img1, img2):\n",
        "    \"\"\"Calculate SSIM (structural similarity) for one channel images.\n",
        "    It is called by func:`calculate_ssim`.\n",
        "    Args:\n",
        "        img1 (ndarray): Images with range [0, 255] with order 'HWC'.\n",
        "        img2 (ndarray): Images with range [0, 255] with order 'HWC'.\n",
        "    Returns:\n",
        "        float: ssim result.\n",
        "    \"\"\"\n",
        "\n",
        "    C1 = (0.01 * 255) ** 2\n",
        "    C2 = (0.03 * 255) ** 2\n",
        "\n",
        "    img1 = img1.astype(np.float64)\n",
        "    img2 = img2.astype(np.float64)\n",
        "    kernel = cv2.getGaussianKernel(11, 1.5)\n",
        "    window = np.outer(kernel, kernel.transpose())\n",
        "\n",
        "    mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]\n",
        "    mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]\n",
        "    mu1_sq = mu1 ** 2\n",
        "    mu2_sq = mu2 ** 2\n",
        "    mu1_mu2 = mu1 * mu2\n",
        "    sigma1_sq = cv2.filter2D(img1 ** 2, -1, window)[5:-5, 5:-5] - mu1_sq\n",
        "    sigma2_sq = cv2.filter2D(img2 ** 2, -1, window)[5:-5, 5:-5] - mu2_sq\n",
        "    sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2\n",
        "\n",
        "    ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))\n",
        "    return ssim_map.mean()\n",
        "\n"
      ],
      "metadata": {
        "id": "51HBKsGg7mYV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "SSIM is used as a metric to measure the similarity between two given images. \n",
        "The Structural Similarity Index (SSIM) metric extracts 3 key features from an image:  \n",
        "   * Luminance \n",
        "   * Contrast\n",
        "   * Structure   \n",
        "**Luminance:** Luminance is measured by averaging over all the pixel values. Its denoted by μ (Mu) and the formula is given below.  \n",
        "**Contrast:** It is measured by taking the standard deviation (square root of variance) of all the pixel values. It is denoted by σ (sigma) and represented by the formula below.  \n",
        "**Structure:** The structural comparison is done by using a consolidated formula (more on that later) but in essence, we divide the input signal with its standard deviation so that the result has unit standard deviation which allows for a more robust comparison.  \n",
        "And finally, the SSIM score is given by,  \n",
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAApUAAAA7CAYAAAAq2HEQAAAgAElEQVR4Ae3dBdQsR9EG4KDB3V2COwR3h+AWPLi7BdfggRCc4O7u7u7u7u5OYP7zzP0rt+/ckZ5Z+fbb7T5nz9rsTE91ddVbb1X37lGVViRQJFAkUCRQJFAkUCRQJFAkMKME9pjx9+XnRQJFAkUCRQJFAkUCRQJFAkUCVQGVRQmKBIoEigSKBIoEigSKBIoEZpZAAZUzi7CcoEigSKBIoEigSKBIoEigSKCAyqIDRQJFAkUCRQJFAkUCRQJFAjNLoIDKmUVYTlAkUCRQJFAkUCRQJFAkUCRQQGXRgSKBIoEigSKBIoEigSKBIoGZJVBA5cwiLCcoEigSKBIoEigSKBIoEigSKKCy6ECRQJFAkUCRQJHAikngn//8Z/WTn/yk+sQnPlF98IMfrN73vvdV73rXu6q3v/3t1Y9//OPK96UVCayaBAqoXLURKf0pEigSKBIoEthoCfz5z3+uvvnNb1Zve9vbquc+97nV05/+9OrJT35y9eAHP7i6yU1uUj3jGc+ofvSjH220jMrNr6YECqhczXEpvSoSKBIoEigS2EAJ/Oc//6k++clP1kDy2c9+dvXb3/62OvTQQ2tJfPGLX6xufOMbVyc/+clrwPnf//53AyVUbnmVJVBA5SqPTulbkUCRQJFAkcBGSUCaG5h8/etfX/3+978/DFASwje+8Y3qbne7W3XsYx+7Ouigg6qf/vSnGyWbcrOrL4ECKld/jEoPiwSKBIoEigTWXAJYx1//+td1uvtVr3pVK2D87Gc/W13talerjn70o9fp8F/84hdrLpVye9tNAgVUbrcRK/0tEigSKBIoElg7Cfz973+v3vSmN1UveclLKmnuZrMw561vfWt15jOfuX5gMv/yl780DyvviwS2VAIFVG6p+MvFiwSKBFZNAhijP/3pT/VCiK997WvVd7/73epb3/pWnXr84Q9/WP3jH/+o/ve//x3Wba/VwZVWJDBVAnTod7/7XXWf+9ynXulN//7617/Wq7y///3vVx6f+tSnqkc96lHVXnvtVd3jHveo9XHq9crvNlsC9E2QonziC1/4QvXRj360ruNl6+hdat9I6le/+lX1y1/+svrb3/42KLgCKgdFtLgDwhltkkNScP7vf/97N6VdnJS37sz/+te/KuxD+jCRo+h+Hj0rOtQvRbJO5Z++Nj7NhQ7kaeWtLVwe+tCHVte5znWqu9zlLtUtb3nL6gY3uEH1wAc+sF6V67dheI0po9s8V3/P5vOtPgC56X153XZv87nijrO410VfY579nfVc5Mxu0acY975zkk1zTPrmPh9gm6B73/ve1Ze+9KV6TDn7RzziEdU973nP6l73uled9j73uc9d3fCGN6y3GpqnHem7l/iuS9fcZ9+9xe9nfXZ9cir+sl2SbbaObUhtlV+GLgOQj33sY6u99967OvKRj1yd6EQnqm5/+9tXSiz8JprjX/SiF1XPf/7zq69//evxcedzAZWdoln8F6KEl7/85dXznve8xV9sRa5gnzVbY3zve99be+NwpzvdqTrb2c62y4NDsM/cvFrRoX6G8AMf+MAu8o/xON/5zlc7agsfojGe0onYoFvd6lb1QghGlIw9XvrSl1bXve51q0te8pLVxz72sfpYhhwIeOQjH1mzm3GuZT0Ds5e61KV2ucfznve81e1ud7vqK1/5ykK6QUaf//zn6+1tMLmb0DCHD3/4w6t3v/vd9WrsoXseO/f/8Ic/1GzRU57ylJoZB9Q+85nPVA94wANqVvLOd75zHeBc7nKXq8d2K4KYNl2L+WS+WGC0yFZs3Xhbx1Y96EEPqv74xz8eNjTmr71Pr3jFK1YXutCFqotf/OK1DfH6FKc4RQ0sMZdaZG2e9KQnVa973euy9kYtoPIwUS/vhYhXzYzVe/YfExlsSvv2t79dvfjFL64d0oc+9KGKMV3XpqD+xCc+cQ1COHmPxz3ucbWzmPWeiw7l6RDAF7L3bDuWC17wgtXRjna0at99961TP8aC8fzNb35TPeYxj6mucIUrVPvvv3/9XcqqS4E/5CEPqY5znOPU7CVAil16y1veUj3rWc/akvq2n/3sZ9XJTnay6jSnOU21zz771PcKgAAnUvXzbq73xje+sWZs3/CGN9QM7byvsYrnw8QBTZidF7zgBRU71tfY9dC7/fbbr2aBLnaxi1WveMUrWn9mz0nnfcc73lEv1sHG0cfPfe5z1ac//ek6Nfma17ymXvktIBIsAbrLbKFrRz3qUauLXOQih92f+wQ62upA59G/Yuum2TpjdNrTnrbOsiitiGb/U1kYvgip9c53vrPWbWQHOyZAeOELX3hYBkSd76tf/eoqN4AcBSopscjdhqyvfe1rK0ru2XvAyPcidxf/8Ic/XOffRf9pY7wBCVFYnEeHPRirj3/84xXldZz8/Xvf+97qy1/+cn0K0ZsbfOUrX1kXM9t2gfGMx3Oe85zqZS97Wd2v97///XVE+dWvfrWyks5kRt/aNPapT31qvWUDZ+CcU5rf+b0+OJ/zOr/ruJ7rtjW0svqYAw44oI4gRL4M1qY0BoKjt4nv/e53vzpiUsOxjg2oPMc5zlE7YPruYf7EBCcLKS6OhIOmO3TJ481vfnP1gx/8oFUsRYfydShsTcifXLFITVDpOCy69OKVr3zl2sY05yU9ZXuOd7zjVec85zkrNsbD3MfcpSmj1oFbwIfh6C9xiUvUdtB9ssVAz7znFbaD/b3//e9fPf7xj68B5bJTsAsQYdYp+TE2X0CsBCL2j+Sn2hr5h87Rq7Of/ew1G9QFKvkLNlHgImXZ1jB1T3jCE2r9syH6sld+h67Rfyn5uD/PgMoiCIJi66bbOmN01rOedTdQSdeijCfVtcjUwFOHHHJIPab2SIVVIjPTppfNz7JBJUeIWTr44IOru9/97jVFetvb3raOVtR7iFQgXtGKTvgOXZ4aHQpiYjDsj370o+uoS5Rzm9vcpn6oXcIUoFkZRnVN1772tet0qY5TWgXKt7jFLWqW4fznP391hCMcodpjjz3qLRa8928Drs3oSbECquqhbnazm9XOwqax6geOe9zjVpe+9KXraD7tY1NAbe8dL7LEDDjP4Q53uDoS5Yxcx/Vct9n8DnvAIKjVIodFTMTmdVftvWCBnkgFGyfAah3rZIBKKQXBTlsjB07GBBcdSmMe/vCHrx/Xv/71W9NJRYd2SHKqDgHqbE8TVHLmFkkc85jHrMcjTYvH2AEQ73nPe6rTn/701UlOcpKaWVJrxAgzzs0AOn63yOdw9Fe/+tXr4GQR13JfAiDs2H3ve9/64e8Dx9rNRfRt2efk07CQfJbV14iULmAZfbPAATt+mctcpp7v8Xk8ky9/J9ixL2VXI/MDDzywZsr5YSz5Mlvomto7/n7Rrdi6HRKeauuMkeAXHgkiwxnpIzIrBZTpWCqb4ZewmAg9pT1t9jD9Tfo6C1RSeowkwGQyiUoCBJhQOglEXfjCF67UfNjyQL4+BZXOYRI87WlPq29UGsF50gkp14+1USx6rnOdq7rABS5QnfSkJ61rnNJOe03Q2E2bwHLE5znPeepi0vR86W8o6M9//vM6/SVddKxjHasGgpzE2DSC4xlYRkIqDKi8/OUvX5+/z9BaAIDpED1shVFI5bHVrwNQ0Re1SiKidWtDoDKcNQZEmktwFqDSRBYUNVvRoZ0SmaJDXaBSjRG27yhHOUqdaWiylHFV8/4sZzlLDSoFArITWMqtauHoFwkq2TSsmCDwpje9aQ2st+p+V+G6xhu4VrsqOO5yztHXIVAJsGP71E+mtW/x+3i2+hsJw+eoSwcyl9lC15YFKout2zm6U2xdF6jcedbuV7au4o8EzMi9vmCneZZBUIldpPDXu971KrU6jC+DyyFGAzAhYQb3Gte4Rs3eqUsymQJkMUoYG+lAuXxpwKbhBggpkuspLlWPZpNXhfPN5lgA9AQnOEHtiLE8GM6uFg78jne8Y3XZy162rnPDSvh3gjEo3Pkdr3/6xcEAlVe96lUHVzWTD1CuMBYF3bz/rr6v4+fGz0a/oiiLH5QtrFsbApXul16ShXotq4uBSiwaXW5LpxYd2qklU3SoC1SqJ+Ksz3jGM9YlN87d1sj/TGc6U3WMYxyjzpYo4ZlaQtN2/rGfhaNfJKhkk6Vd2U1kwBgHM/Z+tsPxyA8sJVCp9hY50teGQKXsHScOKDp3V8McYTz5RVnDvmO7zjHL56FrywKVxdbtHK0ptm4WUMkeYs7pNzIucNzOHnW/GgSVWDlMEiZOJxmYtsY5+g49ry6pCSo5TQXL6FigEfLuaiYL8GrlEgVuA5V+i8L1PUfM4KlLG2p3vetdqzvc4Q41CpcGx3Cqi8oVmuOsjAIAgp0FKgGIvibNLdWrn1L83qfAvO+36/qdiSJ9qMTh1re+dV2Y3uXMt6MMckBl3JfCaHMDU4bxV8PSbEWHmhLZscBmjA51gUoOTMCrXOEjH/nI7hf6/08cJxOj7IU9XDZb1OxYOPpFgUqBrxp5LK4AUGZnneZoU54579ltMlGzZtEMP9BXvzoEKv3PNx+H/exiKo2zWlYkBj+6FeUHoWvLAJXF1u2uiWP95SygEqmBAEMAdmG+3Xu445NBUCmFrfYQqOwqMk5PLo1H6a90pSvtkv5WzM5pOo9JNgSoTC7gi6GfN6h0Xv9aoC4KOyElD43nNMcRuPpPi4owpDmgEhC90Y1uVINKMmpjoXKuv27HiPKBfCvVZlk4tYpyyQWVAreHPexhdSmHcg571anxa7aiQ02J7Hg/Roe6QKXMiayFshssVBMkCIKNyTOf+cz6GHbDFkOcnyA4zcq093Ixn4ajXxSoZO8sSlEytAogejFSHH9WbC2W+pSnPGWdtu5bGTsEKrGU0tp8iixYmk4HJGQBlVnI6AjALfxJjxnf+2m/CF1bBqgstq59jMbYullApTI9BJxs8FhdGwSVFMneRWh3KcqhKFV9iHowyp/WVIbTVEOH7s85jwUcajOBwLY2lankGNSnALi2RwCCrVbPaVgMaQo1psBhDqh0r9JGtpQQ7UuXDYHqnL6swzGYEKm12FtPbeW6yCYXVFoNf/Ob37xm3BlsoKZZY1p0qFvbx+hQF6gEDtkTjJyFPAJGx8ZDwbpdHWwpZKyACdtyYC7V2FlosRWBYjj6RYBK89B2Nte61rVqdlZKjH0vraozW3QDs81H0Y0un9YHKpWO8SUApV0frK5XGoWJ9LBTiB1QsEZ8B2InN6s273EKXVs0qCy2rnvkxti6WUAlfWbfpgTL2aASg2JVd1/aOkRhvy2rtJugEqOnHgTdP3QeBg34sjiIcNraLKDSZPVvBRgH7IT0Y04DrBVUW/1tldQQqHQfWA+r0h3LcHQ1k4nB6Ho0jVbf8c1ju67Z9XnfufXP903w533X77qu43Or4NXiKkWwy38sAuv7zXb4LhdUYrzohp0MgBXGO21jdMjvusYg9Mr30frGLD0ujh/7PKYvcW59ir6mzz7vark61AUqnZfBxpCoJZJV4Og9ROwCWwAS+GRo2Td11NgjKSLn3Qq9DUe/CFAJJAM5pzvd6eoFOoKfttanQzF+6dh1ja9j6Ut6bNv1+j7L6UubXnfpaduxcX26IKvAbglEumpr+0AlxtPWfNhg2Tn7BNpaSM0+IsbOEPRRdqxpF6Ify3oOXVskqDR+xV8e2jukubZuFlCJqaTTU9ogqIz0N/ClxhENDxD2TfzvfOc7NROYMnLYQRv0YgYZQNHXUKGxCY1B7PpniFlApb6p7ZTWsWBHPYvJ39d8b/JjHf1eymMIVDLMQDQGRMSvz22NQQFWrShnpNoeHBymgOyNi360HadPjB2jN6XpC2Om/hOD2PYAkrE5KTsTjBtWO/2N+lpptC6dwfRIPSpHUBebbn8wpf+r8ptcUEn3Tn3qU9f1wVbYNlnKXB2K+7blCcDTphtYlbRORnrDWDaPVddppe+sY6HshRxSfYjX9ERtcnq/5pgFCWxNHOdZhoN+daVicnWoD1TSTzbJLhWOC7bIs375DvABHn0mABKc+s4Ydel3jMsinsPRLwJU2v6MrpzwhCesnvjEJ9aBdNs9SAMD4U0dSt+rqSc7dtNYsS3p9/HaglBOc2qLvqS603xtfhjftCmBuspVrrKLzvkd/dXvtsYPYg7VVdoJAMPY1ugHXW/bUkg2DqjkF1zHhufBUPKj9AuBwZZvNUscurZIUJlr64q/HPaXU0ElbKE80DyZ0gZBpSJNhsWqyOMf//g1OBJFmUxABYVvso4Mh9+lUR5wyHlZVOM8nJ4FQGhWKWWTx++ajfI065vimFlAJQdgsjNiJgmDoralr/keOFbTYoKrwxoClRyR6NM2QvbP5IjamuMMovpCIMxeePbf9MBg+TssZQXBhnD2GGEryR1zxCMesTaI17zmNev6nKGVhG19iM/I20p9+5ECwza7xTJ7YKyl8fWFEU0NnXsTXVuoZXWsonL7LdqaoC+tDXCaALZ5Qrm3baUTfdtOz0Og0vzgROxZasU3HeHc6ELacnUofsNJYdLotH9UoBt0RPAErFnYEnPKHLarA4bUcVgp+mcvWKle82+WJkiwyb09XOmE+U+P7Ber7pq+pFt6YW7sd6t8BpgBth3nfuhFGsSk/crVoT5QmZ5vu7wOR58LKo07UMd+m+NSr8otbM8GzAmUY07TDSlX42BMunQBuysINddtA8dG0DfjbMyNvcCavgsK1A2yhQJ6+iCYFOwIqOhKbilS2xhZ4CkDxdfQfQvf9GPPPfesddw/KtHJ5sbhmEABDr1EfOizsijHdoFKclIWwUaaM45ta32g0m/M1/Qfevgmdt75w963nXfZn4WujQGVbBc/Qd8AFffqnsmb3glcZAii5do6xxV/2e8vp4JKpTz20sZWTmmDoJJi24vLZJS6NknVWIo01RYBmKI5CsJw2CambSIE+gU4rLp2Hg7MeTAijAmHyrjZLgFYHYr+ZwGVhEUxgUSAba+99qoBTZ8QMYOO58DIJQdUijCtEjzVqU5Vb66cOtD0Ws7H2DLkZIC5I2+A0kPtDnAabIiJiO0lO9suxep8dU9WDqfOIb1OzmvjByCqGcVQWETDMHtgrO0jqiaVk0kDB/LUfwHDGc5whhog6yMnlhqOZh8EJVLAgBXDTt/GNEabocIik9HYhzFt+43P3U/KpI3p1xCoJBN7gGEFyZZzwlzQhbTl6lD8BnAyPgy3Db3t9QowcvCctxW8wfiZZ/YiE8SYB1hTQEOgZ9y6QFxca+gZ62I8/b895odzd6/0A1CUhUjv1/U4Gulm/QEuzQe6SL9SfUuvnatDmwgqyYx8ACABhRpmDofjYLetXgYwAXz23Nynm1Lf7ArQZ5y6dIFtNz7munkkcBHAGGcAEzB1bbYLQOMjXF8QZSW9QJqu2oWDQzOfpzZBmr7qC1BI9/WDv7EVFEeJwAj9j+tgp5EndJTeAUHmAP0NmxvHxjO5sg0AJaZVIN/W+kAl3wlojV1h23adRX82FlQ63uJLY802s/HGmb4pI7MbCv8CUMe8zrV1xV8O+8upoJL9N4/p/5Q2CCqd1IBTfPVDokvOH9ARZR7pSEeqgYa/oQIyKQtwxAGkzcTkLGz6beKKfk30YC5MfOcF7jgSE5RDZ7BSp5Oec1ZQ6bycuNQalsz9UepQ8LiW9z63pYPaS4bRb3NAJaODDQXEMbNdhjmu5dm5gQIpJf0iG0wSRslEdX2AjoMQUe+99941yzBrqjLtQ7yWcpRKFwgYK+PelerRbykbaR7MCeXsMshxfs9ALENjmxbMq3Ef05QxAHCYCUyDB3mnj67PHdN2fHzO0fat7Ozr5xCoFGCoW5EFCEDdFpBN0SH9AgysFqTX5hv2CHusrpdjp4t0mF66X2yT8VtEi3+sEZTQZ2yHFa/ATqojXptr+gScHHTQQbsBgLb+5erQpoHKkCf2zzw2Nz0Db2HnsJfS0xaDYIY5fjrHvrDVAg5yi+Pb5O8z15Jt4szYJLaC3fBa0Mdm0Uk6JjD1uSzG1PnV1Q+f64f7wJwKqNguQbp+tNlJMqBrsjDsbNsxzeu5X/fDXwGs5k9b6wOVAL5+boc2BlTSFVlIPsx2cUB7ML4AvSDDGg1yw5CHX5xi64q/bPeXU0FlBAHGbErLApVObAJx3oCVCBPjkAJCrz2wIRbXdAEDCoUpkV4DIAFLTqb5AFaBhL7/OJ0VVLovzogREY2rjRGdN9Pw3vsc0A30ngsqw6BgaEVr5JjTnB8gANaD3SEvqR3GWe0Q0GLLJYxaE8TnXCPnGJNdtAl0MM7GiTNoq7eQUlJzC8AASxxRTiMTTs/fbGKvsQxjGrZNZIXdsv3UPB/kbLeCKW0IVGJVpKiVFzCujGxbm6pDzmX8sEhYUPOTk6dHSjgEedh3zAwG0/jl6mdbP/s+Ax6lJoEWYIMeceDNVdPmozQ3vWdHsFc5LVeHNg1UcuQWGLFt0rpKGprbVckwyRAYE7oo6KDznAu9pKOCkNzGFsUiyLDr6snpHPmbp0qgMJht+7HmXqfvOPoAKNKhCGRkdLCXAE2zkYH0O53UJ2Axp7kOYGwOCbbbWszftppKdouN2Q4tF1SSCT9v8aXyMP+Xnjakk8VI/JqHGmpjpYWsir9MJbbr61xbNxVUmrvGDAaZ0rJBpZMbeMYGexW0tjStOj5AE0AEPAAQK9YwMc3o1nufMy7YOAyV9JsoT20ZZ4Kd4wCdT4GzWozmefRnHqDSAAFCF73oRWs20P1gStLmvfpCEWXU4uSCSqlyC5SAP9fJbfrFOKvjlPrmiE1AoIsR018GEIBi8Nvkk3utvuP0A5vl/oM1ldpSP8UARPTpOKBB/Zt0rrHJNcyuz5D7naBkqLa12V/AiQyMDXnP8wHAT51cfaBSn6XpsEACKHIzF9raVB1yLuMC0Ek/0xdOnnPl4DAsmGHzThA4Zrza+tn3Gf00PoLJSEkCmHQ5nW/SjcpgfCcIGwNmcnRolUClNDPbp7wEwAL+Yz71yTL9Lhx9W02lsRfAA4wCPXNW/WMz9UsPpaDZFsdgDh0jyMHu0RMBUG4z1uroLDwUxNA5WQjg1PgrfcCeY0cXFQzrq37wHRhvfeCb3I8UeJpuJicZCfsxs3P65LPcpnSL7ADnthZAqQ1U0m82ZhnNtWSP9INOsDdtmZGuvoSuDdVUsm1AOnuDgDCfU3mag/QecEToAPnhv6baOucv/nLXkZsKKo0Bxjgds13P3P9uFKiMU7mYSYnpUC+lLsxEVY8FXErlAQhtrF+cwzNnbUKhWQEXbJX6KYtAMCciawBGqoTha7Z5gErndG2F4+p/TAIGMRysZ5E9o4+lNGG0XFAZExGotLBmTDPROFy1Pmp2AG2GkQFzPkZb3xfdjBFZqwt1ff2IbZgiwuR0ABcAekoaFaihM5zQLKs/Fy2LMefvA5UcjWgw/maUjnctUJpFh6K/DLmUMt0xfnQdW8QRCpaaaej43TyfXcP8pssBbs03bGVkB+yLCCBxfOzKGKeXo0OrBCrVmGEQBYwyJerL9G9MC91oA5UYfDWSQLyxpm/0rtksjgI2pSvZ4NAFQMvvBB2czJhmPJ1L6Y9A0Xg7l/IL7BV2LifFPOaabceaU4BLZHvIGoCmZxr9Au6xauarMq+xTfaO3fP7ttYHKtuOX9RngJ55hawxFgHocq8XujYEKvlMAQNCiH1TonXIIYfUskU8yMApO1OKoG47XWcQ1yj+sn9UcmzdVFDZf+XhbwdBJWBj8geY6jqlyangFq1NIdQAYisZLA34yInInAcbCqSaAFIXInmApdnmBSpNAqlthsFkA/6CkfQsuhO1mwzRlgEq41pAbmw7oy7Og4xN1HDGcewinumA6IXRjJXgmA8Ow+e+Zyz8r7p0mfR1aihy+pQzSXLOs0rH9IFKbBAgKWhieKWhI5Bp3sMshjbOZYw4FQ41Sk7okXSgzMMyGhYOE4mlAjSAW/eufMM90hmpMEwWANwFsrv6mqNDqwQq2RRBVMxp80eJ0ZgWutEGKjFRGHDj7d/MBKBDdjy99iyg0nn4DRktWRV67j7ZV8wnQmJMwJD2a8xr12AngVnA1kNAzJ+w4fySRUoCWgsqLeIZ27YLqATkA1wbCwsqbSmW20LXhkAlmfOVAlbjLoAVPMWuEtKrAhg20BikLa4xBVTGeYq/3CGJlQWV0iAUL0BWDFzXsyJsYBL4AAYttNEMdNQjdv02/dxkB+4Yw1g5nX7v9bxApXPZMkO0KjWotgYDi5HlcBkbtV0BkB2/TFAJEAC2sX0Rg8AZ27cy+tmUzbzfh/E1HqJ9KVupWwwHlhIwkGayS4DIfCx1ngMI5n1Piz5fF6g0nlg46R9G3jxhZLvaPAytcwdTKFAzhvSIw1e3PDbl19XXnM/V28pocPCyGoITbKX0r9XqVgSzFWNTozk6tEqgUu2iRWLkwO5g+McuWgndaAOVAXakfKfsOTorqGQDMJwYMSVR7lP2CWBgz8aUNuToVdcxAl6ZKFmWkLXFSoAtNpfsLNa0MGls+YFrhpxXnankw9hscjAObDX7ndtC14ZAZZwPUUOu1kbQQXbHdc15NagIKDrAHkaLa8wCKou/3CHNlQWVBl20K5WR0xgS9RLSbCLCAKMUzOrC3GZyUzDRFIPEMDXbPEElMMyImnCu59z64L4Zi2Dkog/LBJXAgO0XOKCoUQpgaQWtyHAsiIv7yH02UTEPWAaGgXFWYwlw25bECj/pDszEFPY0BxDk9nVVjusClQI1W5YAdtg6Y6i+uKvNw9A6NxZGDa7r0iPX9gAsgdwuprSrX1M/l3rk0OL6WEuZCSBLXZvFFWPTrfqSo0OrBCqV9AA3EVhYUNNkboZkHLrRBip9Zp5i6djksSB9VlDJLkktYwHTQIaNtVhMvWcKKIbuder37KegDWNG98lEgE7fpKJc9WIAABL6SURBVGCVHgCGYwF99Ge7gEoZQAssET5AG4Z2DHMdupYLKo2t8Wfr6HmsveA3jAOyyJxFWESLa8wCKou/3CHNlQWVQCFwmC77DwXoela7w5DYziFqeKz4Q4djtXIMCZDEwGINpcOAl2abJ6jk6NWAApQiKWyKuhATIlZcp9fPBZXuHyNFhhihMeDPsQAa5VD0jNGSJsXyAHaMs9f6ikUdc+70XnJfcxKKrq3SZpixlYIH4EmpgrpTNaA549u8JmaKvgSgb37f956OAraYBuz2PB8Wf0xlVLpApdWPWKkAVQw9Rp8Oqi9WRpICgFl0KORGRgITi744VIygeSU4kZIEQBTMTwkI4hq5z5zIgQceWI81PeJgBI8WDWG7ZUbIYmzL0aFVApVkbbyBbIBGnfrYORxOuA1U0j/yZTc47zEAguxtd4PZcp6xc4B9FCjZhNycllVhy5XN6BMgbVFQBO9jx3rM8eyRGj6lHhhh16fzgmALViwOHar/77qe8QKYAHfnb2vmr2uxkfzJVjXjz87ICpjrxnSMvoWudYFKcqbDglckjCDVQ4CIEWbXsMZsj/I4i7f4M4xxtFlsnXsp/jIkWdW4QWaRX15G/XJcebCmknKgry2eEXXkNNskAJXYiGAcADNgRNojx3FRUIIARDlCTGezzRNUOjfDw9AxPKIqys/5YRCaLE4uqASiGWUyNIEAs9wGWACiNiDWH5ElRtUqcvIFLPXVYgcRd8i6eX61aVZBMuyYKgaleT/N33S9V/MllQbQAkUYL47CJvY28p3SMMLqfeyBCliOKZNwPSUKVpUC3oy3B51JH2M/91u/sXddcwuW3HvsApX0FuMLlIvW3Tt9YowBTHWFDHi0WXSIoXVuTJWCeYsuOFA6sP/++9d7ZBpLbI2FX+61y9HoByZagOefjwRdOXM57iN9dh794eA9OCqOhpPnWMamIXN1aJVAZSqPqa/D0feBSnOTUx+SKT1hc9W9Gle2RzDMMQG/Y4JF9btWUmOcrPCXZlVr7X/UMYZshwVENsCni22NjZIp4juwgdhsNrFLP9vOEZ/RKWSHNKxr03n1fhhTTrerD/H7tmf9ANT4OSUb/EVbWxVQ2da3MZ+FrnWBSiVu/LTgwZ7VSrOajY75gw72D2NqhwcYI9ostq74y5DijueVZSopkkgTsOHshhZgiISsOMQ6UJigtqVSOC4TkLKhqPsapoLzFd2Jdv3LTrPNG1RSbsDNpMHAYU3s6wasNQ2qyaHwPeocAYi2hkFUYyp1bbFNykC1HR+fWdTECOuDB1CAbdIPYwAcRn0jZhVYUBeabs8S57KiEeDCCHHclI1zndKcH+Nly5cABK7PMKuJm9KMNd0CkgURY88j2CEPdVP6Mc8HR8bJTmldoFJQoKZIQKCO1/1yUByvbVcwrqmhnapD+gwcAH/mr0J5LC5H6HrYK3vrYQwAXKy3wAAAaWsYDuDFOJkjtt+a4oydG3i1GMe5OHm6BIDQrSHw09a3XB3aJFAp0ALggEpsUJ9c6Yl0PN2kh+Y5AoDtYbfZOjYvpwl82U0BonpZK3zZe2PEjtN5gM64A60IC6C12T96bzGbYFP6XGA9Zg/JtK8AKjbY/cTWaHSeHWN7ovY//c3Qa7aYnVYeRncxu21tU0ClEgN+RjmLce0qmVNqQzfZm2b6e6qtK/5yd81beVDJiZjgFEU026zjM8EAJtuTYLJEKgx4MHNAJVbLCmuTDyvIcDFUaeTpNQPHiAFjthaScm2CWdeTJrNghXEC7vr+mYDBQvcDHNjHNnDH8DCsHL70DNBmm4+2pt8YMptKc4jSd8178TvpANfzrynqQtW1tDX3Y0IBsACFeiMAnFMQ3TeBFvkBUbGqkgzUrCrGdg5j5H6cF0Nqokt1itBFiTYintqAFIxugAH3BoyMTa/F9fUXu+1eMBfpKvs4Zjs+d4FKAUI4yljlTE8YZaUSgi4OOFquDqXHhx5JrXLGUt2CmhQwGi//EIXpphse9NlnnCwdMhfpkGa+BcskQOFA2nZliH70Pbu2IAjDw7l7CB77akv7zperQ5sEKtUMyg5Jf7MLqU6FLNlFdpgtY2fpimM5aRkazDHb37dwio6QP5aJfgkMXNeKX/+wlhIIbDA9j/1ZI5iwQhuwdB62md8QREsr0w22hp3BWjZ9QdzL0LN5ZHs253FdwdQ+++xTB41NQDt0Lt/royyQOmBg1b22tU0BlUgk24X5Fyblbs2V9Hy7sWPryV0tOTuT+v9cW1f85bC/XHlQKeqUrgIYORITJSJXSoGRxKxZ7cUQYRFTZYmib5NPpAow2rMOgArgGRMVYAJgsYVde7cxVH4fTo4yY3jCAaaT22ccpHOpnwGIGMw2Q8KohSHFmjGwbQ1gA66kSBkoTJB7aZ6TIScX8tt33307V9u5HylqE85mupw7YIsllvohk7SFc2R0AxCI5l0DwAMMsEEMPrANdAMCWAdjMEttD4eD0WDs3Xu671vax9zXGAT3LB0iRTWFNci91jKP6wKV0j++U9cV2+lIF3KY2D/BRdpydSh+A/zRIylqwM+WMgw9Nre5GIF+0/fQITpiDgMGWE0ANwIwjFMs1DJWwGjXvwBFX/qe1VhJwWOOpCXNz9QW9P22+V2uDsW8wa6bK8151Tzvqr+PlGRb+puNNq8Ad9sVsW2pTQ67COTRO2NhvNk2zfhgHIGvZpoylQsGm74Jlvbbb786G0I/MONsdAoqgQrEBFDhGHrHzgGZgl/zgb1kA1LWSsCJ2UJWsOVTGtss64CooOdIA3Yysmljz2le+qMG88DfEXZtB7UpoNK4WdEtBU7Xmr7Y3Fb2InhEmACdzfmea+uKvxz2lysLKk1u9XvSwqJZ6QegUnEyMBEpR2ATE8e4YEcAj7SpTQMm0d0cAGcG/DgPAIll82A0pOQsZABMGYEwciJqTBbqnEMQDTMODJNUovcUVp84RVGkvdr0jRNnuDgT7CaQxwC6TsqMUVaAS3RvgqRRsYkC+GE7nZNcGFzASjQPdFu56vv4dxSGjFGxNx9nDYy1NXJWxwdIY7EYUedlcAFH8k+bCUwG7icFBICK+k0gW9obM6DfCqQBNoCGo+ljddPrtL12T9JYZATIitADeLQdP/QZ1hTQ5zSaLN3Qb1f5+y5QSR+kFt0zQAfsAYCepZMjWIt7y9WhON5KfHokIAk9Mj+k6aT60sYBCDRChzwL1KQFpbDM52DXjTEm33iryzTHupj89Bpdr7ESAjNzZ1b2PFeHNglU0iMZH8BJHSxbd/DBB9djipU0frIo7Dl7LEXO/gXwND5sIV0ASpsBSYyrc9I3WSi2VUZKRsS4KufAYEbDRjqebjqGvoWdU1/sPDIzwD7AwYbTNfNFP/mYZtAV5x56dl8Ycow95t78ZB+b4GfoPPE93yAQZGv5ii6wuymg0rgA1nwcf0/H2I9U1/gxPshiRX49dC1kmmvrir8c9pcrCyoxXVbWSmuYfKI6hsriAsAEcBHpMj4YEtGH3zQbQAoIiUQoEgUEIChYnEdUq4bNohPANDVwzue8DIxjgDvRs+g4HhSWw9MnRhKYUjzMkWJdKLeUkAdl12fXZ1iiUWpAFihsppzdu6g87tf1LaxwPgDZZHJO37uu5l4Z96gzxQi0TSbnZjTjXtJn18ESpY2cySI9Ln3tN8aJDDXXNBEBBI5k6F9rjLXfejRBDsNMbuqIMA7GampzbrIDUAEsBniqkZ/ah0X9rgtUcpZSe2qL6BnW3Gu61aYbuToU94ENSHUhXtNLoDBtxo4OxzHps5SkOQBcRDM/zCusvH+Eoft9zVia8/TbWKdOhD6arxZsADhpar7vnM3vxujQJoFKcjJXjZU6ScAbSyiw957eec9WtQE1Y+04wbAgXADQZJZcQ8lCqjfxml6xh2GDHAuI0Tm6Fcc1n5VFmB8afUFQeO/6SAjkQleLuUJn6V1qS3xHD5EOGPxZWHbnZUsFatLfgHubbPRzU0Al+ZI7wKhcgu6ErvHHbJygWZDh2LYW41f8ZZt0duyPnesvVxZUtt9a+XSsBIA4TC0QppC9ywCNPe+Y4zlfk5qxN8m7GkfEUSgnsAKUMWeMwxAAtFJVmIVI33ada+hzAB6LgmUGql1nXVoXqJx6f6ugQ9F3i6MAQsCyrwGxwKyAD1jAdtIjThkbJSuhhMR3APWUNkaHNg1UTpFn+htz3UIa2ROBaso6psct+jVgjMgQfKRBTvO6AhMpaQQC3aSn7JlGvwAdC5ekX9sWfzbP1/WeHgNOskIydspXutqmgMqu+5/y+SrYuu3uLwuonKJ52+g32FDpJxEy1nSWdPGU2+bIXZOhxfRiMbuaNI4UKkciFSp1rz4TEGaYMcEK+q3wZ7SnAmR94gCsELV6XeSPHVmXNm9QudU6FOMCEAKBdAkT0dewQf66kx5hvNTpMdbYJyyWkgfzQqA1pY3VoQIqx0lZdgiDbpxkWQSbZL7M5nr6gA2UIcFAdjUBjKyH1Dr7JVA1b9gVwNQ2R8qWlG2kDGrX+do+158IrJVUmQfNcq/0dwVUptLIe73Vts4Yb3d/WUBlnq5t26MoqXQ1AGVRDwCVpmYWfWOMqmuqI5X26mOFGF8spBWXHlZxKlHgYNRVqa9S/4nFnAqOyQODYO9M7K00qs/Wqc0bVG61DhkbfaAHakCVeww5ZsGHumd6pHYT641pim1FlFBgLPuAQpdOTNGhAiq7pNn9udS4tLPFfhhAQcEyG1sla2LREN3ps5tqHOmbOk06Z49MpVcCZfbXvpQWifYxi0P3xpYq5VISoIZeGVef7Sqgckiiu3+/1bZuHfxlAZW769XafQLUqYewAMKimagbWsaNKpDHkLq+4vc+I6jWzQpxizw81A1hFNXWWgiFbbVgirE0+aY0IEKNl62YbBqMCV23Nm9QST5bqUOuD0SqfVaTzDH3OXjHW4Rn8YYtrThhddfqoemRWjSGj8MfOk+bbkzRoQIq2yTZ/xkQCfjLJgylevvPNO1bgYjUOxs0ZG+AXnvxApZ2FPBvY8CktDmG0q4aao77UuhDvbSw06I6Oypg7PtqPJ2rgMohibZ/v5W2bh38ZQGV7Xq1Vp8yzqJmKwXVkmEMpzJ9YwSDaXAtUbzrD9Ut+l6qiROR3vGQAsdy6reFPrOkwTAP0qBWedrGxCr/PuZ0zL2u0rGLAJVbpUPkClBa1CGlzdF3rXZNx4ADt6ODbW04e8wlPcJQq+2dWl88VYcKqExHJ++1ABQ7LRiQPrbXo/TklEAg74o7jgIg1Uiq2xbIyKAMNYuAbMEmu2InDCDSP7zYMcTKceeZJZgHIKW7ZWvstywAHwK6BVQOjVr791tl69bFXxZQ2a5Xa/cpx2yxjBQMcKZWaGpNYq5wrNYFAsf8RaaJpVhavRtWCTDwWtQvipvaGGD1SJgudZs5kf7Ua23174BK243ERsDum2McAvVD/d4KHdIn/QYq1eRaHJPTOGEA1Cbv9MhWXIIbLDWHPKWN0SGyIvd4WFyBGV+3fSrVqwoE3SfgDMjMO1AzXkoeZCnogDrCRQJLdlFWRWAiGM5pxtviMIylAJjOCV69Z2tj0U7OudJjAGsgRwAsDd/1L0DxG/IPnbPNjj81UD6gjni7ttgTVeYBMRL35xlQJ/t5t62wddvVXzZtnTGyL7ctDnMIgHmN3eB/f8/rQuU8OyXA2GMOrXrG1uQ66J1n2L6vrB61ZRS2Sjod47GuDahUm4rllX7zwHLYcmPWVnQoT4csJAvZe8Zi2U923UClhTSCNPdoj0AB5CyMXJd+kqdUNOZPoLqMTEtXX5b5OYAruyKwllJvbjfX7Isa9NA7IJQdsLBxHUClUhab7cf9ebZAaupiu6bsmu+LrZtm64xR/Ld9AZVNrVrD94yUOkIRNCewKQ2QZGTVaEmp9dV2bneZAJUWC/jnIf9q4yEdJwU3j1Z0aFiHbEMTsvfszwSsDF43UEnPbDruHv0hAd3DzM27YSYxOYJi9bLN/XPnfb1VOR/GHeMJPCEBhlLeNvMPvaNzxsfixnUAlRZBmUNxf54FajJbi2rF1o23dcbIHsCFqVyUVq7geS00kFKYJZ28grfV2yXMpPQcqn6dASUhSMNZ5Zw+OOGpad82wRYd6t8xAABK5R+vpcHtZLDdmTbpXP+WFffl2YbmSmxmWYzSpmvxGUBlE3MLVhZ1jbjWqjwHUynTkpNCX8bcX7Zs2nQt9E55wqL3MC22bryts+WbeUp/l9VK+ntZki7XKRIoEigSKBIoEigSKBJYYwkUULnGg1turUigSKBIoEigSKBIoEhgWRIooHJZki7XKRIoEigSKBIoEigSKBJYYwkUULnGg1turUigSKBIoEigSKBIoEhgWRIooHJZki7XKRIoEigSKBIoEigSKBJYYwkUULnGg1turUigSKBIoEigSKBIoEhgWRIooHJZki7XKRIoEigSKBIoEigSKBJYYwn8HzQlhlqL/xuGAAAAAElFTkSuQmCC)  \n",
        "\n",
        "\n",
        "where α > 0, β > 0, γ > 0 denote the relative importance of each of the metrics. To simplify the expression, if we assume, α = β = γ = 1 and C3 = C2/2, we can get,  \n",
        "\n",
        "![image.png](data:image/png;base64,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)\n"
      ],
      "metadata": {
        "id": "292BEDm4HewF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def returnSSIMofImage(img1, img2, crop_border, input_order='HWC', test_y_channel=False):\n",
        "    \"\"\"Calculate SSIM (structural similarity).\n",
        "    Ref:\n",
        "    Image quality assessment: From error visibility to structural similarity\n",
        "    The results are the same as that of the official released MATLAB code in\n",
        "    https://ece.uwaterloo.ca/~z70wang/research/ssim/.\n",
        "    For three-channel images, SSIM is calculated for each channel and then\n",
        "    averaged.\n",
        "    Args:\n",
        "        img1 (ndarray): Images with range [0, 255].\n",
        "        img2 (ndarray): Images with range [0, 255].\n",
        "        crop_border (int): Cropped pixels in each edge of an image. These\n",
        "            pixels are not involved in the SSIM calculation.\n",
        "        input_order (str): Whether the input order is 'HWC' or 'CHW'.\n",
        "            Default: 'HWC'.\n",
        "        test_y_channel (bool): Test on Y channel of YCbCr. Default: False.\n",
        "    Returns:\n",
        "        float: ssim result.\n",
        "    \"\"\"\n",
        "\n",
        "    assert img1.shape == img2.shape, (f'Image shapes are differnet: {img1.shape}, {img2.shape}.')\n",
        "    if input_order not in ['HWC', 'CHW']:\n",
        "        raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' '\"HWC\" and \"CHW\"')\n",
        "    img1 = changeChannelOrder(img1, input_order=input_order)\n",
        "    img2 = changeChannelOrder(img2, input_order=input_order)\n",
        "    img1 = img1.astype(np.float64)\n",
        "    img2 = img2.astype(np.float64)\n",
        "\n",
        "    if crop_border != 0:\n",
        "        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]\n",
        "        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]\n",
        "\n",
        "    if test_y_channel:\n",
        "        img1 = toYchannel(img1)\n",
        "        img2 = toYchannel(img2)\n",
        "\n",
        "    ssims = []\n",
        "    for i in range(img1.shape[2]):\n",
        "        ssims.append(calSSIMOfImage(img1[..., i], img2[..., i]))\n",
        "    return np.array(ssims).mean()\n"
      ],
      "metadata": {
        "id": "K4komj4e70Q4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ],
      "metadata": {
        "id": "rY4lsUHL7282"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def setup(args):\n",
        "    save_dir = f'/content/drive/MyDrive/SwinIr/set5test_results/swinir_{args.task}_x{args.scale}'\n",
        "    folder = args.folder_gt\n",
        "    border = args.scale\n",
        "    window_size = 6\n",
        "    return folder, save_dir, border, window_size"
      ],
      "metadata": {
        "id": "RhvL3yru74Mj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def getValImagePair(args, path):\n",
        "    (imgname, imgext) = os.path.splitext(os.path.basename(path))\n",
        "    img_gt = cv2.imread(path, cv2.IMREAD_COLOR).astype(np.float32) / 255.\n",
        "    img_lq = cv2.imread(f'{args.folder_lq}/{imgname}x{args.scale}{imgext}', cv2.IMREAD_COLOR).astype(\n",
        "        np.float32) / 255.\n",
        "    return imgname, img_lq, img_gt\n"
      ],
      "metadata": {
        "id": "0EljnFKQ74QR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This function calculates the absolute Peak signal to noise ratio .  \n",
        "Taking the root mean square of the pixel differences between the two images. \n",
        "The mathematical representation of the PSNR is as follows:\n",
        "![image.png](data:image/png;base64,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)  \n",
        "Where the mean square error is: \n",
        "![image.png](data:image/png;base64,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)  \n",
        "The proposal is that the higher the PSNR, the better degraded image has been reconstructed to match the original image and the better the reconstructive algorithm.  This would occur because we wish to minimize the MSE between images with respect the maximum signal value of the image.\n",
        "\n"
      ],
      "metadata": {
        "id": "4eBMnCh0HGrn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def validateSet(args, model):\n",
        "    # setup folder and path\n",
        "    folder, save_dir, border, window_size = setup(args)\n",
        "    os.makedirs(save_dir, exist_ok=True)\n",
        "    test_results = OrderedDict()\n",
        "    test_results['psnr'] = []\n",
        "    test_results['ssim'] = []\n",
        "    test_results['psnr_y'] = []\n",
        "    test_results['ssim_y'] = []\n",
        "\n",
        "    psnr, ssim, psnr_y, ssim_y = 0, 0, 0, 0\n",
        "    for idx, path in enumerate(sorted(glob.glob(os.path.join(folder, '*')))):\n",
        "        # read image\n",
        "        imgname, img_lq, img_gt = getValImagePair(args, path)  # image to HWC-BGR, float32\n",
        "        img_lq = np.transpose(img_lq if img_lq.shape[2] == 1 else img_lq[:, :, [2, 1, 0]],\n",
        "                              (2, 0, 1))  # HCW-BGR to CHW-RGB\n",
        "        img_lq = torch.from_numpy(img_lq).float().unsqueeze(0).to(device)  # CHW-RGB to NCHW-RGB\n",
        "\n",
        "        # inference\n",
        "        with torch.no_grad():\n",
        "            # pad input image to be a multiple of window_size\n",
        "            _, _, h_old, w_old = img_lq.size()\n",
        "            h_pad = (h_old // window_size + 1) * window_size - h_old\n",
        "            w_pad = (w_old // window_size + 1) * window_size - w_old\n",
        "            img_lq = torch.cat([img_lq, torch.flip(img_lq, [2])], 2)[:, :, :h_old + h_pad, :]\n",
        "            img_lq = torch.cat([img_lq, torch.flip(img_lq, [3])], 3)[:, :, :, :w_old + w_pad]\n",
        "\n",
        "            test_data = {'L': img_lq, 'H': img_gt}\n",
        "            model.loadDataToModel(test_data, need_H=False)\n",
        "            model.test()\n",
        "            output = model.E\n",
        "            output = output[..., :h_old * args.scale, :w_old * args.scale]\n",
        "\n",
        "        # save image\n",
        "        output = output.data.squeeze().float().cpu().clamp_(0, 1).numpy()\n",
        "        if output.ndim == 3:\n",
        "            output = np.transpose(output[[2, 1, 0], :, :], (1, 2, 0))  # CHW-RGB to HCW-BGR\n",
        "        output = (output * 255.0).round().astype(np.uint8)  # float32 to uint8\n",
        "        cv2.imwrite(f'{save_dir}/{imgname}_SwinIR.png', output)\n",
        "        # set5 validation image\n",
        "\n",
        "        # evaluate psnr/ssim/psnr_b\n",
        "        if img_gt is not None:\n",
        "            img_gt = (img_gt * 255.0).round().astype(np.uint8)  # float32 to uint8\n",
        "            img_gt = img_gt[:h_old * args.scale, :w_old * args.scale, ...]  # crop gt\n",
        "            img_gt = np.squeeze(img_gt)\n",
        "\n",
        "            psnr = calPsnrofImage(output, img_gt, crop_border=border)\n",
        "            ssim = returnSSIMofImage(output, img_gt, crop_border=border)\n",
        "            test_results['psnr'].append(psnr)\n",
        "            test_results['ssim'].append(ssim)\n",
        "            if img_gt.ndim == 3:  # RGB image\n",
        "                psnr_y = calPsnrofImage(output, img_gt, crop_border=border, test_y_channel=True)\n",
        "                ssim_y = returnSSIMofImage(output, img_gt, crop_border=border, test_y_channel=True)\n",
        "                test_results['psnr_y'].append(psnr_y)\n",
        "                test_results['ssim_y'].append(ssim_y)\n",
        "\n",
        "            print('Testing {:d} {:20s} - PSNR: {:.2f} dB; SSIM: {:.4f}; '\n",
        "                  'PSNR_Y: {:.2f} dB; SSIM_Y: {:.4f};'.\n",
        "                  format(idx, imgname, psnr, ssim, psnr_y, ssim_y))\n",
        "        else:\n",
        "            print('Testing {:d} {:20s}'.format(idx, imgname))\n",
        "\n",
        "    # summarize psnr/ssim\n",
        "    if img_gt is not None:\n",
        "        ave_psnr = sum(test_results['psnr']) / len(test_results['psnr'])\n",
        "        ave_ssim = sum(test_results['ssim']) / len(test_results['ssim'])\n",
        "        print(\n",
        "            '\\n{} \\n-- Average PSNR/SSIM(RGB): {:.2f} dB; {:.4f}'.format(save_dir, ave_psnr, ave_ssim))\n",
        "        if img_gt.ndim == 3:\n",
        "            ave_psnr_y = sum(test_results['psnr_y']) / len(test_results['psnr_y'])\n",
        "            ave_ssim_y = sum(test_results['ssim_y']) / len(test_results['ssim_y'])\n",
        "            print('-- Average PSNR_Y/SSIM_Y: {:.2f} dB; {:.4f}'.format(ave_psnr_y, ave_ssim_y))\n",
        "\n",
        "    return ave_psnr_y"
      ],
      "metadata": {
        "id": "5gdZ0fMb74TJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def main(args):\n",
        "    jsonDetails = loadTheJson(configLoader.parse_args().jsonDetails, is_train=True)\n",
        "    jsonDetails['workDist'] = configLoader.parse_args().workDist\n",
        "    if jsonDetails['workDist']:\n",
        "        decTheLauncher('pytorch')\n",
        "    jsonDetails['rank'], jsonDetails['world_size'] = getDistributionInfo()\n",
        "    if jsonDetails['rank'] == 0:\n",
        "        makeTheDir((path for key, path in jsonDetails['path'].items() if 'pretrained' not in key))\n",
        "    if jsonDetails['rank'] == 0:\n",
        "        wandb.login(key=\"4532554eb8a1bfe57ebff8dfb0b498c7086e461f\")\n",
        "        wandb.init(project=\"SwinIR\")\n",
        "\n",
        "    iterG, pathG = loadFromLastCheckpoint(jsonDetails['path']['models'], net_type='G')\n",
        "    iterE, pathE = loadFromLastCheckpoint(jsonDetails['path']['models'], net_type='E')\n",
        "    jsonDetails['path']['pretrained_netG'] = pathG\n",
        "    jsonDetails['path']['pretrained_netE'] = pathE\n",
        "\n",
        "    iterOptG, pathOptG = loadFromLastCheckpoint(jsonDetails['path']['models'],\n",
        "                                                net_type='optimizerG')\n",
        "    jsonDetails['path']['pretrained_optimizerG'] = pathOptG\n",
        "    current_step = max(iterG, iterE, iterOptG)\n",
        "\n",
        "    # Save the Json\n",
        "    if jsonDetails['rank'] == 0:\n",
        "        save(jsonDetails)\n",
        "\n",
        "    jsonDetails = DictToNoneDict(jsonDetails)\n",
        "    if jsonDetails['rank'] == 0:\n",
        "        logger_name = 'train'\n",
        "        loggerSetup(logger_name, os.path.join(jsonDetails['path']['log'], logger_name + '.log'))\n",
        "        logger = logging.getLogger(logger_name)\n",
        "        logger.info(dict2str(jsonDetails))\n",
        "    seed = jsonDetails['train']['manual_seed']\n",
        "    if seed is None:\n",
        "        seed = random.randint(1, 10000)\n",
        "    random.seed(seed)\n",
        "    np.random.seed(seed)\n",
        "    torch.manual_seed(seed)\n",
        "    torch.cuda.manual_seed_all(seed)\n",
        "    for phase, data_item in jsonDetails['datasets'].items():\n",
        "        if phase == 'train':\n",
        "            train_path = loadDataPath(data_item)\n",
        "            train_size = int(math.ceil(len(train_path) / data_item['dataloader_batch_size']))\n",
        "            if jsonDetails['rank'] == 0:\n",
        "                logger.info('Number of train images: {:,d}, iters: {:,d}'.format(len(train_path), train_size))\n",
        "            if jsonDetails['workDist']:\n",
        "                train_sampler = DistributedSampler(train_path, shuffle=data_item['dataloader_shuffle'], drop_last=True,\n",
        "                                                   seed=seed)\n",
        "\n",
        "                train_loader = DataLoader(train_path,\n",
        "                                          batch_size=data_item['dataloader_batch_size'] // jsonDetails['num_gpu'],\n",
        "                                          shuffle=False,\n",
        "                                          num_workers=data_item['dataloader_num_workers'] // jsonDetails['num_gpu'],\n",
        "                                          drop_last=True,\n",
        "                                          pin_memory=True,\n",
        "                                          sampler=train_sampler)\n",
        "\n",
        "            else:\n",
        "                train_loader = DataLoader(train_path,\n",
        "                                          batch_size=data_item['dataloader_batch_size'],\n",
        "                                          shuffle=data_item['dataloader_shuffle'],\n",
        "                                          num_workers=data_item['dataloader_num_workers'],\n",
        "                                          drop_last=True,\n",
        "                                          pin_memory=True)\n",
        "\n",
        "        \n",
        "        elif phase == 'test':\n",
        "            test_path = loadDataPath(data_item)\n",
        "            test_loader = DataLoader(test_path, batch_size=1,\n",
        "                                     shuffle=False, num_workers=1,\n",
        "                                     drop_last=False, pin_memory=True)\n",
        "\n",
        "\n",
        "        else:\n",
        "            raise NotImplementedError(\"Phase [%s] is not recognized.\" % phase)\n",
        "\n",
        "    # define the model for training and testing\n",
        "    model = makeModel(jsonDetails)\n",
        "    model.initTrain()\n",
        "\n",
        "    psnr_y_record = 0\n",
        "\n",
        "    for epoch in range(50):  \n",
        "        L1_loss = 0\n",
        "        # print(len(train_loader))\n",
        "        for i, train_data in enumerate(train_loader):\n",
        "\n",
        "            current_step += 1\n",
        "\n",
        "            # update the learning rate\n",
        "            model.getTheLearningRate(current_step)\n",
        "\n",
        "            # Feed the pairs of Data\n",
        "            model.loadDataToModel(train_data)\n",
        "\n",
        "            # optimize the Parameters\n",
        "            model.ParamOptimization(current_step)\n",
        "\n",
        "            # Training information\n",
        "            logs = model.getCurrentLog()  \n",
        "\n",
        "            if current_step % jsonDetails['train']['checkpoint_print'] == 0 and jsonDetails['rank'] == 0:\n",
        "                message = '<epoch:{:3d}, iter:{:8,d}, lr:{:.3e}> '.format(epoch, current_step,model.CurrentLearningRate())\n",
        "                for k, v in logs.items():  \n",
        "                    message += '{:s}: {:.3e} '.format(k, v)\n",
        "                logger.info(message)\n",
        "                wandb.log({\"train_l1_loss\": logs['G_loss']})\n",
        "\n",
        "            # Testing\n",
        "            if current_step % jsonDetails['train']['checkpoint_test'] == 0 and jsonDetails['rank'] == 0:\n",
        "                print(\" ----set5 validation---\")\n",
        "                print(\"current_step: \", current_step)\n",
        "                psnr_y = validateSet(args, model)\n",
        "\n",
        "                wandb.log({\"val_loss\": psnr_y})\n",
        "\n",
        "                if (psnr_y > psnr_y_record):\n",
        "                    model.saveBetterModel(psnr_y, args, current_step)\n",
        "                psnr_y_record = psnr_y\n",
        "                message = \"---validation at \" + str(current_step) + \" iter, PSNR = \" + str(psnr_y_record) + \"---\"\n",
        "                logger.info(message)\n",
        "\n",
        "            # save the model\n",
        "            if current_step % jsonDetails['train']['checkpoint_save'] == 0 and jsonDetails['rank'] == 0:\n",
        "                logger.info('Saving the model.')\n",
        "                print(\"saving model\")\n",
        "                model.save(current_step)\n",
        "\n",
        "            if jsonDetails['rank'] == 0:\n",
        "                L1_loss += logs['G_loss']\n",
        "                print(current_step,i, len(train_loader), 'l1Loss: %.3f' % (L1_loss / (i + 1)))"
      ],
      "metadata": {
        "id": "2XPs9fxX8V5E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "if __name__ == '__main__':\n",
        "    # CONFIG_FILE = 'config.config_ipynb'\n",
        "    # if os.path.isfile(CONFIG_FILE):\n",
        "    #     with open(CONFIG_FILE) as f:\n",
        "    #         sys.argv = f.read().split()\n",
        "\n",
        "    configLoader = argparse.ArgumentParser()\n",
        "    configLoader.add_argument('-f')\n",
        "    configLoader.add_argument('--jsonDetails', type=str, default=\"/content/drive/MyDrive/SwinIr/classical_sr.json\")\n",
        "    configLoader.add_argument('--serverFrame', default='pytorch')\n",
        "    configLoader.add_argument('--local_rank', type=int, default=0)\n",
        "    configLoader.add_argument('--workDist', default=False)\n",
        "    \n",
        "    # Calling for the set5 Validation\n",
        "    configLoader.add_argument('--task', type=str, default='classical_sr')\n",
        "    configLoader.add_argument('--scale', type=int, default=4)\n",
        "    \n",
        "    # Give the path of test set \n",
        "    configLoader.add_argument('--folder_lq', type=str, default=\"/content/drive/MyDrive/SwinIr/testsets/set5/LR_bicubic/X4/\")\n",
        "    configLoader.add_argument('--folder_gt', type=str, default=\"/content/drive/MyDrive/SwinIr/testsets/set5/HR/\")\n",
        "    \n",
        "    # Save the improved model\n",
        "    configLoader.add_argument('--model_save_dir', type=str, default=\"/content/drive/MyDrive/SwinIr/models_improved/\")\n",
        "\n",
        "    args = configLoader.parse_args()\n",
        "    print(args)\n",
        "    main(args)\n"
      ],
      "metadata": {
        "id": "uoNi9mnaFZ-J",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "c9198151-6792-4d4b-f027-e06d56210044"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Namespace(f='/root/.local/share/jupyter/runtime/kernel-4714d2ee-2e0b-4a98-a091-dfdf9ba69c58.json', folder_gt='/content/drive/MyDrive/SwinIr/testsets/set5/HR/', folder_lq='/content/drive/MyDrive/SwinIr/testsets/set5/LR_bicubic/X4/', jsonDetails='/content/drive/MyDrive/SwinIr/classical_sr.json', local_rank=0, model_save_dir='/content/drive/MyDrive/SwinIr/models_improved/', scale=4, serverFrame='pytorch', task='classical_sr', workDist=False)\n",
            "export CUDA_VISIBLE_DEVICES=0\n",
            "number of GPUs is: 1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: W&B API key is configured (use `wandb login --relogin` 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[33mnoisy_labels\u001b[0m (use `wandb login --relogin` to force relogin)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "Tracking run with wandb version 0.12.15"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "Run data is saved locally in <code>/content/wandb/run-20220428_091703-cc6bj4b8</code>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "Syncing run <strong><a href=\"https://wandb.ai/noisy_labels/SwinIR/runs/cc6bj4b8\" target=\"_blank\">restful-violet-166</a></strong> to <a href=\"https://wandb.ai/noisy_labels/SwinIR\" target=\"_blank\">Weights & Biases</a> (<a href=\"https://wandb.me/run\" target=\"_blank\">docs</a>)<br/>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Setting up the new handler!\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "22-04-28 09:17:11.472 :   task: swinIr120_x4\n",
            "  model: plain\n",
            "  gpu_ids: [0]\n",
            "  workDist: False\n",
            "  scale: 4\n",
            "  n_channels: 3\n",
            "  path:[\n",
            "    root: /content/drive/MyDrive/SwinIr/superresolution\n",
            "    pretrained_netG: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4/models/1500_G.pth\n",
            "    pretrained_netE: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4/models/1500_E.pth\n",
            "    task: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4\n",
            "    log: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4\n",
            "    options: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4/options\n",
            "    models: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4/models\n",
            "    images: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4/images\n",
            "    pretrained_optimizerG: /content/drive/MyDrive/SwinIr/superresolution/swinIr120_x4/models/1500_optimizerG.pth\n",
            "  ]\n",
            "  datasets:[\n",
            "    train:[\n",
            "      name: train_dataset\n",
            "      dataset_type: sr\n",
            "      dataroot_H: /content/drive/MyDrive/SwinIr/DIV2K/DIV2K800_sub\n",
            "      dataroot_L: /content/drive/MyDrive/SwinIr/DIV2K/DIV2K800_sub_bicLRx4\n",
            "      H_size: 120\n",
            "      dataloader_shuffle: True\n",
            "      dataloader_num_workers: 1\n",
            "      dataloader_batch_size: 16\n",
            "      phase: train\n",
            "      scale: 4\n",
            "      n_channels: 3\n",
            "    ]\n",
            "    test:[\n",
            "      name: test_dataset\n",
            "      dataset_type: sr\n",
            "      dataroot_H: /content/drive/MyDrive/SwinIr/testsets/set5/HR/\n",
            "      dataroot_L: /content/drive/MyDrive/SwinIr/testsets/set5/LR_bicubic/X4/\n",
            "      phase: test\n",
            "      scale: 4\n",
            "      n_channels: 3\n",
            "    ]\n",
            "  ]\n",
            "  netG:[\n",
            "    net_type: swinir\n",
            "    upscale: 4\n",
            "    in_chans: 3\n",
            "    img_size: 30\n",
            "    window_size: 6\n",
            "    img_range: 1.0\n",
            "    depths: [6, 6, 6, 6, 6, 6]\n",
            "    embed_dim: 180\n",
            "    num_heads: [6, 6, 6, 6, 6, 6]\n",
            "    mlp_ratio: 2\n",
            "    upsampler: pixelshuffle\n",
            "    resi_connection: 1conv\n",
            "    init_type: default\n",
            "    scale: 4\n",
            "  ]\n",
            "  train:[\n",
            "    G_lossfn_type: l1\n",
            "    G_lossfn_weight: 1.0\n",
            "    E_decay: 0.999\n",
            "    G_optimizer_type: adam\n",
            "    G_optimizer_lr: 0.0001\n",
            "    G_optimizer_wd: 0\n",
            "    G_optimizer_clipgrad: None\n",
            "    G_optimizer_reuse: True\n",
            "    G_scheduler_type: MultiStepLR\n",
            "    G_scheduler_milestones: [250000, 400000, 450000, 475000, 500000]\n",
            "    G_scheduler_gamma: 0.5\n",
            "    G_regularizer_orthstep: None\n",
            "    G_regularizer_clipstep: None\n",
            "    G_param_strict: True\n",
            "    E_param_strict: True\n",
            "    checkpoint_test: 1000\n",
            "    checkpoint_save: 1500\n",
            "    checkpoint_print: 100\n",
            "  ]\n",
            "  opt_path: /content/drive/MyDrive/SwinIr/classical_sr.json\n",
            "  is_train: True\n",
            "  find_unused_parameters: True\n",
            "  num_gpu: 1\n",
            "  rank: 0\n",
            "  world_size: 1\n",
            "\n"
          ]
        }
      ]
    }
  ]
}