OptimizedCocogoat.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils.parametrizations import spectral_norm\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from torchsummary import summary\n",
    "import os\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dataset(torch.utils.data.Dataset):\n",
    "\n",
    "    def __init__(self, path):\n",
    "\n",
    "        self.data = np.load(path, mmap_mode='r')\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "\n",
    "        image = self.data[idx]\n",
    "        image = (image+1.0)*0.5\n",
    "        image = image*255.0\n",
    "        image = image.astype('uint8')\n",
    "        pic = Image.fromarray(image)\n",
    "        pic4x4 = pic.resize((4,4))\n",
    "        pic8x8 = pic.resize((8,8))\n",
    "        pic16x16 = pic.resize((16,16))\n",
    "        pic32x32 = pic.resize((32,32))\n",
    "\n",
    "        image4x4 = np.array(pic4x4, dtype=np.float32)\n",
    "        image8x8 = np.array(pic8x8, dtype=np.float32)\n",
    "        image16x16 = np.array(pic16x16, dtype=np.float32)\n",
    "        image32x32 = np.array(pic32x32, dtype=np.float32)\n",
    "        pic.close()\n",
    "        del pic4x4, pic8x8, pic16x16, pic32x32\n",
    "\n",
    "        image4x4 = image4x4/127.5 - 1.0\n",
    "        image4x4 = torch.from_numpy(image4x4)\n",
    "        image4x4 = image4x4.view(image4x4.size(2), image4x4.size(0), image4x4.size(1))\n",
    "        \n",
    "        image8x8 = image8x8/127.5 - 1.0\n",
    "        image8x8 = torch.from_numpy(image8x8)\n",
    "        image8x8 = image8x8.view(image8x8.size(2), image8x8.size(0), image8x8.size(1))\n",
    "\n",
    "        image16x16 = image16x16/127.5 - 1.0\n",
    "        image16x16 = torch.from_numpy(image16x16)\n",
    "        image16x16 = image16x16.view(image16x16.size(2), image16x16.size(0), image16x16.size(1))\n",
    "\n",
    "        image32x32 = image32x32/127.5 - 1.0\n",
    "        image32x32 = torch.from_numpy(image32x32)\n",
    "        image32x32 = image32x32.view(image32x32.size(2), image32x32.size(0), image32x32.size(1))\n",
    "\n",
    "        return image4x4, image8x8, image16x16, image32x32\n",
    "\n",
    "    def __len__(self):\n",
    "\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = Dataset('D:/Python/Projects/Datasets/Complete_dataset.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GenResidualBlock(nn.Module):\n",
    "\n",
    "    '''\n",
    "    No use of BatchNorm in the generator in order to avoid random noise in the outputs.\n",
    "    See ESRGAN paper for further details.\n",
    "    '''\n",
    "\n",
    "    def __init__(self, channels, kernel=3, stride=1, padding=1):\n",
    "\n",
    "        super(GenResidualBlock, self).__init__()\n",
    "\n",
    "        self.convA = nn.Conv2d(channels, channels, kernel, stride, padding, bias=False)\n",
    "        self.convB = nn.Conv2d(channels, channels, kernel, stride, padding, bias=False)\n",
    "        self.convC = nn.Conv2d(channels, channels, kernel, stride, padding, bias=False)\n",
    "\n",
    "        self.PRelu = nn.PReLU()\n",
    "        \n",
    "    def forward(self, input):\n",
    "\n",
    "        r1 = input\n",
    "\n",
    "        x = self.convA(input)\n",
    "        r2 = self.PRelu(x)\n",
    "\n",
    "        x = r2 + r1\n",
    "\n",
    "        x = self.convB(x)\n",
    "        r3 = self.PRelu(x)\n",
    "\n",
    "        x = r3 + r2 + r1\n",
    "\n",
    "        x = self.convC(x)\n",
    "        \n",
    "        output = x + r3 + r2 + r1\n",
    "\n",
    "        del r1, r2, r3, x\n",
    "\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    '''\n",
    "    Using Residual Blocks\n",
    "    '''\n",
    "\n",
    "\n",
    "    def __init__(self, ):\n",
    "\n",
    "        super(Generator, self).__init__()\n",
    "\n",
    "        self.transconv1 = nn.ConvTranspose2d(1024, 128, 4, 1, 0, bias=False)\n",
    "        self.resblock1 = GenResidualBlock(128, 3, 1, 1)\n",
    "        self.conv1 = nn.Conv2d(128, 3, 1, 1, bias=False)\n",
    "        self.resblock2 = GenResidualBlock(128, 3, 1, 1)\n",
    "        self.conv2 = nn.Conv2d(128, 3, 1, 1, bias=False)\n",
    "        self.resblock3 = GenResidualBlock(128, 3, 1, 1)\n",
    "        self.conv3 = nn.Conv2d(128, 3, 1, 1, bias=False)\n",
    "        self.resblock4 = GenResidualBlock(128, 3, 1, 1)\n",
    "        self.conv5 = nn.Conv2d(128, 3, 3, 1, 1, bias=False)\n",
    "        self.resblock5 = GenResidualBlock(3, 3, 1, 1)\n",
    "\n",
    "        # Possibilidade: Usar Linear + LogSoftmax para selecionar os canais que formam a melhor imagem\n",
    "        \n",
    "        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear')\n",
    "        self.tanh = nn.Tanh() # Since our images are between -1 and 1. Consider removing if having problems with vanishing gradients.\n",
    "\n",
    "    def forward(self, input):\n",
    "\n",
    "        x = self.transconv1(input)\n",
    "        x = self.resblock1(x)\n",
    "\n",
    "        output1 = self.conv1(x)\n",
    "        output1 = self.tanh(output1)\n",
    "\n",
    "        x = self.upsample(x)\n",
    "        x = self.resblock2(x)\n",
    "\n",
    "        output2 = self.conv2(x)\n",
    "        output2 = self.tanh(output2)\n",
    "\n",
    "        x = self.upsample(x)\n",
    "        x = self.resblock3(x)\n",
    "\n",
    "        output3 = self.conv3(x)\n",
    "        output3 = self.tanh(output3)\n",
    "\n",
    "        x = self.upsample(x)\n",
    "        x = self.resblock4(x)\n",
    "\n",
    "        #x = self.upsample(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.resblock5(x)\n",
    "\n",
    "        output = self.tanh(x)\n",
    "\n",
    "        del x\n",
    "\n",
    "        return output1, output2, output3, output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "netG = Generator().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator4x4(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator4x4, self).__init__()\n",
    "\n",
    "        self.conv1A = nn.Conv2d(3, 128, 3, 1, 1, bias=False)\n",
    "        self.neuron_out = nn.Linear(4*4*128, 1, bias=True)\n",
    "\n",
    "        self.LRelu = nn.LeakyReLU(0.2)\n",
    "    \n",
    "    def forward(self, input):\n",
    "\n",
    "        x = self.conv1A(input)\n",
    "        features = self.LRelu(x)\n",
    "\n",
    "        x = features.view(features.size(0), -1)\n",
    "\n",
    "        output = self.neuron_out(x)\n",
    "\n",
    "        return output, features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator8x8(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator8x8, self).__init__()\n",
    "\n",
    "        self.conv1A = nn.Conv2d(3, 128, 3, 1, 1, bias=False)\n",
    "        self.conv2A = nn.Conv2d(128, 256, 4, 2, 1, bias=False)\n",
    "        self.conv2B = nn.Conv2d(256, 256, 3, 1, 1, bias=False)\n",
    "        self.batchnorm2B = nn.BatchNorm2d(256)\n",
    "        self.conv2C = nn.Conv2d(256, 256, 3, 1, 1, bias=False)\n",
    "        self.batchnorm2C = nn.BatchNorm2d(256)\n",
    "        self.neuron_out = nn.Linear(4*4*256, 1, bias=True)\n",
    "\n",
    "        self.LRelu = nn.LeakyReLU(0.2)\n",
    "    \n",
    "    def forward(self, input):\n",
    "\n",
    "        x = self.conv1A(input)\n",
    "        x = self.LRelu(x)\n",
    "\n",
    "        x = self.conv2A(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv2B(x)\n",
    "        x = self.batchnorm2B(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv2C(x)\n",
    "        x = self.batchnorm2C(x)\n",
    "        features = self.LRelu(x)\n",
    "\n",
    "        x = features.view(features.size(0), -1)\n",
    "\n",
    "        output = self.neuron_out(x)\n",
    "\n",
    "        #output = self.sigmoid(x)\n",
    "\n",
    "        return output, features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator16x16(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator16x16, self).__init__()\n",
    "\n",
    "        self.conv1A = nn.Conv2d(3, 128, 3, 1, 1, bias=False)\n",
    "        #self.conv1B = nn.Conv2d(200, 200, 3, 1, 1, bias=True)\n",
    "        self.conv2A = nn.Conv2d(128, 256, 4, 2, 1, bias=False)\n",
    "        self.conv2B = nn.Conv2d(256, 256, 3, 1, 1, bias=False)\n",
    "        self.batchnorm2B = nn.BatchNorm2d(256)\n",
    "        self.conv2C = nn.Conv2d(256, 256, 3, 1, 1, bias=False)\n",
    "        self.batchnorm2C = nn.BatchNorm2d(256)\n",
    "        self.conv3A = nn.Conv2d(256, 512, 4, 2, 1, bias=False)\n",
    "        self.conv3B = nn.Conv2d(512, 512, 3, 1, 1, bias=False)\n",
    "        self.batchnorm3B = nn.BatchNorm2d(512)\n",
    "        self.conv3C = nn.Conv2d(512, 512, 3, 1, 1, bias=False)\n",
    "        self.batchnorm3C = nn.BatchNorm2d(512)\n",
    "        self.neuron_out = nn.Linear(4*4*512, 1, bias=True)\n",
    "\n",
    "        self.LRelu = nn.LeakyReLU(0.2)\n",
    "    \n",
    "    def forward(self, input):\n",
    "\n",
    "        x = self.conv1A(input)\n",
    "        x = self.LRelu(x)\n",
    "\n",
    "        x = self.conv2A(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv2B(x)\n",
    "        x = self.batchnorm2B(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv2C(x)\n",
    "        x = self.batchnorm2C(x)\n",
    "        x = self.LRelu(x)\n",
    "\n",
    "        x = self.conv3A(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv3B(x)\n",
    "        x = self.batchnorm3B(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv3C(x)\n",
    "        x = self.batchnorm3C(x)\n",
    "        features = self.LRelu(x)\n",
    "\n",
    "        x = features.view(features.size(0), -1)\n",
    "\n",
    "        output = self.neuron_out(x)\n",
    "\n",
    "        #output = self.sigmoid(x)\n",
    "\n",
    "        return output, features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator32x32(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator32x32, self).__init__()\n",
    "\n",
    "        self.conv1A = nn.Conv2d(3, 128, 3, 1, 1, bias=False)\n",
    "        self.conv2A = nn.Conv2d(128, 256, 4, 2, 1, bias=False)\n",
    "        self.conv2B = nn.Conv2d(256, 256, 3, 1, 1, bias=False)\n",
    "        self.batchnorm2B = nn.BatchNorm2d(256)\n",
    "        self.conv2C = nn.Conv2d(256, 256, 3, 1, 1, bias=False)\n",
    "        self.batchnorm2C = nn.BatchNorm2d(256)\n",
    "        self.conv3A = nn.Conv2d(256, 512, 4, 2, 1, bias=False)\n",
    "        self.conv3B = nn.Conv2d(512, 512, 3, 1, 1, bias=False)\n",
    "        self.batchnorm3B = nn.BatchNorm2d(512)\n",
    "        self.conv3C = nn.Conv2d(512, 512, 3, 1, 1, bias=False)\n",
    "        self.batchnorm3C = nn.BatchNorm2d(512)\n",
    "        self.conv4A = nn.Conv2d(512, 1024, 4, 2, 1, bias=False)\n",
    "        self.conv4B = nn.Conv2d(1024, 1024, 3, 1, 1, bias=False)\n",
    "        self.batchnorm4B = nn.BatchNorm2d(1024)\n",
    "        self.conv4C = nn.Conv2d(1024, 1024, 3, 1, 1, bias=False)\n",
    "        self.batchnorm4C = nn.BatchNorm2d(1024)\n",
    "        self.neuron_out = nn.Linear(4*4*1024, 1, bias=True)\n",
    "\n",
    "        self.LRelu = nn.LeakyReLU(0.2)\n",
    "    \n",
    "    def forward(self, input):\n",
    "\n",
    "        x = self.conv1A(input)\n",
    "        x = self.LRelu(x)\n",
    "\n",
    "        x = self.conv2A(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv2B(x)\n",
    "        x = self.batchnorm2B(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv2C(x)\n",
    "        x = self.batchnorm2C(x)\n",
    "        x = self.LRelu(x)\n",
    "\n",
    "        x = self.conv3A(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv3B(x)\n",
    "        x = self.batchnorm3B(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv3C(x)\n",
    "        x = self.batchnorm3C(x)\n",
    "        x = self.LRelu(x)\n",
    "\n",
    "        x = self.conv4A(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv4B(x)\n",
    "        x = self.batchnorm4B(x)\n",
    "        x = self.LRelu(x)\n",
    "        x = self.conv4C(x)\n",
    "        x = self.batchnorm4C(x)\n",
    "        features = self.LRelu(x)\n",
    "\n",
    "        x = features.view(features.size(0), -1)\n",
    "\n",
    "        output = self.neuron_out(x)\n",
    "\n",
    "        return output, features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "netD1 = Discriminator4x4().to(device)\n",
    "netD2 = Discriminator8x8().to(device)\n",
    "netD3 = Discriminator16x16().to(device)\n",
    "netD4 = Discriminator32x32().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weights_init(net):\n",
    "    '''\n",
    "    Using weights values that are too low can lead to vanishing gradients.\n",
    "    But it might be necessary in some architectures. See ESRGAN paper for further details\n",
    "    '''\n",
    "\n",
    "    for n, p in net.named_parameters():\n",
    "\n",
    "        if 'conv' and 'weight' in n:\n",
    "\n",
    "            #nn.init.normal_(p, 0, 0.2/p.size(0))\n",
    "            nn.init.normal_(p, 0, 0.02)\n",
    "\n",
    "        elif 'conv' and 'bias' in n:\n",
    "\n",
    "            nn.init.constant_(p, 0.)\n",
    "\n",
    "        elif 'neuron' and 'weight' in n:\n",
    "\n",
    "            #nn.init.normal_(p, 0, 0.2/p.size(0))\n",
    "            nn.init.normal_(p, 0, 0.02)\n",
    "\n",
    "        elif 'neuron' and 'bias' in n:\n",
    "\n",
    "            nn.init.constant_(p, 0.)\n",
    "\n",
    "        elif 'batchnorm' and 'weight' in n:\n",
    "            nn.init.normal_(p, 1, 0.02)\n",
    "\n",
    "        elif 'batchnorm' and 'bias' in n:\n",
    "            nn.init.constant_(p, 0.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights_init(netG)\n",
    "weights_init(netD1)\n",
    "weights_init(netD2)\n",
    "weights_init(netD3)\n",
    "weights_init(netD4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizerD1 = optim.Adam(netD1.parameters(), lr=1e-4, betas=(0., 0.999))\n",
    "optimizerD2 = optim.Adam(netD2.parameters(), lr=1e-4, betas=(0., 0.999))\n",
    "optimizerD3 = optim.Adam(netD3.parameters(), lr=1e-4, betas=(0., 0.999))\n",
    "optimizerD4 = optim.Adam(netD4.parameters(), lr=1e-4, betas=(0., 0.999))\n",
    "optimizerG = optim.Adam(netG.parameters(), lr=1e-4, betas=(0., 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dueling Discriminators might be of big help when facing instability issues\n",
    "\n",
    "netDI = Discriminator4x4().to(device)\n",
    "netDII = Discriminator8x8().to(device)\n",
    "netDIII = Discriminator16x16().to(device)\n",
    "netDIV = Discriminator32x32().to(device)\n",
    "\n",
    "optimizerDI = optim.Adam(netDI.parameters(), lr=1e-4, betas=(0., 0.999))\n",
    "optimizerDII = optim.Adam(netDII.parameters(), lr=1e-4, betas=(0., 0.999))\n",
    "optimizerDIII = optim.Adam(netDIII.parameters(), lr=1e-4, betas=(0., 0.999))\n",
    "optimizerDIV = optim.Adam(netDIV.parameters(), lr=1e-4, betas=(0., 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights_init(netDI)\n",
    "weights_init(netDII)\n",
    "weights_init(netDIII)\n",
    "weights_init(netDIV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_numpy(tensor):\n",
    "\n",
    "    tensor = tensor.view(tensor.size(0), tensor.size(2), tensor.size(3), tensor.size(1))\n",
    "    tensor = tensor.detach().cpu().numpy()\n",
    "    tensor = (tensor+1.0)*0.5\n",
    "    \n",
    "    return tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloader = torch.utils.data.DataLoader(data, batch_size=16, shuffle=True, drop_last=True)\n",
    "\n",
    "bce = nn.BCELoss()\n",
    "sigmoid = nn.Sigmoid() # Sigmoid without Logits\n",
    "mse = nn.MSELoss()\n",
    "\n",
    "start_epoch = 0\n",
    "EPOCHS = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# When using Dueling Discriminators, remember to also save parameters for the counterpart discriminators.\n",
    "params = torch.load(\"D:/Python/Projects/GANs/Cocogoat/Prototype_Cocogoat.tar\")\n",
    "\n",
    "netD1.load_state_dict(params['discriminator1_params'])\n",
    "netD2.load_state_dict(params['discriminator2_params'])\n",
    "netD3.load_state_dict(params['discriminator3_params'])\n",
    "netD4.load_state_dict(params['discriminator4_params'])\n",
    "netG.load_state_dict(params['generator_params'])\n",
    "start_epoch = params['epoch']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(45935, 100, 100, 3)\n"
     ]
    }
   ],
   "source": [
    "print(data.data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14|100\n",
      "Discriminators Loss: 3.3302664756774902\n",
      "Gradients Average:\n",
      "\tDiscriminator 1: 0.00443496648222208\tDiscriminator 2: -0.26172342896461487\tDiscriminator 3: -0.09961031377315521\tDiscriminator 4: -2.0361949282232672e-05\n",
      "Real Output Mean: 338.74951171875\tFake Output Mean: 324.5635070800781\n",
      "Generator Loss: 60.98929977416992\tGradients Average: -5.768596020061523e-05\n",
      "Adversarial Loss: 60.98926544189453\tContent Loss: 0.03569215163588524\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_21988/181148400.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     84\u001b[0m         \u001b[0mfake_output3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfeatures_fake3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnetD3\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mout3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     85\u001b[0m         \u001b[0mfake_mean3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfake_output3\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 86\u001b[1;33m         \u001b[0mfake_output4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfeatures_fake4\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnetD4\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mout4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     87\u001b[0m         \u001b[0mfake_mean4\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfake_output4\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     88\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\Python\\lib\\site-packages\\torch\\nn\\modules\\module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m   1128\u001b[0m         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[0;32m   1129\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[1;32m-> 1130\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1131\u001b[0m         \u001b[1;31m# Do not call functions when jit is used\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1132\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_21988/954818652.py\u001b[0m in \u001b[0;36mforward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m     39\u001b[0m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconv3A\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     40\u001b[0m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLRelu\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 41\u001b[1;33m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconv3B\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     42\u001b[0m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbatchnorm3B\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     43\u001b[0m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLRelu\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\Python\\lib\\site-packages\\torch\\nn\\modules\\module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m   1128\u001b[0m         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[0;32m   1129\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[1;32m-> 1130\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1131\u001b[0m         \u001b[1;31m# Do not call functions when jit is used\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1132\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\Python\\lib\\site-packages\\torch\\nn\\modules\\conv.py\u001b[0m in \u001b[0;36mforward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m    455\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    456\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 457\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_conv_forward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    458\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    459\u001b[0m \u001b[1;32mclass\u001b[0m \u001b[0mConv3d\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_ConvNd\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\Python\\lib\\site-packages\\torch\\nn\\modules\\conv.py\u001b[0m in \u001b[0;36m_conv_forward\u001b[1;34m(self, input, weight, bias)\u001b[0m\n\u001b[0;32m    451\u001b[0m                             \u001b[0mweight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstride\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    452\u001b[0m                             _pair(0), self.dilation, self.groups)\n\u001b[1;32m--> 453\u001b[1;33m         return F.conv2d(input, weight, bias, self.stride,\n\u001b[0m\u001b[0;32m    454\u001b[0m                         self.padding, self.dilation, self.groups)\n\u001b[0;32m    455\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "for epoch in range(start_epoch, EPOCHS):\n",
    "\n",
    "    for i, (image4x4, image8x8, image16x16, image32x32) in enumerate(dataloader):\n",
    "\n",
    "        image4x4, image8x8, image16x16, image32x32 = image4x4.to(device), image8x8.to(device), image16x16.to(device), image32x32.to(device)\n",
    "\n",
    "        real_label = torch.full((image4x4.size(0), 1), 1, dtype=torch.float, device=device)\n",
    "        fake_label = torch.full((image4x4.size(0), 1), 0, dtype=torch.float, device=device)\n",
    "\n",
    "        netD1.zero_grad()\n",
    "        netD2.zero_grad()\n",
    "        netD3.zero_grad()\n",
    "        netD4.zero_grad()\n",
    "\n",
    "        real_output1, _ = netD1(image4x4)\n",
    "        real_mean1 = torch.mean(real_output1.detach())\n",
    "        real_output2, _ = netD2(image8x8)\n",
    "        real_mean2 = torch.mean(real_output2.detach())\n",
    "        real_output3, _ = netD3(image16x16)\n",
    "        real_mean3 = torch.mean(real_output3.detach())\n",
    "        real_output4, _ = netD4(image32x32)\n",
    "        real_mean4 = torch.mean(real_output4.detach())\n",
    "\n",
    "        noise = torch.randn((image4x4.size(0), 1024, 1, 1), device=device)\n",
    "\n",
    "        out1, out2, out3, out4 = netG(noise)\n",
    "\n",
    "        fake_output1, _ = netD1(out1)\n",
    "        fake_mean1 = torch.mean(fake_output1.detach())\n",
    "        fake_output2, _ = netD2(out2)\n",
    "        fake_mean2 = torch.mean(fake_output2.detach())\n",
    "        fake_output3, _ = netD3(out3)\n",
    "        fake_mean3 = torch.mean(fake_output3.detach())\n",
    "        fake_output4, _ = netD4(out4)\n",
    "        fake_mean4 = torch.mean(fake_output4.detach())\n",
    "\n",
    "        real_output1 = sigmoid(real_output1 - fake_mean1)\n",
    "        real_output2 = sigmoid(real_output2 - fake_mean2)\n",
    "        real_output3 = sigmoid(real_output3 - fake_mean3)\n",
    "        real_output4 = sigmoid(real_output4 - fake_mean4)\n",
    "\n",
    "        fake_output1 = sigmoid(fake_output1 - real_mean1)\n",
    "        fake_output2 = sigmoid(fake_output2 - real_mean2)\n",
    "        fake_output3 = sigmoid(fake_output3 - real_mean3)\n",
    "        fake_output4 = sigmoid(fake_output4 - real_mean4)\n",
    "\n",
    "        real_loss = bce(real_output1, real_label) + bce(real_output2, real_label) + bce(real_output3, real_label) + bce(real_output4, real_label)\n",
    "        fake_loss = bce(fake_output1, fake_label) + bce(fake_output2, fake_label) + bce(fake_output3, fake_label) + bce(fake_output4, fake_label)\n",
    "\n",
    "        discriminator_loss = real_loss + fake_loss\n",
    "\n",
    "        discriminator_loss.backward()\n",
    "\n",
    "        D1grads = torch.mean(netD1.conv1A.weight.grad)\n",
    "        D2grads = torch.mean(netD2.conv1A.weight.grad)\n",
    "        D3grads = torch.mean(netD3.conv1A.weight.grad)\n",
    "        D4grads = torch.mean(netD4.conv1A.weight.grad)\n",
    "\n",
    "        optimizerD1.step()\n",
    "        optimizerD2.step()\n",
    "        optimizerD3.step()\n",
    "        optimizerD4.step()\n",
    "\n",
    "\n",
    "        netG.zero_grad()\n",
    "\n",
    "        real_output1, features_real1 = netD1(image4x4)\n",
    "        real_mean1 = torch.mean(real_output1.detach())\n",
    "        real_output2, features_real2 = netD2(image8x8)\n",
    "        real_mean2 = torch.mean(real_output2.detach())\n",
    "        real_output3, features_real3 = netD3(image16x16)\n",
    "        real_mean3 = torch.mean(real_output3.detach())\n",
    "        real_output4, features_real4 = netD4(image32x32)\n",
    "        real_mean4 = torch.mean(real_output4.detach())\n",
    "\n",
    "        noise = torch.randn((image4x4.size(0), 1024, 1, 1), device=device)\n",
    "\n",
    "        out1, out2, out3, out4 = netG(noise)\n",
    "\n",
    "        fake_output1, features_fake1 = netD1(out1)\n",
    "        fake_mean1 = torch.mean(fake_output1.detach())\n",
    "        fake_output2, features_fake2 = netD2(out2)\n",
    "        fake_mean2 = torch.mean(fake_output2.detach())\n",
    "        fake_output3, features_fake3 = netD3(out3)\n",
    "        fake_mean3 = torch.mean(fake_output3.detach())\n",
    "        fake_output4, features_fake4 = netD4(out4)\n",
    "        fake_mean4 = torch.mean(fake_output4.detach())\n",
    "\n",
    "        real_output1 = sigmoid(real_output1 - fake_mean1)\n",
    "        real_output2 = sigmoid(real_output2 - fake_mean2)\n",
    "        real_output3 = sigmoid(real_output3 - fake_mean3)\n",
    "        real_output4 = sigmoid(real_output4 - fake_mean4)\n",
    "\n",
    "        fake_output1 = sigmoid(fake_output1 - real_mean1)\n",
    "        fake_output2 = sigmoid(fake_output2 - real_mean2)\n",
    "        fake_output3 = sigmoid(fake_output3 - real_mean3)\n",
    "        fake_output4 = sigmoid(fake_output4 - real_mean4)\n",
    "\n",
    "        real_loss = bce(real_output1, fake_label) + bce(real_output2, fake_label) + bce(real_output3, fake_label) + bce(real_output4, fake_label)\n",
    "        fake_loss = bce(fake_output1, real_label) + bce(fake_output2, real_label) + bce(fake_output3, real_label) + bce(fake_output4, real_label)\n",
    "\n",
    "        adversarial_loss = real_loss + fake_loss\n",
    "\n",
    "        content_loss = mse(features_fake1, features_real1.detach()) + mse(features_fake2, features_real2.detach()) + mse(features_fake3, features_real3.detach()) + mse(features_fake4, features_real4.detach())\n",
    "\n",
    "        generator_loss = adversarial_loss + (content_loss * 1e-3)\n",
    "\n",
    "        generator_loss.backward()\n",
    "\n",
    "        Ggrads = torch.mean(netG.transconv1.weight.grad)\n",
    "\n",
    "        optimizerG.step()\n",
    "\n",
    "        if i % 1000 == 0:\n",
    "            \n",
    "            print(f\"{epoch}|{EPOCHS}\")\n",
    "            print(f\"Discriminators Loss: {discriminator_loss.item()}\")\n",
    "            print(f\"Gradients Average:\\n\\tDiscriminator 1: {D1grads}\\tDiscriminator 2: {D2grads}\\tDiscriminator 3: {D3grads}\\tDiscriminator 4: {D4grads}\")\n",
    "            #print(f\"Adversarial Loss: {adversarial_error.item()}\\tConsistency Loss: {consistency_loss.item()}\")\n",
    "            print(f\"Real Output Mean: {real_mean4}\\tFake Output Mean: {fake_mean4}\")\n",
    "            print(f\"Generator Loss: {generator_loss.item()}\\tGradients Average: {Ggrads}\")\n",
    "            print(f\"Adversarial Loss: {adversarial_loss.item()}\\tContent Loss: {content_loss.item()}\")\n",
    "\n",
    "            with torch.no_grad():\n",
    "\n",
    "                out1, out2, out3, out4 = netG(noise)\n",
    "\n",
    "            out1 = to_numpy(out1)\n",
    "            out2 = to_numpy(out2)\n",
    "            out3 = to_numpy(out3)\n",
    "            out4 = to_numpy(out4)\n",
    "            \n",
    "            fig, ax = plt.subplots(2,4)\n",
    "\n",
    "            for x in range(ax.shape[0]):\n",
    "                for y in range(ax.shape[1]):\n",
    "                    ax[x,y].axis('off')\n",
    "\n",
    "            ax[0,0].imshow(out1[0])\n",
    "            ax[1,0].imshow(out1[1])\n",
    "            ax[0,1].imshow(out2[0])\n",
    "            ax[1,1].imshow(out2[1])\n",
    "            ax[0,2].imshow(out3[0])\n",
    "            ax[1,2].imshow(out3[1])\n",
    "            ax[0,3].imshow(out4[0])\n",
    "            ax[1,3].imshow(out4[1])\n",
    "            plt.show()\n",
    "\n",
    "            torch.save({\n",
    "                    'epoch': epoch,\n",
    "                    'discriminator1_params': netD1.state_dict(),\n",
    "                    'discriminator2_params': netD2.state_dict(),\n",
    "                    'discriminator3_params': netD3.state_dict(),\n",
    "                    'discriminator4_params': netD4.state_dict(),\n",
    "                    'generator_params': netG.state_dict(),\n",
    "                }, f\"D:/Python/Projects/GANs/Cocogoat/Prototype_Cocogoat.tar\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "2469a70536e4d2335a2ea8907942d0699c37342a371ac185bdb5b0aa6f073890"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}