CycleGAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example is a breakdown of the train code released with pytorch-CycleGAN-and-pix2pix.  It's less generic - I'm only including the ResNet implementation, and using their default options from the actual code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Generator Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import init\n",
    "from torch.autograd import Variable\n",
    "import numpy as np\n",
    "import random\n",
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ngpus = 1\n",
    "batch_size = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define a resnet block, using reflective padding and InstanceNorm\n",
    "class ResnetBlock(nn.Module):\n",
    "    def __init__(self, dim, use_bias):\n",
    "        super(ResnetBlock, self).__init__()\n",
    "        self.conv_block = self.build_conv_block(dim, use_bias)\n",
    "    def build_conv_block(self, dim, use_bias):\n",
    "        conv_block = []\n",
    "        conv_block += [nn.ReflectionPad2d(1)]\n",
    "        conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=0, bias=use_bias),\n",
    "                       nn.InstanceNorm2d(dim),\n",
    "                       nn.ReLU(True)]\n",
    "        conv_block += [nn.ReflectionPad2d(1)]\n",
    "        conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=0, bias=use_bias),\n",
    "                       nn.InstanceNorm2d(dim)]\n",
    "\n",
    "        return nn.Sequential(*conv_block)\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = x + self.conv_block(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Defines the generator that consists of Resnet blocks between a few\n",
    "# downsampling/upsampling operations.\n",
    "# Code and idea originally from Justin Johnson's architecture.\n",
    "# https://github.com/jcjohnson/fast-neural-style/\n",
    "class ResnetGenerator(nn.Module):\n",
    "    def __init__(self, input_nc, output_nc, ngf=64):\n",
    "        super(ResnetGenerator, self).__init__()\n",
    "        use_bias = True\n",
    "        n_downsampling = 2\n",
    "        n_blocks = 9\n",
    "\n",
    "        model = [nn.ReflectionPad2d(3),\n",
    "                 nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0,\n",
    "                           bias=use_bias),\n",
    "                 nn.InstanceNorm2d(ngf),\n",
    "                 nn.ReLU(True)]\n",
    "\n",
    "        for i in range(n_downsampling):\n",
    "            mult = 2**i\n",
    "            model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3,\n",
    "                                stride=2, padding=1, bias=use_bias),\n",
    "                      nn.InstanceNorm2d(ngf * mult * 2),\n",
    "                      nn.ReLU(True)]\n",
    "\n",
    "        mult = 2**n_downsampling\n",
    "        for i in range(n_blocks):\n",
    "            model += [ResnetBlock(ngf * mult, use_bias=use_bias)]\n",
    "\n",
    "        for i in range(n_downsampling):\n",
    "            mult = 2**(n_downsampling - i)\n",
    "            model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),\n",
    "                                         kernel_size=3, stride=2,\n",
    "                                         padding=1, output_padding=1,\n",
    "                                         bias=use_bias),\n",
    "                      nn.InstanceNorm2d(int(ngf * mult / 2)),\n",
    "                      nn.ReLU(True)]\n",
    "        model += [nn.ReflectionPad2d(3)]\n",
    "        model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]\n",
    "        model += [nn.Tanh()]\n",
    "\n",
    "        self.model = nn.Sequential(*model)\n",
    "\n",
    "    def forward(self, input):\n",
    "        if ngpus > 1:\n",
    "            return nn.parallel.data_parallel(self.model, input, range(ngpus))\n",
    "        return self.model(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def weights_init(m):\n",
    "    classname = m.__class__.__name__\n",
    "    if classname.find('Conv') != -1:\n",
    "        m.weight.data.normal_(0.0, 0.02)\n",
    "        if hasattr(m.bias, 'data'):\n",
    "            m.bias.data.fill_(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# create generator network\n",
    "def define_G(input_nc, output_nc, ngf):\n",
    "    netG = ResnetGenerator(input_nc, output_nc, ngf)\n",
    "    netG.apply(weights_init)\n",
    "    return netG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Discriminator Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Defines the PatchGAN discriminator with the specified arguments.\n",
    "class NLayerDiscriminator(nn.Module):\n",
    "    def __init__(self, input_nc, ndf=64, n_layers=3):\n",
    "        super(NLayerDiscriminator, self).__init__()\n",
    "        use_bias = True\n",
    "        kw = 4\n",
    "        padw = int(np.ceil((kw-1)/2))\n",
    "        sequence = [\n",
    "            nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw),\n",
    "            nn.LeakyReLU(0.2, True)\n",
    "        ]\n",
    "\n",
    "        nf_mult = 1\n",
    "        nf_mult_prev = 1\n",
    "        for n in range(1, n_layers):\n",
    "            nf_mult_prev = nf_mult\n",
    "            nf_mult = min(2**n, 8)\n",
    "            sequence += [\n",
    "                nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,\n",
    "                          kernel_size=kw, stride=2, padding=padw, bias=use_bias),\n",
    "                nn.InstanceNorm2d(ndf * nf_mult),\n",
    "                nn.LeakyReLU(0.2, True)\n",
    "            ]\n",
    "\n",
    "        nf_mult_prev = nf_mult\n",
    "        nf_mult = min(2**n_layers, 8)\n",
    "        sequence += [\n",
    "            nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,\n",
    "                      kernel_size=kw, stride=1, padding=padw, bias=use_bias),\n",
    "            nn.InstanceNorm2d(ndf * nf_mult),\n",
    "            nn.LeakyReLU(0.2, True)\n",
    "        ]\n",
    "\n",
    "        sequence += [nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)]\n",
    "\n",
    "        self.model = nn.Sequential(*sequence)\n",
    "\n",
    "    def forward(self, input):\n",
    "        if ngpus > 1:\n",
    "            return nn.parallel.data_parallel(self.model, input, range(ngpus))\n",
    "        return self.model(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def define_D(input_nc, ndf, n_layers_D=3):\n",
    "    netD = NLayerDiscriminator(input_nc, ndf, n_layers=3)\n",
    "    netD.apply(weights_init)\n",
    "    return netD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loss Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Defines the GAN loss which uses either LSGAN or the regular GAN.\n",
    "# When LSGAN is used, it is basically same as MSELoss,\n",
    "# but it abstracts away the need to create the target label tensor\n",
    "# that has the same size as the input\n",
    "class GANLoss(nn.Module):\n",
    "    def __init__(self, use_lsgan=True, target_real_label=1.0, target_fake_label=0.0):\n",
    "        super(GANLoss, self).__init__()\n",
    "        self.real_label = target_real_label\n",
    "        self.fake_label = target_fake_label\n",
    "        self.real_label_var = None\n",
    "        self.fake_label_var = None\n",
    "        if use_lsgan:\n",
    "            self.loss = nn.MSELoss()\n",
    "        else:\n",
    "            self.loss = nn.BCELoss()\n",
    "\n",
    "    def get_target_tensor(self, input, target_is_real):\n",
    "        target_tensor = None\n",
    "        if target_is_real:\n",
    "            create_label = ((self.real_label_var is None) or\n",
    "                            (self.real_label_var.numel() != input.numel()))\n",
    "            if create_label:\n",
    "                real_tensor = torch.FloatTensor(input.size()).fill_(self.real_label)\n",
    "                self.real_label_var = Variable(real_tensor, requires_grad=False)\n",
    "            target_tensor = self.real_label_var\n",
    "        else:\n",
    "            create_label = ((self.fake_label_var is None) or\n",
    "                            (self.fake_label_var.numel() != input.numel()))\n",
    "            if create_label:\n",
    "                fake_tensor = torch.FloatTensor(input.size()).fill_(self.fake_label)\n",
    "                self.fake_label_var = Variable(fake_tensor, requires_grad=False)\n",
    "            target_tensor = self.fake_label_var\n",
    "        if torch.cuda.is_available():\n",
    "            target_tensor = target_tensor.cuda()\n",
    "        return target_tensor\n",
    "\n",
    "    def __call__(self, input, target_is_real):\n",
    "        target_tensor = self.get_target_tensor(input, target_is_real)\n",
    "        return self.loss(input, target_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image Pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ImagePool():\n",
    "    def __init__(self, pool_size):\n",
    "        self.pool_size = pool_size\n",
    "        if self.pool_size > 0:\n",
    "            self.num_imgs = 0\n",
    "            self.images = []\n",
    "\n",
    "    def query(self, images):\n",
    "        if self.pool_size == 0:\n",
    "            return images\n",
    "        return_images = []\n",
    "        for image in images.data:\n",
    "            image = torch.unsqueeze(image, 0)\n",
    "            if self.num_imgs < self.pool_size:\n",
    "                self.num_imgs = self.num_imgs + 1\n",
    "                self.images.append(image)\n",
    "                return_images.append(image)\n",
    "            else:\n",
    "                p = random.uniform(0, 1)\n",
    "                if p > 0.5:\n",
    "                    random_id = random.randint(0, self.pool_size-1)\n",
    "                    tmp = self.images[random_id].clone()\n",
    "                    self.images[random_id] = image\n",
    "                    return_images.append(tmp)\n",
    "                else:\n",
    "                    return_images.append(image)\n",
    "        return_images = Variable(torch.cat(return_images, 0))\n",
    "        return return_images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CycleGAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_network(net):\n",
    "    num_params = 0\n",
    "    for param in net.parameters():\n",
    "        num_params += param.numel()\n",
    "    print(net)\n",
    "    print('Total number of parameters: %d' % num_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class CycleGANModel(object):\n",
    "    def initialize(self, isTrain = True):\n",
    "        self.nb = 1 # batch size\n",
    "        self.size = 256 # crop size\n",
    "        self.input_nc = 3 # number of input channels\n",
    "        self.output_nc = 3 # number of output channels\n",
    "        self.ngf = 64 # number of generative filters in the first conv layer\n",
    "        self.ndf = 64 # number of discriminative filters in the first conv layer\n",
    "        self.pool_size = 50 # size of image buffer that stores previously generated images\n",
    "        self.lr = 0.0002 # initial learning rate for Adam\n",
    "        self.old_lr = 0.0002 # initial learning rate for Adam\n",
    "        self.beta1 = 0.5 # momentum term for Adam\n",
    "        self.identity = 0.0 # use identity mapping. Setting identity other than 1 has an effect of scaling the weight of the identity mapping loss. For example, if the weight of the identity loss should be 10 times smaller than the weight of the reconstruction loss, please set optidentity = 0.1\n",
    "        self.lambda_A = 10.0 # weight for cycle loss (A -> B -> A)\n",
    "        self.lambda_B = 10.0 # weight for cycle loss (B -> A -> B)\n",
    "        self.checkpoint_dir = 'checkpoints'\n",
    "        \n",
    "        # inputs\n",
    "        self.input_A = torch.FloatTensor(self.nb, self.input_nc, self.size, self.size)\n",
    "        self.input_B = torch.FloatTensor(self.nb, self.output_nc, self.size, self.size)\n",
    "\n",
    "        # generators\n",
    "        self.netG_A = define_G(self.input_nc, self.output_nc, self.ngf)\n",
    "        self.netG_B = define_G(self.output_nc, self.input_nc, self.ngf)\n",
    "        if torch.cuda.is_available():\n",
    "            self.netG_A.cuda()\n",
    "            self.netG_B.cuda()\n",
    "\n",
    "        if isTrain:\n",
    "            # discriminators\n",
    "            self.netD_A = define_D(self.output_nc, self.ndf)\n",
    "            self.netD_B = define_D(self.input_nc, self.ndf)\n",
    "            if torch.cuda.is_available():\n",
    "                self.netD_A.cuda()\n",
    "                self.netD_B.cuda()\n",
    "            \n",
    "            self.fake_A_pool = ImagePool(self.pool_size)\n",
    "            self.fake_B_pool = ImagePool(self.pool_size)\n",
    "            # define loss functions\n",
    "            self.criterionGAN = GANLoss(use_lsgan=True)\n",
    "            self.criterionCycle = torch.nn.L1Loss()\n",
    "            self.criterionIdt = torch.nn.L1Loss()\n",
    "\n",
    "            # initialize optimizers\n",
    "            self.optimizer_G = torch.optim.Adam(itertools.chain(self.netG_A.parameters(), self.netG_B.parameters()),\n",
    "                                                lr=self.old_lr, betas=(self.beta1, 0.999))\n",
    "            self.optimizer_D_A = torch.optim.Adam(self.netD_A.parameters(), lr=self.old_lr, betas=(self.beta1, 0.999))\n",
    "            self.optimizer_D_B = torch.optim.Adam(self.netD_B.parameters(), lr=self.old_lr, betas=(self.beta1, 0.999))\n",
    "            self.optimizer_D_B = torch.optim.Adam(self.netD_B.parameters(), lr=self.old_lr, betas=(self.beta1, 0.999))\n",
    "\n",
    "        print('---------- Networks initialized -------------')\n",
    "        print_network(self.netG_A)\n",
    "        print_network(self.netG_B)\n",
    "        if isTrain:\n",
    "            print_network(self.netD_A)\n",
    "            print_network(self.netD_B)\n",
    "        print('-----------------------------------------------')\n",
    "\n",
    "    def set_input(self, input):\n",
    "        input_A = input['A']\n",
    "        input_B = input['B']\n",
    "        self.input_A.resize_(input_A.size()).copy_(input_A)\n",
    "        self.input_B.resize_(input_B.size()).copy_(input_B)\n",
    "        self.image_paths = input['A_paths']\n",
    "\n",
    "    def forward(self):\n",
    "        self.real_A = Variable(self.input_A)\n",
    "        self.real_B = Variable(self.input_B)\n",
    "        if torch.cuda.is_available():\n",
    "            self.real_A = self.real_A.cuda()\n",
    "            self.real_B = self.real_B.cuda()\n",
    "\n",
    "    def test(self):\n",
    "        self.real_A = Variable(self.input_A, volatile=True)\n",
    "        self.real_B = Variable(self.input_B, volatile=True)\n",
    "        if torch.cuda.is_available():\n",
    "            self.real_A = self.real_A.cuda()\n",
    "            self.real_B = self.real_B.cuda()\n",
    "\n",
    "        self.fake_B = self.netG_A.forward(self.real_A)\n",
    "        self.rec_A = self.netG_B.forward(self.fake_B)\n",
    "\n",
    "        self.fake_A = self.netG_B.forward(self.real_B)\n",
    "        self.rec_B = self.netG_A.forward(self.fake_A)\n",
    "\n",
    "    # get image paths\n",
    "    def get_image_paths(self):\n",
    "        return self.image_paths\n",
    "\n",
    "    def backward_D_basic(self, netD, real, fake):\n",
    "        # Real\n",
    "        pred_real = netD.forward(real)\n",
    "        loss_D_real = self.criterionGAN(pred_real, True)\n",
    "        # Fake\n",
    "        pred_fake = netD.forward(fake.detach())\n",
    "        loss_D_fake = self.criterionGAN(pred_fake, False)\n",
    "        # Combined loss\n",
    "        loss_D = (loss_D_real + loss_D_fake) * 0.5\n",
    "        # backward\n",
    "        loss_D.backward()\n",
    "        return loss_D\n",
    "\n",
    "    def backward_D_A(self):\n",
    "        fake_B = self.fake_B_pool.query(self.fake_B)\n",
    "        self.loss_D_A = self.backward_D_basic(self.netD_A, self.real_B, fake_B)\n",
    "\n",
    "    def backward_D_B(self):\n",
    "        fake_A = self.fake_A_pool.query(self.fake_A)\n",
    "        self.loss_D_B = self.backward_D_basic(self.netD_B, self.real_A, fake_A)\n",
    "\n",
    "    def backward_G(self):\n",
    "        lambda_idt = self.identity\n",
    "        lambda_A = self.lambda_A\n",
    "        lambda_B = self.lambda_B\n",
    "        # Identity loss\n",
    "        if lambda_idt > 0:\n",
    "            # G_A should be identity if real_B is fed.\n",
    "            self.idt_A = self.netG_A.forward(self.real_B)\n",
    "            self.loss_idt_A = self.criterionIdt(self.idt_A, self.real_B) * lambda_B * lambda_idt\n",
    "            # G_B should be identity if real_A is fed.\n",
    "            self.idt_B = self.netG_B.forward(self.real_A)\n",
    "            self.loss_idt_B = self.criterionIdt(self.idt_B, self.real_A) * lambda_A * lambda_idt\n",
    "        else:\n",
    "            self.loss_idt_A = 0\n",
    "            self.loss_idt_B = 0\n",
    "\n",
    "        # GAN loss\n",
    "        # D_A(G_A(A))\n",
    "        self.fake_B = self.netG_A.forward(self.real_A)\n",
    "        pred_fake = self.netD_A.forward(self.fake_B)\n",
    "        self.loss_G_A = self.criterionGAN(pred_fake, True)\n",
    "        # D_B(G_B(B))\n",
    "        self.fake_A = self.netG_B.forward(self.real_B)\n",
    "        pred_fake = self.netD_B.forward(self.fake_A)\n",
    "        self.loss_G_B = self.criterionGAN(pred_fake, True)\n",
    "        # Forward cycle loss\n",
    "        self.rec_A = self.netG_B.forward(self.fake_B)\n",
    "        self.loss_cycle_A = self.criterionCycle(self.rec_A, self.real_A) * lambda_A\n",
    "        # Backward cycle loss\n",
    "        self.rec_B = self.netG_A.forward(self.fake_A)\n",
    "        self.loss_cycle_B = self.criterionCycle(self.rec_B, self.real_B) * lambda_B\n",
    "        # combined loss\n",
    "        self.loss_G = self.loss_G_A + self.loss_G_B + self.loss_cycle_A + self.loss_cycle_B + self.loss_idt_A + self.loss_idt_B\n",
    "        self.loss_G.backward()\n",
    "\n",
    "    def optimize_parameters(self):\n",
    "        # forward\n",
    "        self.forward()\n",
    "        # G_A and G_B\n",
    "        self.optimizer_G.zero_grad()\n",
    "        self.backward_G()\n",
    "        self.optimizer_G.step()\n",
    "        # D_A\n",
    "        self.optimizer_D_A.zero_grad()\n",
    "        self.backward_D_A()\n",
    "        self.optimizer_D_A.step()\n",
    "        # D_B\n",
    "        self.optimizer_D_B.zero_grad()\n",
    "        self.backward_D_B()\n",
    "        self.optimizer_D_B.step()\n",
    "\n",
    "    def get_current_errors(self):\n",
    "        D_A = self.loss_D_A.data[0]\n",
    "        G_A = self.loss_G_A.data[0]\n",
    "        Cyc_A = self.loss_cycle_A.data[0]\n",
    "        D_B = self.loss_D_B.data[0]\n",
    "        G_B = self.loss_G_B.data[0]\n",
    "        Cyc_B = self.loss_cycle_B.data[0]\n",
    "        if self.identity > 0.0:\n",
    "            idt_A = self.loss_idt_A.data[0]\n",
    "            idt_B = self.loss_idt_B.data[0]\n",
    "            return OrderedDict([('D_A', D_A), ('G_A', G_A), ('Cyc_A', Cyc_A), ('idt_A', idt_A),\n",
    "                                ('D_B', D_B), ('G_B', G_B), ('Cyc_B', Cyc_B), ('idt_B', idt_B)])\n",
    "        else:\n",
    "            return OrderedDict([('D_A', D_A), ('G_A', G_A), ('Cyc_A', Cyc_A),\n",
    "                                ('D_B', D_B), ('G_B', G_B), ('Cyc_B', Cyc_B)])\n",
    "\n",
    "    def save(self, label):\n",
    "        self.save_network(self.netG_A, 'G_A', label)\n",
    "        self.save_network(self.netD_A, 'D_A', label)\n",
    "        self.save_network(self.netG_B, 'G_B', label)\n",
    "        self.save_network(self.netD_B, 'D_B', label)\n",
    "\n",
    "    def update_learning_rate(self, niter_decay):\n",
    "        lrd = self.lr / niter_decay\n",
    "        lr = self.old_lr - lrd\n",
    "        for param_group in self.optimizer_D_A.param_groups:\n",
    "            param_group['lr'] = lr\n",
    "        for param_group in self.optimizer_D_B.param_groups:\n",
    "            param_group['lr'] = lr\n",
    "        for param_group in self.optimizer_G.param_groups:\n",
    "            param_group['lr'] = lr\n",
    "\n",
    "        print('update learning rate: %f -> %f' % (self.old_lr, lr))\n",
    "        self.old_lr = lr\n",
    "    \n",
    "    def save_network(self, network, network_label, epoch_label):\n",
    "        save_filename = '%s_net_%s.pth' % (epoch_label, network_label)\n",
    "        save_path = os.path.join(self.checkpoint_dir, save_filename)\n",
    "        torch.save(network.cpu().state_dict(), save_path)\n",
    "        if torch.cuda.is_available():\n",
    "            network.cuda()\n",
    "\n",
    "    # helper loading function that can be used by subclasses\n",
    "    def load_network(self, network, network_label, epoch_label):\n",
    "        save_filename = '%s_net_%s.pth' % (epoch_label, network_label)\n",
    "        save_path = os.path.join(self.save_dir, save_filename)\n",
    "        network.load_state_dict(torch.load(save_path))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "if [ ! -d datasets/maps ]; then\n",
    "./datasets/download_cyclegan_dataset.sh maps\n",
    "fi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torchvision.transforms as transforms\n",
    "from PIL import Image\n",
    "import os\n",
    "from glob import glob\n",
    "\n",
    "class MapsDataset(Dataset):\n",
    "    def __init__(self, mode):\n",
    "        self.img_paths_A = glob(os.path.join('datasets/maps', mode+'A', '*.jpg'))\n",
    "        self.img_paths_B = glob(os.path.join('datasets/maps', mode+'B', '*.jpg'))\n",
    "        self.img_paths_A = sorted(self.img_paths_A)\n",
    "        self.img_paths_B = sorted(self.img_paths_B)\n",
    "        self.A_size = len(self.img_paths_A)\n",
    "        self.B_size = len(self.img_paths_B)\n",
    "        self.dataset_size = max(self.A_size, self.B_size)\n",
    "        self.transform = self.get_transform()\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        index_A = index % self.A_size\n",
    "        index_B = random.randint(0, self.B_size-1)\n",
    "        \n",
    "        img_path_A = self.img_paths_A[index_A]\n",
    "        img_path_B = self.img_paths_B[index_B]\n",
    "        \n",
    "        raw_img_A = Image.open(img_path_A).convert('RGB')\n",
    "        raw_img_B = Image.open(img_path_B).convert('RGB')\n",
    "        img_A = self.transform(raw_img_A)\n",
    "        img_B = self.transform(raw_img_B)\n",
    "        \n",
    "        return {'A': img_A, 'B': img_B, \n",
    "                'A_paths': img_path_A, 'B_paths': img_path_B,\n",
    "                'raw_A': np.asarray(raw_img_A), 'raw_B': np.asarray(raw_img_B)}\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.dataset_size\n",
    "    \n",
    "    def get_transform(self):\n",
    "        load_size = 286\n",
    "        fine_size = 256\n",
    "        transform_list = [transforms.Scale((load_size, load_size), Image.BICUBIC),\n",
    "                          transforms.RandomCrop(fine_size),\n",
    "                          transforms.ToTensor(),\n",
    "                          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
    "        return transforms.Compose(transform_list)\n",
    "        \n",
    "    def name(self):\n",
    "        return \"MapsDataset\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training images: 1096\n"
     ]
    }
   ],
   "source": [
    "maps_dataset = MapsDataset('train')\n",
    "maps_dataloader = DataLoader(maps_dataset, batch_size=batch_size, shuffle=True, num_workers=2)\n",
    "print('Number of training images: ' + str(len(maps_dataloader)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7f1ed5a85c50>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6oAAADxCAYAAADC3Uq3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1f0a9097b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def unnorm(x):\n",
    "    un_x = 255*(x*0.5+0.5)\n",
    "    return un_x.astype(np.uint8)\n",
    "\n",
    "# visualize to check images\n",
    "test_datum = next(iter(maps_dataloader))\n",
    "plt.figure(figsize=(16,4))\n",
    "plt.subplot(1,4,1)\n",
    "plt.imshow(test_datum['raw_A'][0].numpy())\n",
    "plt.title('Raw A')\n",
    "plt.subplot(1,4,2)\n",
    "plt.imshow(unnorm(test_datum['A'][0].numpy()).transpose(1,2,0))\n",
    "plt.title('A')\n",
    "plt.subplot(1,4,3)\n",
    "plt.imshow(test_datum['raw_B'][0].numpy())\n",
    "plt.title('Raw B')\n",
    "plt.subplot(1,4,4)\n",
    "plt.imshow(unnorm(test_datum['B'][0].numpy()).transpose(1,2,0))\n",
    "plt.title('B')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------- Networks initialized -------------\n",
      "ResnetGenerator (\n",
      "  (model): Sequential (\n",
      "    (0): ReflectionPad2d (3, 3, 3, 3)\n",
      "    (1): Conv2d(3, 64, kernel_size=(7, 7), stride=(1, 1))\n",
      "    (2): InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (3): ReLU (inplace)\n",
      "    (4): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (5): InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (6): ReLU (inplace)\n",
      "    (7): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (8): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (9): ReLU (inplace)\n",
      "    (10): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (11): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (12): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (13): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (14): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (15): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (16): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (17): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (18): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (19): ConvTranspose2d(256, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
      "    (20): InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (21): ReLU (inplace)\n",
      "    (22): ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
      "    (23): InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (24): ReLU (inplace)\n",
      "    (25): ReflectionPad2d (3, 3, 3, 3)\n",
      "    (26): Conv2d(64, 3, kernel_size=(7, 7), stride=(1, 1))\n",
      "    (27): Tanh ()\n",
      "  )\n",
      ")\n",
      "Total number of parameters: 11378179\n",
      "ResnetGenerator (\n",
      "  (model): Sequential (\n",
      "    (0): ReflectionPad2d (3, 3, 3, 3)\n",
      "    (1): Conv2d(3, 64, kernel_size=(7, 7), stride=(1, 1))\n",
      "    (2): InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (3): ReLU (inplace)\n",
      "    (4): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (5): InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (6): ReLU (inplace)\n",
      "    (7): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (8): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (9): ReLU (inplace)\n",
      "    (10): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (11): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (12): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (13): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (14): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (15): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (16): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (17): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (18): ResnetBlock (\n",
      "      (conv_block): Sequential (\n",
      "        (0): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "        (3): ReLU (inplace)\n",
      "        (4): ReflectionPad2d (1, 1, 1, 1)\n",
      "        (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "        (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "      )\n",
      "    )\n",
      "    (19): ConvTranspose2d(256, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
      "    (20): InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (21): ReLU (inplace)\n",
      "    (22): ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
      "    (23): InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (24): ReLU (inplace)\n",
      "    (25): ReflectionPad2d (3, 3, 3, 3)\n",
      "    (26): Conv2d(64, 3, kernel_size=(7, 7), stride=(1, 1))\n",
      "    (27): Tanh ()\n",
      "  )\n",
      ")\n",
      "Total number of parameters: 11378179\n",
      "NLayerDiscriminator (\n",
      "  (model): Sequential (\n",
      "    (0): Conv2d(3, 64, kernel_size=(4, 4), stride=(2, 2), padding=(2, 2))\n",
      "    (1): LeakyReLU (0.2, inplace)\n",
      "    (2): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(2, 2))\n",
      "    (3): InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (4): LeakyReLU (0.2, inplace)\n",
      "    (5): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(2, 2))\n",
      "    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (7): LeakyReLU (0.2, inplace)\n",
      "    (8): Conv2d(256, 512, kernel_size=(4, 4), stride=(1, 1), padding=(2, 2))\n",
      "    (9): InstanceNorm2d(512, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (10): LeakyReLU (0.2, inplace)\n",
      "    (11): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1), padding=(2, 2))\n",
      "  )\n",
      ")\n",
      "Total number of parameters: 2764737\n",
      "NLayerDiscriminator (\n",
      "  (model): Sequential (\n",
      "    (0): Conv2d(3, 64, kernel_size=(4, 4), stride=(2, 2), padding=(2, 2))\n",
      "    (1): LeakyReLU (0.2, inplace)\n",
      "    (2): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(2, 2))\n",
      "    (3): InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (4): LeakyReLU (0.2, inplace)\n",
      "    (5): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(2, 2))\n",
      "    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (7): LeakyReLU (0.2, inplace)\n",
      "    (8): Conv2d(256, 512, kernel_size=(4, 4), stride=(1, 1), padding=(2, 2))\n",
      "    (9): InstanceNorm2d(512, eps=1e-05, momentum=0.1, affine=False)\n",
      "    (10): LeakyReLU (0.2, inplace)\n",
      "    (11): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1), padding=(2, 2))\n",
      "  )\n",
      ")\n",
      "Total number of parameters: 2764737\n",
      "-----------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "model = CycleGANModel()\n",
    "model.initialize(isTrain=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f1cb2fa91fe24bd3bc0673acd61b4052"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "04b6060387a54da48e68bdcd4a29df8c"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 1, iter 0): lossG 2.636077, lossD_A 0.101981, lossD_B 0.205902\n",
      "(epoch 1, iter 100): lossG 3.036292, lossD_A 0.064840, lossD_B 0.127950\n",
      "(epoch 1, iter 200): lossG 2.651728, lossD_A 0.204895, lossD_B 0.190584\n",
      "(epoch 1, iter 300): lossG 4.034714, lossD_A 0.165399, lossD_B 0.083002\n",
      "(epoch 1, iter 400): lossG 3.072157, lossD_A 0.124268, lossD_B 0.145442\n",
      "(epoch 1, iter 500): lossG 3.303264, lossD_A 0.105188, lossD_B 0.168636\n",
      "(epoch 1, iter 600): lossG 3.816211, lossD_A 0.399649, lossD_B 0.177755\n",
      "(epoch 1, iter 700): lossG 2.388910, lossD_A 0.166504, lossD_B 0.094071\n",
      "(epoch 1, iter 800): lossG 3.951657, lossD_A 0.225194, lossD_B 0.186453\n",
      "(epoch 1, iter 900): lossG 3.169069, lossD_A 0.138416, lossD_B 0.104453\n",
      "(epoch 1, iter 1000): lossG 3.565406, lossD_A 0.014407, lossD_B 0.059743\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "087e14b6982945088dcffba220fc967a"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 2, iter 0): lossG 2.490222, lossD_A 0.097117, lossD_B 0.128819\n",
      "(epoch 2, iter 100): lossG 2.899707, lossD_A 0.059223, lossD_B 0.099755\n",
      "(epoch 2, iter 200): lossG 2.297934, lossD_A 0.181214, lossD_B 0.051043\n",
      "(epoch 2, iter 300): lossG 3.333260, lossD_A 0.119503, lossD_B 0.209538\n",
      "(epoch 2, iter 400): lossG 4.858857, lossD_A 0.075732, lossD_B 0.056171\n",
      "(epoch 2, iter 500): lossG 2.586762, lossD_A 0.251751, lossD_B 0.220116\n",
      "(epoch 2, iter 600): lossG 3.288961, lossD_A 0.166470, lossD_B 0.185103\n",
      "(epoch 2, iter 700): lossG 2.854129, lossD_A 0.091361, lossD_B 0.180610\n",
      "(epoch 2, iter 800): lossG 3.103172, lossD_A 0.322113, lossD_B 0.232387\n",
      "(epoch 2, iter 900): lossG 2.997650, lossD_A 0.036631, lossD_B 0.100610\n",
      "(epoch 2, iter 1000): lossG 2.726433, lossD_A 0.063099, lossD_B 0.089531\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2ce26ebc6f98496daa0b4ad1308bc0cc"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 3, iter 0): lossG 3.109198, lossD_A 0.216928, lossD_B 0.218396\n",
      "(epoch 3, iter 100): lossG 2.947299, lossD_A 0.145082, lossD_B 0.272876\n",
      "(epoch 3, iter 200): lossG 3.215147, lossD_A 0.061227, lossD_B 0.187228\n",
      "(epoch 3, iter 300): lossG 2.924899, lossD_A 0.064839, lossD_B 0.093984\n",
      "(epoch 3, iter 400): lossG 3.849916, lossD_A 0.116165, lossD_B 0.110193\n",
      "(epoch 3, iter 500): lossG 3.228843, lossD_A 0.110546, lossD_B 0.235845\n",
      "(epoch 3, iter 600): lossG 4.484268, lossD_A 0.191160, lossD_B 0.102822\n",
      "(epoch 3, iter 700): lossG 3.184188, lossD_A 0.051234, lossD_B 0.207775\n",
      "(epoch 3, iter 800): lossG 2.621077, lossD_A 0.192199, lossD_B 0.302223\n",
      "(epoch 3, iter 900): lossG 3.237728, lossD_A 0.147617, lossD_B 0.220546\n",
      "(epoch 3, iter 1000): lossG 3.076499, lossD_A 0.097567, lossD_B 0.087733\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3b05e8bc4fc34c43814d04601994676a"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 4, iter 0): lossG 2.968611, lossD_A 0.130531, lossD_B 0.113200\n",
      "(epoch 4, iter 100): lossG 3.082429, lossD_A 0.125554, lossD_B 0.065866\n",
      "(epoch 4, iter 200): lossG 3.511784, lossD_A 0.026357, lossD_B 0.298192\n",
      "(epoch 4, iter 300): lossG 2.402703, lossD_A 0.104107, lossD_B 0.224149\n",
      "(epoch 4, iter 400): lossG 3.200895, lossD_A 0.055254, lossD_B 0.242038\n",
      "(epoch 4, iter 500): lossG 2.481311, lossD_A 0.091464, lossD_B 0.155702\n",
      "(epoch 4, iter 600): lossG 4.206094, lossD_A 0.063944, lossD_B 0.193233\n",
      "(epoch 4, iter 700): lossG 2.323821, lossD_A 0.075112, lossD_B 0.164772\n",
      "(epoch 4, iter 800): lossG 3.910687, lossD_A 0.016704, lossD_B 0.260409\n",
      "(epoch 4, iter 900): lossG 3.734071, lossD_A 0.063643, lossD_B 0.055018\n",
      "(epoch 4, iter 1000): lossG 1.963484, lossD_A 0.092426, lossD_B 0.248335\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1efc4c66e58c4e16bc651298169f9635"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 5, iter 0): lossG 2.112999, lossD_A 0.083318, lossD_B 0.270557\n",
      "(epoch 5, iter 100): lossG 2.255711, lossD_A 0.120969, lossD_B 0.254420\n",
      "(epoch 5, iter 200): lossG 3.838321, lossD_A 0.159720, lossD_B 0.316976\n",
      "(epoch 5, iter 300): lossG 2.089946, lossD_A 0.163000, lossD_B 0.197322\n",
      "(epoch 5, iter 400): lossG 3.260026, lossD_A 0.173416, lossD_B 0.170557\n",
      "(epoch 5, iter 500): lossG 2.810236, lossD_A 0.118608, lossD_B 0.088122\n",
      "(epoch 5, iter 600): lossG 2.961822, lossD_A 0.209051, lossD_B 0.223913\n",
      "(epoch 5, iter 700): lossG 4.332600, lossD_A 0.257876, lossD_B 0.155890\n",
      "(epoch 5, iter 800): lossG 2.269272, lossD_A 0.070474, lossD_B 0.157877\n",
      "(epoch 5, iter 900): lossG 2.876507, lossD_A 0.198801, lossD_B 0.163791\n",
      "(epoch 5, iter 1000): lossG 2.857551, lossD_A 0.126363, lossD_B 0.083289\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5eb7695074734872ac8cfbcfab3193bf"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 6, iter 0): lossG 2.656136, lossD_A 0.149832, lossD_B 0.113553\n",
      "(epoch 6, iter 100): lossG 2.718485, lossD_A 0.014131, lossD_B 0.121117\n",
      "(epoch 6, iter 200): lossG 2.682648, lossD_A 0.064979, lossD_B 0.144553\n",
      "(epoch 6, iter 300): lossG 3.045845, lossD_A 0.043170, lossD_B 0.146014\n",
      "(epoch 6, iter 400): lossG 2.269617, lossD_A 0.086344, lossD_B 0.239805\n",
      "(epoch 6, iter 500): lossG 2.907357, lossD_A 0.087690, lossD_B 0.240342\n",
      "(epoch 6, iter 600): lossG 1.880115, lossD_A 0.209883, lossD_B 0.121479\n",
      "(epoch 6, iter 700): lossG 4.569999, lossD_A 0.066386, lossD_B 0.308516\n",
      "(epoch 6, iter 800): lossG 2.603496, lossD_A 0.093463, lossD_B 0.066602\n",
      "(epoch 6, iter 900): lossG 2.260497, lossD_A 0.202968, lossD_B 0.226789\n",
      "(epoch 6, iter 1000): lossG 2.032527, lossD_A 0.221910, lossD_B 0.210945\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "078f78a4f96d4222b7af8395851c8e9b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 7, iter 0): lossG 2.581410, lossD_A 0.069289, lossD_B 0.120551\n",
      "(epoch 7, iter 100): lossG 2.484577, lossD_A 0.124391, lossD_B 0.324805\n",
      "(epoch 7, iter 200): lossG 2.559529, lossD_A 0.072071, lossD_B 0.203690\n",
      "(epoch 7, iter 300): lossG 1.856626, lossD_A 0.131068, lossD_B 0.295567\n",
      "(epoch 7, iter 400): lossG 3.208102, lossD_A 0.112936, lossD_B 0.144267\n",
      "(epoch 7, iter 500): lossG 2.142639, lossD_A 0.083054, lossD_B 0.163007\n",
      "(epoch 7, iter 600): lossG 2.411803, lossD_A 0.062061, lossD_B 0.091853\n",
      "(epoch 7, iter 700): lossG 2.074127, lossD_A 0.033934, lossD_B 0.124050\n",
      "(epoch 7, iter 800): lossG 3.376300, lossD_A 0.054543, lossD_B 0.070812\n",
      "(epoch 7, iter 900): lossG 2.630982, lossD_A 0.075179, lossD_B 0.083999\n",
      "(epoch 7, iter 1000): lossG 1.808774, lossD_A 0.245549, lossD_B 0.225414\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "11d875c0bee9499c8bc8ce39ced19e2b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 8, iter 0): lossG 2.929895, lossD_A 0.088714, lossD_B 0.028374\n",
      "(epoch 8, iter 100): lossG 2.743061, lossD_A 0.226352, lossD_B 0.248858\n",
      "(epoch 8, iter 200): lossG 3.696041, lossD_A 0.112737, lossD_B 0.191907\n",
      "(epoch 8, iter 300): lossG 3.393412, lossD_A 0.120698, lossD_B 0.228490\n",
      "(epoch 8, iter 400): lossG 2.194111, lossD_A 0.302667, lossD_B 0.025903\n",
      "(epoch 8, iter 500): lossG 4.656832, lossD_A 0.102410, lossD_B 0.148095\n",
      "(epoch 8, iter 600): lossG 2.438469, lossD_A 0.206225, lossD_B 0.048625\n",
      "(epoch 8, iter 700): lossG 3.413027, lossD_A 0.055521, lossD_B 0.208004\n",
      "(epoch 8, iter 800): lossG 2.888163, lossD_A 0.141315, lossD_B 0.347487\n",
      "(epoch 8, iter 900): lossG 3.440434, lossD_A 0.125758, lossD_B 0.135403\n",
      "(epoch 8, iter 1000): lossG 2.492664, lossD_A 0.157190, lossD_B 0.108495\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8eecb386cb6b46be88c437717871670c"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 9, iter 0): lossG 2.725267, lossD_A 0.132740, lossD_B 0.028209\n",
      "(epoch 9, iter 100): lossG 2.816722, lossD_A 0.138942, lossD_B 0.124082\n",
      "(epoch 9, iter 200): lossG 3.502584, lossD_A 0.057876, lossD_B 0.033252\n",
      "(epoch 9, iter 300): lossG 2.298862, lossD_A 0.112249, lossD_B 0.087149\n",
      "(epoch 9, iter 400): lossG 2.761014, lossD_A 0.016360, lossD_B 0.074861\n",
      "(epoch 9, iter 500): lossG 3.081973, lossD_A 0.043747, lossD_B 0.095659\n",
      "(epoch 9, iter 600): lossG 3.104747, lossD_A 0.120488, lossD_B 0.145618\n",
      "(epoch 9, iter 700): lossG 1.885746, lossD_A 0.350551, lossD_B 0.287948\n",
      "(epoch 9, iter 800): lossG 1.941661, lossD_A 0.185659, lossD_B 0.120624\n",
      "(epoch 9, iter 900): lossG 2.180694, lossD_A 0.154339, lossD_B 0.202962\n",
      "(epoch 9, iter 1000): lossG 2.312345, lossD_A 0.140301, lossD_B 0.243482\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5ed0a192d2d141cb85dd9918ec4547a8"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 10, iter 0): lossG 2.550315, lossD_A 0.085837, lossD_B 0.238824\n",
      "(epoch 10, iter 100): lossG 3.182607, lossD_A 0.086375, lossD_B 0.236396\n",
      "(epoch 10, iter 200): lossG 1.772833, lossD_A 0.168929, lossD_B 0.103813\n",
      "(epoch 10, iter 300): lossG 2.954842, lossD_A 0.115122, lossD_B 0.174876\n",
      "(epoch 10, iter 400): lossG 2.743472, lossD_A 0.197647, lossD_B 0.241740\n",
      "(epoch 10, iter 500): lossG 2.651565, lossD_A 0.133180, lossD_B 0.086828\n",
      "(epoch 10, iter 600): lossG 2.259725, lossD_A 0.082473, lossD_B 0.170139\n",
      "(epoch 10, iter 700): lossG 2.194291, lossD_A 0.057465, lossD_B 0.221076\n",
      "(epoch 10, iter 800): lossG 3.339966, lossD_A 0.157655, lossD_B 0.091004\n",
      "(epoch 10, iter 900): lossG 1.804929, lossD_A 0.122803, lossD_B 0.071846\n",
      "(epoch 10, iter 1000): lossG 1.869419, lossD_A 0.090496, lossD_B 0.305010\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a08ea34db8c44a81b2823cc99dcc669f"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 11, iter 0): lossG 3.680211, lossD_A 0.139921, lossD_B 0.258698\n",
      "(epoch 11, iter 100): lossG 1.914400, lossD_A 0.134540, lossD_B 0.114886\n",
      "(epoch 11, iter 200): lossG 2.691579, lossD_A 0.285709, lossD_B 0.066249\n",
      "(epoch 11, iter 300): lossG 2.133339, lossD_A 0.053708, lossD_B 0.060597\n",
      "(epoch 11, iter 400): lossG 2.274118, lossD_A 0.164933, lossD_B 0.136348\n",
      "(epoch 11, iter 500): lossG 2.533589, lossD_A 0.258277, lossD_B 0.087225\n",
      "(epoch 11, iter 600): lossG 2.358696, lossD_A 0.260003, lossD_B 0.454783\n",
      "(epoch 11, iter 700): lossG 2.061797, lossD_A 0.212831, lossD_B 0.142261\n",
      "(epoch 11, iter 800): lossG 2.593141, lossD_A 0.059458, lossD_B 0.288495\n",
      "(epoch 11, iter 900): lossG 1.880029, lossD_A 0.108902, lossD_B 0.580600\n",
      "(epoch 11, iter 1000): lossG 1.737935, lossD_A 0.111403, lossD_B 0.315899\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "09583d7622d948ceab7980f91ba8fc67"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 12, iter 0): lossG 2.440217, lossD_A 0.185790, lossD_B 0.179199\n",
      "(epoch 12, iter 100): lossG 2.576341, lossD_A 0.265256, lossD_B 0.068279\n",
      "(epoch 12, iter 200): lossG 1.773135, lossD_A 0.031970, lossD_B 0.292826\n",
      "(epoch 12, iter 300): lossG 2.682512, lossD_A 0.341636, lossD_B 0.101173\n",
      "(epoch 12, iter 400): lossG 1.858947, lossD_A 0.272473, lossD_B 0.237839\n",
      "(epoch 12, iter 500): lossG 2.201997, lossD_A 0.178264, lossD_B 0.042557\n",
      "(epoch 12, iter 600): lossG 2.876566, lossD_A 0.073744, lossD_B 0.099647\n",
      "(epoch 12, iter 700): lossG 2.116507, lossD_A 0.359923, lossD_B 0.216806\n",
      "(epoch 12, iter 800): lossG 2.491221, lossD_A 0.119925, lossD_B 0.134022\n",
      "(epoch 12, iter 900): lossG 2.925280, lossD_A 0.223292, lossD_B 0.146677\n",
      "(epoch 12, iter 1000): lossG 2.036638, lossD_A 0.037458, lossD_B 0.160621\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b00cd4ca69ea42f2abb7b5b02b1c4fe5"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 13, iter 0): lossG 2.250075, lossD_A 0.157001, lossD_B 0.351420\n",
      "(epoch 13, iter 100): lossG 3.564976, lossD_A 0.040497, lossD_B 0.608713\n",
      "(epoch 13, iter 200): lossG 3.245317, lossD_A 0.122720, lossD_B 0.093378\n",
      "(epoch 13, iter 300): lossG 1.912840, lossD_A 0.253154, lossD_B 0.165201\n",
      "(epoch 13, iter 400): lossG 2.190953, lossD_A 0.574780, lossD_B 0.115671\n",
      "(epoch 13, iter 500): lossG 1.798105, lossD_A 0.234645, lossD_B 0.052793\n",
      "(epoch 13, iter 600): lossG 2.225782, lossD_A 0.069006, lossD_B 0.123700\n",
      "(epoch 13, iter 700): lossG 1.828248, lossD_A 0.362414, lossD_B 0.216543\n",
      "(epoch 13, iter 800): lossG 1.939041, lossD_A 0.293868, lossD_B 0.200734\n",
      "(epoch 13, iter 900): lossG 2.743690, lossD_A 0.202050, lossD_B 0.169412\n",
      "(epoch 13, iter 1000): lossG 2.240060, lossD_A 0.047447, lossD_B 0.258316\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1cb63f32fd5f4fba81fc4732802d600b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 14, iter 0): lossG 2.338899, lossD_A 0.051461, lossD_B 0.124975\n",
      "(epoch 14, iter 100): lossG 2.386997, lossD_A 0.151994, lossD_B 0.100213\n",
      "(epoch 14, iter 200): lossG 2.283380, lossD_A 0.216440, lossD_B 0.172557\n",
      "(epoch 14, iter 300): lossG 2.448127, lossD_A 0.261576, lossD_B 0.258531\n",
      "(epoch 14, iter 400): lossG 2.898322, lossD_A 0.081990, lossD_B 0.136170\n",
      "(epoch 14, iter 500): lossG 2.469598, lossD_A 0.103121, lossD_B 0.083060\n",
      "(epoch 14, iter 600): lossG 2.140676, lossD_A 0.301016, lossD_B 0.164498\n",
      "(epoch 14, iter 700): lossG 1.391433, lossD_A 0.167583, lossD_B 0.068914\n",
      "(epoch 14, iter 800): lossG 2.190073, lossD_A 0.121683, lossD_B 0.159595\n",
      "(epoch 14, iter 900): lossG 2.623542, lossD_A 0.262402, lossD_B 0.067858\n",
      "(epoch 14, iter 1000): lossG 1.935760, lossD_A 0.249249, lossD_B 0.138238\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "536b490b8a9f4f54b2a50900ab6ebb23"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 15, iter 0): lossG 2.238220, lossD_A 0.071170, lossD_B 0.104205\n",
      "(epoch 15, iter 100): lossG 1.757500, lossD_A 0.213339, lossD_B 0.232064\n",
      "(epoch 15, iter 200): lossG 2.353848, lossD_A 0.110219, lossD_B 0.135562\n",
      "(epoch 15, iter 300): lossG 2.606965, lossD_A 0.108514, lossD_B 0.132161\n",
      "(epoch 15, iter 400): lossG 2.462319, lossD_A 0.174512, lossD_B 0.230762\n",
      "(epoch 15, iter 500): lossG 2.755263, lossD_A 0.176932, lossD_B 0.160415\n",
      "(epoch 15, iter 600): lossG 3.535079, lossD_A 0.297791, lossD_B 0.172924\n",
      "(epoch 15, iter 700): lossG 1.746626, lossD_A 0.077849, lossD_B 0.276122\n",
      "(epoch 15, iter 800): lossG 2.013104, lossD_A 0.057422, lossD_B 0.111994\n",
      "(epoch 15, iter 900): lossG 3.133460, lossD_A 0.049048, lossD_B 0.197236\n",
      "(epoch 15, iter 1000): lossG 2.665524, lossD_A 0.130427, lossD_B 0.068708\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e723548556184dbbb2ac20d4bbc929c2"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 16, iter 0): lossG 2.500754, lossD_A 0.098223, lossD_B 0.075540\n",
      "(epoch 16, iter 100): lossG 1.746041, lossD_A 0.093434, lossD_B 0.194921\n",
      "(epoch 16, iter 200): lossG 2.138129, lossD_A 0.160624, lossD_B 0.062460\n",
      "(epoch 16, iter 300): lossG 2.294916, lossD_A 0.144531, lossD_B 0.115679\n",
      "(epoch 16, iter 400): lossG 1.893675, lossD_A 0.136607, lossD_B 0.075656\n",
      "(epoch 16, iter 500): lossG 1.891274, lossD_A 0.397409, lossD_B 0.340887\n",
      "(epoch 16, iter 600): lossG 2.304051, lossD_A 0.066456, lossD_B 0.163803\n",
      "(epoch 16, iter 700): lossG 3.222939, lossD_A 0.078349, lossD_B 0.045751\n",
      "(epoch 16, iter 800): lossG 2.566830, lossD_A 0.222056, lossD_B 0.149795\n",
      "(epoch 16, iter 900): lossG 2.713626, lossD_A 0.106349, lossD_B 0.109248\n",
      "(epoch 16, iter 1000): lossG 2.313542, lossD_A 0.136934, lossD_B 0.195319\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a678dcd254a044dba13bbe04b8b43638"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 17, iter 0): lossG 1.988963, lossD_A 0.197304, lossD_B 0.184556\n",
      "(epoch 17, iter 100): lossG 2.962777, lossD_A 0.096509, lossD_B 0.203243\n",
      "(epoch 17, iter 200): lossG 1.991274, lossD_A 0.308308, lossD_B 0.043622\n",
      "(epoch 17, iter 300): lossG 2.080880, lossD_A 0.257347, lossD_B 0.235635\n",
      "(epoch 17, iter 400): lossG 2.292242, lossD_A 0.256087, lossD_B 0.211094\n",
      "(epoch 17, iter 500): lossG 1.712133, lossD_A 0.221105, lossD_B 0.168852\n",
      "(epoch 17, iter 600): lossG 2.311485, lossD_A 0.079851, lossD_B 0.152281\n",
      "(epoch 17, iter 700): lossG 2.369543, lossD_A 0.130865, lossD_B 0.074019\n",
      "(epoch 17, iter 800): lossG 3.005337, lossD_A 0.104653, lossD_B 0.222149\n",
      "(epoch 17, iter 900): lossG 2.352294, lossD_A 0.125317, lossD_B 0.367117\n",
      "(epoch 17, iter 1000): lossG 2.583430, lossD_A 0.210158, lossD_B 0.255395\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f4ef6e7756784cf1bcd9ccf250e772e3"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 18, iter 0): lossG 1.918601, lossD_A 0.081567, lossD_B 0.071602\n",
      "(epoch 18, iter 100): lossG 1.975380, lossD_A 0.184319, lossD_B 0.150062\n",
      "(epoch 18, iter 200): lossG 1.711477, lossD_A 0.351383, lossD_B 0.099330\n",
      "(epoch 18, iter 300): lossG 2.348311, lossD_A 0.202871, lossD_B 0.164206\n",
      "(epoch 18, iter 400): lossG 1.677830, lossD_A 0.126728, lossD_B 0.295036\n",
      "(epoch 18, iter 500): lossG 2.191269, lossD_A 0.110474, lossD_B 0.147701\n",
      "(epoch 18, iter 600): lossG 1.606284, lossD_A 0.122521, lossD_B 0.305491\n",
      "(epoch 18, iter 700): lossG 2.440042, lossD_A 0.105270, lossD_B 0.137006\n",
      "(epoch 18, iter 800): lossG 2.337196, lossD_A 0.081115, lossD_B 0.195156\n",
      "(epoch 18, iter 900): lossG 2.409775, lossD_A 0.047585, lossD_B 0.270043\n",
      "(epoch 18, iter 1000): lossG 1.699811, lossD_A 0.136116, lossD_B 0.267053\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9ab6f4a3b46741089b92669a6a3c6a94"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 19, iter 0): lossG 3.560746, lossD_A 0.029099, lossD_B 0.086145\n",
      "(epoch 19, iter 100): lossG 2.839169, lossD_A 0.050480, lossD_B 0.074802\n",
      "(epoch 19, iter 200): lossG 3.037596, lossD_A 0.103010, lossD_B 0.058353\n",
      "(epoch 19, iter 300): lossG 2.417362, lossD_A 0.034745, lossD_B 0.156326\n",
      "(epoch 19, iter 400): lossG 1.928918, lossD_A 0.104116, lossD_B 0.156192\n",
      "(epoch 19, iter 500): lossG 2.773281, lossD_A 0.231464, lossD_B 0.236928\n",
      "(epoch 19, iter 600): lossG 2.245655, lossD_A 0.161927, lossD_B 0.084426\n",
      "(epoch 19, iter 700): lossG 1.755312, lossD_A 0.185515, lossD_B 0.261548\n",
      "(epoch 19, iter 800): lossG 1.833330, lossD_A 0.172835, lossD_B 0.233936\n",
      "(epoch 19, iter 900): lossG 3.010665, lossD_A 0.208673, lossD_B 0.174240\n",
      "(epoch 19, iter 1000): lossG 2.898489, lossD_A 0.073955, lossD_B 0.380786\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "417328e824a84000aef156251700bacf"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 20, iter 0): lossG 2.916944, lossD_A 0.221810, lossD_B 0.265571\n",
      "(epoch 20, iter 100): lossG 2.648677, lossD_A 0.166515, lossD_B 0.185985\n",
      "(epoch 20, iter 200): lossG 2.003422, lossD_A 0.187451, lossD_B 0.196172\n",
      "(epoch 20, iter 300): lossG 2.198528, lossD_A 0.113876, lossD_B 0.152142\n",
      "(epoch 20, iter 400): lossG 1.965014, lossD_A 0.192543, lossD_B 0.257690\n",
      "(epoch 20, iter 500): lossG 1.795787, lossD_A 0.252308, lossD_B 0.100261\n",
      "(epoch 20, iter 600): lossG 1.085863, lossD_A 0.173463, lossD_B 0.354158\n",
      "(epoch 20, iter 700): lossG 2.595331, lossD_A 0.051018, lossD_B 0.191840\n",
      "(epoch 20, iter 800): lossG 2.649835, lossD_A 0.186922, lossD_B 0.304596\n",
      "(epoch 20, iter 900): lossG 2.393883, lossD_A 0.188322, lossD_B 0.523986\n",
      "(epoch 20, iter 1000): lossG 2.823240, lossD_A 0.066895, lossD_B 0.180611\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "02b7ba16f3d3416b86ea1efe87d0b0af"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 21, iter 0): lossG 2.137576, lossD_A 0.120870, lossD_B 0.175409\n",
      "(epoch 21, iter 100): lossG 2.257216, lossD_A 0.075613, lossD_B 0.121311\n",
      "(epoch 21, iter 200): lossG 2.134327, lossD_A 0.059790, lossD_B 0.124445\n",
      "(epoch 21, iter 300): lossG 1.544067, lossD_A 0.429867, lossD_B 0.281477\n",
      "(epoch 21, iter 400): lossG 2.179233, lossD_A 0.187650, lossD_B 0.205143\n",
      "(epoch 21, iter 500): lossG 2.659003, lossD_A 0.037245, lossD_B 0.039967\n",
      "(epoch 21, iter 600): lossG 2.208543, lossD_A 0.246190, lossD_B 0.230133\n",
      "(epoch 21, iter 700): lossG 1.643743, lossD_A 0.194832, lossD_B 0.257737\n",
      "(epoch 21, iter 800): lossG 1.916631, lossD_A 0.189539, lossD_B 0.082668\n",
      "(epoch 21, iter 900): lossG 2.631688, lossD_A 0.073165, lossD_B 0.249876\n",
      "(epoch 21, iter 1000): lossG 2.815580, lossD_A 0.182752, lossD_B 0.193383\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0dbc5ed86e73472581d79aca84e7904e"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 22, iter 0): lossG 1.863924, lossD_A 0.057300, lossD_B 0.208777\n",
      "(epoch 22, iter 100): lossG 1.895093, lossD_A 0.092592, lossD_B 0.482186\n",
      "(epoch 22, iter 200): lossG 1.917275, lossD_A 0.111940, lossD_B 0.284093\n",
      "(epoch 22, iter 300): lossG 1.702877, lossD_A 0.289232, lossD_B 0.136923\n",
      "(epoch 22, iter 400): lossG 2.000779, lossD_A 0.224945, lossD_B 0.227341\n",
      "(epoch 22, iter 500): lossG 1.772743, lossD_A 0.078636, lossD_B 0.208994\n",
      "(epoch 22, iter 600): lossG 2.485816, lossD_A 0.047239, lossD_B 0.114367\n",
      "(epoch 22, iter 700): lossG 1.856411, lossD_A 0.137043, lossD_B 0.321837\n",
      "(epoch 22, iter 800): lossG 1.847505, lossD_A 0.122652, lossD_B 0.286462\n",
      "(epoch 22, iter 900): lossG 1.651559, lossD_A 0.130695, lossD_B 0.228015\n",
      "(epoch 22, iter 1000): lossG 1.982007, lossD_A 0.189002, lossD_B 0.084030\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a9bc667e13b44eaea45f22adb29f7a43"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 23, iter 0): lossG 2.332274, lossD_A 0.064353, lossD_B 0.158870\n",
      "(epoch 23, iter 100): lossG 2.604247, lossD_A 0.256077, lossD_B 0.192396\n",
      "(epoch 23, iter 200): lossG 1.939138, lossD_A 0.036485, lossD_B 0.257840\n",
      "(epoch 23, iter 300): lossG 1.467304, lossD_A 0.109348, lossD_B 0.425429\n",
      "(epoch 23, iter 400): lossG 1.943343, lossD_A 0.149726, lossD_B 0.107576\n",
      "(epoch 23, iter 500): lossG 2.472866, lossD_A 0.102366, lossD_B 0.248778\n",
      "(epoch 23, iter 600): lossG 3.428490, lossD_A 0.183051, lossD_B 0.139046\n",
      "(epoch 23, iter 700): lossG 2.158294, lossD_A 0.106619, lossD_B 0.259711\n",
      "(epoch 23, iter 800): lossG 2.440934, lossD_A 0.027166, lossD_B 0.102549\n",
      "(epoch 23, iter 900): lossG 1.609053, lossD_A 0.269168, lossD_B 0.248836\n",
      "(epoch 23, iter 1000): lossG 2.108860, lossD_A 0.104120, lossD_B 0.127453\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fe4d41f96ae2492f9f259b0c200b9efe"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 24, iter 0): lossG 2.647311, lossD_A 0.224592, lossD_B 0.133939\n",
      "(epoch 24, iter 100): lossG 2.641265, lossD_A 0.167874, lossD_B 0.128967\n",
      "(epoch 24, iter 200): lossG 2.245327, lossD_A 0.116701, lossD_B 0.084256\n",
      "(epoch 24, iter 300): lossG 1.683135, lossD_A 0.221325, lossD_B 0.111814\n",
      "(epoch 24, iter 400): lossG 2.181446, lossD_A 0.192873, lossD_B 0.153713\n",
      "(epoch 24, iter 500): lossG 2.498052, lossD_A 0.111596, lossD_B 0.073416\n",
      "(epoch 24, iter 600): lossG 2.385938, lossD_A 0.064717, lossD_B 0.150450\n",
      "(epoch 24, iter 700): lossG 3.052559, lossD_A 0.047592, lossD_B 0.207162\n",
      "(epoch 24, iter 800): lossG 3.252699, lossD_A 0.407032, lossD_B 0.183548\n",
      "(epoch 24, iter 900): lossG 1.469890, lossD_A 0.081393, lossD_B 0.119003\n",
      "(epoch 24, iter 1000): lossG 1.909397, lossD_A 0.175084, lossD_B 0.337072\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7d64a3bd07824d5da889844579bbace9"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 25, iter 0): lossG 2.107002, lossD_A 0.029116, lossD_B 0.244451\n",
      "(epoch 25, iter 100): lossG 2.178784, lossD_A 0.089267, lossD_B 0.137932\n",
      "(epoch 25, iter 200): lossG 2.435865, lossD_A 0.096896, lossD_B 0.106923\n",
      "(epoch 25, iter 300): lossG 2.274104, lossD_A 0.243517, lossD_B 0.066104\n",
      "(epoch 25, iter 400): lossG 2.299850, lossD_A 0.035466, lossD_B 0.154214\n",
      "(epoch 25, iter 500): lossG 1.932456, lossD_A 0.056948, lossD_B 0.222020\n",
      "(epoch 25, iter 600): lossG 2.401023, lossD_A 0.167335, lossD_B 0.265251\n",
      "(epoch 25, iter 700): lossG 2.696760, lossD_A 0.276018, lossD_B 0.189328\n",
      "(epoch 25, iter 800): lossG 2.014390, lossD_A 0.040093, lossD_B 0.163197\n",
      "(epoch 25, iter 900): lossG 2.689270, lossD_A 0.136458, lossD_B 0.195687\n",
      "(epoch 25, iter 1000): lossG 1.860499, lossD_A 0.403369, lossD_B 0.072572\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dae11cefe28f44a2b2e62b278c2c2023"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 26, iter 0): lossG 2.280788, lossD_A 0.118003, lossD_B 0.153509\n",
      "(epoch 26, iter 100): lossG 2.815177, lossD_A 0.137408, lossD_B 0.123877\n",
      "(epoch 26, iter 200): lossG 1.548958, lossD_A 0.208922, lossD_B 0.191898\n",
      "(epoch 26, iter 300): lossG 2.738744, lossD_A 0.180209, lossD_B 0.198976\n",
      "(epoch 26, iter 400): lossG 1.862414, lossD_A 0.111888, lossD_B 0.175338\n",
      "(epoch 26, iter 500): lossG 1.965744, lossD_A 0.229898, lossD_B 0.116899\n",
      "(epoch 26, iter 600): lossG 1.888452, lossD_A 0.109548, lossD_B 0.301964\n",
      "(epoch 26, iter 700): lossG 2.412497, lossD_A 0.075101, lossD_B 0.195116\n",
      "(epoch 26, iter 800): lossG 1.890890, lossD_A 0.058017, lossD_B 0.176793\n",
      "(epoch 26, iter 900): lossG 3.069943, lossD_A 0.022596, lossD_B 0.104693\n",
      "(epoch 26, iter 1000): lossG 1.950754, lossD_A 0.210950, lossD_B 0.072592\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "365371920e3a4d07a8ab962095d768ae"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 27, iter 0): lossG 2.725062, lossD_A 0.244656, lossD_B 0.137400\n",
      "(epoch 27, iter 100): lossG 2.247747, lossD_A 0.087023, lossD_B 0.214595\n",
      "(epoch 27, iter 200): lossG 1.486240, lossD_A 0.097019, lossD_B 0.108310\n",
      "(epoch 27, iter 300): lossG 1.994220, lossD_A 0.188588, lossD_B 0.201389\n",
      "(epoch 27, iter 400): lossG 2.004972, lossD_A 0.265581, lossD_B 0.094596\n",
      "(epoch 27, iter 500): lossG 1.604177, lossD_A 0.240751, lossD_B 0.249544\n",
      "(epoch 27, iter 600): lossG 1.788649, lossD_A 0.232798, lossD_B 0.170685\n",
      "(epoch 27, iter 700): lossG 1.998740, lossD_A 0.167275, lossD_B 0.154949\n",
      "(epoch 27, iter 800): lossG 2.303834, lossD_A 0.144557, lossD_B 0.198436\n",
      "(epoch 27, iter 900): lossG 1.871283, lossD_A 0.201543, lossD_B 0.084716\n",
      "(epoch 27, iter 1000): lossG 2.011697, lossD_A 0.096197, lossD_B 0.281268\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "59310e6a47d54c8ba53c39cfa5cf868d"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 28, iter 0): lossG 1.821142, lossD_A 0.360614, lossD_B 0.208105\n",
      "(epoch 28, iter 100): lossG 2.221756, lossD_A 0.161283, lossD_B 0.300425\n",
      "(epoch 28, iter 200): lossG 2.036263, lossD_A 0.218512, lossD_B 0.072828\n",
      "(epoch 28, iter 300): lossG 1.801677, lossD_A 0.108757, lossD_B 0.062195\n",
      "(epoch 28, iter 400): lossG 2.322426, lossD_A 0.031161, lossD_B 0.186656\n",
      "(epoch 28, iter 500): lossG 2.254307, lossD_A 0.221254, lossD_B 0.199477\n",
      "(epoch 28, iter 600): lossG 4.446827, lossD_A 0.191157, lossD_B 0.189859\n",
      "(epoch 28, iter 700): lossG 2.077847, lossD_A 0.121627, lossD_B 0.217165\n",
      "(epoch 28, iter 800): lossG 1.520982, lossD_A 0.433228, lossD_B 0.260168\n",
      "(epoch 28, iter 900): lossG 1.760218, lossD_A 0.134138, lossD_B 0.382178\n",
      "(epoch 28, iter 1000): lossG 2.149570, lossD_A 0.253527, lossD_B 0.277481\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6f168eea5d4346c2a87caeb84d5090ed"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 29, iter 0): lossG 2.157819, lossD_A 0.332543, lossD_B 0.227899\n",
      "(epoch 29, iter 100): lossG 2.783394, lossD_A 0.161480, lossD_B 0.162828\n",
      "(epoch 29, iter 200): lossG 2.385908, lossD_A 0.139906, lossD_B 0.188828\n",
      "(epoch 29, iter 300): lossG 2.660316, lossD_A 0.037489, lossD_B 0.141874\n",
      "(epoch 29, iter 400): lossG 2.169842, lossD_A 0.166196, lossD_B 0.229582\n",
      "(epoch 29, iter 500): lossG 1.567146, lossD_A 0.274430, lossD_B 0.117875\n",
      "(epoch 29, iter 600): lossG 1.816562, lossD_A 0.170925, lossD_B 0.308842\n",
      "(epoch 29, iter 700): lossG 2.351902, lossD_A 0.043881, lossD_B 0.041721\n",
      "(epoch 29, iter 800): lossG 2.878996, lossD_A 0.202881, lossD_B 0.201418\n",
      "(epoch 29, iter 900): lossG 2.236259, lossD_A 0.235292, lossD_B 0.089854\n",
      "(epoch 29, iter 1000): lossG 1.768578, lossD_A 0.089225, lossD_B 0.213310\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e246e0e63fdd4ed2ad360671990702cb"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 30, iter 0): lossG 1.718282, lossD_A 0.156979, lossD_B 0.123296\n",
      "(epoch 30, iter 100): lossG 2.187099, lossD_A 0.130020, lossD_B 0.301518\n",
      "(epoch 30, iter 200): lossG 1.464636, lossD_A 0.078515, lossD_B 0.160961\n",
      "(epoch 30, iter 300): lossG 2.101438, lossD_A 0.206106, lossD_B 0.356843\n",
      "(epoch 30, iter 400): lossG 1.681086, lossD_A 0.047110, lossD_B 0.372826\n",
      "(epoch 30, iter 500): lossG 2.571720, lossD_A 0.203269, lossD_B 0.175815\n",
      "(epoch 30, iter 600): lossG 2.347691, lossD_A 0.068226, lossD_B 0.149361\n",
      "(epoch 30, iter 700): lossG 2.080832, lossD_A 0.188774, lossD_B 0.164978\n",
      "(epoch 30, iter 800): lossG 1.814300, lossD_A 0.275983, lossD_B 0.199435\n",
      "(epoch 30, iter 900): lossG 2.664516, lossD_A 0.077489, lossD_B 0.164951\n",
      "(epoch 30, iter 1000): lossG 2.143219, lossD_A 0.028529, lossD_B 0.216424\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9f66c25f318c4cae9249e0d163a83db7"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 31, iter 0): lossG 3.049145, lossD_A 0.110824, lossD_B 0.073430\n",
      "(epoch 31, iter 100): lossG 2.349468, lossD_A 0.107997, lossD_B 0.143682\n",
      "(epoch 31, iter 200): lossG 2.174205, lossD_A 0.183521, lossD_B 0.234560\n",
      "(epoch 31, iter 300): lossG 1.722440, lossD_A 0.408143, lossD_B 0.277203\n",
      "(epoch 31, iter 400): lossG 2.949945, lossD_A 0.207708, lossD_B 0.249949\n",
      "(epoch 31, iter 500): lossG 1.399786, lossD_A 0.268328, lossD_B 0.279464\n",
      "(epoch 31, iter 600): lossG 2.150937, lossD_A 0.302895, lossD_B 0.087544\n",
      "(epoch 31, iter 700): lossG 2.306050, lossD_A 0.180130, lossD_B 0.229803\n",
      "(epoch 31, iter 800): lossG 1.860995, lossD_A 0.060649, lossD_B 0.234386\n",
      "(epoch 31, iter 900): lossG 2.679600, lossD_A 0.076129, lossD_B 0.107574\n",
      "(epoch 31, iter 1000): lossG 3.124583, lossD_A 0.043559, lossD_B 0.120832\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0819bb52967f40f5b65d3c850499991d"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 32, iter 0): lossG 2.102951, lossD_A 0.175702, lossD_B 0.327381\n",
      "(epoch 32, iter 100): lossG 1.860758, lossD_A 0.121211, lossD_B 0.158897\n",
      "(epoch 32, iter 200): lossG 2.087744, lossD_A 0.082408, lossD_B 0.088439\n",
      "(epoch 32, iter 300): lossG 2.326480, lossD_A 0.114072, lossD_B 0.174682\n",
      "(epoch 32, iter 400): lossG 1.279568, lossD_A 0.275135, lossD_B 0.120487\n",
      "(epoch 32, iter 500): lossG 1.871165, lossD_A 0.135925, lossD_B 0.186195\n",
      "(epoch 32, iter 600): lossG 1.721973, lossD_A 0.216484, lossD_B 0.125987\n",
      "(epoch 32, iter 700): lossG 2.239357, lossD_A 0.230197, lossD_B 0.092947\n",
      "(epoch 32, iter 800): lossG 2.152716, lossD_A 0.132908, lossD_B 0.107851\n",
      "(epoch 32, iter 900): lossG 2.499091, lossD_A 0.092067, lossD_B 0.127054\n",
      "(epoch 32, iter 1000): lossG 1.958521, lossD_A 0.089016, lossD_B 0.184056\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "96f7ecb612f1464db35cb120283ea83f"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 33, iter 0): lossG 1.938734, lossD_A 0.129310, lossD_B 0.213010\n",
      "(epoch 33, iter 100): lossG 2.064727, lossD_A 0.106331, lossD_B 0.039769\n",
      "(epoch 33, iter 200): lossG 1.720385, lossD_A 0.159155, lossD_B 0.192182\n",
      "(epoch 33, iter 300): lossG 2.062685, lossD_A 0.190522, lossD_B 0.224964\n",
      "(epoch 33, iter 400): lossG 1.970141, lossD_A 0.050535, lossD_B 0.150388\n",
      "(epoch 33, iter 500): lossG 1.958541, lossD_A 0.130240, lossD_B 0.077127\n",
      "(epoch 33, iter 600): lossG 1.685913, lossD_A 0.099198, lossD_B 0.101232\n",
      "(epoch 33, iter 700): lossG 2.268254, lossD_A 0.039270, lossD_B 0.257521\n",
      "(epoch 33, iter 800): lossG 2.081335, lossD_A 0.014874, lossD_B 0.096067\n",
      "(epoch 33, iter 900): lossG 1.538940, lossD_A 0.433546, lossD_B 0.311004\n",
      "(epoch 33, iter 1000): lossG 2.726763, lossD_A 0.124637, lossD_B 0.234507\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "700111d2f0d84df29ebb430feb02d16d"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 34, iter 0): lossG 2.370731, lossD_A 0.214177, lossD_B 0.134132\n",
      "(epoch 34, iter 100): lossG 2.360584, lossD_A 0.083122, lossD_B 0.239233\n",
      "(epoch 34, iter 200): lossG 2.002912, lossD_A 0.142494, lossD_B 0.299341\n",
      "(epoch 34, iter 300): lossG 2.547054, lossD_A 0.141561, lossD_B 0.084032\n",
      "(epoch 34, iter 400): lossG 2.275207, lossD_A 0.129573, lossD_B 0.085632\n",
      "(epoch 34, iter 500): lossG 2.677938, lossD_A 0.058680, lossD_B 0.171364\n",
      "(epoch 34, iter 600): lossG 1.958972, lossD_A 0.203386, lossD_B 0.134182\n",
      "(epoch 34, iter 700): lossG 2.075882, lossD_A 0.064776, lossD_B 0.188955\n",
      "(epoch 34, iter 800): lossG 2.089365, lossD_A 0.172989, lossD_B 0.274046\n",
      "(epoch 34, iter 900): lossG 2.308915, lossD_A 0.140582, lossD_B 0.136776\n",
      "(epoch 34, iter 1000): lossG 2.677312, lossD_A 0.040709, lossD_B 0.133090\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "eb8a4c16033f4f5e880be164e90a14f7"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 35, iter 0): lossG 1.156519, lossD_A 0.387085, lossD_B 0.231795\n",
      "(epoch 35, iter 100): lossG 2.811223, lossD_A 0.053838, lossD_B 0.092526\n",
      "(epoch 35, iter 200): lossG 2.032208, lossD_A 0.304136, lossD_B 0.257090\n",
      "(epoch 35, iter 300): lossG 1.370832, lossD_A 0.205833, lossD_B 0.131412\n",
      "(epoch 35, iter 400): lossG 2.197007, lossD_A 0.055610, lossD_B 0.113935\n",
      "(epoch 35, iter 500): lossG 1.657158, lossD_A 0.217581, lossD_B 0.261040\n",
      "(epoch 35, iter 600): lossG 2.311972, lossD_A 0.207570, lossD_B 0.127191\n",
      "(epoch 35, iter 700): lossG 1.508817, lossD_A 0.202540, lossD_B 0.253082\n",
      "(epoch 35, iter 800): lossG 2.560434, lossD_A 0.129648, lossD_B 0.174047\n",
      "(epoch 35, iter 900): lossG 2.117226, lossD_A 0.074680, lossD_B 0.278201\n",
      "(epoch 35, iter 1000): lossG 2.653576, lossD_A 0.092661, lossD_B 0.246130\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a5d28db754be4b409d7586e534f70ce3"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 36, iter 0): lossG 1.809048, lossD_A 0.120953, lossD_B 0.182315\n",
      "(epoch 36, iter 100): lossG 2.370123, lossD_A 0.067214, lossD_B 0.294433\n",
      "(epoch 36, iter 200): lossG 2.062820, lossD_A 0.087656, lossD_B 0.206717\n",
      "(epoch 36, iter 300): lossG 2.195127, lossD_A 0.094578, lossD_B 0.283067\n",
      "(epoch 36, iter 400): lossG 2.689895, lossD_A 0.037835, lossD_B 0.152181\n",
      "(epoch 36, iter 500): lossG 1.790789, lossD_A 0.095414, lossD_B 0.113674\n",
      "(epoch 36, iter 600): lossG 1.919467, lossD_A 0.289061, lossD_B 0.303539\n",
      "(epoch 36, iter 700): lossG 2.475647, lossD_A 0.177955, lossD_B 0.184280\n",
      "(epoch 36, iter 800): lossG 1.736101, lossD_A 0.208737, lossD_B 0.289649\n",
      "(epoch 36, iter 900): lossG 1.836530, lossD_A 0.054877, lossD_B 0.149431\n",
      "(epoch 36, iter 1000): lossG 1.724959, lossD_A 0.074648, lossD_B 0.394266\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "02fa03e96d2443d784f8ab4ced2dacf1"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 37, iter 0): lossG 2.102492, lossD_A 0.154413, lossD_B 0.132647\n",
      "(epoch 37, iter 100): lossG 1.733286, lossD_A 0.078238, lossD_B 0.193266\n",
      "(epoch 37, iter 200): lossG 1.537560, lossD_A 0.084714, lossD_B 0.204361\n",
      "(epoch 37, iter 300): lossG 1.473620, lossD_A 0.062194, lossD_B 0.230352\n",
      "(epoch 37, iter 400): lossG 1.474345, lossD_A 0.055961, lossD_B 0.084032\n",
      "(epoch 37, iter 500): lossG 2.364598, lossD_A 0.127050, lossD_B 0.170396\n",
      "(epoch 37, iter 600): lossG 2.492203, lossD_A 0.073280, lossD_B 0.126615\n",
      "(epoch 37, iter 700): lossG 2.281887, lossD_A 0.209396, lossD_B 0.208525\n",
      "(epoch 37, iter 800): lossG 2.583807, lossD_A 0.146721, lossD_B 0.063610\n",
      "(epoch 37, iter 900): lossG 2.199941, lossD_A 0.066736, lossD_B 0.259548\n",
      "(epoch 37, iter 1000): lossG 2.454885, lossD_A 0.122029, lossD_B 0.073140\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0cc467ddd2e54d1eb084955bf8f9304a"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 38, iter 0): lossG 2.279683, lossD_A 0.220227, lossD_B 0.411312\n",
      "(epoch 38, iter 100): lossG 1.874871, lossD_A 0.072749, lossD_B 0.091784\n",
      "(epoch 38, iter 200): lossG 2.998213, lossD_A 0.038288, lossD_B 0.219511\n",
      "(epoch 38, iter 300): lossG 2.227799, lossD_A 0.022922, lossD_B 0.136506\n",
      "(epoch 38, iter 400): lossG 1.541750, lossD_A 0.199501, lossD_B 0.371523\n",
      "(epoch 38, iter 500): lossG 1.720284, lossD_A 0.182566, lossD_B 0.229090\n",
      "(epoch 38, iter 600): lossG 2.232615, lossD_A 0.301452, lossD_B 0.056784\n",
      "(epoch 38, iter 700): lossG 2.547709, lossD_A 0.112756, lossD_B 0.301665\n",
      "(epoch 38, iter 800): lossG 1.887817, lossD_A 0.058163, lossD_B 0.140702\n",
      "(epoch 38, iter 900): lossG 1.812137, lossD_A 0.054743, lossD_B 0.178645\n",
      "(epoch 38, iter 1000): lossG 1.802969, lossD_A 0.238594, lossD_B 0.284585\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e908fa85807e4420849cc875f66d4633"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 39, iter 0): lossG 2.802710, lossD_A 0.028559, lossD_B 0.176575\n",
      "(epoch 39, iter 100): lossG 1.507998, lossD_A 0.465130, lossD_B 0.230716\n",
      "(epoch 39, iter 200): lossG 2.905182, lossD_A 0.117822, lossD_B 0.087858\n",
      "(epoch 39, iter 300): lossG 1.749262, lossD_A 0.155974, lossD_B 0.350685\n",
      "(epoch 39, iter 400): lossG 1.840330, lossD_A 0.185883, lossD_B 0.243918\n",
      "(epoch 39, iter 500): lossG 2.071297, lossD_A 0.172379, lossD_B 0.169900\n",
      "(epoch 39, iter 600): lossG 2.090710, lossD_A 0.061511, lossD_B 0.183820\n",
      "(epoch 39, iter 700): lossG 1.447621, lossD_A 0.253489, lossD_B 0.186266\n",
      "(epoch 39, iter 800): lossG 2.569318, lossD_A 0.182053, lossD_B 0.251282\n",
      "(epoch 39, iter 900): lossG 1.415096, lossD_A 0.145515, lossD_B 0.222082\n",
      "(epoch 39, iter 1000): lossG 2.227936, lossD_A 0.145204, lossD_B 0.108296\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "031d0134799c43a6bfe79d9db88c5464"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 40, iter 0): lossG 1.500178, lossD_A 0.178352, lossD_B 0.254882\n",
      "(epoch 40, iter 100): lossG 1.480144, lossD_A 0.137754, lossD_B 0.374319\n",
      "(epoch 40, iter 200): lossG 2.430922, lossD_A 0.048050, lossD_B 0.183969\n",
      "(epoch 40, iter 300): lossG 2.075690, lossD_A 0.045652, lossD_B 0.220770\n",
      "(epoch 40, iter 400): lossG 1.388106, lossD_A 0.125127, lossD_B 0.080468\n",
      "(epoch 40, iter 500): lossG 1.847280, lossD_A 0.119623, lossD_B 0.141769\n",
      "(epoch 40, iter 600): lossG 1.190824, lossD_A 0.508208, lossD_B 0.086360\n",
      "(epoch 40, iter 700): lossG 1.466952, lossD_A 0.116850, lossD_B 0.142074\n",
      "(epoch 40, iter 800): lossG 2.942414, lossD_A 0.140702, lossD_B 0.116430\n",
      "(epoch 40, iter 900): lossG 2.087432, lossD_A 0.183042, lossD_B 0.241381\n",
      "(epoch 40, iter 1000): lossG 2.109900, lossD_A 0.102364, lossD_B 0.111510\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f9a50cb7a1654a4ea6febf406af09f3f"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 41, iter 0): lossG 1.880223, lossD_A 0.112111, lossD_B 0.082859\n",
      "(epoch 41, iter 100): lossG 1.992562, lossD_A 0.076874, lossD_B 0.266475\n",
      "(epoch 41, iter 200): lossG 1.485483, lossD_A 0.111933, lossD_B 0.155231\n",
      "(epoch 41, iter 300): lossG 2.430799, lossD_A 0.112321, lossD_B 0.353191\n",
      "(epoch 41, iter 400): lossG 2.378527, lossD_A 0.081379, lossD_B 0.199091\n",
      "(epoch 41, iter 500): lossG 2.477933, lossD_A 0.172896, lossD_B 0.251721\n",
      "(epoch 41, iter 600): lossG 1.914217, lossD_A 0.033147, lossD_B 0.169245\n",
      "(epoch 41, iter 700): lossG 1.857479, lossD_A 0.097195, lossD_B 0.138451\n",
      "(epoch 41, iter 800): lossG 1.940077, lossD_A 0.357154, lossD_B 0.332711\n",
      "(epoch 41, iter 900): lossG 1.718187, lossD_A 0.222555, lossD_B 0.070449\n",
      "(epoch 41, iter 1000): lossG 1.832464, lossD_A 0.131706, lossD_B 0.109574\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7dfc9434009042f9b662e2367a4ba506"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 42, iter 0): lossG 1.747491, lossD_A 0.220255, lossD_B 0.374227\n",
      "(epoch 42, iter 100): lossG 1.488646, lossD_A 0.110139, lossD_B 0.336053\n",
      "(epoch 42, iter 200): lossG 2.069948, lossD_A 0.097468, lossD_B 0.196064\n",
      "(epoch 42, iter 300): lossG 1.716018, lossD_A 0.084431, lossD_B 0.109795\n",
      "(epoch 42, iter 400): lossG 1.568582, lossD_A 0.188078, lossD_B 0.183474\n",
      "(epoch 42, iter 500): lossG 2.466365, lossD_A 0.096557, lossD_B 0.083925\n",
      "(epoch 42, iter 600): lossG 2.184655, lossD_A 0.078529, lossD_B 0.142107\n",
      "(epoch 42, iter 700): lossG 2.002652, lossD_A 0.071447, lossD_B 0.146024\n",
      "(epoch 42, iter 800): lossG 2.028661, lossD_A 0.097010, lossD_B 0.216029\n",
      "(epoch 42, iter 900): lossG 2.180304, lossD_A 0.137870, lossD_B 0.146439\n",
      "(epoch 42, iter 1000): lossG 1.805152, lossD_A 0.361365, lossD_B 0.156553\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4923dabfd39a421ea08b7775a5efeb5a"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 43, iter 0): lossG 1.539906, lossD_A 0.207299, lossD_B 0.050518\n",
      "(epoch 43, iter 100): lossG 3.601400, lossD_A 0.260399, lossD_B 0.204046\n",
      "(epoch 43, iter 200): lossG 2.166157, lossD_A 0.204954, lossD_B 0.175675\n",
      "(epoch 43, iter 300): lossG 1.903377, lossD_A 0.214123, lossD_B 0.159362\n",
      "(epoch 43, iter 400): lossG 3.327934, lossD_A 0.109903, lossD_B 0.251208\n",
      "(epoch 43, iter 500): lossG 2.322996, lossD_A 0.117483, lossD_B 0.180903\n",
      "(epoch 43, iter 600): lossG 2.226792, lossD_A 0.113721, lossD_B 0.123196\n",
      "(epoch 43, iter 700): lossG 2.043190, lossD_A 0.163481, lossD_B 0.143807\n",
      "(epoch 43, iter 800): lossG 1.658093, lossD_A 0.201936, lossD_B 0.141907\n",
      "(epoch 43, iter 900): lossG 1.971673, lossD_A 0.165344, lossD_B 0.119031\n",
      "(epoch 43, iter 1000): lossG 2.246502, lossD_A 0.153029, lossD_B 0.077696\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d1a40a546914678a1eca1363f617659"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 44, iter 0): lossG 4.185691, lossD_A 0.405361, lossD_B 0.169399\n",
      "(epoch 44, iter 100): lossG 1.678361, lossD_A 0.202963, lossD_B 0.197609\n",
      "(epoch 44, iter 200): lossG 1.755890, lossD_A 0.161723, lossD_B 0.176795\n",
      "(epoch 44, iter 300): lossG 1.753246, lossD_A 0.089248, lossD_B 0.026789\n",
      "(epoch 44, iter 400): lossG 1.946189, lossD_A 0.299686, lossD_B 0.106442\n",
      "(epoch 44, iter 500): lossG 1.691149, lossD_A 0.194098, lossD_B 0.113343\n",
      "(epoch 44, iter 600): lossG 1.803121, lossD_A 0.087401, lossD_B 0.219162\n",
      "(epoch 44, iter 700): lossG 2.046566, lossD_A 0.033088, lossD_B 0.174155\n",
      "(epoch 44, iter 800): lossG 1.707624, lossD_A 0.231458, lossD_B 0.161356\n",
      "(epoch 44, iter 900): lossG 1.760972, lossD_A 0.170669, lossD_B 0.383479\n",
      "(epoch 44, iter 1000): lossG 2.274751, lossD_A 0.130687, lossD_B 0.193507\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3f576704df734faaaf52174aad3b8a84"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 45, iter 0): lossG 1.719724, lossD_A 0.138178, lossD_B 0.226583\n",
      "(epoch 45, iter 100): lossG 1.945911, lossD_A 0.143021, lossD_B 0.286666\n",
      "(epoch 45, iter 200): lossG 2.017721, lossD_A 0.277557, lossD_B 0.156222\n",
      "(epoch 45, iter 300): lossG 2.263778, lossD_A 0.076609, lossD_B 0.278457\n",
      "(epoch 45, iter 400): lossG 2.714739, lossD_A 0.060675, lossD_B 0.135245\n",
      "(epoch 45, iter 500): lossG 2.074000, lossD_A 0.092632, lossD_B 0.189711\n",
      "(epoch 45, iter 600): lossG 2.383842, lossD_A 0.075570, lossD_B 0.137834\n",
      "(epoch 45, iter 700): lossG 1.745535, lossD_A 0.068886, lossD_B 0.356675\n",
      "(epoch 45, iter 800): lossG 1.722811, lossD_A 0.061757, lossD_B 0.293830\n",
      "(epoch 45, iter 900): lossG 1.895945, lossD_A 0.087886, lossD_B 0.307507\n",
      "(epoch 45, iter 1000): lossG 2.135277, lossD_A 0.108023, lossD_B 0.157545\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "31662f807d7c46b2b6d604fc5788d819"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 46, iter 0): lossG 2.093343, lossD_A 0.361268, lossD_B 0.239120\n",
      "(epoch 46, iter 100): lossG 2.138206, lossD_A 0.277338, lossD_B 0.175928\n",
      "(epoch 46, iter 200): lossG 2.483608, lossD_A 0.170425, lossD_B 0.243187\n",
      "(epoch 46, iter 300): lossG 2.519667, lossD_A 0.127627, lossD_B 0.189992\n",
      "(epoch 46, iter 400): lossG 2.046603, lossD_A 0.136344, lossD_B 0.276038\n",
      "(epoch 46, iter 500): lossG 2.155772, lossD_A 0.068940, lossD_B 0.207021\n",
      "(epoch 46, iter 600): lossG 2.097958, lossD_A 0.215152, lossD_B 0.211361\n",
      "(epoch 46, iter 700): lossG 2.069828, lossD_A 0.072584, lossD_B 0.139764\n",
      "(epoch 46, iter 800): lossG 2.039464, lossD_A 0.069073, lossD_B 0.131799\n",
      "(epoch 46, iter 900): lossG 2.262754, lossD_A 0.325454, lossD_B 0.206244\n",
      "(epoch 46, iter 1000): lossG 1.867080, lossD_A 0.115002, lossD_B 0.226951\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a0ebabca6aba4970bc90b43a43c31db5"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 47, iter 0): lossG 1.420560, lossD_A 0.099474, lossD_B 0.187878\n",
      "(epoch 47, iter 100): lossG 2.944269, lossD_A 0.013697, lossD_B 0.148836\n",
      "(epoch 47, iter 200): lossG 2.533446, lossD_A 0.078948, lossD_B 0.097793\n",
      "(epoch 47, iter 300): lossG 1.723586, lossD_A 0.212006, lossD_B 0.232478\n",
      "(epoch 47, iter 400): lossG 1.772074, lossD_A 0.063372, lossD_B 0.070773\n",
      "(epoch 47, iter 500): lossG 1.706115, lossD_A 0.142577, lossD_B 0.232743\n",
      "(epoch 47, iter 600): lossG 2.323722, lossD_A 0.180495, lossD_B 0.471373\n",
      "(epoch 47, iter 700): lossG 2.316991, lossD_A 0.096419, lossD_B 0.179885\n",
      "(epoch 47, iter 800): lossG 1.580585, lossD_A 0.070847, lossD_B 0.179402\n",
      "(epoch 47, iter 900): lossG 1.680261, lossD_A 0.166066, lossD_B 0.042453\n",
      "(epoch 47, iter 1000): lossG 2.086038, lossD_A 0.203725, lossD_B 0.172483\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f9ec0d2630d3400fbd7dedfae6215761"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 48, iter 0): lossG 1.750139, lossD_A 0.142480, lossD_B 0.127912\n",
      "(epoch 48, iter 100): lossG 2.586998, lossD_A 0.026807, lossD_B 0.175139\n",
      "(epoch 48, iter 200): lossG 2.578701, lossD_A 0.173913, lossD_B 0.267260\n",
      "(epoch 48, iter 300): lossG 1.812027, lossD_A 0.192843, lossD_B 0.403392\n",
      "(epoch 48, iter 400): lossG 2.241701, lossD_A 0.039106, lossD_B 0.263370\n",
      "(epoch 48, iter 500): lossG 2.465758, lossD_A 0.158197, lossD_B 0.075164\n",
      "(epoch 48, iter 600): lossG 1.832046, lossD_A 0.252248, lossD_B 0.529140\n",
      "(epoch 48, iter 700): lossG 2.306535, lossD_A 0.154689, lossD_B 0.174834\n",
      "(epoch 48, iter 800): lossG 1.560966, lossD_A 0.231878, lossD_B 0.214495\n",
      "(epoch 48, iter 900): lossG 3.235929, lossD_A 0.152318, lossD_B 0.108175\n",
      "(epoch 48, iter 1000): lossG 2.660664, lossD_A 0.069012, lossD_B 0.142157\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2a317f94632f4d4d8efc6cefc5aaeace"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 49, iter 0): lossG 1.813592, lossD_A 0.177219, lossD_B 0.368934\n",
      "(epoch 49, iter 100): lossG 1.800597, lossD_A 0.172455, lossD_B 0.217746\n",
      "(epoch 49, iter 200): lossG 2.098989, lossD_A 0.197992, lossD_B 0.139799\n",
      "(epoch 49, iter 300): lossG 1.792319, lossD_A 0.105770, lossD_B 0.161998\n",
      "(epoch 49, iter 400): lossG 1.753829, lossD_A 0.086607, lossD_B 0.291488\n",
      "(epoch 49, iter 500): lossG 2.012805, lossD_A 0.051759, lossD_B 0.109270\n",
      "(epoch 49, iter 600): lossG 2.111917, lossD_A 0.105816, lossD_B 0.214440\n",
      "(epoch 49, iter 700): lossG 1.590228, lossD_A 0.220146, lossD_B 0.159962\n",
      "(epoch 49, iter 800): lossG 1.984284, lossD_A 0.131242, lossD_B 0.253097\n",
      "(epoch 49, iter 900): lossG 1.942571, lossD_A 0.057398, lossD_B 0.202219\n",
      "(epoch 49, iter 1000): lossG 2.193229, lossD_A 0.053364, lossD_B 0.185809\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "37135748a33f46459d345dafd46ddbe4"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 50, iter 0): lossG 1.486042, lossD_A 0.098996, lossD_B 0.067086\n",
      "(epoch 50, iter 100): lossG 1.854268, lossD_A 0.046155, lossD_B 0.258539\n",
      "(epoch 50, iter 200): lossG 2.348106, lossD_A 0.131410, lossD_B 0.142854\n",
      "(epoch 50, iter 300): lossG 2.050724, lossD_A 0.039371, lossD_B 0.163456\n",
      "(epoch 50, iter 400): lossG 2.278204, lossD_A 0.056558, lossD_B 0.083445\n",
      "(epoch 50, iter 500): lossG 2.231571, lossD_A 0.143025, lossD_B 0.179417\n",
      "(epoch 50, iter 600): lossG 2.262378, lossD_A 0.129618, lossD_B 0.125210\n",
      "(epoch 50, iter 700): lossG 1.931142, lossD_A 0.095867, lossD_B 0.197310\n",
      "(epoch 50, iter 800): lossG 1.632141, lossD_A 0.239986, lossD_B 0.190759\n",
      "(epoch 50, iter 900): lossG 2.547599, lossD_A 0.172337, lossD_B 0.103026\n",
      "(epoch 50, iter 1000): lossG 0.936039, lossD_A 0.253070, lossD_B 0.198416\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cfb9d17a1503412f8b28b0ae041e4ebe"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 51, iter 0): lossG 1.548424, lossD_A 0.046029, lossD_B 0.245096\n",
      "(epoch 51, iter 100): lossG 1.431072, lossD_A 0.219858, lossD_B 0.299900\n",
      "(epoch 51, iter 200): lossG 1.742909, lossD_A 0.134638, lossD_B 0.234364\n",
      "(epoch 51, iter 300): lossG 1.893183, lossD_A 0.106045, lossD_B 0.163702\n",
      "(epoch 51, iter 400): lossG 2.589140, lossD_A 0.108368, lossD_B 0.110475\n",
      "(epoch 51, iter 500): lossG 1.845817, lossD_A 0.183718, lossD_B 0.363677\n",
      "(epoch 51, iter 600): lossG 3.057420, lossD_A 0.038124, lossD_B 0.228675\n",
      "(epoch 51, iter 700): lossG 2.185453, lossD_A 0.063757, lossD_B 0.259557\n",
      "(epoch 51, iter 800): lossG 1.970672, lossD_A 0.239052, lossD_B 0.076981\n",
      "(epoch 51, iter 900): lossG 2.549804, lossD_A 0.073187, lossD_B 0.198167\n",
      "(epoch 51, iter 1000): lossG 2.231448, lossD_A 0.084836, lossD_B 0.189474\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "115cc0d588594bce994939702ca7a3e3"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 52, iter 0): lossG 2.214821, lossD_A 0.124741, lossD_B 0.291110\n",
      "(epoch 52, iter 100): lossG 1.984900, lossD_A 0.336772, lossD_B 0.325145\n",
      "(epoch 52, iter 200): lossG 1.812908, lossD_A 0.039550, lossD_B 0.100323\n",
      "(epoch 52, iter 300): lossG 2.090843, lossD_A 0.160414, lossD_B 0.279582\n",
      "(epoch 52, iter 400): lossG 2.532780, lossD_A 0.106791, lossD_B 0.086736\n",
      "(epoch 52, iter 500): lossG 3.510747, lossD_A 0.133143, lossD_B 0.118513\n",
      "(epoch 52, iter 600): lossG 1.491615, lossD_A 0.060528, lossD_B 0.166319\n",
      "(epoch 52, iter 700): lossG 3.446753, lossD_A 0.032502, lossD_B 0.156113\n",
      "(epoch 52, iter 800): lossG 2.234034, lossD_A 0.108294, lossD_B 0.135273\n",
      "(epoch 52, iter 900): lossG 1.504388, lossD_A 0.061604, lossD_B 0.304522\n",
      "(epoch 52, iter 1000): lossG 2.179816, lossD_A 0.310966, lossD_B 0.109770\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5274ceee7a774186b57fc59d9be0ea7b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 53, iter 0): lossG 2.217454, lossD_A 0.061271, lossD_B 0.200829\n",
      "(epoch 53, iter 100): lossG 2.050689, lossD_A 0.057035, lossD_B 0.272933\n",
      "(epoch 53, iter 200): lossG 1.969708, lossD_A 0.251005, lossD_B 0.169433\n",
      "(epoch 53, iter 300): lossG 2.692278, lossD_A 0.306367, lossD_B 0.155389\n",
      "(epoch 53, iter 400): lossG 1.491706, lossD_A 0.241108, lossD_B 0.330594\n",
      "(epoch 53, iter 500): lossG 2.229747, lossD_A 0.065708, lossD_B 0.121553\n",
      "(epoch 53, iter 600): lossG 1.308270, lossD_A 0.114080, lossD_B 0.219476\n",
      "(epoch 53, iter 700): lossG 1.697307, lossD_A 0.129133, lossD_B 0.121819\n",
      "(epoch 53, iter 800): lossG 1.844599, lossD_A 0.146502, lossD_B 0.045451\n",
      "(epoch 53, iter 900): lossG 1.868465, lossD_A 0.237478, lossD_B 0.147463\n",
      "(epoch 53, iter 1000): lossG 1.963070, lossD_A 0.143102, lossD_B 0.186571\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "90e3bc6261d14fa5ac749374cff385bd"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 54, iter 0): lossG 1.908253, lossD_A 0.042276, lossD_B 0.232806\n",
      "(epoch 54, iter 100): lossG 2.992383, lossD_A 0.141858, lossD_B 0.061949\n",
      "(epoch 54, iter 200): lossG 1.899231, lossD_A 0.267714, lossD_B 0.250381\n",
      "(epoch 54, iter 300): lossG 2.641237, lossD_A 0.020775, lossD_B 0.404073\n",
      "(epoch 54, iter 400): lossG 2.088633, lossD_A 0.252793, lossD_B 0.298071\n",
      "(epoch 54, iter 500): lossG 1.854813, lossD_A 0.077909, lossD_B 0.331863\n",
      "(epoch 54, iter 600): lossG 1.381033, lossD_A 0.252184, lossD_B 0.077538\n",
      "(epoch 54, iter 700): lossG 2.001869, lossD_A 0.063801, lossD_B 0.164949\n",
      "(epoch 54, iter 800): lossG 2.203664, lossD_A 0.248466, lossD_B 0.333835\n",
      "(epoch 54, iter 900): lossG 1.397278, lossD_A 0.066643, lossD_B 0.453574\n",
      "(epoch 54, iter 1000): lossG 4.195925, lossD_A 0.111525, lossD_B 0.066136\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3bdd4d104ff44d9a8050f6deee87b6d2"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 55, iter 0): lossG 1.910908, lossD_A 0.098737, lossD_B 0.106010\n",
      "(epoch 55, iter 100): lossG 1.648758, lossD_A 0.059676, lossD_B 0.285045\n",
      "(epoch 55, iter 200): lossG 1.773934, lossD_A 0.074706, lossD_B 0.160466\n",
      "(epoch 55, iter 300): lossG 2.004724, lossD_A 0.097790, lossD_B 0.174994\n",
      "(epoch 55, iter 400): lossG 2.198316, lossD_A 0.033879, lossD_B 0.242119\n",
      "(epoch 55, iter 500): lossG 1.539049, lossD_A 0.163195, lossD_B 0.177251\n",
      "(epoch 55, iter 600): lossG 1.912095, lossD_A 0.150426, lossD_B 0.609995\n",
      "(epoch 55, iter 700): lossG 2.067750, lossD_A 0.035753, lossD_B 0.059093\n",
      "(epoch 55, iter 800): lossG 1.992362, lossD_A 0.020891, lossD_B 0.187674\n",
      "(epoch 55, iter 900): lossG 2.129339, lossD_A 0.256806, lossD_B 0.119469\n",
      "(epoch 55, iter 1000): lossG 1.495382, lossD_A 0.057124, lossD_B 0.356551\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "82ca614caf804e32a9aaf6fb8ffeaca3"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 56, iter 0): lossG 1.929685, lossD_A 0.273532, lossD_B 0.176673\n",
      "(epoch 56, iter 100): lossG 2.016891, lossD_A 0.070278, lossD_B 0.360546\n",
      "(epoch 56, iter 200): lossG 2.090163, lossD_A 0.187255, lossD_B 0.088196\n",
      "(epoch 56, iter 300): lossG 1.870584, lossD_A 0.057487, lossD_B 0.170513\n",
      "(epoch 56, iter 400): lossG 1.538476, lossD_A 0.117451, lossD_B 0.285926\n",
      "(epoch 56, iter 500): lossG 2.310274, lossD_A 0.079151, lossD_B 0.132257\n",
      "(epoch 56, iter 600): lossG 3.231281, lossD_A 0.086572, lossD_B 0.203258\n",
      "(epoch 56, iter 700): lossG 2.855269, lossD_A 0.040031, lossD_B 0.193533\n",
      "(epoch 56, iter 800): lossG 1.768973, lossD_A 0.080104, lossD_B 0.100781\n",
      "(epoch 56, iter 900): lossG 1.813648, lossD_A 0.148643, lossD_B 0.212642\n",
      "(epoch 56, iter 1000): lossG 2.402752, lossD_A 0.047534, lossD_B 0.191997\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6a3175d2b60f4444afac1025352788e2"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 57, iter 0): lossG 1.455601, lossD_A 0.247980, lossD_B 0.409405\n",
      "(epoch 57, iter 100): lossG 2.418736, lossD_A 0.125220, lossD_B 0.102048\n",
      "(epoch 57, iter 200): lossG 1.897820, lossD_A 0.077763, lossD_B 0.092841\n",
      "(epoch 57, iter 300): lossG 2.015390, lossD_A 0.124533, lossD_B 0.174027\n",
      "(epoch 57, iter 400): lossG 1.520212, lossD_A 0.177463, lossD_B 0.243585\n",
      "(epoch 57, iter 500): lossG 1.479822, lossD_A 0.127821, lossD_B 0.057923\n",
      "(epoch 57, iter 600): lossG 1.484829, lossD_A 0.266013, lossD_B 0.173948\n",
      "(epoch 57, iter 700): lossG 1.719691, lossD_A 0.182933, lossD_B 0.043808\n",
      "(epoch 57, iter 800): lossG 1.315698, lossD_A 0.370153, lossD_B 0.418492\n",
      "(epoch 57, iter 900): lossG 2.036703, lossD_A 0.064511, lossD_B 0.318428\n",
      "(epoch 57, iter 1000): lossG 1.932102, lossD_A 0.141374, lossD_B 0.092166\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "199c47c5e52a44fb8bc172aa25c2f952"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 58, iter 0): lossG 1.830759, lossD_A 0.137538, lossD_B 0.123898\n",
      "(epoch 58, iter 100): lossG 2.037585, lossD_A 0.042977, lossD_B 0.171700\n",
      "(epoch 58, iter 200): lossG 1.499874, lossD_A 0.154533, lossD_B 0.281085\n",
      "(epoch 58, iter 300): lossG 1.969276, lossD_A 0.196252, lossD_B 0.265894\n",
      "(epoch 58, iter 400): lossG 1.787114, lossD_A 0.239575, lossD_B 0.065441\n",
      "(epoch 58, iter 500): lossG 1.636060, lossD_A 0.129084, lossD_B 0.355647\n",
      "(epoch 58, iter 600): lossG 1.897413, lossD_A 0.108465, lossD_B 0.156042\n",
      "(epoch 58, iter 700): lossG 1.674806, lossD_A 0.188220, lossD_B 0.271375\n",
      "(epoch 58, iter 800): lossG 1.413359, lossD_A 0.199366, lossD_B 0.126176\n",
      "(epoch 58, iter 900): lossG 1.647086, lossD_A 0.100691, lossD_B 0.157420\n",
      "(epoch 58, iter 1000): lossG 2.046332, lossD_A 0.177361, lossD_B 0.168587\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5c4cf643070c46e7b45c1f7c66d0d256"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 59, iter 0): lossG 1.540113, lossD_A 0.046727, lossD_B 0.289334\n",
      "(epoch 59, iter 100): lossG 1.323235, lossD_A 0.052112, lossD_B 0.107104\n",
      "(epoch 59, iter 200): lossG 2.149329, lossD_A 0.160679, lossD_B 0.212770\n",
      "(epoch 59, iter 300): lossG 1.840325, lossD_A 0.311233, lossD_B 0.143483\n",
      "(epoch 59, iter 400): lossG 1.588609, lossD_A 0.187474, lossD_B 0.157776\n",
      "(epoch 59, iter 500): lossG 2.962156, lossD_A 0.114226, lossD_B 0.112815\n",
      "(epoch 59, iter 600): lossG 2.342973, lossD_A 0.127892, lossD_B 0.092005\n",
      "(epoch 59, iter 700): lossG 2.478531, lossD_A 0.087902, lossD_B 0.104414\n",
      "(epoch 59, iter 800): lossG 2.023143, lossD_A 0.056395, lossD_B 0.125467\n",
      "(epoch 59, iter 900): lossG 1.904326, lossD_A 0.064024, lossD_B 0.180918\n",
      "(epoch 59, iter 1000): lossG 1.639686, lossD_A 0.292613, lossD_B 0.157830\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a97e974a8a2f4d5d9ce36a6db0a821ba"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 60, iter 0): lossG 2.165569, lossD_A 0.025175, lossD_B 0.344488\n",
      "(epoch 60, iter 100): lossG 2.329719, lossD_A 0.081924, lossD_B 0.173408\n",
      "(epoch 60, iter 200): lossG 2.085863, lossD_A 0.267242, lossD_B 0.230643\n",
      "(epoch 60, iter 300): lossG 1.242398, lossD_A 0.273253, lossD_B 0.295780\n",
      "(epoch 60, iter 400): lossG 1.710919, lossD_A 0.093710, lossD_B 0.208109\n",
      "(epoch 60, iter 500): lossG 1.972482, lossD_A 0.032829, lossD_B 0.094451\n",
      "(epoch 60, iter 600): lossG 1.569533, lossD_A 0.268153, lossD_B 0.285574\n",
      "(epoch 60, iter 700): lossG 1.319906, lossD_A 0.261075, lossD_B 0.298615\n",
      "(epoch 60, iter 800): lossG 1.889493, lossD_A 0.033119, lossD_B 0.214245\n",
      "(epoch 60, iter 900): lossG 2.168799, lossD_A 0.053034, lossD_B 0.172452\n",
      "(epoch 60, iter 1000): lossG 1.865559, lossD_A 0.127479, lossD_B 0.199590\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8468639bdc544526971fb3b7b63b9b3a"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 61, iter 0): lossG 2.361079, lossD_A 0.057726, lossD_B 0.101931\n",
      "(epoch 61, iter 100): lossG 1.497636, lossD_A 0.221427, lossD_B 0.155473\n",
      "(epoch 61, iter 200): lossG 2.354466, lossD_A 0.276752, lossD_B 0.179934\n",
      "(epoch 61, iter 300): lossG 2.491564, lossD_A 0.077584, lossD_B 0.161093\n",
      "(epoch 61, iter 400): lossG 1.244142, lossD_A 0.411290, lossD_B 0.217877\n",
      "(epoch 61, iter 500): lossG 2.277121, lossD_A 0.196965, lossD_B 0.130350\n",
      "(epoch 61, iter 600): lossG 1.302106, lossD_A 0.087478, lossD_B 0.364302\n",
      "(epoch 61, iter 700): lossG 2.558396, lossD_A 0.085339, lossD_B 0.220248\n",
      "(epoch 61, iter 800): lossG 1.464440, lossD_A 0.101431, lossD_B 0.125434\n",
      "(epoch 61, iter 900): lossG 2.127755, lossD_A 0.046906, lossD_B 0.204925\n",
      "(epoch 61, iter 1000): lossG 2.332231, lossD_A 0.191766, lossD_B 0.073828\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9fbb697b9a4c40b9a20c62a371d1f016"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 62, iter 0): lossG 1.949889, lossD_A 0.077307, lossD_B 0.139675\n",
      "(epoch 62, iter 100): lossG 1.697098, lossD_A 0.117258, lossD_B 0.296319\n",
      "(epoch 62, iter 200): lossG 1.772421, lossD_A 0.114173, lossD_B 0.233701\n",
      "(epoch 62, iter 300): lossG 1.622769, lossD_A 0.164269, lossD_B 0.299396\n",
      "(epoch 62, iter 400): lossG 2.029436, lossD_A 0.179468, lossD_B 0.114912\n",
      "(epoch 62, iter 500): lossG 2.829310, lossD_A 0.137346, lossD_B 0.168963\n",
      "(epoch 62, iter 600): lossG 1.478493, lossD_A 0.238873, lossD_B 0.057191\n",
      "(epoch 62, iter 700): lossG 1.695319, lossD_A 0.119482, lossD_B 0.344665\n",
      "(epoch 62, iter 800): lossG 2.131418, lossD_A 0.125564, lossD_B 0.166447\n",
      "(epoch 62, iter 900): lossG 2.057883, lossD_A 0.189017, lossD_B 0.186909\n",
      "(epoch 62, iter 1000): lossG 2.149444, lossD_A 0.046360, lossD_B 0.346037\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a6ec96cb153943ff963dd17763e0f566"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 63, iter 0): lossG 2.405365, lossD_A 0.060813, lossD_B 0.090631\n",
      "(epoch 63, iter 100): lossG 1.426935, lossD_A 0.185975, lossD_B 0.136792\n",
      "(epoch 63, iter 200): lossG 1.900841, lossD_A 0.091603, lossD_B 0.159064\n",
      "(epoch 63, iter 300): lossG 1.523286, lossD_A 0.260264, lossD_B 0.088148\n",
      "(epoch 63, iter 400): lossG 1.802296, lossD_A 0.316681, lossD_B 0.216549\n",
      "(epoch 63, iter 500): lossG 1.807430, lossD_A 0.067387, lossD_B 0.291726\n",
      "(epoch 63, iter 600): lossG 2.065410, lossD_A 0.285656, lossD_B 0.215303\n",
      "(epoch 63, iter 700): lossG 2.119820, lossD_A 0.071852, lossD_B 0.250043\n",
      "(epoch 63, iter 800): lossG 2.308392, lossD_A 0.057838, lossD_B 0.140305\n",
      "(epoch 63, iter 900): lossG 1.444855, lossD_A 0.275305, lossD_B 0.174871\n",
      "(epoch 63, iter 1000): lossG 2.144279, lossD_A 0.043282, lossD_B 0.180885\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aab2d01d69a84ea9b1b22e8f30dd5ed5"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 64, iter 0): lossG 1.662960, lossD_A 0.102947, lossD_B 0.340763\n",
      "(epoch 64, iter 100): lossG 1.922262, lossD_A 0.154322, lossD_B 0.250737\n",
      "(epoch 64, iter 200): lossG 2.058378, lossD_A 0.030875, lossD_B 0.207814\n",
      "(epoch 64, iter 300): lossG 1.527258, lossD_A 0.162399, lossD_B 0.333720\n",
      "(epoch 64, iter 400): lossG 1.832890, lossD_A 0.059831, lossD_B 0.119254\n",
      "(epoch 64, iter 500): lossG 2.303726, lossD_A 0.172526, lossD_B 0.212476\n",
      "(epoch 64, iter 600): lossG 1.462527, lossD_A 0.106900, lossD_B 0.120606\n",
      "(epoch 64, iter 700): lossG 1.602929, lossD_A 0.099180, lossD_B 0.266800\n",
      "(epoch 64, iter 800): lossG 1.498946, lossD_A 0.170254, lossD_B 0.302219\n",
      "(epoch 64, iter 900): lossG 2.145333, lossD_A 0.259059, lossD_B 0.149631\n",
      "(epoch 64, iter 1000): lossG 1.804310, lossD_A 0.149083, lossD_B 0.224389\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7fc7f2be6d8a4ff69e2ddcb8edb9b08b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 65, iter 0): lossG 1.885010, lossD_A 0.045129, lossD_B 0.344830\n",
      "(epoch 65, iter 100): lossG 2.875367, lossD_A 0.090719, lossD_B 0.149868\n",
      "(epoch 65, iter 200): lossG 1.496931, lossD_A 0.034638, lossD_B 0.232813\n",
      "(epoch 65, iter 300): lossG 2.344473, lossD_A 0.075651, lossD_B 0.248368\n",
      "(epoch 65, iter 400): lossG 2.233206, lossD_A 0.159390, lossD_B 0.527274\n",
      "(epoch 65, iter 500): lossG 1.716157, lossD_A 0.076530, lossD_B 0.193363\n",
      "(epoch 65, iter 600): lossG 1.598665, lossD_A 0.270192, lossD_B 0.095089\n",
      "(epoch 65, iter 700): lossG 1.558948, lossD_A 0.132974, lossD_B 0.090676\n",
      "(epoch 65, iter 800): lossG 1.474151, lossD_A 0.201718, lossD_B 0.198220\n",
      "(epoch 65, iter 900): lossG 2.392177, lossD_A 0.186423, lossD_B 0.067071\n",
      "(epoch 65, iter 1000): lossG 2.096383, lossD_A 0.208580, lossD_B 0.099589\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ec0e536d26974b57a03c885e7ebc114e"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 66, iter 0): lossG 1.868599, lossD_A 0.082326, lossD_B 0.071384\n",
      "(epoch 66, iter 100): lossG 1.763536, lossD_A 0.055242, lossD_B 0.236175\n",
      "(epoch 66, iter 200): lossG 1.747844, lossD_A 0.183524, lossD_B 0.234686\n",
      "(epoch 66, iter 300): lossG 1.302832, lossD_A 0.077461, lossD_B 0.127630\n",
      "(epoch 66, iter 400): lossG 1.639674, lossD_A 0.092521, lossD_B 0.295470\n",
      "(epoch 66, iter 500): lossG 2.234421, lossD_A 0.063865, lossD_B 0.165580\n",
      "(epoch 66, iter 600): lossG 1.818450, lossD_A 0.051556, lossD_B 0.252504\n",
      "(epoch 66, iter 700): lossG 1.763149, lossD_A 0.046483, lossD_B 0.197442\n",
      "(epoch 66, iter 800): lossG 1.736354, lossD_A 0.068164, lossD_B 0.214249\n",
      "(epoch 66, iter 900): lossG 1.734034, lossD_A 0.399615, lossD_B 0.118680\n",
      "(epoch 66, iter 1000): lossG 1.924036, lossD_A 0.189179, lossD_B 0.332130\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8971437183a74136ad0892f4214293d9"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 67, iter 0): lossG 1.817915, lossD_A 0.033679, lossD_B 0.208286\n",
      "(epoch 67, iter 100): lossG 2.484664, lossD_A 0.276795, lossD_B 0.316016\n",
      "(epoch 67, iter 200): lossG 1.410679, lossD_A 0.226497, lossD_B 0.169447\n",
      "(epoch 67, iter 300): lossG 1.761964, lossD_A 0.143769, lossD_B 0.226289\n",
      "(epoch 67, iter 400): lossG 1.543716, lossD_A 0.151930, lossD_B 0.207463\n",
      "(epoch 67, iter 500): lossG 1.804830, lossD_A 0.076134, lossD_B 0.258742\n",
      "(epoch 67, iter 600): lossG 2.346096, lossD_A 0.100022, lossD_B 0.185834\n",
      "(epoch 67, iter 700): lossG 2.220233, lossD_A 0.115513, lossD_B 0.275829\n",
      "(epoch 67, iter 800): lossG 2.065701, lossD_A 0.067922, lossD_B 0.363702\n",
      "(epoch 67, iter 900): lossG 1.892800, lossD_A 0.095925, lossD_B 0.209470\n",
      "(epoch 67, iter 1000): lossG 2.678236, lossD_A 0.093301, lossD_B 0.258551\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed99f2fb77ba43368fb574862bd665e2"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 68, iter 0): lossG 1.887777, lossD_A 0.213006, lossD_B 0.276858\n",
      "(epoch 68, iter 100): lossG 1.521817, lossD_A 0.422854, lossD_B 0.175863\n",
      "(epoch 68, iter 200): lossG 2.936799, lossD_A 0.079947, lossD_B 0.168085\n",
      "(epoch 68, iter 300): lossG 1.924562, lossD_A 0.072839, lossD_B 0.206604\n",
      "(epoch 68, iter 400): lossG 2.164832, lossD_A 0.033227, lossD_B 0.099815\n",
      "(epoch 68, iter 500): lossG 1.559435, lossD_A 0.199256, lossD_B 0.222941\n",
      "(epoch 68, iter 600): lossG 1.889993, lossD_A 0.455496, lossD_B 0.281457\n",
      "(epoch 68, iter 700): lossG 2.320319, lossD_A 0.242840, lossD_B 0.278202\n",
      "(epoch 68, iter 800): lossG 2.346368, lossD_A 0.101651, lossD_B 0.208662\n",
      "(epoch 68, iter 900): lossG 1.141201, lossD_A 0.110664, lossD_B 0.072275\n",
      "(epoch 68, iter 1000): lossG 2.667904, lossD_A 0.043898, lossD_B 0.095264\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c5b7f2a2e6804a6d9675867d342ece74"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 69, iter 0): lossG 2.181173, lossD_A 0.165222, lossD_B 0.131651\n",
      "(epoch 69, iter 100): lossG 2.268931, lossD_A 0.070070, lossD_B 0.221680\n",
      "(epoch 69, iter 200): lossG 2.230165, lossD_A 0.037701, lossD_B 0.223964\n",
      "(epoch 69, iter 300): lossG 2.259275, lossD_A 0.097036, lossD_B 0.183609\n",
      "(epoch 69, iter 400): lossG 2.015645, lossD_A 0.024719, lossD_B 0.262593\n",
      "(epoch 69, iter 500): lossG 1.838573, lossD_A 0.097958, lossD_B 0.032266\n",
      "(epoch 69, iter 600): lossG 2.733501, lossD_A 0.099310, lossD_B 0.140620\n",
      "(epoch 69, iter 700): lossG 2.232999, lossD_A 0.294297, lossD_B 0.192126\n",
      "(epoch 69, iter 800): lossG 1.641249, lossD_A 0.040168, lossD_B 0.101332\n",
      "(epoch 69, iter 900): lossG 1.626757, lossD_A 0.096605, lossD_B 0.267486\n",
      "(epoch 69, iter 1000): lossG 1.486297, lossD_A 0.114756, lossD_B 0.224977\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dde3f79f21674575b6c38ac8d88930ef"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 70, iter 0): lossG 2.039821, lossD_A 0.106906, lossD_B 0.128103\n",
      "(epoch 70, iter 100): lossG 1.734894, lossD_A 0.099180, lossD_B 0.254381\n",
      "(epoch 70, iter 200): lossG 2.597631, lossD_A 0.130907, lossD_B 0.185642\n",
      "(epoch 70, iter 300): lossG 1.705272, lossD_A 0.213236, lossD_B 0.150410\n",
      "(epoch 70, iter 400): lossG 1.965333, lossD_A 0.136174, lossD_B 0.176158\n",
      "(epoch 70, iter 500): lossG 1.801915, lossD_A 0.065311, lossD_B 0.326913\n",
      "(epoch 70, iter 600): lossG 2.333569, lossD_A 0.079013, lossD_B 0.201343\n",
      "(epoch 70, iter 700): lossG 1.838656, lossD_A 0.075282, lossD_B 0.241083\n",
      "(epoch 70, iter 800): lossG 1.693538, lossD_A 0.151850, lossD_B 0.092152\n",
      "(epoch 70, iter 900): lossG 1.425521, lossD_A 0.322053, lossD_B 0.213452\n",
      "(epoch 70, iter 1000): lossG 1.365547, lossD_A 0.210409, lossD_B 0.221033\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5e27bc431a3f4b86933bad8baee078de"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 71, iter 0): lossG 2.099267, lossD_A 0.138745, lossD_B 0.226790\n",
      "(epoch 71, iter 100): lossG 2.097924, lossD_A 0.140773, lossD_B 0.199419\n",
      "(epoch 71, iter 200): lossG 1.669240, lossD_A 0.083535, lossD_B 0.248124\n",
      "(epoch 71, iter 300): lossG 1.891677, lossD_A 0.059631, lossD_B 0.357048\n",
      "(epoch 71, iter 400): lossG 1.084998, lossD_A 0.220453, lossD_B 0.383054\n",
      "(epoch 71, iter 500): lossG 1.778682, lossD_A 0.121414, lossD_B 0.289986\n",
      "(epoch 71, iter 600): lossG 1.460974, lossD_A 0.091661, lossD_B 0.304010\n",
      "(epoch 71, iter 700): lossG 2.589352, lossD_A 0.144947, lossD_B 0.134250\n",
      "(epoch 71, iter 800): lossG 1.470175, lossD_A 0.196625, lossD_B 0.140283\n",
      "(epoch 71, iter 900): lossG 2.539209, lossD_A 0.029037, lossD_B 0.345443\n",
      "(epoch 71, iter 1000): lossG 2.158098, lossD_A 0.134357, lossD_B 0.092911\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac2bf9ab9baf4982a579ea1b7fe37853"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 72, iter 0): lossG 1.480824, lossD_A 0.262026, lossD_B 0.227424\n",
      "(epoch 72, iter 100): lossG 1.598354, lossD_A 0.143893, lossD_B 0.167254\n",
      "(epoch 72, iter 200): lossG 2.022200, lossD_A 0.117817, lossD_B 0.269777\n",
      "(epoch 72, iter 300): lossG 2.613070, lossD_A 0.059864, lossD_B 0.229475\n",
      "(epoch 72, iter 400): lossG 1.796981, lossD_A 0.162104, lossD_B 0.308210\n",
      "(epoch 72, iter 500): lossG 2.146238, lossD_A 0.031482, lossD_B 0.096500\n",
      "(epoch 72, iter 600): lossG 1.713568, lossD_A 0.146436, lossD_B 0.185821\n",
      "(epoch 72, iter 700): lossG 1.449303, lossD_A 0.184823, lossD_B 0.031419\n",
      "(epoch 72, iter 800): lossG 2.002977, lossD_A 0.209902, lossD_B 0.193689\n",
      "(epoch 72, iter 900): lossG 1.524656, lossD_A 0.099082, lossD_B 0.202504\n",
      "(epoch 72, iter 1000): lossG 1.827330, lossD_A 0.277886, lossD_B 0.230220\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1d3bd2f1c0e94c19a397ae36229ed985"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(epoch 73, iter 0): lossG 1.826973, lossD_A 0.111571, lossD_B 0.223329\n",
      "(epoch 73, iter 100): lossG 1.213725, lossD_A 0.176861, lossD_B 0.210474\n",
      "(epoch 73, iter 200): lossG 1.640519, lossD_A 0.246351, lossD_B 0.207229\n",
      "(epoch 73, iter 300): lossG 2.291671, lossD_A 0.106889, lossD_B 0.212099\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm_notebook\n",
    "niter = 100 # number of iterations at starting learning rate\n",
    "niter_decay = 100 # number of iterations to linearly decay learning rate to zero\n",
    "epoch_progress_bar = tqdm_notebook(total=niter+niter_decay+1, desc='Total progress')\n",
    "for epoch in range(1, niter+niter_decay+1):\n",
    "    progress_bar = tqdm_notebook(total=len(maps_dataloader), desc='epoch '+str(epoch), leave=False)\n",
    "    for i, data in enumerate(maps_dataloader):\n",
    "        model.set_input(data)\n",
    "        model.optimize_parameters()\n",
    "        if i % 100 == 0:\n",
    "            print('(epoch %d, iter %d): lossG %f, lossD_A %f, lossD_B %f' % (epoch, i, model.loss_G.data[0], model.loss_D_A.data[0], model.loss_D_B.data[0]))\n",
    "            if i > 0:\n",
    "                model.save('latest')\n",
    "        progress_bar.update(1)\n",
    "    if epoch > niter_decay:\n",
    "        model.update_learning_rate(niter_decay)\n",
    "    epoch_progress_bar.update(1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}