wgan_ct_ssl.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']='2'\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": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/aray/pathology_gan\n",
      "26214\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%cd \"~/pathology_gan\"\n",
    "\n",
    "x_train, y_train, x_test, y_test, x_valid, y_valid = load_data()\n",
    "\n",
    "x_train = torch.from_numpy(np.moveaxis(x_train.astype(np.float32), -1, 1))\n",
    "x_test  = torch.from_numpy(np.moveaxis(x_test.astype(np.float32), -1, 1))\n",
    "x_valid  = torch.from_numpy(np.moveaxis(x_valid.astype(np.float32), -1, 1))\n",
    "\n",
    "y_train = torch.from_numpy(y_train).float() \n",
    "y_test = torch.from_numpy(y_test).float() \n",
    "y_valid = torch.from_numpy(y_valid).float() \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_train, y_train), batch_size=128, shuffle=True, num_workers=0, pin_memory=True)\n",
    "validloader = DataLoader(TensorDataset(x_valid, y_valid), batch_size=128, shuffle=True, num_workers=0, pin_memory=True)\n",
    "\n",
    "percent = int(x_train.shape[0]*.1)\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",
    "trainloader = DataLoader(TensorDataset(x_train_small, y_train_small), batch_size=128, shuffle=True, num_workers=0, pin_memory=True)\n",
    "\n",
    "plt.hist(y_train_small.numpy(), bins=2)\n",
    "print(percent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_small = y_train_small.type(torch.LongTensor)\n",
    "y_valid=y_valid.type(torch.LongTensor)\n",
    "trainloader = DataLoader(TensorDataset(x_train_small, y_train_small), batch_size=128, shuffle=True, num_workers=0, pin_memory=True)\n",
    "validloader = DataLoader(TensorDataset(x_valid, y_valid), batch_size=128, shuffle=True, num_workers=0, pin_memory=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": 129,
   "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.conv = 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.Flatten()\n",
    "        )\n",
    "        self.fc = nn.Linear(4*n_filters*int(w/2**3)*int(h/2**3), 2, bias=True)\n",
    "\n",
    "    def forward(self, x, clf=True, dropout=True):\n",
    "        flatten = self.conv(x)\n",
    "        if dropout:\n",
    "            flatten = F.dropout(flatten, p=0.5)\n",
    "        \n",
    "        out = self.fc(flatten)\n",
    "        \n",
    "        if clf:\n",
    "            return F.softmax(out, dim=1)\n",
    "\n",
    "#         expsum = torch.exp(out).sum(dim=1)\n",
    "#         out = expsum/(expsum+1)\n",
    "        return out, flatten\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 1, 1, 1, 0, 1, 1, 0, 1, 1])\n",
      "torch.return_types.max(\n",
      "values=tensor([0.5035, 0.5199, 0.5135, 0.5093, 0.5137, 0.5102, 0.5050, 0.5155, 0.5110,\n",
      "        0.5026], grad_fn=<MaxBackward0>),\n",
      "indices=tensor([1, 1, 1, 1, 0, 1, 1, 0, 1, 1]))\n"
     ]
    }
   ],
   "source": [
    "pred = Discriminator(64,64,3)(x_train[:10], clf=True)\n",
    "print(torch.argmax(pred, dim=1))\n",
    "print(torch.max(pred, dim=1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SSL_WGAN:\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.Clf_opt = optim.Adam(self.D.parameters(), lr=lr/2, betas=betas)\n",
    "        self.Clf_criterion = torch.nn.CrossEntropyLoss()\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, train_loader, validation_loader, X_unlabled, epochs, 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(train_loader), desc=\"epoch \"+str(epoch)):\n",
    "            for i, data in enumerate(train_loader):\n",
    "#                 if i%((n_samples//128)//100)==0:\n",
    "#                     print(\".\", end=\"\", flush=True)\n",
    "                X = data[0]\n",
    "                y = data[1].view(-1)\n",
    "                batch_size = X.shape[0]\n",
    "                idx_u = np.random.choice(X_unlabled.shape[0], batch_size, replace=False)\n",
    "                X_u = X_unlabled[idx_u]\n",
    "                if self.use_cuda:\n",
    "                    X_u = X_u.cuda()\n",
    "                    X = X.cuda()\n",
    "                    y = y.cuda()\n",
    "                    \n",
    "                loss, acc = self._train_Clf(X, y)\n",
    "                clf_loss.append(loss)\n",
    "                clf_acc.append(acc)                                \n",
    "                    \n",
    "                ct, loss = self._train_D(X_u)\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_G1(X_u))\n",
    "            \n",
    "            if epoch % 20 == 0:\n",
    "                acc_val = self._eval_Clf(validation_loader)\n",
    "                clf_loss_m = sum(clf_loss)/len(clf_loss)\n",
    "                clf_acc_m = sum(clf_acc)/len(clf_acc)     \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['clf_loss'].append(clf_loss_m)\n",
    "                self.stats['clf_acc'].append(clf_acc_m)\n",
    "    #             self.stats['clf_loss_val'].append(loss_val)\n",
    "                self.stats['clf_acc_val'].append(acc_val)\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(\"Epoch: %d, G loss: %f\"%(epoch, g_loss_m))\n",
    "                print(\"Clf loss: %f, acc: %.3f, acc_val: %.3f\"%(clf_loss_m, clf_acc_m, acc_val))\n",
    "                print(\"D loss: %f; ct: %f\"%(d_loss_m, ct_m))\n",
    "            \n",
    "            if epoch % 50 == 0:\n",
    "                with torch.no_grad():\n",
    "                    self.G.eval()\n",
    "#                     self.D.eval()\n",
    "#                     print(self.D(X_unlabled[:10].cuda()).view(-1))\n",
    "#                     self.D.train()\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  epoch % 20 == 0 and 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 _eval_Clf(self, validation_loader):\n",
    "        self.D.eval()        \n",
    "        with torch.no_grad():\n",
    "            acc = .0\n",
    "            for i, data in enumerate(validation_loader):\n",
    "                X = data[0]\n",
    "                y = data[1].view(-1)\n",
    "                if self.use_cuda:\n",
    "                    X = X.cuda()\n",
    "                    y = y.cuda()\n",
    "                predicted = torch.argmax(self.D(X), dim=1)\n",
    "                acc+=(predicted == y).sum()/float(predicted.shape[0])       \n",
    "        self.D.train()\n",
    "        return (acc/(i+1)).detach().item()\n",
    "\n",
    "#     def _train_Clf(self, data, labels):\n",
    "#         self.D_opt.zero_grad()\n",
    "        \n",
    "#         predicted = self.D(data, clf=True)\n",
    "    \n",
    "#         loss = self.Clf_criterion(predicted, labels)\n",
    "        \n",
    "#         loss.backward()\n",
    "#         self.Clf_opt.step()    \n",
    "      \n",
    "#         acc = (predicted.detach().cpu() == labels.detach().cpu()).sum()/float(predicted.shape[0])\n",
    "\n",
    "#         return loss.detach().item(), acc\n",
    "    \n",
    "    def _train_Clf(self, data, labels):\n",
    "        self.D_opt.zero_grad()\n",
    "        \n",
    "        predicted = self.D(data, clf=True, dropout=True)\n",
    "    \n",
    "        loss = self.Clf_criterion(predicted, labels)\n",
    "        \n",
    "        loss.backward()\n",
    "        self.Clf_opt.step()    \n",
    "      \n",
    "        acc = (torch.argmax(predicted.detach().cpu(), dim=1) == labels.detach().cpu()).sum()/float(predicted.shape[0])\n",
    "\n",
    "        return loss.detach().item(), acc\n",
    "        \n",
    "#     def _D_loss(self, out):\n",
    "#         expsum = torch.exp(out).sum(dim=1)\n",
    "#         return expsum/(expsum+1)    \n",
    "    \n",
    "    def _train_D(self, data):\n",
    "        self.D_opt.zero_grad()\n",
    "\n",
    "        batch_size = data.shape[0]\n",
    "        generated_data = self.sample_generator(batch_size)\n",
    "        \n",
    "        real_fc1, real_flatten1 = self.D(data, clf=False)\n",
    "        real_fc2, real_flatten2 = self.D(data, clf=False)\n",
    "        gen_fc, _ = self.D(generated_data, clf=False)\n",
    "       \n",
    "        ct = self.lambda_ct*((torch.softmax(real_fc1, dim=1) - torch.softmax(real_fc2, dim=1))**2).mean(dim=1) - self.M\n",
    "        ct = torch.max(ct, torch.zeros_like(ct)).mean(dim=0)\n",
    "\n",
    "        gen_mean = F.softplus(torch.logsumexp(gen_fc, dim=1)).mean()\n",
    "        real_mean = F.softplus(torch.logsumexp(real_fc1, dim=1)).mean()\n",
    "\n",
    "        d_loss =  0.5*(ct - torch.logsumexp(real_fc1, dim=1).mean() + real_mean + gen_mean)\n",
    "        \n",
    "        d_loss.backward()\n",
    "        self.D_opt.step()\n",
    "\n",
    "\n",
    "        return ct.detach().item(), d_loss.detach().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, clf=False)\n",
    "#         g_loss = -d_generated.mean()\n",
    "#         g_loss.backward()\n",
    "#         self.G_opt.step()\n",
    "        \n",
    "#         for p in self.D.parameters():\n",
    "#             p.requires_grad = True\n",
    "\n",
    "#         return g_loss.detach().item()\n",
    "    \n",
    "    def _train_G1(self, real_data):\n",
    "        for p in self.D.parameters():\n",
    "            p.requires_grad = False\n",
    "            \n",
    "        self.G_opt.zero_grad()\n",
    "\n",
    "        batch_size = real_data.shape[0]\n",
    "        generated_data = self.sample_generator(batch_size)\n",
    "\n",
    "        _, d_real_output = self.D(real_data, clf=False, dropout=False)\n",
    "        _, d_gen_output = self.D(generated_data, clf=False, dropout=False)\n",
    "\n",
    "        g_loss = ((d_gen_output.mean(dim=0)-d_real_output.mean(dim=0))**2).mean()\n",
    "        g_loss.backward()\n",
    "        self.G_opt.step()\n",
    "        \n",
    "        for p in self.D.parameters():\n",
    "            p.requires_grad = True\n",
    "\n",
    "        return g_loss.detach().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, clf=False)\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, clf=False)\n",
    "#         d2, d_2 = self.D(real_data, clf=False)\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()) - self.M\n",
    "#         return torch.max(ct, torch.zeros_like(ct)).mean()\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 = SSL_WGAN(64, 64, 3, 'ssl_wgan2_010')\n",
    "wgan_ct.train(trainloader, validloader, x_train, 2000, x_train.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.804443359375\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "with open('results/ssl_wgan2_010/clf_acc.csv', 'w', newline='') as myfile:\n",
    "    wr = csv.writer(myfile)\n",
    "    wr.writerow(wgan_ct.stats['clf_acc'])\n",
    "print(np.max(wgan_ct.stats['clf_acc_val']))\n",
    "# wgan_ct.stats['clf_acc_val'][499]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('results/ssl_wgan_010/clf_acc_val.csv', newline='') as f:\n",
    "    reader = csv.reader(f)\n",
    "    clf1= list(reader)\n",
    "    clf1 = [float(r) for r in clf1[0]]    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe044affe80>"
      ]
     },
     "execution_count": 151,
     "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"
    }
   ],
   "source": [
    "plt.figure(figsize=(18,5))\n",
    "acc_max = np.max(wgan_ct.stats['clf_acc_val'])\n",
    "acc_max_e = np.argmax(wgan_ct.stats['clf_acc_val'])\n",
    "plt.axhline(y=acc_max, color='k', linestyle='-', alpha=0.2, linewidth=1)\n",
    "plt.axvline(x=acc_max_e, color='k', linestyle='-', alpha=0.2, linewidth=1)\n",
    "plt.plot(clf1[:100], label='Clf1')\n",
    "plt.plot(wgan_ct.stats['clf_acc_val'], label='Clf2')\n",
    "plt.xlabel('Epochs x20')\n",
    "plt.ylabel('Acc')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe044acc4a8>"
      ]
     },
     "execution_count": 136,
     "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"
    },
    {
     "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",
    "\n",
    "plt.plot(wgan_ct.stats['ct'], label='CT')\n",
    "plt.xlabel('Epochs x20')\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 x20')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure(figsize=(18,5))\n",
    "plt.plot(wgan_ct.stats['clf_loss'], label='Clf train')\n",
    "plt.xlabel('Epochs x20')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure(figsize=(18,5))\n",
    "acc_max = np.max(wgan_ct.stats['clf_acc_val'])\n",
    "acc_max_e = np.argmax(wgan_ct.stats['clf_acc_val'])\n",
    "plt.axhline(y=acc_max, color='k', linestyle='-', alpha=0.2, linewidth=1)\n",
    "plt.axvline(x=acc_max_e, color='k', linestyle='-', alpha=0.2, linewidth=1)\n",
    "plt.plot(wgan_ct.stats['clf_acc'], label='Train')\n",
    "plt.plot(wgan_ct.stats['clf_acc_val'], label='Validation')\n",
    "plt.xlabel('Epochs x20')\n",
    "plt.ylabel('Acc')\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
}