wgan_ct.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import os\n",
    "import time\n",
    "\n",
    "os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' \n",
    "os.environ['CUDA_VISIBLE_DEVICES']='0'\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import h5py\n",
    "import imageio\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "# from torchvision import datasets, transforms\n",
    "# from torch.autograd import Variable\n",
    "import torch.autograd as autograd\n",
    "import torchvision.utils as vutils\n",
    "\n",
    "from torch.utils.data import DataLoader, TensorDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data():\n",
    "    x_train = (h5py.File('camelyonpatch_level_2_split_train_x.h5', 'r')['x'][:, 16:80,16:80] - 127.5) / 127.5\n",
    "    y_train = h5py.File('camelyonpatch_level_2_split_train_y.h5', 'r')['y'][:].reshape(-1,1)\n",
    "    x_test = (h5py.File('camelyonpatch_level_2_split_test_x.h5', 'r')['x'][:, 16:80,16:80] - 127.5) / 127.5\n",
    "    y_test = h5py.File('camelyonpatch_level_2_split_test_y.h5', 'r')['y'][:].reshape(-1,1)\n",
    "    x_valid = (h5py.File('camelyonpatch_level_2_split_valid_x.h5', 'r')['x'][:, 16:80,16:80] - 127.5) / 127.5\n",
    "    y_valid = h5py.File('camelyonpatch_level_2_split_valid_y.h5', 'r')['y'][:].reshape(-1,1)\n",
    "              \n",
    "    return x_train, y_train, x_test, y_test, x_valid, y_valid\n",
    "\n",
    "def plot_samples(samples, folder=None, epoch=None, i=None):\n",
    "    rt = int(np.sqrt(samples.shape[0]))\n",
    "    r, c = rt, rt\n",
    "    # r, c = 6, 12\n",
    "\n",
    "    generatedImage = 0.5 * samples + 0.5\n",
    "\n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "\n",
    "    axs = [fig.add_subplot(r,c,i+1) for i in range(r*c)]\n",
    "    cnt = 0\n",
    "    for ax in axs:\n",
    "        ax.imshow(generatedImage[cnt],interpolation='nearest')\n",
    "        ax.axis('off')\n",
    "        ax.set_aspect('equal')\n",
    "        cnt+=1\n",
    "    fig.subplots_adjust(wspace=.004, hspace=.02)\n",
    "\n",
    "    if folder:\n",
    "        path = 'results/'+folder+'/samples'\n",
    "        if not os.path.exists('results'):\n",
    "            os.mkdir('results')\n",
    "        if not os.path.exists('results/'+folder):\n",
    "            os.mkdir('results/'+folder)\n",
    "        if not os.path.exists(path):\n",
    "            os.mkdir(path)\n",
    "        step = \"\"\n",
    "        if i:\n",
    "            step = '_'+str(i)\n",
    "        fig.savefig(path+'/epoch_%d%s.png' % (epoch, step))\n",
    "        plt.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/aray/pathology_gan\n"
     ]
    }
   ],
   "source": [
    "%cd \"~/pathology_gan\"\n",
    "\n",
    "x_train, y_train, x_test, y_test, x_valid, y_valid = load_data()\n",
    "\n",
    "X = torch.from_numpy(np.moveaxis(np.concatenate([x_train, x_test, x_valid]).astype(np.float32), -1, 1))\n",
    "# y = torch.from_numpy(np.concatenate([y_train, y_test, y_valid]))\n",
    "\n",
    "trainloader = DataLoader(TensorDataset(X), batch_size=128, shuffle=True, num_workers=0, pin_memory=True)\n",
    "\n",
    "# percent = int(x_train.shape[0]*.01)\n",
    "# np.random.seed(17)\n",
    "# idx_small = np.random.choice(range(x_train.shape[0]), percent, replace=False)\n",
    "\n",
    "# x_train_small = x_train[idx_small]\n",
    "# y_train_small = y_train[idx_small]\n",
    "# plt.hist(y_train_small, bins=2)\n",
    "# print(percent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# noise = np.random.normal(0,1,size=(16,100))\n",
    "# imgs = saved_actor.predict(noise)\n",
    "# plot_samples(imgs)\n",
    "\n",
    "# imgs_real = .5+.5*np.moveaxis(x_train[np.random.choice(range(x_train.shape[0]), 12*6, replace=False)], -1, 1)\n",
    "# plot_samples(x_train[np.random.choice(range(x_train.shape[0]), 12*6, replace=False)])\n",
    "# print(imgs_real.shape)\n",
    "# plt.figure(figsize=(24,12))\n",
    "# plt.imshow(np.transpose(make_grid(torch.from_numpy(imgs_real), nrow=12, ).numpy(), (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self, w, h, c, latent_dim):\n",
    "        super(Generator, self).__init__()\n",
    "        \n",
    "        self.w = w\n",
    "        self.h = h\n",
    "        self.c = c\n",
    "        self.latent_dim = latent_dim\n",
    "        \n",
    "        self.n_filters = 128\n",
    "        \n",
    "        self.input = nn.Sequential(\n",
    "            nn.Linear(latent_dim, self.n_filters * w//4 * h//4),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        self.deconv = nn.Sequential(\n",
    "            nn.Upsample(size=[w//2, h//2], mode='nearest'),\n",
    "            nn.Conv2d(self.n_filters, self.n_filters//2, 3, stride=1, padding=1),\n",
    "            nn.ReLU(True),\n",
    "            \n",
    "            nn.Upsample(size=[w, h], mode='nearest'),\n",
    "            nn.Conv2d(self.n_filters//2, self.n_filters//4, 4, stride=2, padding=1),\n",
    "            nn.ReLU(True),\n",
    "            \n",
    "            nn.Upsample(size=[w, h], mode='nearest'),\n",
    "            nn.Conv2d(self.n_filters//4, self.n_filters//8, 3, stride=1, padding=1),\n",
    "            nn.ReLU(True),\n",
    "\n",
    "            nn.Upsample(size=[w, h], mode='nearest'),\n",
    "            nn.Conv2d(self.n_filters//8, self.n_filters//16, 4, stride=2, padding=1),\n",
    "            nn.ReLU(True),\n",
    "\n",
    "            nn.Upsample(size=[w, h], mode='nearest'),\n",
    "            nn.Conv2d(self.n_filters//16, self.n_filters//32, 3, stride=1, padding=1),\n",
    "            nn.ReLU(True),\n",
    "\n",
    "            nn.Conv2d(self.n_filters//32, c, 3, stride=1, padding=1),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        output = self.input(x)\n",
    "        # print(output.shape)\n",
    "        output = output.view(-1, self.n_filters, self.w//4, self.h//4)\n",
    "        # print(output.shape)\n",
    "        return self.deconv(output) #.view(-1, self.w, self.h, self.c)\n",
    "\n",
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, h, w, c):\n",
    "        super(Discriminator, self).__init__()\n",
    "        \n",
    "        self.w = w\n",
    "        self.h = h\n",
    "        self.c = c\n",
    "        n_filters = 32\n",
    "\n",
    "        self.main = nn.Sequential(\n",
    "            nn.Conv2d(c, n_filters, 4, stride=2, padding=1),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout2d(p=0.2),\n",
    "            nn.Conv2d(n_filters, 2*n_filters, 4, stride=2, padding=1),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout2d(p=0.2),\n",
    "            nn.Conv2d(2*n_filters, 4*n_filters, 4, stride=2, padding=1),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout2d(p=0.5),\n",
    "            nn.Flatten()\n",
    "        )\n",
    "        self.output = nn.Linear(4*n_filters*int(w/2**3)*int(h/2**3), 1,bias=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.main(x)\n",
    "#         print(out.shape)\n",
    "        out2 = self.output(out)\n",
    "#         print(out2.shape)\n",
    "        return out2, out\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WGAN_CT:\n",
    "    def __init__(self, w, h, c, model_name, latent_dim=100):\n",
    "        self.model_name = model_name\n",
    "        self.latent_dim = latent_dim \n",
    "        self.lambda_gp = 10\n",
    "        self.lambda_ct = 2\n",
    "        self.d_iterations = 5\n",
    "        self.print_every = 10\n",
    "        # CT multiplier\n",
    "        self.M = .1\n",
    "        self.use_cuda = True\n",
    "        self.D = Discriminator(w, h, c)\n",
    "        self.G = Generator(w, h, c, latent_dim)\n",
    "\n",
    "        lr = 1e-4\n",
    "        betas = (.9, .99)\n",
    "\n",
    "        self.D_opt = optim.Adam(self.D.parameters(), lr=lr, betas=betas)\n",
    "        self.G_opt = optim.Adam(self.G.parameters(), lr=lr, betas=betas)\n",
    "\n",
    "\n",
    "        if self.use_cuda:\n",
    "            self.D = self.D.cuda()\n",
    "            self.G = self.G.cuda()\n",
    "\n",
    "        if not os.path.exists('results/'+model_name):\n",
    "            os.mkdir('results/'+model_name)\n",
    "\n",
    "    def train(self, data_loader, epochs, n_samples, save_training_gif=True):\n",
    "        print(n_samples, n_samples//128)\n",
    "        if save_training_gif:\n",
    "            # Fix latents to see how image generation improves during training\n",
    "            self.fixed_latents = torch.randn((12*6, self.latent_dim))\n",
    "            if self.use_cuda:\n",
    "                self.fixed_latents = self.fixed_latents.cuda()\n",
    "            self.training_progress_images = []\n",
    "\n",
    "        self.stats = {\n",
    "            'clf_loss': [],\n",
    "            'clf_acc': [],\n",
    "            'clf_loss_val': [],\n",
    "            'clf_acc_val': [],\n",
    "            'g_loss': [],\n",
    "            'd_loss': [],\n",
    "            'd_loss_real': [],\n",
    "            'd_loss_fake': [],\n",
    "            'gp': [],\n",
    "            'ct': [],\n",
    "            \n",
    "        }\n",
    "\n",
    "        for epoch in range(epochs):\n",
    "#             clf_loss = []\n",
    "#             clf_acc = []\n",
    "            g_loss = []\n",
    "            d_loss = []\n",
    "            d_loss_fake = []\n",
    "            d_loss_real = []\n",
    "            gradient_penalty = []\n",
    "            consistency_term = []\n",
    "\n",
    "            # for i, data in tqdm(enumerate(data_loader), desc=\"epoch \"+str(epoch)):\n",
    "            for i, data in enumerate(data_loader):\n",
    "                if i%((n_samples//128)//100)==0:\n",
    "                    print(\".\", end=\"\", flush=True)\n",
    "                X = data[0]\n",
    "                if self.use_cuda:\n",
    "                    X = X.cuda()\n",
    "\n",
    "                r, g, gp, ct, loss = self._train_D(X)\n",
    "                d_loss_real.append(r)\n",
    "                d_loss_fake.append(g)\n",
    "                gradient_penalty.append(gp)\n",
    "                consistency_term.append(ct)\n",
    "                d_loss.append(loss)\n",
    "                \n",
    "                # Only update generator every |d_iterations| iterations\n",
    "                if i % self.d_iterations == 0:\n",
    "                    g_loss.append(self._train_G(X.shape[0]))\n",
    "            \n",
    "            g_loss_m = sum(g_loss)/len(g_loss)\n",
    "            d_loss_m = sum(d_loss)/len(d_loss)\n",
    "            real_m = sum(d_loss_real)/len(d_loss_real)\n",
    "            fake_m = sum(d_loss_fake)/len(d_loss_fake)\n",
    "            gp_m = sum(gradient_penalty)/len(gradient_penalty)\n",
    "            ct_m = sum(consistency_term)/len(consistency_term)\n",
    "            self.stats['g_loss'].append(g_loss_m)\n",
    "            self.stats['d_loss'].append(d_loss_m)\n",
    "            self.stats['d_loss_real'].append(real_m)\n",
    "            self.stats['d_loss_fake'].append(fake_m)\n",
    "            self.stats['gp'].append(gp_m)\n",
    "            self.stats['ct'].append(ct_m)\n",
    "            print()\n",
    "            print(epoch)\n",
    "            print(\"D loss: %f; real: %f; fake: %f; gp: %f; ct: %f\"%(d_loss_m, real_m, fake_m, gp_m, ct_m))\n",
    "            print(\"G loss: %f\"%(g_loss_m))\n",
    "            \n",
    "            if epoch % 10 == 0:\n",
    "                with torch.no_grad():\n",
    "                    self.G.eval()\n",
    "                    imgs = self.G(torch.randn((16, self.latent_dim)).cuda()).cpu().numpy()\n",
    "                    plot_samples(np.moveaxis(imgs, 1,-1), self.model_name, epoch)\n",
    "                    self.G.train()\n",
    "\n",
    "            if save_training_gif:\n",
    "                with torch.no_grad():\n",
    "                    self.G.eval()\n",
    "                    img_grid = vutils.make_grid(self.G(self.fixed_latents).cpu(), nrow=12).numpy()\n",
    "                    # (width, height, channels)\n",
    "                    img_grid = .5+.5*np.transpose(img_grid, (1, 2, 0))\n",
    "                    self.training_progress_images.append(img_grid)\n",
    "                    self.G.train()\n",
    "\n",
    "            # if i % self.print_every == 0:\n",
    "            #     print(\"Iteration {}\".format(i + 1))\n",
    "            #     print(\"D: {}\".format(self.losses['D'][-1]))\n",
    "            #     print(\"GP: {}\".format(self.losses['GP'][-1]))\n",
    "            #     print(\"Gradient norm: {}\".format(self.losses['gradient_norm'][-1]))\n",
    "            #     if self.num_steps > self.critic_iterations:\n",
    "            #         print(\"G: {}\".format(self.losses['G'][-1]))\n",
    "\n",
    "        if save_training_gif:\n",
    "            imageio.mimsave('results/'+self.model_name+'/training_{}_epochs.gif'.format(epochs), self.training_progress_images)\n",
    "\n",
    "    def _train_D(self, data):\n",
    "        for p in self.D.parameters():\n",
    "            p.requires_grad = True\n",
    "            \n",
    "        self.D_opt.zero_grad()\n",
    "\n",
    "        batch_size = data.shape[0]\n",
    "\n",
    "        d1, d_1 = self.D(data)\n",
    "        d2, d_2 = self.D(data)\n",
    "\n",
    "        ct = self.lambda_ct*((d1.view(-1) - d2.view(-1))**2+0.1*((d_1.view(-1) - d_2.view(-1))**2).mean(dim=1)) - self.M\n",
    "\n",
    "        generated_data = self.sample_generator(batch_size)\n",
    "        d_generated, _ = self.D(generated_data)\n",
    "        \n",
    "        gradient_penalty = self._gradient_penalty(data, generated_data)\n",
    "\n",
    "        gen_mean = d_generated.mean()\n",
    "        real_mean = d1.mean()\n",
    "        d_loss = gen_mean - real_mean + gradient_penalty +gradient_penalty + ct\n",
    "        d_loss.backward()\n",
    "\n",
    "        self.D_opt.step()\n",
    "\n",
    "\n",
    "        return (-real_mean.detach().cpu().item(), gen_mean.detach().cpu().item(), gradient_penalty.detach().cpu().item(), \n",
    "                ct.detach().cpu().item(), d_loss.detach().cpu().item())\n",
    "\n",
    "    def _train_G(self, batch_size):\n",
    "        for p in self.D.parameters():\n",
    "            p.requires_grad = False\n",
    "            \n",
    "        self.G_opt.zero_grad()\n",
    "\n",
    "        # Get generated data\n",
    "        generated_data = self.sample_generator(batch_size)\n",
    "\n",
    "        # Calculate loss and optimize\n",
    "        d_generated, _ = self.D(generated_data)\n",
    "        g_loss = -d_generated.mean()\n",
    "        g_loss.backward()\n",
    "        self.G_opt.step()\n",
    "\n",
    "        return g_loss.detach().cpu().item()\n",
    "\n",
    "    def _gradient_penalty(self, real_data, generated_data):\n",
    "        batch_size = real_data.shape[0]\n",
    "\n",
    "        # Calculate interpolation\n",
    "        alpha = torch.rand(batch_size, 1, 1, 1)\n",
    "        alpha = alpha.expand_as(real_data)\n",
    "        if self.use_cuda:\n",
    "            alpha = alpha.cuda()\n",
    "        interpolated = alpha * real_data + (1 - alpha) * generated_data\n",
    "        # interpolated = Variable(interpolated, requires_grad=True)\n",
    "        if self.use_cuda:\n",
    "            interpolated = interpolated.cuda()\n",
    "\n",
    "        # Calculate probability of interpolated examples\n",
    "        dis_interpolated, _ = self.D(interpolated)\n",
    "        grad_outputs = torch.ones(dis_interpolated.shape)\n",
    "        if self.use_cuda:\n",
    "            grad_outputs=grad_outputs.cuda()\n",
    "\n",
    "        # Calculate gradients of probabilities with respect to examples\n",
    "        gradients = autograd.grad(outputs=dis_interpolated, inputs=interpolated,\n",
    "                               grad_outputs=grad_outputs, create_graph=True, retain_graph=True)[0]\n",
    "\n",
    "        # Gradients have shape (batch_size, num_channels, img_width, img_height),\n",
    "        # so flatten to easily take norm per example in batch\n",
    "        gradients = gradients.view(batch_size, -1)\n",
    "#         self.losses['gradient_norm'].append(gradients.norm(2, dim=1).mean().data[0])\n",
    "\n",
    "        # Derivatives of the gradient close to 0 can cause problems because of\n",
    "        # the square root, so manually calculate norm and add epsilon\n",
    "        gradients_norm = ((torch.sqrt(torch.sum(gradients ** 2, dim=1) + 1e-12) - 1) ** 2).mean()\n",
    "        # Return gradient penalty\n",
    "        return self.lambda_gp*gradients_norm #((gradients.norm(2, dim=1) - 1) ** 2).mean()\n",
    "\n",
    "    def _consistency_term(self, real_data):\n",
    "        d1, d_1 = self.D(real_data)\n",
    "        d2, d_2 = self.D(real_data)\n",
    "\n",
    "#         ct = (d1 - d2).norm(2, dim=1) + 0.1 * (d_1 - d_2).norm(2, dim=1) - self.M\n",
    "        ct = self.lambda_ct*((d1.view(-1) - d2.view(-1))**2+0.1*((d_1.view(-1) - d_2.view(-1))**2).mean(dim=1)) - self.M\n",
    "        return torch.max(ct, 0)\n",
    "        \n",
    "    def sample_generator(self, num_samples):\n",
    "        latent_samples = torch.randn((num_samples, self.latent_dim), requires_grad=True)\n",
    "        if self.use_cuda:\n",
    "            latent_samples = latent_samples.cuda()\n",
    "        generated_data = self.G(latent_samples)\n",
    "        return generated_data\n",
    "\n",
    "    def sample(self, num_samples):\n",
    "        generated_data = self.sample_generator(num_samples)\n",
    "        # Remove color channel\n",
    "        return generated_data.data.cpu().numpy()[:, 0, :, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wgan_ct = WGAN_CT(64, 64, 3, 'wgan_ct')\n",
    "wgan_ct.train(trainloader, 1000, X.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/torch/serialization.py:360: UserWarning: Couldn't retrieve source code for container of type Discriminator. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/usr/local/lib/python3.5/dist-packages/torch/serialization.py:360: UserWarning: Couldn't retrieve source code for container of type Generator. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "torch.save(wgan_ct.D, 'results/wgan_ct/wgan_ct_D.pt')\n",
    "torch.save(wgan_ct.G, 'results/wgan_ct/wgan_ct_G.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5a2a88e588>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(18,5))\n",
    "plt.plot(wgan_ct.stats['ct'], label='CT')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "# plt.figure(figsize=(18,5))\n",
    "plt.plot(wgan_ct.stats['gp'], label='GP')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure(figsize=(18,5))\n",
    "plt.plot(wgan_ct.stats['d_loss'], label='D')\n",
    "plt.plot(wgan_ct.stats['g_loss'], label='G')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure(figsize=(18,5))\n",
    "plt.plot(wgan_ct.stats['d_loss_real'], label='D real')\n",
    "plt.plot(wgan_ct.stats['d_loss_fake'], label='D fake')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.5439, device='cuda:0', grad_fn=<MeanBackward0>)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wgan_ct._consistency_term(X[:10].cuda())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = X[:10].cuda()\n",
    "d1, d_1 = wgan_ct.D(data)\n",
    "d2, d_2 = wgan_ct.D(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 1]) torch.Size([10, 8192])\n"
     ]
    }
   ],
   "source": [
    "print(d1.shape, d_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0012, 0.0061, 0.0044, 0.0043, 0.0034, 0.0013, 0.0010, 0.0051, 0.0062,\n",
       "        0.0117], device='cuda:0', grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ct = 2.0*((d1.view(-1) - d2.view(-1))**2+0.1*((d_1.view(-1) - d_2.view(-1))**2).mean())\n",
    "torch.max(ct,torch.zeros_like(ct)).mean()\n",
    "ct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], device='cuda:0')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], device='cuda:0',\n",
       "       grad_fn=<MaxBackward2>)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0108, 0.0506, 0.0414, 0.0410, 0.0346, 0.0129, 0.0022, 0.0457, 0.0513,\n",
       "        0.0733], device='cuda:0', grad_fn=<SqrtBackward>)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((d1.view(-1) - d2.view(-1))**2).sqrt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.0364, device='cuda:0', grad_fn=<MeanBackward0>)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(d1 - d2).norm(2, dim=1).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 32768])\n",
      "torch.Size([10, 128, 16, 16])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([10, 3, 64, 64])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen = Generator(64,64,3).cuda()\n",
    "noise = torch.FloatTensor(10, 100).normal_(0, 1).cuda()\n",
    "\n",
    "data_fake = gen(noise)\n",
    "data_fake.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dis = Discriminator(64,64,3).cuda()\n",
    "dis(tmp)[0].shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('../data', train=True, download=True,\n",
    "                   transform=transforms.Compose([\n",
    "                       transforms.ToTensor(),\n",
    "                   ])),\n",
    "    batch_size=BATCH_SIZE, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('../data', train=False, transform=transforms.Compose([\n",
    "                       transforms.ToTensor(),\n",
    "                   ])),\n",
    "    batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "# ================== main script ======================\n",
    "\n",
    "netG = Generator()\n",
    "netG.apply(weights_init)\n",
    "netD = Discriminator()\n",
    "netD.apply(weights_init)\n",
    "\n",
    "print netG\n",
    "print netD\n",
    "\n",
    "if use_cuda:\n",
    "    netD = netD.cuda()\n",
    "    netG = netG.cuda()\n",
    "\n",
    "optimizerD = optim.Adam(netD.parameters(), lr=1e-4, betas=(0.5, 0.9))\n",
    "optimizerG = optim.Adam(netG.parameters(), lr=1e-4, betas=(0.5, 0.9))\n",
    "\n",
    "one = torch.FloatTensor([1])\n",
    "mone = one * -1\n",
    "zero = torch.FloatTensor([0])\n",
    "if use_cuda:\n",
    "    one = one.cuda()\n",
    "    mone = mone.cuda()\n",
    "    zero = zero.cuda()\n",
    "\n",
    "def dataset():\n",
    "    while 1:\n",
    "        for images,targets in train_loader:\n",
    "            #print(images)\n",
    "            yield images\n",
    "data=dataset()\n",
    "fixed_noise = Variable(torch.randn(100, NOISE_SZ).cuda(),requires_grad = False)\n",
    "\n",
    "for iteration in xrange(ITERS):\n",
    "    ############################\n",
    "    # (1) Update D network\n",
    "    ###########################\n",
    "    netD.train()\n",
    "    for p in netD.parameters():  \n",
    "        p.requires_grad = True  \n",
    "    for iter_d in xrange(CRITIC_ITERS):\n",
    "        _data = data.next()\n",
    "        real_data = torch.Tensor(_data)\n",
    "        if use_cuda:\n",
    "            real_data = real_data.cuda()\n",
    "        real_data_v = autograd.Variable(real_data)\n",
    "\n",
    "        netD.zero_grad()\n",
    "\n",
    "\n",
    "        # train with fake\n",
    "        noise = torch.randn(BATCH_SIZE, NOISE_SZ)\n",
    "        if use_cuda:\n",
    "            noise = noise.cuda()\n",
    "        noise_v = autograd.Variable(noise, volatile=True)  \n",
    "        fake = autograd.Variable(netG(noise_v).data)\n",
    "        D_fake1_1,D_fake1_2 = netD(fake)\n",
    "        D_fake1 = D_fake1_1.mean()\n",
    "        D_fake1.backward((one))\n",
    "\n",
    "        # train with gradient penalty\n",
    "        gradient_penalty = calc_gradient_penalty(netD, real_data_v.data, fake.data)\n",
    "        gradient_penalty.backward()\n",
    "               \n",
    "        # train with real\n",
    "        D_real1_1,D_real1_2 = netD(real_data_v)\n",
    "        D_real1 = D_real1_1.mean()      \n",
    "        D_real1.backward((mone),retain_graph=True)\n",
    "        \n",
    "        # train with CT penalty\n",
    "        D_real2_1,D_real2_2 = netD(real_data_v)\n",
    "\n",
    "        ct_penalty = LAMBDA_2*((D_real1_1-D_real2_1)**2)       \n",
    "        ct_penalty += LAMBDA_2*0.1*((D_real1_2-D_real2_2)**2).mean(dim=1)\n",
    "        ct_penalty = torch.max(Variable(torch.zeros(ct_penalty.size()).cuda() if use_cuda else torch.zeros(ct_penalty.size())),ct_penalty-Factor_M)\n",
    "        ct_penalty = ct_penalty.mean()\n",
    "        #print(ct_penalty)\n",
    "        ct_penalty.backward()\n",
    "\n",
    "        D_cost = -D_real1 + D_fake1 + gradient_penalty + ct_penalty\n",
    "        #print(-D_real1.data[0] , D_fake1.data[0] , gradient_penalty.data[0] ,ct_penalty.data[0])\n",
    "        #D_cost.backward()\n",
    "        Wasserstein_D = D_real1 - D_fake1\n",
    "        optimizerD.step()\n",
    "\n",
    "    #if not FIXED_GENERATOR:\n",
    "        ############################\n",
    "        # (2) Update G network\n",
    "        ###########################\n",
    "    netD.eval()\n",
    "    for p in netD.parameters():\n",
    "        p.requires_grad = False  \n",
    "    netG.zero_grad()\n",
    "\n",
    "    noise = torch.randn(BATCH_SIZE, NOISE_SZ)\n",
    "    if use_cuda:\n",
    "        noise = noise.cuda()\n",
    "    noisev = autograd.Variable(noise,requires_grad=True) \n",
    "    fake = netG(noisev)\n",
    "    G,_ = netD(fake)\n",
    "    G = G.mean()\n",
    "    G.backward(mone)\n",
    "    G_cost = -G\n",
    "    optimizerG.step()\n",
    "    print((iteration,D_cost.data[0],Wasserstein_D.data[0]))\n",
    "    if iteration%100==0:\n",
    "        fake = netG(fixed_noise).view(-1, 1,28,28)\n",
    "        vutils.save_image(fake.data,\n",
    "                    'fake_samples_epoch_%03d.png' %  iteration,\n",
    "                    normalize=True)\n",
    "\n",
    "torch.save(netG.state_dict(), 'netG_mnist.pth')\n",
    "torch.save(netD.state_dict(), 'netD_mnist.pth')"
   ]
  }
 ],
 "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": 4
}