{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1czVdIlqnImH"
   },
   "source": [
    "# Pix2Pix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1KD3ZgLs80vY"
   },
   "source": [
    "### Goals\n",
    "In this notebook, you will write a generative model based on the paper [*Image-to-Image Translation with Conditional Adversarial Networks*](https://arxiv.org/abs/1611.07004) by Isola et al. 2017, also known as Pix2Pix.\n",
    "\n",
    "You will be training a model that can convert aerial satellite imagery (\"input\") into map routes (\"output\"), as was done in the original paper. Since the architecture for the generator is a U-Net, which you've already implemented (with minor changes), the emphasis of the assignment will be on the loss function. So that you can see outputs more quickly, you'll be able to see your model train starting from a pre-trained checkpoint - but feel free to train it from scratch on your own too.\n",
    "\n",
    "\n",
    "![pix2pix example](pix2pix_ex.png)\n",
    "\n",
    "\n",
    "<!-- You will take the segmentations that you generated in the previous assignment and produce photorealistic images. -->\n",
    "\n",
    "### Learning Objectives\n",
    "1.   Implement the loss of a Pix2Pix model that differentiates it from a supervised U-Net.\n",
    "2.   Observe the change in generator priorities as the Pix2Pix generator trains, changing its emphasis from reconstruction to realism.\n",
    "\n",
    "<!-- When you're done with this assignment, you'll be able to understand much of [*Image-to-Image Translation with Conditional Adversarial Networks*](https://arxiv.org/abs/1611.07004), which introduced Pix2Pix.\n",
    "\n",
    "You'll be using the same U-Net as in the previous assignment, but you'll write another discriminator and change the loss to make it a GAN. -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wU8DDM6l9rZb"
   },
   "source": [
    "## Getting Started\n",
    "You will start by importing libraries, defining a visualization function, and getting the pre-trained Pix2Pix checkpoint. You will also be provided with the U-Net code for the Pix2Pix generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JfkorNJrnmNO"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from tqdm.auto import tqdm\n",
    "from torchvision import transforms\n",
    "from torchvision.datasets import VOCSegmentation\n",
    "from torchvision.utils import make_grid\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "torch.manual_seed(0)\n",
    "\n",
    "def show_tensor_images(image_tensor, num_images=25, size=(1, 28, 28)):\n",
    "    '''\n",
    "    Function for visualizing images: Given a tensor of images, number of images, and\n",
    "    size per image, plots and prints the images in an uniform grid.\n",
    "    '''\n",
    "    image_shifted = image_tensor\n",
    "    image_unflat = image_shifted.detach().cpu().view(-1, *size)\n",
    "    image_grid = make_grid(image_unflat[:num_images], nrow=5)\n",
    "    plt.imshow(image_grid.permute(1, 2, 0).squeeze())\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NjFyvNTG1CqY"
   },
   "source": [
    "#### U-Net Code\n",
    "\n",
    "The U-Net code will be much like the code you wrote for the last assignment, but with optional dropout and batchnorm. The structure is changed slightly for Pix2Pix, so that the final image is closer in size to the input image. Feel free to investigate the code if you're interested!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xvY4ZNyUviY9"
   },
   "outputs": [],
   "source": [
    "def crop(image, new_shape):\n",
    "    '''\n",
    "    Function for cropping an image tensor: Given an image tensor and the new shape,\n",
    "    crops to the center pixels (assumes that the input's size and the new size are\n",
    "    even numbers).\n",
    "    Parameters:\n",
    "        image: image tensor of shape (batch size, channels, height, width)\n",
    "        new_shape: a torch.Size object with the shape you want x to have\n",
    "    '''\n",
    "    middle_height = image.shape[2] // 2\n",
    "    middle_width = image.shape[3] // 2\n",
    "    starting_height = middle_height - new_shape[2] // 2\n",
    "    final_height = starting_height + new_shape[2]\n",
    "    starting_width = middle_width - new_shape[3] // 2\n",
    "    final_width = starting_width + new_shape[3]\n",
    "    cropped_image = image[:, :, starting_height:final_height, starting_width:final_width]\n",
    "    return cropped_image\n",
    "\n",
    "class ContractingBlock(nn.Module):\n",
    "    '''\n",
    "    ContractingBlock Class\n",
    "    Performs two convolutions followed by a max pool operation.\n",
    "    Values:\n",
    "        input_channels: the number of channels to expect from a given input\n",
    "    '''\n",
    "    def __init__(self, input_channels, use_dropout=False, use_bn=True):\n",
    "        super(ContractingBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(input_channels, input_channels * 2, kernel_size=3, padding=1)\n",
    "        self.conv2 = nn.Conv2d(input_channels * 2, input_channels * 2, kernel_size=3, padding=1)\n",
    "        self.activation = nn.LeakyReLU(0.2)\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        if use_bn:\n",
    "            self.batchnorm = nn.BatchNorm2d(input_channels * 2)\n",
    "        self.use_bn = use_bn\n",
    "        if use_dropout:\n",
    "            self.dropout = nn.Dropout()\n",
    "        self.use_dropout = use_dropout\n",
    "\n",
    "    def forward(self, x):\n",
    "        '''\n",
    "        Function for completing a forward pass of ContractingBlock: \n",
    "        Given an image tensor, completes a contracting block and returns the transformed tensor.\n",
    "        Parameters:\n",
    "            x: image tensor of shape (batch size, channels, height, width)\n",
    "        '''\n",
    "        x = self.conv1(x)\n",
    "        if self.use_bn:\n",
    "            x = self.batchnorm(x)\n",
    "        if self.use_dropout:\n",
    "            x = self.dropout(x)\n",
    "        x = self.activation(x)\n",
    "        x = self.conv2(x)\n",
    "        if self.use_bn:\n",
    "            x = self.batchnorm(x)\n",
    "        if self.use_dropout:\n",
    "            x = self.dropout(x)\n",
    "        x = self.activation(x)\n",
    "        x = self.maxpool(x)\n",
    "        return x\n",
    "\n",
    "class ExpandingBlock(nn.Module):\n",
    "    '''\n",
    "    ExpandingBlock Class:\n",
    "    Performs an upsampling, a convolution, a concatenation of its two inputs,\n",
    "    followed by two more convolutions with optional dropout\n",
    "    Values:\n",
    "        input_channels: the number of channels to expect from a given input\n",
    "    '''\n",
    "    def __init__(self, input_channels, use_dropout=False, use_bn=True):\n",
    "        super(ExpandingBlock, self).__init__()\n",
    "        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)\n",
    "        self.conv1 = nn.Conv2d(input_channels, input_channels // 2, kernel_size=2)\n",
    "        self.conv2 = nn.Conv2d(input_channels, input_channels // 2, kernel_size=3, padding=1)\n",
    "        self.conv3 = nn.Conv2d(input_channels // 2, input_channels // 2, kernel_size=2, padding=1)\n",
    "        if use_bn:\n",
    "            self.batchnorm = nn.BatchNorm2d(input_channels // 2)\n",
    "        self.use_bn = use_bn\n",
    "        self.activation = nn.ReLU()\n",
    "        if use_dropout:\n",
    "            self.dropout = nn.Dropout()\n",
    "        self.use_dropout = use_dropout\n",
    "\n",
    "    def forward(self, x, skip_con_x):\n",
    "        '''\n",
    "        Function for completing a forward pass of ExpandingBlock: \n",
    "        Given an image tensor, completes an expanding block and returns the transformed tensor.\n",
    "        Parameters:\n",
    "            x: image tensor of shape (batch size, channels, height, width)\n",
    "            skip_con_x: the image tensor from the contracting path (from the opposing block of x)\n",
    "                    for the skip connection\n",
    "        '''\n",
    "        x = self.upsample(x)\n",
    "        x = self.conv1(x)\n",
    "        skip_con_x = crop(skip_con_x, x.shape)\n",
    "        x = torch.cat([x, skip_con_x], axis=1)\n",
    "        x = self.conv2(x)\n",
    "        if self.use_bn:\n",
    "            x = self.batchnorm(x)\n",
    "        if self.use_dropout:\n",
    "            x = self.dropout(x)\n",
    "        x = self.activation(x)\n",
    "        x = self.conv3(x)\n",
    "        if self.use_bn:\n",
    "            x = self.batchnorm(x)\n",
    "        if self.use_dropout:\n",
    "            x = self.dropout(x)\n",
    "        x = self.activation(x)\n",
    "        return x\n",
    "\n",
    "class FeatureMapBlock(nn.Module):\n",
    "    '''\n",
    "    FeatureMapBlock Class\n",
    "    The final layer of a U-Net - \n",
    "    maps each pixel to a pixel with the correct number of output dimensions\n",
    "    using a 1x1 convolution.\n",
    "    Values:\n",
    "        input_channels: the number of channels to expect from a given input\n",
    "        output_channels: the number of channels to expect for a given output\n",
    "    '''\n",
    "    def __init__(self, input_channels, output_channels):\n",
    "        super(FeatureMapBlock, self).__init__()\n",
    "        self.conv = nn.Conv2d(input_channels, output_channels, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        '''\n",
    "        Function for completing a forward pass of FeatureMapBlock: \n",
    "        Given an image tensor, returns it mapped to the desired number of channels.\n",
    "        Parameters:\n",
    "            x: image tensor of shape (batch size, channels, height, width)\n",
    "        '''\n",
    "        x = self.conv(x)\n",
    "        return x\n",
    "\n",
    "class UNet(nn.Module):\n",
    "    '''\n",
    "    UNet Class\n",
    "    A series of 4 contracting blocks followed by 4 expanding blocks to \n",
    "    transform an input image into the corresponding paired image, with an upfeature\n",
    "    layer at the start and a downfeature layer at the end.\n",
    "    Values:\n",
    "        input_channels: the number of channels to expect from a given input\n",
    "        output_channels: the number of channels to expect for a given output\n",
    "    '''\n",
    "    def __init__(self, input_channels, output_channels, hidden_channels=32):\n",
    "        super(UNet, self).__init__()\n",
    "        self.upfeature = FeatureMapBlock(input_channels, hidden_channels)\n",
    "        self.contract1 = ContractingBlock(hidden_channels, use_dropout=True)\n",
    "        self.contract2 = ContractingBlock(hidden_channels * 2, use_dropout=True)\n",
    "        self.contract3 = ContractingBlock(hidden_channels * 4, use_dropout=True)\n",
    "        self.contract4 = ContractingBlock(hidden_channels * 8)\n",
    "        self.contract5 = ContractingBlock(hidden_channels * 16)\n",
    "        self.contract6 = ContractingBlock(hidden_channels * 32)\n",
    "        self.expand0 = ExpandingBlock(hidden_channels * 64)\n",
    "        self.expand1 = ExpandingBlock(hidden_channels * 32)\n",
    "        self.expand2 = ExpandingBlock(hidden_channels * 16)\n",
    "        self.expand3 = ExpandingBlock(hidden_channels * 8)\n",
    "        self.expand4 = ExpandingBlock(hidden_channels * 4)\n",
    "        self.expand5 = ExpandingBlock(hidden_channels * 2)\n",
    "        self.downfeature = FeatureMapBlock(hidden_channels, output_channels)\n",
    "        self.sigmoid = torch.nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        '''\n",
    "        Function for completing a forward pass of UNet: \n",
    "        Given an image tensor, passes it through U-Net and returns the output.\n",
    "        Parameters:\n",
    "            x: image tensor of shape (batch size, channels, height, width)\n",
    "        '''\n",
    "        x0 = self.upfeature(x)\n",
    "        x1 = self.contract1(x0)\n",
    "        x2 = self.contract2(x1)\n",
    "        x3 = self.contract3(x2)\n",
    "        x4 = self.contract4(x3)\n",
    "        x5 = self.contract5(x4)\n",
    "        x6 = self.contract6(x5)\n",
    "        x7 = self.expand0(x6, x5)\n",
    "        x8 = self.expand1(x7, x4)\n",
    "        x9 = self.expand2(x8, x3)\n",
    "        x10 = self.expand3(x9, x2)\n",
    "        x11 = self.expand4(x10, x1)\n",
    "        x12 = self.expand5(x11, x0)\n",
    "        xn = self.downfeature(x12)\n",
    "        return self.sigmoid(xn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T6ndvjc_1KXx"
   },
   "source": [
    "## PatchGAN Discriminator\n",
    "\n",
    "Next, you will define a discriminator based on the contracting path of the U-Net to allow you to evaluate the realism of the generated images. Remember that the discriminator outputs a one-channel matrix of classifications instead of a single value. Your discriminator's final layer will simply map from the final number of hidden channels to a single prediction for every pixel of the layer before it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0nVuJPjV1f92"
   },
   "outputs": [],
   "source": [
    "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CLASS: Discriminator\n",
    "class Discriminator(nn.Module):\n",
    "    '''\n",
    "    Discriminator Class\n",
    "    Structured like the contracting path of the U-Net, the discriminator will\n",
    "    output a matrix of values classifying corresponding portions of the image as real or fake. \n",
    "    Parameters:\n",
    "        input_channels: the number of image input channels\n",
    "        hidden_channels: the initial number of discriminator convolutional filters\n",
    "    '''\n",
    "    def __init__(self, input_channels, hidden_channels=8):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.upfeature = FeatureMapBlock(input_channels, hidden_channels)\n",
    "        self.contract1 = ContractingBlock(hidden_channels, use_bn=False)\n",
    "        self.contract2 = ContractingBlock(hidden_channels * 2)\n",
    "        self.contract3 = ContractingBlock(hidden_channels * 4)\n",
    "        self.contract4 = ContractingBlock(hidden_channels * 8)\n",
    "        #### START CODE HERE ####\n",
    "        self.final = nn.Conv2d(hidden_channels * 16, 1, kernel_size=1)\n",
    "        #### END CODE HERE ####\n",
    "\n",
    "    def forward(self, x, y):\n",
    "        x = torch.cat([x, y], axis=1)\n",
    "        x0 = self.upfeature(x)\n",
    "        x1 = self.contract1(x0)\n",
    "        x2 = self.contract2(x1)\n",
    "        x3 = self.contract3(x2)\n",
    "        x4 = self.contract4(x3)\n",
    "        xn = self.final(x4)\n",
    "        return xn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AFZBTJ_4Ubld"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "# UNIT TEST\n",
    "test_discriminator = Discriminator(10, 1)\n",
    "assert tuple(test_discriminator(\n",
    "    torch.randn(1, 5, 256, 256), \n",
    "    torch.randn(1, 5, 256, 256)\n",
    ").shape) == (1, 1, 16, 16)\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qRk_8azSq3tF"
   },
   "source": [
    "## Training Preparation\n",
    "<!-- You'll be using the same U-Net as in the previous assignment, but you'll write another discriminator and change the loss to make it a GAN. -->\n",
    "\n",
    "Now you can begin putting everything together for training. You start by defining some new parameters as well as the ones you are familiar with:\n",
    "  *   **real_dim**: the number of channels of the real image and the number expected in the output image\n",
    "  *   **adv_criterion**: an adversarial loss function to keep track of how well the GAN is fooling the discriminator and how well the discriminator is catching the GAN\n",
    "  *   **recon_criterion**: a loss function that rewards similar images to the ground truth, which \"reconstruct\" the image\n",
    "  *   **lambda_recon**: a parameter for how heavily the reconstruction loss should be weighed\n",
    "  *   **n_epochs**: the number of times you iterate through the entire dataset when training\n",
    "  *   **input_dim**: the number of channels of the input image\n",
    "  *   **display_step**: how often to display/visualize the images\n",
    "  *   **batch_size**: the number of images per forward/backward pass\n",
    "  *   **lr**: the learning rate\n",
    "  *   **target_shape**: the size of the output image (in pixels)\n",
    "  *   **device**: the device type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UXptQZcwrBrq"
   },
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "# New parameters\n",
    "adv_criterion = nn.BCEWithLogitsLoss() \n",
    "recon_criterion = nn.L1Loss() \n",
    "lambda_recon = 200\n",
    "\n",
    "n_epochs = 20\n",
    "input_dim = 3\n",
    "real_dim = 3\n",
    "display_step = 200\n",
    "batch_size = 4\n",
    "lr = 0.0002\n",
    "target_shape = 256\n",
    "device = 'cuda'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WPOUC6-nVDCv"
   },
   "source": [
    "You will then pre-process the images of the dataset to make sure they're all the same size and that the size change due to U-Net layers is accounted for. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PNAK2XqMJ419"
   },
   "outputs": [],
   "source": [
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "])\n",
    "\n",
    "import torchvision\n",
    "dataset = torchvision.datasets.ImageFolder(\"maps\", transform=transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "t7vKN1POUjud"
   },
   "source": [
    "Next, you can initialize your generator (U-Net) and discriminator, as well as their optimizers. Finally, you will also load your pre-trained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vBY3Y9UrUgVX"
   },
   "outputs": [],
   "source": [
    "gen = UNet(input_dim, real_dim).to(device)\n",
    "gen_opt = torch.optim.Adam(gen.parameters(), lr=lr)\n",
    "disc = Discriminator(input_dim + real_dim).to(device)\n",
    "disc_opt = torch.optim.Adam(disc.parameters(), lr=lr)\n",
    "\n",
    "def weights_init(m):\n",
    "    if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\n",
    "        torch.nn.init.normal_(m.weight, 0.0, 0.02)\n",
    "    if isinstance(m, nn.BatchNorm2d):\n",
    "        torch.nn.init.normal_(m.weight, 0.0, 0.02)\n",
    "        torch.nn.init.constant_(m.bias, 0)\n",
    "\n",
    "# Feel free to change pretrained to False if you're training the model from scratch\n",
    "pretrained = True\n",
    "if pretrained:\n",
    "    loaded_state = torch.load(\"pix2pix_15000.pth\")\n",
    "    gen.load_state_dict(loaded_state[\"gen\"])\n",
    "    gen_opt.load_state_dict(loaded_state[\"gen_opt\"])\n",
    "    disc.load_state_dict(loaded_state[\"disc\"])\n",
    "    disc_opt.load_state_dict(loaded_state[\"disc_opt\"])\n",
    "else:\n",
    "    gen = gen.apply(weights_init)\n",
    "    disc = disc.apply(weights_init)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YcpFbNDYzJrh"
   },
   "source": [
    "While there are some changes to the U-Net architecture for Pix2Pix, the most important distinguishing feature of Pix2Pix is its adversarial loss. You will be implementing that here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YZE-Eyj0LOpm"
   },
   "outputs": [],
   "source": [
    "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CLASS: get_gen_loss\n",
    "def get_gen_loss(gen, disc, real, condition, adv_criterion, recon_criterion, lambda_recon):\n",
    "    '''\n",
    "    Return the loss of the generator given inputs.\n",
    "    Parameters:\n",
    "        gen: the generator; takes the condition and returns potential images\n",
    "        disc: the discriminator; takes images and the condition and\n",
    "          returns real/fake prediction matrices\n",
    "        real: the real images (e.g. maps) to be used to evaluate the reconstruction\n",
    "        condition: the source images (e.g. satellite imagery) which are used to produce the real images\n",
    "        adv_criterion: the adversarial loss function; takes the discriminator \n",
    "                  predictions and the true labels and returns a adversarial \n",
    "                  loss (which you aim to minimize)\n",
    "        recon_criterion: the reconstruction loss function; takes the generator \n",
    "                    outputs and the real images and returns a reconstructuion \n",
    "                    loss (which you aim to minimize)\n",
    "        lambda_recon: the degree to which the reconstruction loss should be weighted in the sum\n",
    "    '''\n",
    "    # Steps: 1) Generate the fake images, based on the conditions.\n",
    "    #        2) Evaluate the fake images and the condition with the discriminator.\n",
    "    #        3) Calculate the adversarial and reconstruction losses.\n",
    "    #        4) Add the two losses, weighting the reconstruction loss appropriately.\n",
    "    #### START CODE HERE ####\n",
    "    fake = gen(condition)\n",
    "    disc_fake_hat = disc(fake, condition)\n",
    "    gen_adv_loss = adv_criterion(disc_fake_hat, torch.ones_like(disc_fake_hat))\n",
    "    gen_rec_loss = recon_criterion(real, fake)\n",
    "    gen_loss = gen_adv_loss + lambda_recon * gen_rec_loss\n",
    "    #### END CODE HERE ####\n",
    "    return gen_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "KLndbJ213hV5",
    "outputId": "a713cd00-2b7d-41da-a3cb-90f4dc0ca49f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "# UNIT TEST\n",
    "def test_gen_reasonable(num_images=10):\n",
    "    gen = torch.zeros_like\n",
    "    disc = lambda x, y: torch.ones(len(x), 1)\n",
    "    real = None\n",
    "    condition = torch.ones(num_images, 3, 10, 10)\n",
    "    adv_criterion = torch.mul\n",
    "    recon_criterion = lambda x, y: torch.tensor(0)\n",
    "    lambda_recon = 0\n",
    "    assert get_gen_loss(gen, disc, real, condition, adv_criterion, recon_criterion, lambda_recon).sum() == num_images\n",
    "\n",
    "    disc = lambda x, y: torch.zeros(len(x), 1)\n",
    "    assert torch.abs(get_gen_loss(gen, disc, real, condition, adv_criterion, recon_criterion, lambda_recon)).sum() == 0\n",
    "\n",
    "    adv_criterion = lambda x, y: torch.tensor(0)\n",
    "    recon_criterion = lambda x, y: torch.abs(x - y).max()\n",
    "    real = torch.randn(num_images, 3, 10, 10)\n",
    "    lambda_recon = 2\n",
    "    gen = lambda x: real + 1\n",
    "    assert torch.abs(get_gen_loss(gen, disc, real, condition, adv_criterion, recon_criterion, lambda_recon) - 2) < 1e-4\n",
    "\n",
    "    adv_criterion = lambda x, y: (x + y).max() + x.max()\n",
    "    assert torch.abs(get_gen_loss(gen, disc, real, condition, adv_criterion, recon_criterion, lambda_recon) - 3) < 1e-4\n",
    "test_gen_reasonable()\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SMDZWZTz3ivA"
   },
   "source": [
    "## Pix2Pix Training\n",
    "\n",
    "Finally, you can train the model and see some of your maps!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 373,
     "referenced_widgets": [
      "aa7565ec3f294fd6b9c592bd5fc0dfcb",
      "fe98210470c3421c9a39734dc1203817",
      "a47c53e27edd4ef2b5bc79b3d64c44d3",
      "54a72fb618d146babc5830644ff65992",
      "6bf1b15c1b8e42758c8e9768115d6f8e",
      "bc3d591d82414f86888f2512bb3eb02a",
      "8cdec6ea735847709cc610fef8dc5755",
      "5042b39eadc14d5ab8b310e23d9c7d96"
     ]
    },
    "colab_type": "code",
    "id": "fy6UBV60HtnY",
    "outputId": "c174bb25-acbf-4507-c6e2-6bf7ef08661c"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5fea174d4b4e4fa3b5af867c6ecfcab4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=549.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pretrained initial state\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-177ac0af42d2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     62\u001b[0m                     }, f\"pix2pix_{cur_step}.pth\")\n\u001b[1;32m     63\u001b[0m             \u001b[0mcur_step\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-10-177ac0af42d2>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(save_model)\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_epochs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m         \u001b[0;31m# Dataloader returns the batches\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataloader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m             \u001b[0mimage_width\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m             \u001b[0mcondition\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0mimage_width\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tqdm/notebook.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    213\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    214\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 215\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtqdm_notebook\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    216\u001b[0m                 \u001b[0;31m# return super(tqdm...) will not catch exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    217\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tqdm/std.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1102\u001b[0m                 fp_write=getattr(self.fp, 'write', sys.stderr.write))\n\u001b[1;32m   1103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1104\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1105\u001b[0m             \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1106\u001b[0m             \u001b[0;31m# Update and possibly print the progressbar.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    343\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    344\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__next__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 345\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    346\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    347\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    383\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    384\u001b[0m         \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 385\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_fetcher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    386\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    387\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36mfetch\u001b[0;34m(self, possibly_batched_index)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, index)\u001b[0m\n\u001b[1;32m    138\u001b[0m         \u001b[0msample\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    139\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m             \u001b[0msample\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    141\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_transform\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    142\u001b[0m             \u001b[0mtarget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torchvision/transforms/transforms.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, img)\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransforms\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m             \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torchvision/transforms/transforms.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, pic)\u001b[0m\n\u001b[1;32m     99\u001b[0m             \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mConverted\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    100\u001b[0m         \"\"\"\n\u001b[0;32m--> 101\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_tensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    102\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torchvision/transforms/functional.py\u001b[0m in \u001b[0;36mto_tensor\u001b[0;34m(pic)\u001b[0m\n\u001b[1;32m     98\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     99\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mByteTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 100\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m255\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    101\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    102\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from skimage import color\n",
    "import numpy as np\n",
    "\n",
    "def train(save_model=False):\n",
    "    mean_generator_loss = 0\n",
    "    mean_discriminator_loss = 0\n",
    "    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
    "    cur_step = 0\n",
    "\n",
    "    for epoch in range(n_epochs):\n",
    "        # Dataloader returns the batches\n",
    "        for image, _ in tqdm(dataloader):\n",
    "            image_width = image.shape[3]\n",
    "            condition = image[:, :, :, :image_width // 2]\n",
    "            condition = nn.functional.interpolate(condition, size=target_shape)\n",
    "            real = image[:, :, :, image_width // 2:]\n",
    "            real = nn.functional.interpolate(real, size=target_shape)\n",
    "            cur_batch_size = len(condition)\n",
    "            condition = condition.to(device)\n",
    "            real = real.to(device)\n",
    "\n",
    "            ### Update discriminator ###\n",
    "            disc_opt.zero_grad() # Zero out the gradient before backpropagation\n",
    "            with torch.no_grad():\n",
    "                fake = gen(condition)\n",
    "            disc_fake_hat = disc(fake.detach(), condition) # Detach generator\n",
    "            disc_fake_loss = adv_criterion(disc_fake_hat, torch.zeros_like(disc_fake_hat))\n",
    "            disc_real_hat = disc(real, condition)\n",
    "            disc_real_loss = adv_criterion(disc_real_hat, torch.ones_like(disc_real_hat))\n",
    "            disc_loss = (disc_fake_loss + disc_real_loss) / 2\n",
    "            disc_loss.backward(retain_graph=True) # Update gradients\n",
    "            disc_opt.step() # Update optimizer\n",
    "\n",
    "            ### Update generator ###\n",
    "            gen_opt.zero_grad()\n",
    "            gen_loss = get_gen_loss(gen, disc, real, condition, adv_criterion, recon_criterion, lambda_recon)\n",
    "            gen_loss.backward() # Update gradients\n",
    "            gen_opt.step() # Update optimizer\n",
    "\n",
    "            # Keep track of the average discriminator loss\n",
    "            mean_discriminator_loss += disc_loss.item() / display_step\n",
    "            # Keep track of the average generator loss\n",
    "            mean_generator_loss += gen_loss.item() / display_step\n",
    "\n",
    "            ### Visualization code ###\n",
    "            if cur_step % display_step == 0:\n",
    "                if cur_step > 0:\n",
    "                    print(f\"Epoch {epoch}: Step {cur_step}: Generator (U-Net) loss: {mean_generator_loss}, Discriminator loss: {mean_discriminator_loss}\")\n",
    "                else:\n",
    "                    print(\"Pretrained initial state\")\n",
    "                show_tensor_images(condition, size=(input_dim, target_shape, target_shape))\n",
    "                show_tensor_images(real, size=(real_dim, target_shape, target_shape))\n",
    "                show_tensor_images(fake, size=(real_dim, target_shape, target_shape))\n",
    "                mean_generator_loss = 0\n",
    "                mean_discriminator_loss = 0\n",
    "                # You can change save_model to True if you'd like to save the model\n",
    "                if save_model:\n",
    "                    torch.save({'gen': gen.state_dict(),\n",
    "                        'gen_opt': gen_opt.state_dict(),\n",
    "                        'disc': disc.state_dict(),\n",
    "                        'disc_opt': disc_opt.state_dict()\n",
    "                    }, f\"pix2pix_{cur_step}.pth\")\n",
    "            cur_step += 1\n",
    "train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "C3W2: Pix2Pix.ipynb",
   "provenance": []
  },
  "coursera": {
   "schema_names": [
    "GANSC3-2B"
   ]
  },
  "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.6.9"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "5042b39eadc14d5ab8b310e23d9c7d96": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "54a72fb618d146babc5830644ff65992": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5042b39eadc14d5ab8b310e23d9c7d96",
      "placeholder": "​",
      "style": "IPY_MODEL_8cdec6ea735847709cc610fef8dc5755",
      "value": " 23/275 [00:15&lt;02:49,  1.49it/s]"
     }
    },
    "6bf1b15c1b8e42758c8e9768115d6f8e": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "8cdec6ea735847709cc610fef8dc5755": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "a47c53e27edd4ef2b5bc79b3d64c44d3": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "danger",
      "description": "  8%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_bc3d591d82414f86888f2512bb3eb02a",
      "max": 275,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_6bf1b15c1b8e42758c8e9768115d6f8e",
      "value": 23
     }
    },
    "aa7565ec3f294fd6b9c592bd5fc0dfcb": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_a47c53e27edd4ef2b5bc79b3d64c44d3",
       "IPY_MODEL_54a72fb618d146babc5830644ff65992"
      ],
      "layout": "IPY_MODEL_fe98210470c3421c9a39734dc1203817"
     }
    },
    "bc3d591d82414f86888f2512bb3eb02a": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "fe98210470c3421c9a39734dc1203817": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}