training_notebook_SRGAN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Training notebook**"
      ],
      "metadata": {
        "id": "SdkDiYlhBIJJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dentro de este notebook desglosamos el entrenamiento de nuestro modelo de SRGAN"
      ],
      "metadata": {
        "id": "EshL0DIFBQJx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Importamos archivos"
      ],
      "metadata": {
        "id": "iRDBKdz6BXzF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y3JL5eWSwZNc",
        "outputId": "85ba9078-a792-47e5-c184-def2334b5680"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creamos las funciones necesarias"
      ],
      "metadata": {
        "id": "i-qnmdOBBkvV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import transforms\n",
        "from torch.utils.data import Dataset\n",
        "\n",
        "import os\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "import random\n",
        "\n",
        "\n",
        "from skimage.color import rgb2ycbcr\n",
        "from skimage.metrics import peak_signal_noise_ratio as compare_pnsr\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm import tqdm"
      ],
      "metadata": {
        "id": "u6w7Yj3Kx2CY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class MeanShift(nn.Conv2d):\n",
        "    def __init__(\n",
        "        self, rgb_range = 1,\n",
        "        norm_mean=(0.485, 0.456, 0.406), norm_std=(0.229, 0.224, 0.225), sign=-1):\n",
        "\n",
        "        super(MeanShift, self).__init__(3, 3, kernel_size=1)\n",
        "        std = torch.Tensor(norm_std)\n",
        "        self.weight.data = torch.eye(3).view(3, 3, 1, 1) / std.view(3, 1, 1, 1)\n",
        "        self.bias.data = sign * rgb_range * torch.Tensor(norm_mean) / std\n",
        "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "        \n",
        "        for p in self.parameters():\n",
        "            p.requires_grad = False\n",
        "\n",
        "\n",
        "class perceptual_loss(nn.Module):\n",
        "\n",
        "    def __init__(self, vgg):\n",
        "        super(perceptual_loss, self).__init__()\n",
        "        self.normalization_mean = [0.485, 0.456, 0.406]\n",
        "        self.normalization_std = [0.229, 0.224, 0.225]\n",
        "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "        self.transform = MeanShift(norm_mean = self.normalization_mean, norm_std = self.normalization_std).to(self.device)\n",
        "        self.vgg = vgg\n",
        "        self.criterion = nn.MSELoss()\n",
        "    def forward(self, HR, SR, layer = 'relu5_4'):\n",
        "        ## HR and SR should be normalized [0,1]\n",
        "        hr = self.transform(HR)\n",
        "        sr = self.transform(SR)\n",
        "        \n",
        "        hr_feat = getattr(self.vgg(hr), layer)\n",
        "        sr_feat = getattr(self.vgg(sr), layer)\n",
        "        \n",
        "        return self.criterion(hr_feat, sr_feat), hr_feat, sr_feat\n",
        "\n",
        "class TVLoss(nn.Module):\n",
        "    def __init__(self, tv_loss_weight=1):\n",
        "        super(TVLoss, self).__init__()\n",
        "        self.tv_loss_weight = tv_loss_weight\n",
        "\n",
        "    def forward(self, x):\n",
        "        batch_size = x.size()[0]\n",
        "        h_x = x.size()[2]\n",
        "        w_x = x.size()[3]\n",
        "        count_h = self.tensor_size(x[:, :, 1:, :])\n",
        "        count_w = self.tensor_size(x[:, :, :, 1:])\n",
        "        h_tv = torch.pow((x[:, :, 1:, :] - x[:, :, :h_x - 1, :]), 2).sum()\n",
        "        w_tv = torch.pow((x[:, :, :, 1:] - x[:, :, :, :w_x - 1]), 2).sum()\n",
        "        \n",
        "        return self.tv_loss_weight * 2 * (h_tv / count_h + w_tv / count_w) / batch_size\n",
        "\n",
        "    @staticmethod\n",
        "    def tensor_size(t):\n",
        "        return t.size()[1] * t.size()[2] * t.size()[3]\n"
      ],
      "metadata": {
        "id": "B8CT7m2PBxUZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class mydata(Dataset):\n",
        "    def __init__(self, LR_path, GT_path, in_memory = True, transform = None):\n",
        "        \n",
        "        self.LR_path = LR_path\n",
        "        self.GT_path = GT_path\n",
        "        self.in_memory = in_memory\n",
        "        self.transform = transform\n",
        "        \n",
        "        self.LR_img = sorted(os.listdir(LR_path))\n",
        "        self.GT_img = sorted(os.listdir(GT_path))\n",
        "        \n",
        "        if in_memory:\n",
        "            self.LR_img = [np.array(Image.open(os.path.join(self.LR_path, lr)).convert(\"RGB\")).astype(np.uint8) for lr in self.LR_img]\n",
        "            self.GT_img = [np.array(Image.open(os.path.join(self.GT_path, gt)).convert(\"RGB\")).astype(np.uint8) for gt in self.GT_img]\n",
        "        \n",
        "    def __len__(self):\n",
        "        \n",
        "        return len(self.LR_img)\n",
        "        \n",
        "    def __getitem__(self, i):\n",
        "        \n",
        "        img_item = {}\n",
        "        \n",
        "        if self.in_memory:\n",
        "            GT = self.GT_img[i].astype(np.float32)\n",
        "            LR = self.LR_img[i].astype(np.float32)\n",
        "            \n",
        "        else:\n",
        "            GT = np.array(Image.open(os.path.join(self.GT_path, self.GT_img[i])).convert(\"RGB\"))\n",
        "            LR = np.array(Image.open(os.path.join(self.LR_path, self.LR_img[i])).convert(\"RGB\"))\n",
        "\n",
        "        img_item['GT'] = (GT / 127.5) - 1.0\n",
        "        img_item['LR'] = (LR / 127.5) - 1.0\n",
        "                \n",
        "        if self.transform is not None:\n",
        "            img_item = self.transform(img_item)\n",
        "            \n",
        "        img_item['GT'] = img_item['GT'].transpose(2, 0, 1).astype(np.float32)\n",
        "        img_item['LR'] = img_item['LR'].transpose(2, 0, 1).astype(np.float32)\n",
        "        \n",
        "        return img_item\n",
        "    \n",
        "    \n",
        "class testOnly_data(Dataset):\n",
        "    def __init__(self, LR_path, in_memory = True, transform = None):\n",
        "        \n",
        "        self.LR_path = LR_path\n",
        "        self.LR_img = sorted(os.listdir(LR_path))\n",
        "        self.in_memory = in_memory\n",
        "        if in_memory:\n",
        "            self.LR_img = [np.array(Image.open(os.path.join(self.LR_path, lr))) for lr in self.LR_img]\n",
        "        \n",
        "    def __len__(self):\n",
        "        \n",
        "        return len(self.LR_img)\n",
        "        \n",
        "    def __getitem__(self, i):\n",
        "        \n",
        "        img_item = {}\n",
        "        \n",
        "        if self.in_memory:\n",
        "            LR = self.LR_img[i]\n",
        "            \n",
        "        else:\n",
        "            LR = np.array(Image.open(os.path.join(self.LR_path, self.LR_img[i])))\n",
        "\n",
        "        img_item['LR'] = (LR / 127.5) - 1.0                \n",
        "        img_item['LR'] = img_item['LR'].transpose(2, 0, 1).astype(np.float32)\n",
        "        \n",
        "        return img_item\n",
        "\n",
        "\n",
        "class crop(object):\n",
        "    def __init__(self, scale, patch_size):\n",
        "        \n",
        "        self.scale = scale\n",
        "        self.patch_size = patch_size\n",
        "        \n",
        "    def __call__(self, sample):\n",
        "        LR_img, GT_img = sample['LR'], sample['GT']\n",
        "        ih, iw = LR_img.shape[:2]\n",
        "        \n",
        "        ix = random.randrange(0, iw - self.patch_size +1)\n",
        "        iy = random.randrange(0, ih - self.patch_size +1)\n",
        "        \n",
        "        tx = ix * self.scale\n",
        "        ty = iy * self.scale\n",
        "        \n",
        "        LR_patch = LR_img[iy : iy + self.patch_size, ix : ix + self.patch_size]\n",
        "        GT_patch = GT_img[ty : ty + (self.scale * self.patch_size), tx : tx + (self.scale * self.patch_size)]\n",
        "        \n",
        "        return {'LR' : LR_patch, 'GT' : GT_patch}\n",
        "\n",
        "class augmentation(object):\n",
        "    \n",
        "    def __call__(self, sample):\n",
        "        LR_img, GT_img = sample['LR'], sample['GT']\n",
        "        \n",
        "        hor_flip = random.randrange(0,2)\n",
        "        ver_flip = random.randrange(0,2)\n",
        "        rot = random.randrange(0,2)\n",
        "    \n",
        "        if hor_flip:\n",
        "            temp_LR = np.fliplr(LR_img)\n",
        "            LR_img = temp_LR.copy()\n",
        "            temp_GT = np.fliplr(GT_img)\n",
        "            GT_img = temp_GT.copy()\n",
        "            \n",
        "            del temp_LR, temp_GT\n",
        "        \n",
        "        if ver_flip:\n",
        "            temp_LR = np.flipud(LR_img)\n",
        "            LR_img = temp_LR.copy()\n",
        "            temp_GT = np.flipud(GT_img)\n",
        "            GT_img = temp_GT.copy()\n",
        "            \n",
        "            del temp_LR, temp_GT\n",
        "            \n",
        "        if rot:\n",
        "            LR_img = LR_img.transpose(1, 0, 2)\n",
        "            GT_img = GT_img.transpose(1, 0, 2)\n",
        "        \n",
        "        \n",
        "        return {'LR' : LR_img, 'GT' : GT_img}\n",
        "        \n",
        "\n"
      ],
      "metadata": {
        "id": "9d55QG2oCS6J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "class _conv(nn.Conv2d):\n",
        "    def __init__(self, in_channels, out_channels, kernel_size, stride, padding, bias):\n",
        "        super(_conv, self).__init__(in_channels = in_channels, out_channels = out_channels, \n",
        "                               kernel_size = kernel_size, stride = stride, padding = (kernel_size) // 2, bias = True)\n",
        "        \n",
        "        self.weight.data = torch.normal(torch.zeros((out_channels, in_channels, kernel_size, kernel_size)), 0.02)\n",
        "        self.bias.data = torch.zeros((out_channels))\n",
        "        \n",
        "        for p in self.parameters():\n",
        "            p.requires_grad = True\n",
        "        \n",
        "\n",
        "class conv(nn.Module):\n",
        "    def __init__(self, in_channel, out_channel, kernel_size, BN = False, act = None, stride = 1, bias = True):\n",
        "        super(conv, self).__init__()\n",
        "        m = []\n",
        "        m.append(_conv(in_channels = in_channel, out_channels = out_channel, \n",
        "                               kernel_size = kernel_size, stride = stride, padding = (kernel_size) // 2, bias = True))\n",
        "        \n",
        "        if BN:\n",
        "            m.append(nn.BatchNorm2d(num_features = out_channel))\n",
        "        \n",
        "        if act is not None:\n",
        "            m.append(act)\n",
        "        \n",
        "        self.body = nn.Sequential(*m)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        out = self.body(x)\n",
        "        return out\n",
        "        \n",
        "class ResBlock(nn.Module):\n",
        "    def __init__(self, channels, kernel_size, act = nn.ReLU(inplace = True), bias = True):\n",
        "        super(ResBlock, self).__init__()\n",
        "        m = []\n",
        "        m.append(conv(channels, channels, kernel_size, BN = True, act = act))\n",
        "        m.append(conv(channels, channels, kernel_size, BN = True, act = None))\n",
        "        self.body = nn.Sequential(*m)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        res = self.body(x)\n",
        "        res += x\n",
        "        return res\n",
        "    \n",
        "class BasicBlock(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels, kernel_size, num_res_block, act = nn.ReLU(inplace = True)):\n",
        "        super(BasicBlock, self).__init__()\n",
        "        m = []\n",
        "        \n",
        "        self.conv = conv(in_channels, out_channels, kernel_size, BN = False, act = act)\n",
        "        for i in range(num_res_block):\n",
        "            m.append(ResBlock(out_channels, kernel_size, act))\n",
        "        \n",
        "        m.append(conv(out_channels, out_channels, kernel_size, BN = True, act = None))\n",
        "        \n",
        "        self.body = nn.Sequential(*m)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        res = self.conv(x)\n",
        "        out = self.body(res)\n",
        "        out += res\n",
        "        \n",
        "        return out\n",
        "        \n",
        "class Upsampler(nn.Module):\n",
        "    def __init__(self, channel, kernel_size, scale, act = nn.ReLU(inplace = True)):\n",
        "        super(Upsampler, self).__init__()\n",
        "        m = []\n",
        "        m.append(conv(channel, channel * scale * scale, kernel_size))\n",
        "        m.append(nn.PixelShuffle(scale))\n",
        "    \n",
        "        if act is not None:\n",
        "            m.append(act)\n",
        "        \n",
        "        self.body = nn.Sequential(*m)\n",
        "    \n",
        "    def forward(self, x):\n",
        "        out = self.body(x)\n",
        "        return out\n",
        "\n",
        "class discrim_block(nn.Module):\n",
        "    def __init__(self, in_feats, out_feats, kernel_size, act = nn.LeakyReLU(inplace = True)):\n",
        "        super(discrim_block, self).__init__()\n",
        "        m = []\n",
        "        m.append(conv(in_feats, out_feats, kernel_size, BN = True, act = act))\n",
        "        m.append(conv(out_feats, out_feats, kernel_size, BN = True, act = act, stride = 2))\n",
        "        self.body = nn.Sequential(*m)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        out = self.body(x)\n",
        "        return out"
      ],
      "metadata": {
        "id": "P_pNSkUTDap5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Generator(nn.Module):\n",
        "    \n",
        "    def __init__(self, img_feat = 3, n_feats = 64, kernel_size = 3, num_block = 16, act = nn.PReLU(), scale=4):\n",
        "        super(Generator, self).__init__()\n",
        "        \n",
        "        self.conv01 = conv(in_channel = img_feat, out_channel = n_feats, kernel_size = 9, BN = False, act = act)\n",
        "        \n",
        "        resblocks = [ResBlock(channels = n_feats, kernel_size = 3, act = act) for _ in range(num_block)]\n",
        "        self.body = nn.Sequential(*resblocks)\n",
        "        \n",
        "        self.conv02 = conv(in_channel = n_feats, out_channel = n_feats, kernel_size = 3, BN = True, act = None)\n",
        "        \n",
        "        if(scale == 4):\n",
        "            upsample_blocks = [Upsampler(channel = n_feats, kernel_size = 3, scale = 2, act = act) for _ in range(2)]\n",
        "        else:\n",
        "            upsample_blocks = [Upsampler(channel = n_feats, kernel_size = 3, scale = scale, act = act)]\n",
        "\n",
        "        self.tail = nn.Sequential(*upsample_blocks)\n",
        "        \n",
        "        self.last_conv = conv(in_channel = n_feats, out_channel = img_feat, kernel_size = 3, BN = False, act = nn.Tanh())\n",
        "        \n",
        "    def forward(self, x):\n",
        "        \n",
        "        x = self.conv01(x)\n",
        "        _skip_connection = x\n",
        "        \n",
        "        x = self.body(x)\n",
        "        x = self.conv02(x)\n",
        "        feat = x + _skip_connection\n",
        "        \n",
        "        x = self.tail(feat)\n",
        "        x = self.last_conv(x)\n",
        "        \n",
        "        return x, feat\n",
        "    \n",
        "class Discriminator(nn.Module):\n",
        "    \n",
        "    def __init__(self, img_feat = 3, n_feats = 64, kernel_size = 3, act = nn.LeakyReLU(inplace = True), num_of_block = 3, patch_size = 96):\n",
        "        super(Discriminator, self).__init__()\n",
        "        self.act = act\n",
        "        \n",
        "        self.conv01 = conv(in_channel = img_feat, out_channel = n_feats, kernel_size = 3, BN = False, act = self.act)\n",
        "        self.conv02 = conv(in_channel = n_feats, out_channel = n_feats, kernel_size = 3, BN = False, act = self.act, stride = 2)\n",
        "        \n",
        "        body = [discrim_block(in_feats = n_feats * (2 ** i), out_feats = n_feats * (2 ** (i + 1)), kernel_size = 3, act = self.act) for i in range(num_of_block)]    \n",
        "        self.body = nn.Sequential(*body)\n",
        "        \n",
        "        self.linear_size = ((patch_size // (2 ** (num_of_block + 1))) ** 2) * (n_feats * (2 ** num_of_block))\n",
        "        \n",
        "        tail = []\n",
        "        \n",
        "        tail.append(nn.Linear(self.linear_size, 1024))\n",
        "        tail.append(self.act)\n",
        "        tail.append(nn.Linear(1024, 1))\n",
        "        tail.append(nn.Sigmoid())\n",
        "        \n",
        "        self.tail = nn.Sequential(*tail)\n",
        "        \n",
        "        \n",
        "    def forward(self, x):\n",
        "        \n",
        "        x = self.conv01(x)\n",
        "        x = self.conv02(x)\n",
        "        x = self.body(x)        \n",
        "        x = x.view(-1, self.linear_size)\n",
        "        x = self.tail(x)\n",
        "        \n",
        "        return x\n",
        "\n"
      ],
      "metadata": {
        "id": "f1f0RhAkDIL-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "from torchvision import models\n",
        "from collections import namedtuple\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "\n",
        "class vgg19(nn.Module):\n",
        "    \n",
        "    def __init__(self, pre_trained = True, require_grad = False):\n",
        "        super(vgg19, self).__init__()\n",
        "        self.vgg_feature = models.vgg19(pretrained = pre_trained).features\n",
        "        self.seq_list = [nn.Sequential(ele) for ele in self.vgg_feature]\n",
        "        self.vgg_layer = ['conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1', \n",
        "                         'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2',\n",
        "                         'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', 'conv3_3', 'relu3_3', 'conv3_4', 'relu3_4', 'pool3',\n",
        "                         'conv4_1', 'relu4_1', 'conv4_2', 'relu4_2', 'conv4_3', 'relu4_3', 'conv4_4', 'relu4_4', 'pool4',\n",
        "                         'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2', 'conv5_3', 'relu5_3', 'conv5_4', 'relu5_4', 'pool5']\n",
        "        \n",
        "        if not require_grad:\n",
        "            for parameter in self.parameters():\n",
        "                parameter.requires_grad = False\n",
        "        \n",
        "    def forward(self, x):\n",
        "        \n",
        "        conv1_1 = self.seq_list[0](x)\n",
        "        relu1_1 = self.seq_list[1](conv1_1)\n",
        "        conv1_2 = self.seq_list[2](relu1_1)\n",
        "        relu1_2 = self.seq_list[3](conv1_2)\n",
        "        pool1 = self.seq_list[4](relu1_2)\n",
        "        \n",
        "        conv2_1 = self.seq_list[5](pool1)\n",
        "        relu2_1 = self.seq_list[6](conv2_1)\n",
        "        conv2_2 = self.seq_list[7](relu2_1)\n",
        "        relu2_2 = self.seq_list[8](conv2_2)\n",
        "        pool2 = self.seq_list[9](relu2_2)\n",
        "        \n",
        "        conv3_1 = self.seq_list[10](pool2)\n",
        "        relu3_1 = self.seq_list[11](conv3_1)\n",
        "        conv3_2 = self.seq_list[12](relu3_1)\n",
        "        relu3_2 = self.seq_list[13](conv3_2)\n",
        "        conv3_3 = self.seq_list[14](relu3_2)\n",
        "        relu3_3 = self.seq_list[15](conv3_3)\n",
        "        conv3_4 = self.seq_list[16](relu3_3)\n",
        "        relu3_4 = self.seq_list[17](conv3_4)\n",
        "        pool3 = self.seq_list[18](relu3_4)\n",
        "        \n",
        "        conv4_1 = self.seq_list[19](pool3)\n",
        "        relu4_1 = self.seq_list[20](conv4_1)\n",
        "        conv4_2 = self.seq_list[21](relu4_1)\n",
        "        relu4_2 = self.seq_list[22](conv4_2)\n",
        "        conv4_3 = self.seq_list[23](relu4_2)\n",
        "        relu4_3 = self.seq_list[24](conv4_3)\n",
        "        conv4_4 = self.seq_list[25](relu4_3)\n",
        "        relu4_4 = self.seq_list[26](conv4_4)\n",
        "        pool4 = self.seq_list[27](relu4_4)\n",
        "        \n",
        "        conv5_1 = self.seq_list[28](pool4)\n",
        "        relu5_1 = self.seq_list[29](conv5_1)\n",
        "        conv5_2 = self.seq_list[30](relu5_1)\n",
        "        relu5_2 = self.seq_list[31](conv5_2)\n",
        "        conv5_3 = self.seq_list[32](relu5_2)\n",
        "        relu5_3 = self.seq_list[33](conv5_3)\n",
        "        conv5_4 = self.seq_list[34](relu5_3)\n",
        "        relu5_4 = self.seq_list[35](conv5_4)\n",
        "        pool5 = self.seq_list[36](relu5_4)\n",
        "        \n",
        "        vgg_output = namedtuple(\"vgg_output\", self.vgg_layer)\n",
        "        \n",
        "        vgg_list = [conv1_1, relu1_1, conv1_2, relu1_2, pool1, \n",
        "                         conv2_1, relu2_1, conv2_2, relu2_2, pool2,\n",
        "                         conv3_1, relu3_1, conv3_2, relu3_2, conv3_3, relu3_3, conv3_4, relu3_4, pool3,\n",
        "                         conv4_1, relu4_1, conv4_2, relu4_2, conv4_3, relu4_3, conv4_4, relu4_4, pool4,\n",
        "                         conv5_1, relu5_1, conv5_2, relu5_2, conv5_3, relu5_3, conv5_4, relu5_4, pool5]\n",
        "        \n",
        "        out = vgg_output(*vgg_list)\n",
        "        \n",
        "        \n",
        "        return out"
      ],
      "metadata": {
        "id": "6hOcFiXhCLTN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def train(args):\n",
        "\n",
        "    losses = []\n",
        "    epochs = []\n",
        "    progress_bar = iter(tqdm(range(args.pre_train_epoch)))\n",
        "    \n",
        "\n",
        "    \n",
        "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "    \n",
        "    transform  = transforms.Compose([crop(args.scale, args.patch_size), augmentation()])\n",
        "    dataset = mydata(GT_path = args.GT_path, LR_path = args.LR_path, in_memory = args.in_memory, transform = transform)\n",
        "    loader = DataLoader(dataset, batch_size = args.batch_size, shuffle = True, num_workers = args.num_workers)\n",
        "    \n",
        "    generator = Generator(img_feat = 3, n_feats = 64, kernel_size = 3, num_block = args.res_num, scale=args.scale)\n",
        "    \n",
        "    \n",
        "    if args.fine_tuning:        \n",
        "        generator.load_state_dict(torch.load(args.generator_path))\n",
        "        print(\"pre-trained model is loaded\")\n",
        "        print(\"path : %s\"%(args.generator_path))\n",
        "        \n",
        "    generator = generator.to(device)\n",
        "    generator.train()\n",
        "    \n",
        "    l2_loss = nn.MSELoss()\n",
        "    g_optim = optim.Adam(generator.parameters(), lr = 1e-4)\n",
        "        \n",
        "    pre_epoch = 0\n",
        "    fine_epoch = 0\n",
        "    \n",
        "    #### Train using L2_loss\n",
        "    while pre_epoch < args.pre_train_epoch:\n",
        "        for i, tr_data in enumerate(loader):\n",
        "            gt = tr_data['GT'].to(device)\n",
        "            lr = tr_data['LR'].to(device)\n",
        "\n",
        "            output, _ = generator(lr)\n",
        "            loss = l2_loss(gt, output)\n",
        "\n",
        "            g_optim.zero_grad()\n",
        "            loss.backward()\n",
        "            g_optim.step()\n",
        "\n",
        "            next(progress_bar)\n",
        "\n",
        "        pre_epoch += 1\n",
        "        \n",
        "\n",
        "        if pre_epoch % 2 == 0:\n",
        "            losses.append(loss.item())\n",
        "            epochs.append(pre_epoch)\n",
        "            \n",
        "        \n",
        "        if pre_epoch % args.epoch ==0:\n",
        "            progress_bar.close()\n",
        "            print('\\n Model saved \\n')\n",
        "            torch.save(generator.state_dict(), './model/pre_trained_model_%03d.pt'%pre_epoch)\n",
        "            print('\\n Graph \\n')\n",
        "            plt.title('Epoch - Loss Graph (MSE)')\n",
        "            plt.ylabel('Loss')\n",
        "            plt.xlabel('Epoch')\n",
        "            plt.plot(epochs,losses)\n",
        "            plt.show()\n",
        "         \n"
      ],
      "metadata": {
        "id": "pxdUxAUmhRqn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "    #### Train using perceptual & adversarial loss\n",
        "    vgg_net = vgg19().to(device)\n",
        "    vgg_net = vgg_net.eval()\n",
        "    \n",
        "    discriminator = Discriminator(patch_size = args.patch_size * args.scale)\n",
        "    discriminator = discriminator.to(device)\n",
        "    discriminator.train()\n",
        "    \n",
        "    \n",
        "    scheduler = optim.lr_scheduler.StepLR(g_optim, step_size = 2000, gamma = 0.1)\n",
        "    d_optim = optim.Adam(discriminator.parameters(), lr = 1e-4)\n",
        "    \n",
        "    VGG_loss = perceptual_loss(vgg_net)\n",
        "    cross_ent = nn.BCELoss()\n",
        "    tv_loss = TVLoss()\n",
        "    real_label = torch.ones((args.batch_size, 1)).to(device)\n",
        "    fake_label = torch.zeros((args.batch_size, 1)).to(device)\n",
        "    \n",
        "    while fine_epoch < args.fine_train_epoch:\n",
        "        \n",
        "        scheduler.step()\n",
        "        \n",
        "        for i, tr_data in enumerate(loader):\n",
        "            gt = tr_data['GT'].to(device)\n",
        "            lr = tr_data['LR'].to(device)\n",
        "                        \n",
        "            ## Training Discriminator\n",
        "            output, _ = generator(lr)\n",
        "            fake_prob = discriminator(output)\n",
        "            real_prob = discriminator(gt)\n",
        "            \n",
        "            d_loss_real = cross_ent(real_prob, real_label)\n",
        "            d_loss_fake = cross_ent(fake_prob, fake_label)\n",
        "            \n",
        "            d_loss = d_loss_real + d_loss_fake\n",
        "\n",
        "            g_optim.zero_grad()\n",
        "            d_optim.zero_grad()\n",
        "            d_loss.backward()\n",
        "            d_optim.step()\n",
        "            \n",
        "            ## Training Generator\n",
        "            output, _ = generator(lr)\n",
        "            fake_prob = discriminator(output)\n",
        "            \n",
        "            _percep_loss, hr_feat, sr_feat = VGG_loss((gt + 1.0) / 2.0, (output + 1.0) / 2.0, layer = args.feat_layer)\n",
        "            \n",
        "            L2_loss = l2_loss(output, gt)\n",
        "            percep_loss = args.vgg_rescale_coeff * _percep_loss\n",
        "            adversarial_loss = args.adv_coeff * cross_ent(fake_prob, real_label)\n",
        "            total_variance_loss = args.tv_loss_coeff * tv_loss(args.vgg_rescale_coeff * (hr_feat - sr_feat)**2)\n",
        "            \n",
        "            g_loss = percep_loss + adversarial_loss + total_variance_loss + L2_loss\n",
        "            \n",
        "            g_optim.zero_grad()\n",
        "            d_optim.zero_grad()\n",
        "            g_loss.backward()\n",
        "            g_optim.step()\n",
        "\n",
        "            \n",
        "        fine_epoch += 1\n",
        "\n",
        "        if fine_epoch % 2 == 0:\n",
        "            print(fine_epoch)\n",
        "            print(g_loss.item())\n",
        "            print(d_loss.item())\n",
        "            print('=========')\n",
        "\n",
        "        if fine_epoch % 500 ==0:\n",
        "            #torch.save(generator.state_dict(), './model/SRGAN_gene_%03d.pt'%fine_epoch)\n",
        "            #torch.save(discriminator.state_dict(), './model/SRGAN_discrim_%03d.pt'%fine_epoch)\n",
        "            torch.save(generator.state_dict(), './model/SRGAN_gene_%03d.pt'%fine_epoch)\n",
        "            torch.save(discriminator.state_dict(), './model/SRGAN_discrim_%03d.pt'%fine_epoch)"
      ],
      "metadata": {
        "id": "7cmDawEGpJgE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conocemos los directorios que están disponibles para su ejecución"
      ],
      "metadata": {
        "id": "oUAz2ijBEU9Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "os.mkdir('model')"
      ],
      "metadata": {
        "id": "xOwFDrgqlGUy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import glob\n",
        "\n",
        "# providing the path\n",
        "glob.iglob('/content/drive/MyDrive/proyecto_final_ia/jupiter_2/*')\n",
        "\n",
        "# iterating over the files in that path of directory\n",
        "for items in glob.iglob('/content/drive/MyDrive/proyecto_final_ia/jupiter_2/*'):\n",
        "   print(items)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gZ4NuS8N3qB_",
        "outputId": "1b98827e-e056-4d82-f5d8-8d911fdc9702"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/MyDrive/proyecto_final_ia/jupiter_2/LR\n",
            "/content/drive/MyDrive/proyecto_final_ia/jupiter_2/HR\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class arguments:\n",
        "  def __init__(args, LR_path, GT_path, epoch, scale, patch_size, in_memory, batch_size, num_workers, res_num, fine_tuning, pre_train_epoch, fine_train_epoch):\n",
        "    args.LR_path = LR_path\n",
        "    args.GT_path = GT_path\n",
        "    args.epoch = epoch\n",
        "    args.scale = scale\n",
        "    args.patch_size = patch_size\n",
        "    args.in_memory = in_memory\n",
        "    args.batch_size = batch_size\n",
        "    args.num_workers = num_workers\n",
        "    args.res_num = res_num\n",
        "    args.fine_tuning = fine_tuning\n",
        "    args.pre_train_epoch = pre_train_epoch\n",
        "    args.fine_train_epoch = fine_train_epoch\n",
        "\n",
        "args = arguments('/content/drive/MyDrive/proyecto_final_ia/jupiter_2/LR','/content/drive/MyDrive/proyecto_final_ia/jupiter_2/HR', 80,4,24, True, 16,0,16, False, 80,4000)\n",
        "\n",
        "print('Training model... \\n')\n",
        "\n",
        "train(args)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 628
        },
        "id": "XmiS0QyVfc0E",
        "outputId": "9867f671-588d-462c-ed63-d14d09f606ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training model... \n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 99%|█████████▉| 79/80 [00:01<00:00, 43.84it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            " Model saved \n",
            "\n",
            "\n",
            " Graph \n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}