Computer_Vision/Chapter13/CycleGAN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CycleGAN.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PacktPublishing/Hands-On-Computer-Vision-with-PyTorch/blob/master/Chapter13/CycleGAN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNYTA_siln-p"
      },
      "source": [
        "!wget -q https://www.dropbox.com/s/2xltmolfbfharri/apples_oranges.zip\n",
        "!unzip -q apples_oranges.zip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RIJGnn38l2xM",
        "outputId": "c5fe279e-adf8-4339-c34b-68c2a07dce40",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "!pip install torch_snippets torch_summary\n",
        "import itertools\n",
        "from PIL import Image\n",
        "from torch_snippets import *\n",
        "from torchvision import transforms\n",
        "from torchvision.utils import make_grid\n",
        "from torchsummary import summary"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting torch_snippets\n",
            "  Downloading https://files.pythonhosted.org/packages/50/13/302867fc4189c33290179a92e745cbfe6132c3120f5cbad245026a7eccf9/torch_snippets-0.234-py3-none-any.whl\n",
            "Collecting torch_summary\n",
            "  Downloading https://files.pythonhosted.org/packages/83/49/f9db57bcad7246591b93519fd8e5166c719548c45945ef7d2fc9fcba46fb/torch_summary-1.4.3-py3-none-any.whl\n",
            "Collecting loguru\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/6d/48/0a7d5847e3de329f1d0134baf707b689700b53bd3066a5a8cfd94b3c9fc8/loguru-0.5.3-py3-none-any.whl (57kB)\n",
            "\u001b[K     |████████████████████████████████| 61kB 9.0MB/s \n",
            "\u001b[?25hCollecting opencv-python-headless\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/08/e9/57d869561389884136be65a2d1bc038fe50171e2ba348fda269a4aab8032/opencv_python_headless-4.4.0.46-cp36-cp36m-manylinux2014_x86_64.whl (36.7MB)\n",
            "\u001b[K     |████████████████████████████████| 36.7MB 73kB/s \n",
            "\u001b[?25hRequirement already satisfied: dill in /usr/local/lib/python3.6/dist-packages (from torch_snippets) (0.3.3)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.6/dist-packages (from torch_snippets) (7.0.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from torch_snippets) (4.41.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torch_snippets) (1.18.5)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (from torch_snippets) (3.2.2)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (from torch_snippets) (1.1.4)\n",
            "Collecting aiocontextvars>=0.2.0; python_version < \"3.7\"\n",
            "  Downloading https://files.pythonhosted.org/packages/db/c1/7a723e8d988de0a2e623927396e54b6831b68cb80dce468c945b849a9385/aiocontextvars-0.2.2-py2.py3-none-any.whl\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib->torch_snippets) (0.10.0)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->torch_snippets) (2.4.7)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->torch_snippets) (1.3.1)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->torch_snippets) (2.8.1)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas->torch_snippets) (2018.9)\n",
            "Collecting contextvars==2.4; python_version < \"3.7\"\n",
            "  Downloading https://files.pythonhosted.org/packages/83/96/55b82d9f13763be9d672622e1b8106c85acb83edd7cc2fa5bc67cd9877e9/contextvars-2.4.tar.gz\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from cycler>=0.10->matplotlib->torch_snippets) (1.15.0)\n",
            "Collecting immutables>=0.9\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/99/e0/ea6fd4697120327d26773b5a84853f897a68e33d3f9376b00a8ff96e4f63/immutables-0.14-cp36-cp36m-manylinux1_x86_64.whl (98kB)\n",
            "\u001b[K     |████████████████████████████████| 102kB 14.3MB/s \n",
            "\u001b[?25hBuilding wheels for collected packages: contextvars\n",
            "  Building wheel for contextvars (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for contextvars: filename=contextvars-2.4-cp36-none-any.whl size=7666 sha256=70ea82871a70f9e33a0d9d17305dc45baed76439680be17043b0fcb03632425e\n",
            "  Stored in directory: /root/.cache/pip/wheels/a5/7d/68/1ebae2668bda2228686e3c1cf16f2c2384cea6e9334ad5f6de\n",
            "Successfully built contextvars\n",
            "Installing collected packages: immutables, contextvars, aiocontextvars, loguru, opencv-python-headless, torch-snippets, torch-summary\n",
            "Successfully installed aiocontextvars-0.2.2 contextvars-2.4 immutables-0.14 loguru-0.5.3 opencv-python-headless-4.4.0.46 torch-snippets-0.234 torch-summary-1.4.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BsSIvEHcl6r7"
      },
      "source": [
        "IMAGE_SIZE = 256\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize(int(IMAGE_SIZE*1.33)),\n",
        "    transforms.RandomCrop((IMAGE_SIZE,IMAGE_SIZE)),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JN4bPxjYl8fM"
      },
      "source": [
        "class CycleGANDataset(Dataset):\n",
        "    def __init__(self, apples, oranges):\n",
        "        self.apples = Glob(apples)\n",
        "        self.oranges = Glob(oranges)\n",
        "\n",
        "    def __getitem__(self, ix):\n",
        "        apple = self.apples[ix % len(self.apples)]\n",
        "        orange = choose(self.oranges)\n",
        "        apple = Image.open(apple).convert('RGB')\n",
        "        orange = Image.open(orange).convert('RGB')\n",
        "        return apple, orange\n",
        "\n",
        "    def __len__(self): return max(len(self.apples), len(self.oranges))\n",
        "    def choose(self): return self[randint(len(self))]\n",
        "\n",
        "    def collate_fn(self, batch):\n",
        "        srcs, trgs = list(zip(*batch))\n",
        "        srcs = torch.cat([transform(img)[None] for img in srcs], 0).to(device).float()\n",
        "        trgs = torch.cat([transform(img)[None] for img in trgs], 0).to(device).float()\n",
        "        return srcs.to(device), trgs.to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-U3g9Gb8l_aa",
        "outputId": "73768266-5b9e-4937-9837-564b9aed1876",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "trn_ds = CycleGANDataset('apples_train', 'oranges_train')\n",
        "val_ds = CycleGANDataset('apples_test', 'oranges_test')\n",
        "\n",
        "trn_dl = DataLoader(trn_ds, batch_size=1, shuffle=True, collate_fn=trn_ds.collate_fn)\n",
        "val_dl = DataLoader(val_ds, batch_size=5, shuffle=True, collate_fn=val_ds.collate_fn)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020-11-04 18:49:57.993 | INFO     | torch_snippets.loader:Glob:181 - 3067 files found at apples_train\n",
            "2020-11-04 18:49:57.996 | INFO     | torch_snippets.loader:Glob:181 - 479 files found at oranges_train\n",
            "2020-11-04 18:49:58.000 | INFO     | torch_snippets.loader:Glob:181 - 1021 files found at apples_test\n",
            "2020-11-04 18:49:58.002 | INFO     | torch_snippets.loader:Glob:181 - 160 files found at oranges_test\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ua6A14QWmA7s"
      },
      "source": [
        "def weights_init_normal(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find(\"Conv\") != -1:\n",
        "        torch.nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
        "        if hasattr(m, \"bias\") and m.bias is not None:\n",
        "            torch.nn.init.constant_(m.bias.data, 0.0)\n",
        "    elif classname.find(\"BatchNorm2d\") != -1:\n",
        "        torch.nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
        "        torch.nn.init.constant_(m.bias.data, 0.0)\n",
        "class ResidualBlock(nn.Module):\n",
        "    def __init__(self, in_features):\n",
        "        super(ResidualBlock, self).__init__()\n",
        "\n",
        "        self.block = nn.Sequential(\n",
        "            nn.ReflectionPad2d(1),\n",
        "            nn.Conv2d(in_features, in_features, 3),\n",
        "            nn.InstanceNorm2d(in_features),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.ReflectionPad2d(1),\n",
        "            nn.Conv2d(in_features, in_features, 3),\n",
        "            nn.InstanceNorm2d(in_features),\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        return x + self.block(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ur5TL0h7mFLY"
      },
      "source": [
        "class GeneratorResNet(nn.Module):\n",
        "    def __init__(self, num_residual_blocks=9):\n",
        "        super(GeneratorResNet, self).__init__()\n",
        "        out_features = 64\n",
        "        channels = 3\n",
        "        model = [\n",
        "            nn.ReflectionPad2d(3),\n",
        "            nn.Conv2d(channels, out_features, 7),\n",
        "            nn.InstanceNorm2d(out_features),\n",
        "            nn.ReLU(inplace=True),\n",
        "        ]\n",
        "        in_features = out_features\n",
        "        # Downsampling\n",
        "        for _ in range(2):\n",
        "            out_features *= 2\n",
        "            model += [\n",
        "                nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),\n",
        "                nn.InstanceNorm2d(out_features),\n",
        "                nn.ReLU(inplace=True),\n",
        "            ]\n",
        "            in_features = out_features\n",
        "\n",
        "        # Residual blocks\n",
        "        for _ in range(num_residual_blocks):\n",
        "            model += [ResidualBlock(out_features)]\n",
        "\n",
        "        # Upsampling\n",
        "        for _ in range(2):\n",
        "            out_features //= 2\n",
        "            model += [\n",
        "                nn.Upsample(scale_factor=2),\n",
        "                nn.Conv2d(in_features, out_features, 3, stride=1, padding=1),\n",
        "                nn.InstanceNorm2d(out_features),\n",
        "                nn.ReLU(inplace=True),\n",
        "            ]\n",
        "            in_features = out_features\n",
        "\n",
        "        # Output layer\n",
        "        model += [nn.ReflectionPad2d(channels), nn.Conv2d(out_features, channels, 7), nn.Tanh()]\n",
        "        self.model = nn.Sequential(*model)\n",
        "        self.apply(weights_init_normal)\n",
        "    def forward(self, x):\n",
        "        return self.model(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jL70jua7mHRR"
      },
      "source": [
        "class Discriminator(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Discriminator, self).__init__()\n",
        "\n",
        "        channels, height, width = 3, IMAGE_SIZE, IMAGE_SIZE\n",
        "\n",
        "        def discriminator_block(in_filters, out_filters, normalize=True):\n",
        "            \"\"\"Returns downsampling layers of each discriminator block\"\"\"\n",
        "            layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n",
        "            if normalize:\n",
        "                layers.append(nn.InstanceNorm2d(out_filters))\n",
        "            layers.append(nn.LeakyReLU(0.2, inplace=True))\n",
        "            return layers\n",
        "\n",
        "        self.model = nn.Sequential(\n",
        "            *discriminator_block(channels, 64, normalize=False),\n",
        "            *discriminator_block(64, 128),\n",
        "            *discriminator_block(128, 256),\n",
        "            *discriminator_block(256, 512),\n",
        "            nn.ZeroPad2d((1, 0, 1, 0)),\n",
        "            nn.Conv2d(512, 1, 4, padding=1)\n",
        "        )\n",
        "        self.apply(weights_init_normal)\n",
        "\n",
        "    def forward(self, img):\n",
        "        return self.model(img)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NgPzlws1mJGU"
      },
      "source": [
        "@torch.no_grad()\n",
        "def generate_sample():\n",
        "    data = next(iter(val_dl))\n",
        "    G_AB.eval()\n",
        "    G_BA.eval()\n",
        "    \n",
        "    real_A, real_B = data\n",
        "    fake_B = G_AB(real_A)\n",
        "    fake_A = G_BA(real_B)\n",
        "    # Arange images along x-axis\n",
        "    real_A = make_grid(real_A, nrow=5, normalize=True)\n",
        "    real_B = make_grid(real_B, nrow=5, normalize=True)\n",
        "    fake_A = make_grid(fake_A, nrow=5, normalize=True)\n",
        "    fake_B = make_grid(fake_B, nrow=5, normalize=True)\n",
        "    # Arange images along y-axis\n",
        "    image_grid = torch.cat((real_A, fake_B, real_B, fake_A), 1)\n",
        "    show(image_grid.detach().cpu().permute(1,2,0).numpy(), sz=12)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vbWP5fLPmLI5"
      },
      "source": [
        "def generator_train_step(Gs, optimizer, real_A, real_B):\n",
        "    G_AB, G_BA = Gs\n",
        "    optimizer.zero_grad()\n",
        "    loss_id_A = criterion_identity(G_BA(real_A), real_A)\n",
        "    loss_id_B = criterion_identity(G_AB(real_B), real_B)\n",
        "\n",
        "    loss_identity = (loss_id_A + loss_id_B) / 2\n",
        "    fake_B = G_AB(real_A)\n",
        "    loss_GAN_AB = criterion_GAN(D_B(fake_B), torch.Tensor(np.ones((len(real_A), 1, 16, 16))).to(device))\n",
        "    fake_A = G_BA(real_B)\n",
        "    loss_GAN_BA = criterion_GAN(D_A(fake_A), torch.Tensor(np.ones((len(real_A), 1, 16, 16))).to(device))\n",
        "\n",
        "    loss_GAN = (loss_GAN_AB + loss_GAN_BA) / 2\n",
        "    recov_A = G_BA(fake_B)\n",
        "    loss_cycle_A = criterion_cycle(recov_A, real_A)\n",
        "    recov_B = G_AB(fake_A)\n",
        "    loss_cycle_B = criterion_cycle(recov_B, real_B)\n",
        "\n",
        "    loss_cycle = (loss_cycle_A + loss_cycle_B) / 2\n",
        "    loss_G = loss_GAN + lambda_cyc * loss_cycle + lambda_id * loss_identity\n",
        "    loss_G.backward()\n",
        "    optimizer.step()\n",
        "    return loss_G, loss_identity, loss_GAN, loss_cycle, loss_G, fake_A, fake_B"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ja2h_bu4mWsU"
      },
      "source": [
        "def discriminator_train_step(D, real_data, fake_data, optimizer):\n",
        "    optimizer.zero_grad()\n",
        "    loss_real = criterion_GAN(D(real_data), torch.Tensor(np.ones((len(real_data), 1, 16, 16))).to(device))\n",
        "    loss_fake = criterion_GAN(D(fake_data.detach()), torch.Tensor(np.zeros((len(real_data), 1, 16, 16))).to(device))\n",
        "    loss_D = (loss_real + loss_fake) / 2\n",
        "    loss_D.backward()\n",
        "    optimizer.step()\n",
        "    return loss_D"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tbIQMqcpmYJx"
      },
      "source": [
        "G_AB = GeneratorResNet().to(device)\n",
        "G_BA = GeneratorResNet().to(device)\n",
        "D_A = Discriminator().to(device)\n",
        "D_B = Discriminator().to(device)\n",
        "\n",
        "criterion_GAN = torch.nn.MSELoss()\n",
        "criterion_cycle = torch.nn.L1Loss()\n",
        "criterion_identity = torch.nn.L1Loss()\n",
        "\n",
        "optimizer_G = torch.optim.Adam(\n",
        "    itertools.chain(G_AB.parameters(), G_BA.parameters()), lr=0.0002, betas=(0.5, 0.999)\n",
        ")\n",
        "optimizer_D_A = torch.optim.Adam(D_A.parameters(), lr=0.0002, betas=(0.5, 0.999))\n",
        "optimizer_D_B = torch.optim.Adam(D_B.parameters(), lr=0.0002, betas=(0.5, 0.999))\n",
        "\n",
        "lambda_cyc, lambda_id = 10.0, 5.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CQnri-dpmaCp",
        "outputId": "c0d03b6a-e3af-49e8-b43f-72fd17ecf478",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "n_epochs = 10\n",
        "log = Report(n_epochs)\n",
        "for epoch in range(n_epochs):\n",
        "    N = len(trn_dl)\n",
        "    for bx, batch in enumerate(trn_dl):\n",
        "        real_A, real_B = batch\n",
        "\n",
        "        loss_G, loss_identity, loss_GAN, loss_cycle, loss_G, fake_A, fake_B = generator_train_step((G_AB,G_BA), optimizer_G, real_A, real_B)\n",
        "        loss_D_A = discriminator_train_step(D_A, real_A, fake_A, optimizer_D_A)\n",
        "        loss_D_B = discriminator_train_step(D_B, real_B, fake_B, optimizer_D_B)\n",
        "        loss_D = (loss_D_A + loss_D_B) / 2\n",
        "        \n",
        "        log.record(epoch+(1+bx)/N, loss_D=loss_D.item(), loss_G=loss_G.item(), \n",
        "                   loss_GAN=loss_GAN.item(), loss_cycle=loss_cycle.item(), \n",
        "                   loss_identity=loss_identity.item(), end='\\r')\n",
        "        if bx%100==0: generate_sample()\n",
        "\n",
        "    log.report_avgs(epoch+1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\rEPOCH: 0.000\tloss_D: 1.495\tloss_G: 12.493\tloss_GAN: 1.655\tloss_cycle: 0.734\tloss_identity: 0.699\t(0.88s - 27022.12s remaining)"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 0.033\tloss_D: 0.493\tloss_G: 2.204\tloss_GAN: 0.857\tloss_cycle: 0.099\tloss_identity: 0.071\t(69.10s - 20913.16s remaining)"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 0.066\tloss_D: 0.283\tloss_G: 2.625\tloss_GAN: 0.505\tloss_cycle: 0.153\tloss_identity: 0.118\t(140.12s - 21240.59s remaining)"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 0.098\tloss_D: 0.215\tloss_G: 2.611\tloss_GAN: 0.334\tloss_cycle: 0.155\tloss_identity: 0.146\t(211.07s - 21295.81s remaining)"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 0.131\tloss_D: 0.184\tloss_G: 1.951\tloss_GAN: 0.430\tloss_cycle: 0.109\tloss_identity: 0.085\t(281.95s - 21282.65s remaining)"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 0.163\tloss_D: 0.195\tloss_G: 2.200\tloss_GAN: 0.385\tloss_cycle: 0.121\tloss_identity: 0.120\t(352.70s - 21238.79s remaining)"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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
            "text/plain": [
              "<Figure size 864x864 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "EPOCH: 0.167\tloss_D: 0.463\tloss_G: 2.237\tloss_GAN: 0.551\tloss_cycle: 0.117\tloss_identity: 0.103\t(360.50s - 21276.61s remaining)"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0muEWW0jmdZ8"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}