Assignment_8.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Assignment_8.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "bUqBCNHGlYoq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# http://pytorch.org/\n",
        "from os.path import exists\n",
        "from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag\n",
        "platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())\n",
        "cuda_output = !ldconfig -p|grep cudart.so|sed -e 's/.*\\.\\([0-9]*\\)\\.\\([0-9]*\\)$/cu\\1\\2/'\n",
        "accelerator = cuda_output[0] if exists('/dev/nvidia0') else 'cpu'\n",
        "\n",
        "!pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.4.1-{platform}-linux_x86_64.whl torchvision\n",
        "import torch"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9_hcDXUMkEH_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import  torchvision\n",
        "from torchvision import datasets as dsets\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import os,time\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import itertools\n",
        "import pickle\n",
        "import imageio\n",
        "import torch.optim as optim\n",
        "from torch.autograd import Variable\n",
        "import pdb"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWu2SkYhzslR",
        "colab_type": "code",
        "outputId": "366e8371-45d7-4819-88a3-62d7b21832e0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "!pip install pillow==4.1.1\n",
        "%reload_ext autoreload\n",
        "%autoreload"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: pillow==4.1.1 in /usr/local/lib/python3.6/dist-packages (4.1.1)\n",
            "Requirement already satisfied: olefile in /usr/local/lib/python3.6/dist-packages (from pillow==4.1.1) (0.46)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tfd7v53sju4a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!unzip soccerballdata.zip"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CkWQg_wMYpDh",
        "colab_type": "code",
        "outputId": "b4e1e220-5930-47e2-a92c-09ef6a61b16c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Data augmentation and normalization for training\n",
        "# Just normalization for validation\n",
        "batch_size = 4\n",
        "data_transforms = transforms.Compose([\n",
        "        transforms.Resize((64,64)),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))\n",
        "    ])\n",
        "data_dir = 'soccerballdata'\n",
        "train_datasets = dsets.ImageFolder(data_dir,transform=data_transforms)\n",
        "train_loaders = torch.utils.data.DataLoader(train_datasets, batch_size=batch_size,\n",
        "                                             shuffle=True, num_workers=4)\n",
        "\n",
        "cuda = torch.cuda.is_available()\n",
        "print(cuda)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HdksXk3hrNSN",
        "colab_type": "code",
        "outputId": "b9250bc3-3a10-4c6e-96d9-ce90d6344565",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "len(train_datasets), train_datasets[0][0].shape, train_datasets[0][1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(202, torch.Size([3, 64, 64]), 0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LnSq-fuaBgDl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def normal_init(m,mean,std):\n",
        "  if isinstance(m, nn.ConvTranspose2d) or isinstance(m,nn.Conv2d):\n",
        "    m.weight.data.normal_(mean,std)\n",
        "    m.bias.data.zero_()\n",
        "    \n",
        "#weight_init  \n",
        "def weight_init(self, mean=0.0, std=0.02):\n",
        "  for m in self._modules:\n",
        "    normal_init(self._modules[m], mean, std)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TOx_zqC96z16",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Generator\n",
        "# torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size,\n",
        "#                          stride=1, padding=0, output_padding=0,\n",
        "#                          groups=1, bias=True)\n",
        "# output_height = (height-1)*stride + kernel_size - 2*padding + output_padding\n",
        "# batch x 100-> batch x noisy input vector of size 100\n",
        "\n",
        "class Generator(nn.Module):\n",
        "    # initializers\n",
        "    def __init__(self, d=128):\n",
        "        super(Generator, self).__init__()\n",
        "        self.deconv1 = nn.ConvTranspose2d(100, d*8, 4, 1, 0)\n",
        "        self.deconv1_bn = nn.BatchNorm2d(d*8)\n",
        "        self.deconv2 = nn.ConvTranspose2d(d*8, d*4, 4, 2, 1)\n",
        "        self.deconv2_bn = nn.BatchNorm2d(d*4)\n",
        "        self.deconv3 = nn.ConvTranspose2d(d*4, d*2, 4, 2, 1)\n",
        "        self.deconv3_bn = nn.BatchNorm2d(d*2)\n",
        "        self.deconv4 = nn.ConvTranspose2d(d*2, d, 4, 2, 1)\n",
        "        self.deconv4_bn = nn.BatchNorm2d(d)\n",
        "        self.deconv5 = nn.ConvTranspose2d(d, 3, 4, 2, 1)\n",
        "\n",
        "    # forward method\n",
        "    def forward(self, input):\n",
        "        # x = F.relu(self.deconv1(input))\n",
        "        x = F.relu(self.deconv1_bn(self.deconv1(input)))\n",
        "        x = F.relu(self.deconv2_bn(self.deconv2(x)))\n",
        "        x = F.relu(self.deconv3_bn(self.deconv3(x)))\n",
        "        x = F.relu(self.deconv4_bn(self.deconv4(x)))\n",
        "        x = F.tanh(self.deconv5(x))\n",
        "\n",
        "        return x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ntEUb78x-TkS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Discriminator\n",
        "class Discriminator(nn.Module):\n",
        "  #initializers\n",
        "  def __init__(self,d=128):\n",
        "    super(Discriminator, self).__init__()\n",
        "    self.conv1 = nn.Conv2d(3, d, 4, 2, 1)\n",
        "    self.conv2 = nn.Conv2d(d, d*2, 4, 2, 1)\n",
        "    self.conv2_bn = nn.BatchNorm2d(d*2)\n",
        "    self.conv3 = nn.Conv2d(d*2, d*4, 4, 2, 1)\n",
        "    self.conv3_bn = nn.BatchNorm2d(d*4)\n",
        "    self.conv4 = nn.Conv2d(d*4, d*8, 4, 2, 1)\n",
        "    self.conv4_bn = nn.BatchNorm2d(d*8)\n",
        "    self.conv5 = nn.Conv2d(d*8, 1, 4, 1, 0)\n",
        "    \n",
        "  def forward(self,input):\n",
        "    x = F.leaky_relu(self.conv1(input),0.2)\n",
        "    x = F.leaky_relu(self.conv2_bn(self.conv2(x)),0.2)\n",
        "    x = F.leaky_relu(self.conv3_bn(self.conv3(x)),0.2)\n",
        "    x = F.leaky_relu(self.conv4_bn(self.conv4(x)),0.2)\n",
        "    x = F.sigmoid(self.conv5(x))\n",
        "    return x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pXEZdcQa-lP7",
        "colab_type": "code",
        "outputId": "7fe90efd-d10f-4b4d-b469-25fbe6d98f84",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        }
      },
      "source": [
        "fixed_z_ = torch.randn((5*5,100)).view(-1,100,1,1) # fixed noise for Generator\n",
        "fixed_z_ = Variable(fixed_z_.cuda(), volatile = True)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:2: UserWarning: volatile was removed and now has no effect. Use `with torch.no_grad():` instead.\n",
            "  \n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wExtqGJNCxmA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def show_result(num_epoch, show = False, save = False, path = 'result.png', isFix=False):\n",
        "    z_ = torch.randn((5*5, 100)).view(-1, 100, 1, 1)\n",
        "    z_ = Variable(z_.cuda(), volatile=True)\n",
        "\n",
        "    G.eval()\n",
        "    if isFix:\n",
        "        test_images = G(fixed_z_)\n",
        "    else:\n",
        "        test_images = G(z_)\n",
        "    G.train()\n",
        "\n",
        "    size_figure_grid = 5\n",
        "    fig, ax = plt.subplots(size_figure_grid, size_figure_grid, figsize=(5, 5))\n",
        "    for i, j in itertools.product(range(size_figure_grid), range(size_figure_grid)):\n",
        "        ax[i, j].get_xaxis().set_visible(False)\n",
        "        ax[i, j].get_yaxis().set_visible(False)\n",
        "\n",
        "    for k in range(5*5):\n",
        "        i = k // 5\n",
        "        j = k % 5\n",
        "        ax[i, j].cla()\n",
        "        ax[i, j].imshow(test_images[k, 0].cpu().data.numpy(), cmap='gray')\n",
        "\n",
        "    label = 'Epoch {0}'.format(num_epoch)\n",
        "    fig.text(0.5, 0.04, label, ha='center')\n",
        "    plt.savefig(path)\n",
        "\n",
        "    if show:\n",
        "        plt.show()\n",
        "    else:\n",
        "        plt.close()\n",
        "\n",
        "def show_train_hist(hist, show = False, save = False, path = 'Train_hist.png'):\n",
        "    x = range(len(hist['D_losses']))\n",
        "\n",
        "    y1 = hist['D_losses']\n",
        "    y2 = hist['G_losses']\n",
        "\n",
        "    plt.plot(x, y1, label='D_loss')\n",
        "    plt.plot(x, y2, label='G_loss')\n",
        "\n",
        "    plt.xlabel('Iter')\n",
        "    plt.ylabel('Loss')\n",
        "\n",
        "    plt.legend(loc=4)\n",
        "    plt.grid(True)\n",
        "    plt.tight_layout()\n",
        "\n",
        "    if save:\n",
        "        plt.savefig(path)\n",
        "\n",
        "    if show:\n",
        "        plt.show()\n",
        "    else:\n",
        "        plt.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ah9JA0O3C9v6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#training parameters\n",
        "lr = 0.0002\n",
        "train_epoch = 100\n",
        "img_size = 64"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k1CJ1-LPD_RS",
        "colab_type": "code",
        "outputId": "4b480135-de4b-419e-f606-719f227e8cbf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 353
        }
      },
      "source": [
        "#network\n",
        "G = Generator()\n",
        "D = Discriminator()\n",
        "\n",
        "G.apply(weight_init)\n",
        "D.apply(weight_init)\n",
        "\n",
        "G.cuda(),D.cuda()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Generator(\n",
              "   (deconv1): ConvTranspose2d(100, 1024, kernel_size=(4, 4), stride=(1, 1))\n",
              "   (deconv1_bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "   (deconv2): ConvTranspose2d(1024, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              "   (deconv2_bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "   (deconv3): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              "   (deconv3_bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "   (deconv4): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              "   (deconv4_bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "   (deconv5): ConvTranspose2d(128, 3, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              " ), Discriminator(\n",
              "   (conv1): Conv2d(3, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              "   (conv2): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              "   (conv2_bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "   (conv3): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              "   (conv3_bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "   (conv4): Conv2d(512, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
              "   (conv4_bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "   (conv5): Conv2d(1024, 1, kernel_size=(4, 4), stride=(1, 1))\n",
              " ))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZVkWpUNvEeDh",
        "colab_type": "code",
        "outputId": "2554c515-e454-4021-8a1a-0a4fca31c67a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        }
      },
      "source": [
        "#Binary Cross Entropy Loss\n",
        "BCE_loss = nn.BCELoss()\n",
        "\n",
        "#Adam Optimizers\n",
        "G_optimizer = optim.Adam(G.parameters(), lr=lr, betas=(0.5,0.999))\n",
        "D_optimizer = optim.Adam(D.parameters(), lr=lr, betas=(0.5,0.999))\n",
        "\n",
        "G_optimizer,D_optimizer"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Adam (\n",
              " Parameter Group 0\n",
              "     amsgrad: False\n",
              "     betas: (0.5, 0.999)\n",
              "     eps: 1e-08\n",
              "     lr: 0.0002\n",
              "     weight_decay: 0\n",
              " ), Adam (\n",
              " Parameter Group 0\n",
              "     amsgrad: False\n",
              "     betas: (0.5, 0.999)\n",
              "     eps: 1e-08\n",
              "     lr: 0.0002\n",
              "     weight_decay: 0\n",
              " ))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I2CimiaYINbK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# results save folder\n",
        "if not os.path.isdir('Soccerball_DCGAN_results'):\n",
        "    os.mkdir('Soccerball_DCGAN_results')\n",
        "if not os.path.isdir('Soccerball_DCGAN_results/Random_results'):\n",
        "    os.mkdir('Soccerball_DCGAN_results/Random_results')\n",
        "if not os.path.isdir('Soccerball_DCGAN_results/Fixed_results'):\n",
        "    os.mkdir('Soccerball_DCGAN_results/Fixed_results')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VtFQ2CoiI4A3",
        "colab_type": "code",
        "outputId": "2d329bc3-75fd-4185-d8b1-bfc9d2de0293",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1902
        }
      },
      "source": [
        "train_hist={}\n",
        "train_hist['D_losses']=[]\n",
        "train_hist['G_losses']=[]\n",
        "train_hist['per_epoch_ptimes']=[]\n",
        "train_hist['total_ptimes']=[]\n",
        "num_iter=0\n",
        "\n",
        "print('training start!')\n",
        "start_time=time.time()\n",
        "for epoch in range(train_epoch):\n",
        "  D_losses = []\n",
        "  G_losses = []\n",
        "  epoch_start_time=time.time()\n",
        "  for x_,label in train_loaders:\n",
        "    #train Discriminator D\n",
        "    D.zero_grad()\n",
        "    mini_batch = x_.size()[0]\n",
        "    y_real_ = torch.ones(mini_batch)\n",
        "    y_fake_ = torch.zeros(mini_batch)\n",
        "    \n",
        "    x_,y_real_,y_fake_ = Variable(x_.cuda()), Variable(y_real_.cuda()), Variable(y_fake_.cuda())\n",
        "    D_result = D(x_).squeeze()\n",
        "    D_real_loss = BCE_loss(D_result, y_real_)\n",
        "    \n",
        "    z_ = torch.randn((mini_batch,100)).view(-1,100,1,1)\n",
        "    z_ = Variable(z_.cuda())\n",
        "    G_result = G(z_)\n",
        "    D_result = D(G_result).squeeze()\n",
        "    D_fake_loss = BCE_loss(D_result, y_fake_)\n",
        "    D_fake_score = D_result.data.mean()\n",
        "    \n",
        "    D_train_loss = D_real_loss + D_fake_loss\n",
        "    D_train_loss.backward()\n",
        "    D_optimizer.step()\n",
        "    \n",
        "    # D_losses.append(D_train_loss.data[0])\n",
        "    D_losses.append(D_train_loss.data[0])\n",
        "    \n",
        "    #train generator G\n",
        "    G.zero_grad()\n",
        "    z_ = torch.randn((mini_batch,100)).view(-1,100,1,1)\n",
        "    z_ = Variable(z_.cuda())\n",
        "    G_result = G(z_)\n",
        "    D_result = D(G_result).squeeze()\n",
        "    G_train_loss = BCE_loss(D_result, y_real_)\n",
        "    G_train_loss.backward()\n",
        "    G_optimizer.step()\n",
        "    \n",
        "    G_losses.append(G_train_loss.data[0])\n",
        "    num_iter += 1\n",
        "    \n",
        "  epoch_end_time = time.time()\n",
        "  per_epoch_ptimes = epoch_end_time - epoch_start_time\n",
        "  \n",
        "  print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), train_epoch, per_epoch_ptimes, torch.mean(torch.FloatTensor(D_losses)),\n",
        "                                                              torch.mean(torch.FloatTensor(G_losses))))\n",
        "  p = 'Soccerball_DCGAN_results/Random_results/Soccerball_DCGAN_' + str(epoch + 1) + '.png'\n",
        "  fixed_p = 'Soccerball_DCGAN_results/Fixed_results/Soccerball_DCGAN_' + str(epoch + 1) + '.png'\n",
        "  show_result((epoch+1), save=True, path=p, isFix=False)\n",
        "  show_result((epoch+1), save=True, path=fixed_p, isFix=True)\n",
        "  train_hist['D_losses'].append(torch.mean(torch.FloatTensor(D_losses)))\n",
        "  train_hist['G_losses'].append(torch.mean(torch.FloatTensor(G_losses)))\n",
        "  train_hist['per_epoch_ptimes'].append(per_epoch_ptimes)\n",
        "  \n",
        "end_time = time.time()\n",
        "total_ptime = end_time - start_time\n",
        "train_hist['total_ptimes'].append(total_ptime)\n",
        "\n",
        "print(\"Avg per epoch ptime: %.2f, total %d epochs ptime: %.2f\" % (torch.mean(torch.FloatTensor(train_hist['per_epoch_ptimes'])), train_epoch, total_ptime))\n",
        "print(\"Training finish!... save training results\")\n",
        "torch.save(G.state_dict(), \"Soccerball_DCGAN_results/generator_param.pkl\")\n",
        "torch.save(D.state_dict(), \"Soccerball_DCGAN_results/discriminator_param.pkl\")\n",
        "with open('Soccerball_DCGAN_results/train_hist.pkl', 'wb') as f:\n",
        "    pickle.dump(train_hist, f)\n",
        "\n",
        "show_train_hist(train_hist, save=True, path='Soccerball_DCGAN_results/Soccerball_DCGAN_train_hist.png')\n",
        "\n",
        "images = []\n",
        "for e in range(train_epoch):\n",
        "    img_name = 'Soccerball_DCGAN_results/Fixed_results/Soccerball_DCGAN_' + str(e + 1) + '.png'\n",
        "    images.append(imageio.imread(img_name))\n",
        "imageio.mimsave('Soccerball_DCGAN_results/generation_animation.gif', images, fps=5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "training start!\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:1006: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
            "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n",
            "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:995: UserWarning: nn.functional.tanh is deprecated. Use torch.tanh instead.\n",
            "  warnings.warn(\"nn.functional.tanh is deprecated. Use torch.tanh instead.\")\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:37: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:49: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[1/100] - ptime: 12.68, loss_d: 0.889, loss_g: 12.632\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:3: UserWarning: volatile was removed and now has no effect. Use `with torch.no_grad():` instead.\n",
            "  This is separate from the ipykernel package so we can avoid doing imports until\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[2/100] - ptime: 13.30, loss_d: 0.659, loss_g: 8.871\n",
            "[3/100] - ptime: 13.46, loss_d: 0.699, loss_g: 8.179\n",
            "[4/100] - ptime: 13.50, loss_d: 0.476, loss_g: 6.769\n",
            "[5/100] - ptime: 13.26, loss_d: 0.512, loss_g: 7.049\n",
            "[6/100] - ptime: 13.29, loss_d: 0.662, loss_g: 6.250\n",
            "[7/100] - ptime: 13.00, loss_d: 0.490, loss_g: 6.254\n",
            "[8/100] - ptime: 12.98, loss_d: 0.580, loss_g: 6.839\n",
            "[9/100] - ptime: 13.20, loss_d: 0.674, loss_g: 7.205\n",
            "[10/100] - ptime: 13.15, loss_d: 0.680, loss_g: 5.534\n",
            "[11/100] - ptime: 13.22, loss_d: 0.906, loss_g: 4.923\n",
            "[12/100] - ptime: 13.27, loss_d: 0.825, loss_g: 3.935\n",
            "[13/100] - ptime: 13.07, loss_d: 0.590, loss_g: 4.066\n",
            "[14/100] - ptime: 13.32, loss_d: 0.712, loss_g: 3.885\n",
            "[15/100] - ptime: 12.93, loss_d: 0.566, loss_g: 4.421\n",
            "[16/100] - ptime: 13.18, loss_d: 0.587, loss_g: 4.226\n",
            "[17/100] - ptime: 13.29, loss_d: 0.596, loss_g: 4.045\n",
            "[18/100] - ptime: 13.46, loss_d: 0.527, loss_g: 4.292\n",
            "[19/100] - ptime: 13.15, loss_d: 0.454, loss_g: 4.393\n",
            "[20/100] - ptime: 13.00, loss_d: 0.392, loss_g: 4.636\n",
            "[21/100] - ptime: 13.19, loss_d: 0.420, loss_g: 3.955\n",
            "[22/100] - ptime: 13.33, loss_d: 0.447, loss_g: 4.724\n",
            "[23/100] - ptime: 13.33, loss_d: 0.436, loss_g: 4.651\n",
            "[24/100] - ptime: 13.43, loss_d: 0.502, loss_g: 5.040\n",
            "[25/100] - ptime: 13.05, loss_d: 0.508, loss_g: 4.549\n",
            "[26/100] - ptime: 13.21, loss_d: 0.419, loss_g: 4.615\n",
            "[27/100] - ptime: 13.19, loss_d: 0.360, loss_g: 5.028\n",
            "[28/100] - ptime: 13.25, loss_d: 0.470, loss_g: 4.565\n",
            "[29/100] - ptime: 13.30, loss_d: 0.313, loss_g: 4.975\n",
            "[30/100] - ptime: 13.08, loss_d: 0.403, loss_g: 5.087\n",
            "[31/100] - ptime: 13.07, loss_d: 0.464, loss_g: 4.853\n",
            "[32/100] - ptime: 13.15, loss_d: 0.385, loss_g: 5.051\n",
            "[33/100] - ptime: 13.28, loss_d: 0.308, loss_g: 4.909\n",
            "[34/100] - ptime: 13.24, loss_d: 0.325, loss_g: 5.182\n",
            "[35/100] - ptime: 13.14, loss_d: 0.297, loss_g: 5.409\n",
            "[36/100] - ptime: 13.16, loss_d: 0.321, loss_g: 5.344\n",
            "[37/100] - ptime: 13.56, loss_d: 0.306, loss_g: 5.261\n",
            "[38/100] - ptime: 13.23, loss_d: 0.300, loss_g: 5.776\n",
            "[39/100] - ptime: 13.42, loss_d: 0.379, loss_g: 5.667\n",
            "[40/100] - ptime: 13.31, loss_d: 0.254, loss_g: 5.610\n",
            "[41/100] - ptime: 13.35, loss_d: 0.238, loss_g: 5.802\n",
            "[42/100] - ptime: 13.35, loss_d: 0.235, loss_g: 6.334\n",
            "[43/100] - ptime: 13.77, loss_d: 0.252, loss_g: 6.142\n",
            "[44/100] - ptime: 13.22, loss_d: 0.270, loss_g: 6.715\n",
            "[45/100] - ptime: 13.37, loss_d: 0.211, loss_g: 6.367\n",
            "[46/100] - ptime: 13.26, loss_d: 0.333, loss_g: 7.285\n",
            "[47/100] - ptime: 13.32, loss_d: 0.235, loss_g: 6.729\n",
            "[48/100] - ptime: 13.15, loss_d: 0.328, loss_g: 6.583\n",
            "[49/100] - ptime: 13.40, loss_d: 0.218, loss_g: 6.214\n",
            "[50/100] - ptime: 13.30, loss_d: 0.194, loss_g: 7.213\n",
            "[51/100] - ptime: 13.42, loss_d: 0.129, loss_g: 6.149\n",
            "[52/100] - ptime: 13.22, loss_d: 0.326, loss_g: 7.992\n",
            "[53/100] - ptime: 13.62, loss_d: 0.179, loss_g: 6.983\n",
            "[54/100] - ptime: 13.28, loss_d: 0.173, loss_g: 7.466\n",
            "[55/100] - ptime: 13.44, loss_d: 0.186, loss_g: 6.828\n",
            "[56/100] - ptime: 13.43, loss_d: 0.336, loss_g: 7.572\n",
            "[57/100] - ptime: 13.43, loss_d: 0.404, loss_g: 6.385\n",
            "[58/100] - ptime: 13.32, loss_d: 0.254, loss_g: 6.895\n",
            "[59/100] - ptime: 13.34, loss_d: 0.159, loss_g: 6.260\n",
            "[60/100] - ptime: 13.44, loss_d: 0.092, loss_g: 6.077\n",
            "[61/100] - ptime: 13.16, loss_d: 0.206, loss_g: 8.365\n",
            "[62/100] - ptime: 13.32, loss_d: 0.141, loss_g: 6.597\n",
            "[63/100] - ptime: 13.80, loss_d: 0.185, loss_g: 7.094\n",
            "[64/100] - ptime: 13.37, loss_d: 0.234, loss_g: 9.151\n",
            "[65/100] - ptime: 13.30, loss_d: 0.293, loss_g: 7.754\n",
            "[66/100] - ptime: 13.43, loss_d: 0.376, loss_g: 7.825\n",
            "[67/100] - ptime: 13.39, loss_d: 0.198, loss_g: 6.414\n",
            "[68/100] - ptime: 13.47, loss_d: 0.196, loss_g: 7.791\n",
            "[69/100] - ptime: 13.07, loss_d: 0.193, loss_g: 6.502\n",
            "[70/100] - ptime: 13.28, loss_d: 0.127, loss_g: 6.663\n",
            "[71/100] - ptime: 13.43, loss_d: 0.165, loss_g: 8.031\n",
            "[72/100] - ptime: 13.38, loss_d: 0.180, loss_g: 8.493\n",
            "[73/100] - ptime: 13.44, loss_d: 0.156, loss_g: 8.382\n",
            "[74/100] - ptime: 13.52, loss_d: 0.192, loss_g: 8.659\n",
            "[75/100] - ptime: 13.59, loss_d: 0.197, loss_g: 7.814\n",
            "[76/100] - ptime: 13.37, loss_d: 0.233, loss_g: 7.603\n",
            "[77/100] - ptime: 13.35, loss_d: 0.156, loss_g: 8.238\n",
            "[78/100] - ptime: 13.23, loss_d: 0.173, loss_g: 9.947\n",
            "[79/100] - ptime: 13.35, loss_d: 0.076, loss_g: 6.705\n",
            "[80/100] - ptime: 13.19, loss_d: 0.069, loss_g: 6.119\n",
            "[81/100] - ptime: 13.13, loss_d: 0.060, loss_g: 7.084\n",
            "[82/100] - ptime: 13.36, loss_d: 0.114, loss_g: 8.725\n",
            "[83/100] - ptime: 13.45, loss_d: 0.099, loss_g: 9.336\n",
            "[84/100] - ptime: 13.39, loss_d: 0.104, loss_g: 13.043\n",
            "[85/100] - ptime: 13.51, loss_d: 0.135, loss_g: 19.991\n",
            "[86/100] - ptime: 13.39, loss_d: 0.122, loss_g: 8.367\n",
            "[87/100] - ptime: 13.53, loss_d: 0.165, loss_g: 10.023\n",
            "[88/100] - ptime: 13.24, loss_d: 0.116, loss_g: 7.627\n",
            "[89/100] - ptime: 13.25, loss_d: 0.173, loss_g: 10.982\n",
            "[90/100] - ptime: 13.65, loss_d: 0.068, loss_g: 6.879\n",
            "[91/100] - ptime: 13.39, loss_d: 0.087, loss_g: 16.788\n",
            "[92/100] - ptime: 13.42, loss_d: 0.152, loss_g: 14.418\n",
            "[93/100] - ptime: 13.28, loss_d: 0.049, loss_g: 8.253\n",
            "[94/100] - ptime: 13.28, loss_d: 0.061, loss_g: 9.340\n",
            "[95/100] - ptime: 13.62, loss_d: 0.106, loss_g: 9.608\n",
            "[96/100] - ptime: 13.50, loss_d: 0.085, loss_g: 8.097\n",
            "[97/100] - ptime: 13.37, loss_d: 0.164, loss_g: 14.336\n",
            "[98/100] - ptime: 13.35, loss_d: 0.503, loss_g: 11.805\n",
            "[99/100] - ptime: 13.23, loss_d: 0.271, loss_g: 8.505\n",
            "[100/100] - ptime: 13.23, loss_d: 0.108, loss_g: 7.778\n",
            "Avg per epoch ptime: 13.31, total 100 epochs ptime: 1580.84\n",
            "Training finish!... save training results\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DDSSzbeJJiLV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}