├── Mnist_version
    ├── AnoGAN_MNIST.ipynb
    ├── result
    │   ├── gen_0_0.png
    │   ├── gen_4485_0.png
    │   ├── gen_4486_0.png
    │   └── gen_4487_0.png
    └── saved_model
    │   ├── discriminator.pkl
    │   ├── epoch_3430
    │       ├── discriminator.pkl
    │       └── generator.pkl
    │   └── generator.pkl
└── README.md


/Mnist_version/AnoGAN_MNIST.ipynb:
--------------------------------------------------------------------------------
   1 | {
   2 |  "cells": [
   3 |   {
   4 |    "cell_type": "code",
   5 |    "execution_count": 1,
   6 |    "metadata": {
   7 |     "collapsed": true
   8 |    },
   9 |    "outputs": [],
  10 |    "source": [
  11 |     "import os\n",
  12 |     "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0,1,2,3,4,5,6,7\"\n",
  13 |     "\n",
  14 |     "import torch\n",
  15 |     "import torch.nn as nn\n",
  16 |     "import torch.utils as utils\n",
  17 |     "import torch.nn.init as init\n",
  18 |     "from torch.autograd import Variable\n",
  19 |     "import torchvision.utils as v_utils\n",
  20 |     "import torchvision.datasets as dset\n",
  21 |     "import torchvision.transforms as transforms\n",
  22 |     "import numpy as np\n",
  23 |     "import matplotlib.pyplot as plt\n",
  24 |     "from collections import OrderedDict"
  25 |    ]
  26 |   },
  27 |   {
  28 |    "cell_type": "code",
  29 |    "execution_count": 2,
  30 |    "metadata": {
  31 |     "collapsed": true
  32 |    },
  33 |    "outputs": [],
  34 |    "source": [
  35 |     "epoch = 1\n",
  36 |     "batch_size = 8192\n",
  37 |     "learning_rate = 0.0002\n",
  38 |     "num_gpus = 8"
  39 |    ]
  40 |   },
  41 |   {
  42 |    "cell_type": "code",
  43 |    "execution_count": 3,
  44 |    "metadata": {},
  45 |    "outputs": [],
  46 |    "source": [
  47 |     "# Download Data\n",
  48 |     "\n",
  49 |     "mnist_train = dset.MNIST(\"./\", train=True, \n",
  50 |     "                         transform=transforms.Compose([\n",
  51 |     "                             transforms.ToTensor(),\n",
  52 |     "                             transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
  53 |     "                        ]),\n",
  54 |     "                        target_transform=None,\n",
  55 |     "                        download=True)\n",
  56 |     "\n",
  57 |     "mnist_test = dset.MNIST(\"./\", train=False, \n",
  58 |     "                         transform=transforms.Compose([\n",
  59 |     "                             transforms.ToTensor(),\n",
  60 |     "                             transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
  61 |     "                        ]),\n",
  62 |     "                        target_transform=None,\n",
  63 |     "                        download=True)\n",
  64 |     "\n",
  65 |     "# Set Data Loader(input pipeline)\n",
  66 |     "\n",
  67 |     "train_loader = torch.utils.data.DataLoader(dataset=mnist_train,batch_size=batch_size,shuffle=True,drop_last=True)"
  68 |    ]
  69 |   },
  70 |   {
  71 |    "cell_type": "code",
  72 |    "execution_count": 4,
  73 |    "metadata": {
  74 |     "collapsed": true
  75 |    },
  76 |    "outputs": [],
  77 |    "source": [
  78 |     "# Generator receives random noise z and create 1x28x28 image\n",
  79 |     "# we can name each layer using OrderedDict\n",
  80 |     "\n",
  81 |     "class Generator(nn.Module):\n",
  82 |     "    def __init__(self):\n",
  83 |     "        super(Generator,self).__init__()\n",
  84 |     "        self.layer1 = nn.Sequential(\n",
  85 |     "             nn.Linear(100,7*7*512),\n",
  86 |     "             nn.BatchNorm1d(7*7*512),\n",
  87 |     "             nn.ReLU(),\n",
  88 |     "        )\n",
  89 |     "        self.layer2 = nn.Sequential(\n",
  90 |     "                        nn.ConvTranspose2d(512,256,3,2,1,1),\n",
  91 |     "                        nn.BatchNorm2d(256),\n",
  92 |     "                        nn.LeakyReLU(),\n",
  93 |     "                        nn.ConvTranspose2d(256,128,3,1,1),\n",
  94 |     "                        nn.BatchNorm2d(128),    \n",
  95 |     "                        nn.LeakyReLU(),\n",
  96 |     "            )\n",
  97 |     "        self.layer3 = nn.Sequential(\n",
  98 |     "                        nn.ConvTranspose2d(128,64,3,1,1),\n",
  99 |     "                        nn.BatchNorm2d(64),    \n",
 100 |     "                        nn.LeakyReLU(),\n",
 101 |     "                        nn.ConvTranspose2d(64,1,3,2,1,1),\n",
 102 |     "                        nn.Tanh()\n",
 103 |     "            )\n",
 104 |     "\n",
 105 |     "    def forward(self,z):\n",
 106 |     "        out = self.layer1(z)\n",
 107 |     "        out = out.view(out.size()[0],512,7,7)\n",
 108 |     "        out = self.layer2(out)\n",
 109 |     "        out = self.layer3(out)\n",
 110 |     "        return out"
 111 |    ]
 112 |   },
 113 |   {
 114 |    "cell_type": "code",
 115 |    "execution_count": 5,
 116 |    "metadata": {
 117 |     "collapsed": true
 118 |    },
 119 |    "outputs": [],
 120 |    "source": [
 121 |     "# Discriminator receives 1x28x28 image and returns a float number 0~1\n",
 122 |     "# we can name each layer using OrderedDict\n",
 123 |     "\n",
 124 |     "class Discriminator(nn.Module):\n",
 125 |     "    def __init__(self):\n",
 126 |     "        super(Discriminator,self).__init__()\n",
 127 |     "        self.layer1 = nn.Sequential(\n",
 128 |     "                        nn.Conv2d(1,8,3,padding=1),   # batch x 16 x 28 x 28\n",
 129 |     "                        nn.BatchNorm2d(8),    \n",
 130 |     "                        nn.LeakyReLU(),\n",
 131 |     "                        nn.Conv2d(8,16,3,stride=2,padding=1),  # batch x 32 x 28 x 28\n",
 132 |     "                        nn.BatchNorm2d(16),    \n",
 133 |     "                        nn.LeakyReLU(),\n",
 134 |     "                        #('max1',nn.MaxPool2d(2,2))   # batch x 32 x 14 x 14\n",
 135 |     "        )\n",
 136 |     "        self.layer2 = nn.Sequential(\n",
 137 |     "                        nn.Conv2d(16,32,3,stride=2,padding=1),  # batch x 64 x 14 x 14\n",
 138 |     "                        nn.BatchNorm2d(32),\n",
 139 |     "                        nn.LeakyReLU(),\n",
 140 |     "                        #nn.MaxPool2d(2,2),\n",
 141 |     "                        nn.Conv2d(32,64,3,padding=1),  # batch x 128 x 7 x 7\n",
 142 |     "                        nn.BatchNorm2d(64),\n",
 143 |     "                        nn.LeakyReLU()\n",
 144 |     "        )\n",
 145 |     "        self.fc = nn.Sequential(\n",
 146 |     "                        nn.Linear(64*7*7,1),\n",
 147 |     "                        nn.Sigmoid()\n",
 148 |     "        )\n",
 149 |     "\n",
 150 |     "    def forward(self,x):\n",
 151 |     "        out = self.layer1(x)\n",
 152 |     "        out = self.layer2(out)\n",
 153 |     "        out = out.view(out.size()[0], -1)\n",
 154 |     "        feature = out\n",
 155 |     "        out = self.fc(out)\n",
 156 |     "        return out,feature"
 157 |    ]
 158 |   },
 159 |   {
 160 |    "cell_type": "code",
 161 |    "execution_count": 6,
 162 |    "metadata": {
 163 |     "collapsed": true
 164 |    },
 165 |    "outputs": [],
 166 |    "source": [
 167 |     "# Put class objects on Multiple GPUs using \n",
 168 |     "# torch.nn.DataParallel(module, device_ids=None, output_device=None, dim=0)\n",
 169 |     "# device_ids: default all devices / output_device: default device 0 \n",
 170 |     "# along with .cuda()\n",
 171 |     "\n",
 172 |     "generator = nn.DataParallel(Generator()).cuda()\n",
 173 |     "discriminator = nn.DataParallel(Discriminator()).cuda()"
 174 |    ]
 175 |   },
 176 |   {
 177 |    "cell_type": "code",
 178 |    "execution_count": 7,
 179 |    "metadata": {
 180 |     "collapsed": true
 181 |    },
 182 |    "outputs": [],
 183 |    "source": [
 184 |     "# loss function, optimizers, and labels for training\n",
 185 |     "\n",
 186 |     "loss_func = nn.MSELoss()\n",
 187 |     "gen_optim = torch.optim.Adam(generator.parameters(), lr= 5*learning_rate,betas=(0.5,0.999))\n",
 188 |     "dis_optim = torch.optim.Adam(discriminator.parameters(), lr=learning_rate,betas=(0.5,0.999))\n",
 189 |     "\n",
 190 |     "ones_label = Variable(torch.ones(batch_size,1)).cuda()\n",
 191 |     "zeros_label = Variable(torch.zeros(batch_size,1)).cuda()\n",
 192 |     "\n",
 193 |     "def image_check(gen_fake):\n",
 194 |     "    img = gen_fake.data.numpy()\n",
 195 |     "    for i in range(2):\n",
 196 |     "        plt.imshow(img[i][0],cmap='gray')\n",
 197 |     "        plt.show()"
 198 |    ]
 199 |   },
 200 |   {
 201 |    "cell_type": "code",
 202 |    "execution_count": 8,
 203 |    "metadata": {},
 204 |    "outputs": [
 205 |     {
 206 |      "name": "stdout",
 207 |      "output_type": "stream",
 208 |      "text": [
 209 |       "\n",
 210 |       "--------model restored--------\n",
 211 |       "\n"
 212 |      ]
 213 |     }
 214 |    ],
 215 |    "source": [
 216 |     "# model restore if any\n",
 217 |     "\n",
 218 |     "try:\n",
 219 |     "    generator.load_state_dict(torch.load('./saved_model/generator.pkl'))\n",
 220 |     "    discriminator.load_state_dict(torch.load('./saved_model/discriminator.pkl'))\n",
 221 |     "    print(\"\\n--------model restored--------\\n\")\n",
 222 |     "except:\n",
 223 |     "    print(\"\\n--------model not restored--------\\n\")\n",
 224 |     "    pass\n"
 225 |    ]
 226 |   },
 227 |   {
 228 |    "cell_type": "code",
 229 |    "execution_count": 9,
 230 |    "metadata": {
 231 |     "scrolled": false
 232 |    },
 233 |    "outputs": [
 234 |     {
 235 |      "name": "stdout",
 236 |      "output_type": "stream",
 237 |      "text": [
 238 |       "0th iteration gen_loss: \n",
 239 |       " 0.2497\n",
 240 |       "[torch.cuda.FloatTensor of size 1 (GPU 0)]\n",
 241 |       " dis_loss: \n",
 242 |       " 0.5002\n",
 243 |       "[torch.cuda.FloatTensor of size 1 (GPU 0)]\n",
 244 |       "\n"
 245 |      ]
 246 |     },
 247 |     {
 248 |      "data": {
 249 |       "image/png": "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\n",
 250 |       "text/plain": [
 251 |        "<matplotlib.figure.Figure at 0x7f2b802f9e10>"
 252 |       ]
 253 |      },
 254 |      "metadata": {},
 255 |      "output_type": "display_data"
 256 |     },
 257 |     {
 258 |      "data": {
 259 |       "image/png": "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\n",
 260 |       "text/plain": [
 261 |        "<matplotlib.figure.Figure at 0x7f2b8012f208>"
 262 |       ]
 263 |      },
 264 |      "metadata": {},
 265 |      "output_type": "display_data"
 266 |     }
 267 |    ],
 268 |    "source": [
 269 |     "# train\n",
 270 |     "\n",
 271 |     "for i in range(epoch):\n",
 272 |     "    for j,(image,label) in enumerate(train_loader):\n",
 273 |     "        image = Variable(image).cuda()\n",
 274 |     "        \n",
 275 |     "        # generator\n",
 276 |     "        gen_optim.zero_grad()\n",
 277 |     "        \n",
 278 |     "        z = Variable(init.normal(torch.Tensor(batch_size,100),mean=0,std=0.1)).cuda()\n",
 279 |     "        gen_fake = generator.forward(z)\n",
 280 |     "        dis_fake,_ = discriminator.forward(gen_fake)\n",
 281 |     "        \n",
 282 |     "        gen_loss = torch.sum(loss_func(dis_fake,ones_label)) # fake classified as real\n",
 283 |     "        gen_loss.backward(retain_graph=True)\n",
 284 |     "        gen_optim.step()\n",
 285 |     "    \n",
 286 |     "        # discriminator\n",
 287 |     "        dis_optim.zero_grad()\n",
 288 |     "        \n",
 289 |     "        z = Variable(init.normal(torch.Tensor(batch_size,100),mean=0,std=0.1)).cuda()\n",
 290 |     "        gen_fake = generator.forward(z)\n",
 291 |     "        dis_fake,_ = discriminator.forward(gen_fake)\n",
 292 |     "        \n",
 293 |     "        dis_real,_ = discriminator.forward(image)\n",
 294 |     "        dis_loss = torch.sum(loss_func(dis_fake,zeros_label)) + torch.sum(loss_func(dis_real,ones_label))\n",
 295 |     "        dis_loss.backward()\n",
 296 |     "        dis_optim.step()\n",
 297 |     "    \n",
 298 |     "        # model save\n",
 299 |     "        if j % 50 == 0:\n",
 300 |     "            #print(gen_loss,dis_loss)\n",
 301 |     "            torch.save(generator.state_dict(),'./saved_model/generator.pkl')\n",
 302 |     "            torch.save(discriminator.state_dict(),'./saved_model/discriminator.pkl')\n",
 303 |     "\n",
 304 |     "\n",
 305 |     "            print(\"{}th iteration gen_loss: {} dis_loss: {}\".format(i,gen_loss.data,dis_loss.data))\n",
 306 |     "            v_utils.save_image(gen_fake.data[0:25],\"./result/gen_{}_{}.png\".format(i,j), nrow=5)\n",
 307 |     "            \n",
 308 |     "    image_check(gen_fake.cpu())"
 309 |    ]
 310 |   },
 311 |   {
 312 |    "cell_type": "markdown",
 313 |    "metadata": {},
 314 |    "source": [
 315 |     "## latent Z optimization"
 316 |    ]
 317 |   },
 318 |   {
 319 |    "cell_type": "code",
 320 |    "execution_count": 60,
 321 |    "metadata": {
 322 |     "collapsed": true
 323 |    },
 324 |    "outputs": [],
 325 |    "source": [
 326 |     "# Lambda = 0.1 according to paper\n",
 327 |     "# x is new data, G_z is closely regenerated data\n",
 328 |     "\n",
 329 |     "def Anomaly_score(x,G_z,Lambda=0.1):\n",
 330 |     "    _,x_feature = discriminator(x)\n",
 331 |     "    _,G_z_feature = discriminator(G_z)\n",
 332 |     "    \n",
 333 |     "    residual_loss = torch.sum(torch.abs(x-G_z))\n",
 334 |     "    discrimination_loss = torch.sum(torch.abs(x_feature-G_z_feature))\n",
 335 |     "    \n",
 336 |     "    total_loss = (1-Lambda)*residual_loss + Lambda*discrimination_loss\n",
 337 |     "    return total_loss"
 338 |    ]
 339 |   },
 340 |   {
 341 |    "cell_type": "code",
 342 |    "execution_count": 61,
 343 |    "metadata": {},
 344 |    "outputs": [
 345 |     {
 346 |      "data": {
 347 |       "text/plain": [
 348 |        "torch.Size([8, 1, 28, 28])"
 349 |       ]
 350 |      },
 351 |      "execution_count": 61,
 352 |      "metadata": {},
 353 |      "output_type": "execute_result"
 354 |     }
 355 |    ],
 356 |    "source": [
 357 |     "import os\n",
 358 |     "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\"\n",
 359 |     "\n",
 360 |     "start_idx = 64\n",
 361 |     "test_size = 8\n",
 362 |     "\n",
 363 |     "test_data_mnist = mnist_test.__dict__['test_data'][start_idx:start_idx+test_size]\n",
 364 |     "test_data_mnist = test_data_mnist.view(test_size,1,28,28).type_as(torch.FloatTensor())\n",
 365 |     "test_data_mnist.size()"
 366 |    ]
 367 |   },
 368 |   {
 369 |    "cell_type": "code",
 370 |    "execution_count": 62,
 371 |    "metadata": {
 372 |     "collapsed": true
 373 |    },
 374 |    "outputs": [],
 375 |    "source": [
 376 |     "generator = nn.DataParallel(Generator(),device_ids=[0])\n",
 377 |     "discriminator = nn.DataParallel(Discriminator(),device_ids=[0])\n",
 378 |     "\n",
 379 |     "#generator,discriminator"
 380 |    ]
 381 |   },
 382 |   {
 383 |    "cell_type": "code",
 384 |    "execution_count": 63,
 385 |    "metadata": {
 386 |     "scrolled": true
 387 |    },
 388 |    "outputs": [
 389 |     {
 390 |      "name": "stdout",
 391 |      "output_type": "stream",
 392 |      "text": [
 393 |       "\n",
 394 |       "--------model restored--------\n",
 395 |       "\n"
 396 |      ]
 397 |     }
 398 |    ],
 399 |    "source": [
 400 |     "# model restore if any\n",
 401 |     "\n",
 402 |     "try:\n",
 403 |     "    generator.load_state_dict(torch.load('./saved_model/generator.pkl'))\n",
 404 |     "    discriminator.load_state_dict(torch.load('./saved_model/discriminator.pkl'))\n",
 405 |     "\n",
 406 |     "    print(\"\\n--------model restored--------\\n\")\n",
 407 |     "\n",
 408 |     "except:\n",
 409 |     "    print(\"\\n--------model not restored--------\\n\")\n",
 410 |     "    pass\n",
 411 |     "\n"
 412 |    ]
 413 |   },
 414 |   {
 415 |    "cell_type": "markdown",
 416 |    "metadata": {},
 417 |    "source": [
 418 |     "## Test with Normal(=MNIST) Data"
 419 |    ]
 420 |   },
 421 |   {
 422 |    "cell_type": "code",
 423 |    "execution_count": 64,
 424 |    "metadata": {},
 425 |    "outputs": [
 426 |     {
 427 |      "name": "stdout",
 428 |      "output_type": "stream",
 429 |      "text": [
 430 |       "Variable containing:\n",
 431 |       "1.00000e+05 *\n",
 432 |       "  2.0270\n",
 433 |       "[torch.cuda.FloatTensor of size 1 (GPU 0)]\n",
 434 |       "\n"
 435 |      ]
 436 |     }
 437 |    ],
 438 |    "source": [
 439 |     "z = Variable(init.normal(torch.zeros(test_size,100),mean=0,std=0.1),requires_grad=True)\n",
 440 |     "z_optimizer = torch.optim.Adam([z],lr=1e-4)\n",
 441 |     "\n",
 442 |     "gen_fake = generator(z.cuda())\n",
 443 |     "loss = Anomaly_score(Variable(test_data_mnist).cuda(),gen_fake)\n",
 444 |     "print(loss)"
 445 |    ]
 446 |   },
 447 |   {
 448 |    "cell_type": "code",
 449 |    "execution_count": 66,
 450 |    "metadata": {
 451 |     "scrolled": true
 452 |    },
 453 |    "outputs": [
 454 |     {
 455 |      "name": "stdout",
 456 |      "output_type": "stream",
 457 |      "text": [
 458 |       "\n",
 459 |       "1.00000e+05 *\n",
 460 |       "  2.2237\n",
 461 |       "[torch.FloatTensor of size 1]\n",
 462 |       "\n",
 463 |       "\n",
 464 |       "1.00000e+05 *\n",
 465 |       "  2.2237\n",
 466 |       "[torch.FloatTensor of size 1]\n",
 467 |       "\n",
 468 |       "\n",
 469 |       "1.00000e+05 *\n",
 470 |       "  2.2237\n",
 471 |       "[torch.FloatTensor of size 1]\n",
 472 |       "\n",
 473 |       "\n",
 474 |       "1.00000e+05 *\n",
 475 |       "  2.2237\n",
 476 |       "[torch.FloatTensor of size 1]\n",
 477 |       "\n",
 478 |       "\n",
 479 |       "1.00000e+05 *\n",
 480 |       "  2.2237\n",
 481 |       "[torch.FloatTensor of size 1]\n",
 482 |       "\n",
 483 |       "\n",
 484 |       "1.00000e+05 *\n",
 485 |       "  2.2237\n",
 486 |       "[torch.FloatTensor of size 1]\n",
 487 |       "\n",
 488 |       "\n",
 489 |       "1.00000e+05 *\n",
 490 |       "  2.2237\n",
 491 |       "[torch.FloatTensor of size 1]\n",
 492 |       "\n",
 493 |       "\n",
 494 |       "1.00000e+05 *\n",
 495 |       "  2.2237\n",
 496 |       "[torch.FloatTensor of size 1]\n",
 497 |       "\n",
 498 |       "\n",
 499 |       "1.00000e+05 *\n",
 500 |       "  2.2237\n",
 501 |       "[torch.FloatTensor of size 1]\n",
 502 |       "\n",
 503 |       "\n",
 504 |       "1.00000e+05 *\n",
 505 |       "  2.2236\n",
 506 |       "[torch.FloatTensor of size 1]\n",
 507 |       "\n",
 508 |       "\n",
 509 |       "1.00000e+05 *\n",
 510 |       "  2.2237\n",
 511 |       "[torch.FloatTensor of size 1]\n",
 512 |       "\n",
 513 |       "\n",
 514 |       "1.00000e+05 *\n",
 515 |       "  2.2236\n",
 516 |       "[torch.FloatTensor of size 1]\n",
 517 |       "\n",
 518 |       "\n",
 519 |       "1.00000e+05 *\n",
 520 |       "  2.2236\n",
 521 |       "[torch.FloatTensor of size 1]\n",
 522 |       "\n",
 523 |       "\n",
 524 |       "1.00000e+05 *\n",
 525 |       "  2.2236\n",
 526 |       "[torch.FloatTensor of size 1]\n",
 527 |       "\n",
 528 |       "\n",
 529 |       "1.00000e+05 *\n",
 530 |       "  2.2236\n",
 531 |       "[torch.FloatTensor of size 1]\n",
 532 |       "\n",
 533 |       "\n",
 534 |       "1.00000e+05 *\n",
 535 |       "  2.2236\n",
 536 |       "[torch.FloatTensor of size 1]\n",
 537 |       "\n",
 538 |       "\n",
 539 |       "1.00000e+05 *\n",
 540 |       "  2.2236\n",
 541 |       "[torch.FloatTensor of size 1]\n",
 542 |       "\n",
 543 |       "\n",
 544 |       "1.00000e+05 *\n",
 545 |       "  2.2236\n",
 546 |       "[torch.FloatTensor of size 1]\n",
 547 |       "\n",
 548 |       "\n",
 549 |       "1.00000e+05 *\n",
 550 |       "  2.2236\n",
 551 |       "[torch.FloatTensor of size 1]\n",
 552 |       "\n",
 553 |       "\n",
 554 |       "1.00000e+05 *\n",
 555 |       "  2.2236\n",
 556 |       "[torch.FloatTensor of size 1]\n",
 557 |       "\n",
 558 |       "\n",
 559 |       "1.00000e+05 *\n",
 560 |       "  2.2236\n",
 561 |       "[torch.FloatTensor of size 1]\n",
 562 |       "\n",
 563 |       "\n",
 564 |       "1.00000e+05 *\n",
 565 |       "  2.2236\n",
 566 |       "[torch.FloatTensor of size 1]\n",
 567 |       "\n",
 568 |       "\n",
 569 |       "1.00000e+05 *\n",
 570 |       "  2.2236\n",
 571 |       "[torch.FloatTensor of size 1]\n",
 572 |       "\n",
 573 |       "\n",
 574 |       "1.00000e+05 *\n",
 575 |       "  2.2236\n",
 576 |       "[torch.FloatTensor of size 1]\n",
 577 |       "\n",
 578 |       "\n",
 579 |       "1.00000e+05 *\n",
 580 |       "  2.2236\n",
 581 |       "[torch.FloatTensor of size 1]\n",
 582 |       "\n",
 583 |       "\n",
 584 |       "1.00000e+05 *\n",
 585 |       "  2.2236\n",
 586 |       "[torch.FloatTensor of size 1]\n",
 587 |       "\n",
 588 |       "\n",
 589 |       "1.00000e+05 *\n",
 590 |       "  2.2236\n",
 591 |       "[torch.FloatTensor of size 1]\n",
 592 |       "\n",
 593 |       "\n",
 594 |       "1.00000e+05 *\n",
 595 |       "  2.2235\n",
 596 |       "[torch.FloatTensor of size 1]\n",
 597 |       "\n",
 598 |       "\n",
 599 |       "1.00000e+05 *\n",
 600 |       "  2.2235\n",
 601 |       "[torch.FloatTensor of size 1]\n",
 602 |       "\n",
 603 |       "\n",
 604 |       "1.00000e+05 *\n",
 605 |       "  2.2235\n",
 606 |       "[torch.FloatTensor of size 1]\n",
 607 |       "\n",
 608 |       "\n",
 609 |       "1.00000e+05 *\n",
 610 |       "  2.2235\n",
 611 |       "[torch.FloatTensor of size 1]\n",
 612 |       "\n",
 613 |       "\n",
 614 |       "1.00000e+05 *\n",
 615 |       "  2.2235\n",
 616 |       "[torch.FloatTensor of size 1]\n",
 617 |       "\n",
 618 |       "\n",
 619 |       "1.00000e+05 *\n",
 620 |       "  2.2235\n",
 621 |       "[torch.FloatTensor of size 1]\n",
 622 |       "\n",
 623 |       "\n",
 624 |       "1.00000e+05 *\n",
 625 |       "  2.2235\n",
 626 |       "[torch.FloatTensor of size 1]\n",
 627 |       "\n",
 628 |       "\n",
 629 |       "1.00000e+05 *\n",
 630 |       "  2.2235\n",
 631 |       "[torch.FloatTensor of size 1]\n",
 632 |       "\n",
 633 |       "\n",
 634 |       "1.00000e+05 *\n",
 635 |       "  2.2235\n",
 636 |       "[torch.FloatTensor of size 1]\n",
 637 |       "\n",
 638 |       "\n",
 639 |       "1.00000e+05 *\n",
 640 |       "  2.2235\n",
 641 |       "[torch.FloatTensor of size 1]\n",
 642 |       "\n",
 643 |       "\n",
 644 |       "1.00000e+05 *\n",
 645 |       "  2.2235\n",
 646 |       "[torch.FloatTensor of size 1]\n",
 647 |       "\n",
 648 |       "\n",
 649 |       "1.00000e+05 *\n",
 650 |       "  2.2235\n",
 651 |       "[torch.FloatTensor of size 1]\n",
 652 |       "\n",
 653 |       "\n",
 654 |       "1.00000e+05 *\n",
 655 |       "  2.2235\n",
 656 |       "[torch.FloatTensor of size 1]\n",
 657 |       "\n",
 658 |       "\n",
 659 |       "1.00000e+05 *\n",
 660 |       "  2.2235\n",
 661 |       "[torch.FloatTensor of size 1]\n",
 662 |       "\n",
 663 |       "\n",
 664 |       "1.00000e+05 *\n",
 665 |       "  2.2235\n",
 666 |       "[torch.FloatTensor of size 1]\n",
 667 |       "\n",
 668 |       "\n",
 669 |       "1.00000e+05 *\n",
 670 |       "  2.2235\n",
 671 |       "[torch.FloatTensor of size 1]\n",
 672 |       "\n",
 673 |       "\n",
 674 |       "1.00000e+05 *\n",
 675 |       "  2.2235\n",
 676 |       "[torch.FloatTensor of size 1]\n",
 677 |       "\n",
 678 |       "\n",
 679 |       "1.00000e+05 *\n",
 680 |       "  2.2235\n",
 681 |       "[torch.FloatTensor of size 1]\n",
 682 |       "\n",
 683 |       "\n",
 684 |       "1.00000e+05 *\n",
 685 |       "  2.2235\n",
 686 |       "[torch.FloatTensor of size 1]\n",
 687 |       "\n",
 688 |       "\n",
 689 |       "1.00000e+05 *\n",
 690 |       "  2.2235\n",
 691 |       "[torch.FloatTensor of size 1]\n",
 692 |       "\n",
 693 |       "\n",
 694 |       "1.00000e+05 *\n",
 695 |       "  2.2235\n",
 696 |       "[torch.FloatTensor of size 1]\n",
 697 |       "\n",
 698 |       "\n",
 699 |       "1.00000e+05 *\n",
 700 |       "  2.2235\n",
 701 |       "[torch.FloatTensor of size 1]\n",
 702 |       "\n",
 703 |       "\n",
 704 |       "1.00000e+05 *\n",
 705 |       "  2.2235\n",
 706 |       "[torch.FloatTensor of size 1]\n",
 707 |       "\n"
 708 |      ]
 709 |     }
 710 |    ],
 711 |    "source": [
 712 |     "for i in range(5000):\n",
 713 |     "    gen_fake = generator(z.cuda())\n",
 714 |     "    loss = Anomaly_score(Variable(test_data_mnist).cuda(),gen_fake,Lambda=0.01)\n",
 715 |     "    loss.backward()\n",
 716 |     "    z_optimizer.step()\n",
 717 |     "    \n",
 718 |     "    if i%100==0:\n",
 719 |     "        print(loss.cpu().data)\n",
 720 |     "        '''\n",
 721 |     "        target = test_data_mnist[1,0,:,:].numpy()\n",
 722 |     "        plt.imshow(target,cmap=\"gray\")\n",
 723 |     "        plt.show()\n",
 724 |     "        \n",
 725 |     "        img=gen_fake.cpu().data[1,0,:,:].numpy()\n",
 726 |     "        plt.imshow(img,cmap='gray')\n",
 727 |     "        plt.show()\n",
 728 |     "        '''"
 729 |    ]
 730 |   },
 731 |   {
 732 |    "cell_type": "code",
 733 |    "execution_count": 67,
 734 |    "metadata": {
 735 |     "scrolled": false
 736 |    },
 737 |    "outputs": [
 738 |     {
 739 |      "data": {
 740 |       "image/png": "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\n",
 741 |       "text/plain": [
 742 |        "<matplotlib.figure.Figure at 0x7f2b7805c438>"
 743 |       ]
 744 |      },
 745 |      "metadata": {},
 746 |      "output_type": "display_data"
 747 |     },
 748 |     {
 749 |      "name": "stdout",
 750 |      "output_type": "stream",
 751 |      "text": [
 752 |       "real data\n"
 753 |      ]
 754 |     },
 755 |     {
 756 |      "data": {
 757 |       "image/png": "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\n",
 758 |       "text/plain": [
 759 |        "<matplotlib.figure.Figure at 0x7f2b78042668>"
 760 |       ]
 761 |      },
 762 |      "metadata": {},
 763 |      "output_type": "display_data"
 764 |     },
 765 |     {
 766 |      "name": "stdout",
 767 |      "output_type": "stream",
 768 |      "text": [
 769 |       "generated data\n",
 770 |       "\n",
 771 |       "------------------------------------\n",
 772 |       "\n"
 773 |      ]
 774 |     },
 775 |     {
 776 |      "data": {
 777 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAADC5JREFUeJzt3W+oVPedx/H3d00lkPpALbHGurFbkmVLYO0iYSHLxk1JkywFU0KlPlhcttQ+MLDCQjYkDxpYhLBsu6l5IFgiNdCmLRg3UoptCWHTBQkxf2hSbWtI3Op60UoCjXlSNN99cI/lVu/M3DtzZs7o9/0CmZnzO3++Obmf+Z0z58z8IjORVM+fdF2ApG4Yfqkowy8VZfilogy/VJThl4oy/FJRhl8qyvBLRV03yY1FhLcTSmOWmbGQ+Ubq+SPi3oj4VUS8FREPj7IuSZMVw97bHxFLgF8DdwOngJeBLZl5tM8y9vzSmE2i578deCsz387M3wPfAzaNsD5JEzRK+NcAJ+e8PtVM+yMRsS0ijkTEkRG2Jallo3zgN9+hxRWH9Zm5B9gDHvZL02SUnv8UsHbO608Ap0crR9KkjBL+l4FbIuKTEbEU+BJwsJ2yJI3b0If9mXkhIh4EfgwsAfZm5i9aq0zSWA19qW+ojXnOL43dRG7ykXT1MvxSUYZfKsrwS0UZfqkowy8VZfilogy/VJThl4oy/FJRhl8qyvBLRRl+qSjDLxVl+KWiDL9UlOGXijL8UlGGXyrK8EtFGX6pKMMvFWX4paIMv1SU4ZeKMvxSUYZfKsrwS0UZfqmooYfoBoiIE8D7wEXgQmZuaKMoXTuOHz/es+2hhx7qu+yBAwfaLkdzjBT+xt9l5rkW1iNpgjzsl4oaNfwJ/CQiXomIbW0UJGkyRj3svyMzT0fEjcBPI+KXmfni3BmaNwXfGKQpM1LPn5mnm8ezwAHg9nnm2ZOZG/wwUJouQ4c/Im6IiGWXngOfA95sqzBJ4zXKYf8q4EBEXFrPdzPzUCtVSRq7ocOfmW8Df9liLboGZWbPtjvvvLPvsl7nHy8v9UlFGX6pKMMvFWX4paIMv1SU4ZeKauNbferYypUre7Zt29b/zupdu3b1bf/ggw+GqknTz55fKsrwS0UZfqkowy8VZfilogy/VJThl4ryOv81YPny5T3bdu7c2XfZ1157rW/7oUP+RMO1yp5fKsrwS0UZfqkowy8VZfilogy/VJThl4oy/FJRhl8qyvBLRRl+qSjDLxVl+KWiDL9UlOGXihr4ff6I2At8Hjibmbc101YA3wfWASeAzZn53vjKVD933XXX0MuuWbOmxUquNDMz09m21d9Cev5vA/deNu1h4PnMvAV4vnkt6SoyMPyZ+SLw7mWTNwH7muf7gPtbrkvSmA17zr8qM2cAmscb2ytJ0iSM/Tf8ImIb0H/AOEkTN2zPfyYiVgM0j2d7zZiZezJzQ2ZuGHJbksZg2PAfBLY2z7cCz7VTjqRJGRj+iHgGOAz8eUSciogvA48Dd0fEceDu5rWkq8jAc/7M3NKj6bMt16Ih3XrrrUMve+7cuRYrudILL7zQs2379u1j3bb68w4/qSjDLxVl+KWiDL9UlOGXijL8UlEO0X0VuP766/u2P/DAAz3bLl682HfZ997zm9hV2fNLRRl+qSjDLxVl+KWiDL9UlOGXijL8UlFe578KPProo33bb7755p5tFy5c6Lvsfffd17d9/fr1fdsH2bx5c8+2Q4cOjbRujcaeXyrK8EtFGX6pKMMvFWX4paIMv1SU4ZeKisyc3MYiJrexa8ign9desWLF2LYdEX3bR/n72bVrV9/2HTt2DL3uyjKz//+0hj2/VJThl4oy/FJRhl8qyvBLRRl+qSjDLxU18Pv8EbEX+DxwNjNva6Y9BnwF+G0z2yOZ+aNxFVndoGvt/Rw+fLhv+xNPPNG3/fTp00NvG2D//v0920b579LoFtLzfxu4d57p/5mZ65t/Bl+6ygwMf2a+CLw7gVokTdAo5/wPRsTPI2JvRCxvrSJJEzFs+HcDnwLWAzPA13vNGBHbIuJIRBwZcluSxmCo8Gfmmcy8mJkfAt8Cbu8z757M3JCZG4YtUlL7hgp/RKye8/ILwJvtlCNpUhZyqe8ZYCPwsYg4BXwN2BgR64EETgBfHWONksZgYPgzc8s8k58aQy3q4ciR/h+XPPnkkz3bBv02/qDf9R9k3bp1fduXLl3as22SvyWhK3mHn1SU4ZeKMvxSUYZfKsrwS0UZfqkoh+i+Ctxzzz1dl9DTddf1/xNasmTJhCrRYtnzS0UZfqkowy8VZfilogy/VJThl4oy/FJRXufXSFauXNm3fdmyZROqRItlzy8VZfilogy/VJThl4oy/FJRhl8qyvBLRRl+qSjDLxVl+KWiDL9UlOGXijL8UlGGXyrK8EtFDfw+f0SsBZ4GPg58COzJzG9GxArg+8A64ASwOTPfG1+pmkY33XTT0MsePny4xUq0WAvp+S8A/5KZfwH8NbA9Ij4NPAw8n5m3AM83ryVdJQaGPzNnMvPV5vn7wDFgDbAJ2NfMtg+4f1xFSmrfos75I2Id8BngJWBVZs7A7BsEcGPbxUkanwX/hl9EfBTYD+zIzN9FxEKX2wZsG648SeOyoJ4/Ij7CbPC/k5nPNpPPRMTqpn01cHa+ZTNzT2ZuyMwNbRQsqR0Dwx+zXfxTwLHM/MacpoPA1ub5VuC59suTNC4LOey/A/gH4I2IeL2Z9gjwOPCDiPgy8Bvgi+MpUdNs48aNQy/7zjvvtFeIFm1g+DPzf4BeJ/ifbbccSZPiHX5SUYZfKsrwS0UZfqkowy8VZfilogy/VJThl4oy/FJRhl8qyvBLRRl+qSjDLxVl+KWiFvwzXtIwTp482bPt6NGjE6xEl7Pnl4oy/FJRhl8qyvBLRRl+qSjDLxVl+KWivM6vkZw4caJv++7du3u2nT9/vuVqtBj2/FJRhl8qyvBLRRl+qSjDLxVl+KWiDL9UVGRm/xki1gJPAx8HPgT2ZOY3I+Ix4CvAb5tZH8nMHw1YV/+NSRpZZsZC5ltI+FcDqzPz1YhYBrwC3A9sBs5n5n8stCjDL43fQsM/8A6/zJwBZprn70fEMWDNaOVJ6tqizvkjYh3wGeClZtKDEfHziNgbEct7LLMtIo5ExJGRKpXUqoGH/X+YMeKjwH8DOzPz2YhYBZwDEvg3Zk8N/mnAOjzsl8astXN+gIj4CPBD4MeZ+Y152tcBP8zM2wasx/BLY7bQ8A887I+IAJ4Cjs0NfvNB4CVfAN5cbJGSurOQT/v/BvgZ8Aazl/oAHgG2AOuZPew/AXy1+XCw37rs+aUxa/Wwvy2GXxq/1g77JV2bDL9UlOGXijL8UlGGXyrK8EtFGX6pKMMvFWX4paIMv1SU4ZeKMvxSUYZfKsrwS0VNeojuc8D/znn9sWbaNJrW2qa1LrC2YbVZ280LnXGi3+e/YuMRRzJzQ2cF9DGttU1rXWBtw+qqNg/7paIMv1RU1+Hf0/H2+5nW2qa1LrC2YXVSW6fn/JK603XPL6kjnYQ/Iu6NiF9FxFsR8XAXNfQSESci4o2IeL3rIcaaYdDORsSbc6atiIifRsTx5nHeYdI6qu2xiPi/Zt+9HhF/31FtayPihYg4FhG/iIh/bqZ3uu/61NXJfpv4YX9ELAF+DdwNnAJeBrZk5tGJFtJDRJwANmRm59eEI+JvgfPA05dGQ4qIfwfezczHmzfO5Zn5r1NS22MscuTmMdXWa2Tpf6TDfdfmiNdt6KLnvx14KzPfzszfA98DNnVQx9TLzBeBdy+bvAnY1zzfx+wfz8T1qG0qZOZMZr7aPH8fuDSydKf7rk9dnegi/GuAk3Nen2K6hvxO4CcR8UpEbOu6mHmsujQyUvN4Y8f1XG7gyM2TdNnI0lOz74YZ8bptXYR/vtFEpumSwx2Z+VfAfcD25vBWC7Mb+BSzw7jNAF/vsphmZOn9wI7M/F2Xtcw1T12d7Lcuwn8KWDvn9SeA0x3UMa/MPN08ngUOMHuaMk3OXBoktXk823E9f5CZZzLzYmZ+CHyLDvddM7L0fuA7mflsM7nzfTdfXV3tty7C/zJwS0R8MiKWAl8CDnZQxxUi4obmgxgi4gbgc0zf6MMHga3N863Acx3W8kemZeTmXiNL0/G+m7YRrzu5yae5lPEEsATYm5k7J17EPCLiz5jt7WH2G4/f7bK2iHgG2Mjst77OAF8D/gv4AfCnwG+AL2bmxD9461HbRhY5cvOYaus1svRLdLjv2hzxupV6vMNPqsk7/KSiDL9UlOGXijL8UlGGXyrK8EtFGX6pKMMvFfX/32CImc8FzDYAAAAASUVORK5CYII=\n",
 778 |       "text/plain": [
 779 |        "<matplotlib.figure.Figure at 0x7f2b7f5619e8>"
 780 |       ]
 781 |      },
 782 |      "metadata": {},
 783 |      "output_type": "display_data"
 784 |     },
 785 |     {
 786 |      "name": "stdout",
 787 |      "output_type": "stream",
 788 |      "text": [
 789 |       "real data\n"
 790 |      ]
 791 |     },
 792 |     {
 793 |      "data": {
 794 |       "image/png": "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\n",
 795 |       "text/plain": [
 796 |        "<matplotlib.figure.Figure at 0x7f2b802857b8>"
 797 |       ]
 798 |      },
 799 |      "metadata": {},
 800 |      "output_type": "display_data"
 801 |     },
 802 |     {
 803 |      "name": "stdout",
 804 |      "output_type": "stream",
 805 |      "text": [
 806 |       "generated data\n",
 807 |       "\n",
 808 |       "------------------------------------\n",
 809 |       "\n"
 810 |      ]
 811 |     },
 812 |     {
 813 |      "data": {
 814 |       "image/png": "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\n",
 815 |       "text/plain": [
 816 |        "<matplotlib.figure.Figure at 0x7f2b802430b8>"
 817 |       ]
 818 |      },
 819 |      "metadata": {},
 820 |      "output_type": "display_data"
 821 |     },
 822 |     {
 823 |      "name": "stdout",
 824 |      "output_type": "stream",
 825 |      "text": [
 826 |       "real data\n"
 827 |      ]
 828 |     },
 829 |     {
 830 |      "data": {
 831 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAADs5JREFUeJzt3X+MVfWZx/HPowyKAzFM+OlUFiTSuDFZqqPZpHXFGBp3g4EaIeA/bFp3+kdNrNlEJsakGlNTV2F3jUkTGklpArZNgBWYjS2aWtu4IYxE0ZalJQRhdsiwCBGZRPn17B9z2Exx7vfcuffce+7M834l5P547rnnyQ2fOffe77nfr7m7AMRzTdkNACgH4QeCIvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/ENSkZu7MzDidEGgwd7dqHlfXkd/MHjCzQ2Z22Mx66nmuyMws+Q9oBKv13H4zu1bSnyQtldQvaZ+kNe7+x8Q2HPlHkRdwfn+BsWjGkf9uSYfd/Yi7n5f0c0nL63g+AE1UT/g7JR0fcbs/u+8vmFm3mfWZWV8d+wJQsHq+8BvtrcWX3p+6+0ZJGyXe9gOtpJ4jf7+km0fc/oqkgfraAdAs9YR/n6RbzWyBmU2WtFrSzmLaAtBoNb/td/eLZvaYpF9JulbSJnf/Q2GdBcK3+ShDzUN9Ne2Mz/xAwzXlJB8A4xfhB4Ii/EBQhB8IivADQRF+ICjCDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBNXXqboyuo6MjWZ83b16y/v777xfZDoLgyA8ERfiBoAg/EBThB4Ii/EBQhB8IivADQTF7bxO0tbUl6729vcn6vffem6ynzhMYGhpKbouJh9l7ASQRfiAowg8ERfiBoAg/EBThB4Ii/EBQdf2e38yOSvpM0iVJF929q4imJprJkycn6wsXLkzWv/jii2T9tttuq1jr6+tLbou4ipjM4z53P1XA8wBoIt72A0HVG36X9Gsze8/MuotoCEBz1Pu2/+vuPmBmsyTtMbP/dvd3Rj4g+6PAHwagxdR15Hf3gezypKQdku4e5TEb3b2LLwOB1lJz+M2s3cymXbku6ZuSPiqqMQCNVc/b/tmSdpjZlefZ6u5vFNIVgIarOfzufkTS3xTYy4Q1d+7cZH3WrFkNfX5gNAz1AUERfiAowg8ERfiBoAg/EBThB4Jiie4muOOOO5L166+/Plk/d+5csr548eKKtV27diW3LdOaNWuS9U2bNiXrDz74YLL+5ptvjrmnSDjyA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQjPM3wYIFC5L1a65J/w3evn17sv7cc8+NuadmWbZsWcXaCy+8kNw2myuioldeeSVZ37p1a8Xa+vXrk9tGWNqcIz8QFOEHgiL8QFCEHwiK8ANBEX4gKMIPBMU4fxPceOONdW2/d+/egjopXt7y4ytXrqxYmzlzZnLb6667LllftGhRsv7ss8/WVJOkhx56KFnfsWNHsj4ecOQHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaByx/nNbJOkZZJOuvvt2X0dkn4hab6ko5JWufuZxrXZ2vJ+d7506dJk/cKFC8l6e3v7mHtqlieeeCJZf/jhhyvW8tYryJO3nsGUKVMq1vLmUOjp6UnWo4zz/1TSA1fd1yPpLXe/VdJb2W0A40hu+N39HUmnr7p7uaTN2fXNklYU3BeABqv1M/9sdz8hSdnlrOJaAtAMDT+338y6JXU3ej8AxqbWI/+gmc2VpOzyZKUHuvtGd+9y964a9wWgAWoN/05Ja7PrayW9Xkw7AJolN/xm9pqk/5L0VTPrN7PvSPqRpKVm9mdJS7PbAMaR3M/87l5pEfX7C+5l3LrzzjuT9YULFybr7p6sd3Z2jrmnouT9Zr6rK/1p7oYbbqh533mvS1tbW7J++fLlmvf97rvv1rzteMEZfkBQhB8IivADQRF+ICjCDwRF+IGgmLq7APfcc0+ynjd19/nz55P1vCGtekyalP4vcNdddyXrS5YsqXnfx48fT9bfeOONZP3UqVPJ+po1lUappTlz5iS3zZvaeyLgyA8ERfiBoAg/EBThB4Ii/EBQhB8IivADQTHOX6UVKyrPUfr0008nt82bJnpwcDBZ37BhQ7Kekpq+WpIeeeSRZH3dunXJ+owZM5L1/v7+irWXXnopue3LL7+crOdJ/dx4YGAgue3Zs2fr2vd4wJEfCIrwA0ERfiAowg8ERfiBoAg/EBThB4JinL9K999feaby6dOnJ7fNm4L6k08+SdaPHTuWrKdMnTo1We/uTq+kNnv27GT9008/TdZTr9vhw4eT2+bJWxp9wYIFFWsHDx5MblvPtN/jBUd+ICjCDwRF+IGgCD8QFOEHgiL8QFCEHwgqd5zfzDZJWibppLvfnt33jKR/kvS/2cOecvf/bFSTrSC11HTeeHOeHTt2JOt55wmknDlzJlm/6aabkvW8uQY2b96crB85cqRiLW8sPe917e3tTdbnz59fsbZnz57kthFUc+T/qaQHRrn/X919cfZvQgcfmIhyw+/u70g63YReADRRPZ/5HzOzA2a2yczS57cCaDm1hv/HkhZKWizphKT1lR5oZt1m1mdmfTXuC0AD1BR+dx9090vuflnSTyTdnXjsRnfvcvfKsykCaLqawm9mc0fc/Jakj4ppB0CzVDPU95qkJZJmmFm/pB9IWmJmiyW5pKOSvtvAHgE0QG743X20Rc5fbUAvLW1oaKhhz7179+6GPXfeWHpHR0eyfv78+WT9xRdfTNYvXryYrKfknd/Q3t6erE+aVPm/9/bt22vqaSLhDD8gKMIPBEX4gaAIPxAU4QeCIvxAUEzdXaXUUF/ecFreEt333Xdfsv7BBx8k6yltbW3J+scff5ysz5w5M1nPm9r7+PHjFWt5P9nNWyY7b6gvNVT4+eefJ7eNgCM/EBThB4Ii/EBQhB8IivADQRF+ICjCDwRl9UwLPeadmTVvZwWbM2dOxdq+ffuS23Z2dibr+/fvT9YfffTRZD01lp53jkHeFNZ54/xTpkxJ1g8dOlSxllpCW8o/h+DSpUvJ+rZt2yrWVq9endy2mbkomrtXNZc8R34gKMIPBEX4gaAIPxAU4QeCIvxAUIQfCIpx/iqlfnv+5JNPJrd9/vnnk/W835ZfuHAhWX/77bcr1g4cOJDcdt26dcl63nwA9S5PnpI37feWLVuS9dT5EfVMKd7qGOcHkET4gaAIPxAU4QeCIvxAUIQfCIrwA0HljvOb2c2SfiZpjqTLkja6+7+bWYekX0iaL+mopFXufibnucbtOH9K3lh33u/x88bab7nllrr2X6bUmgZ5v8fftWtXsr5q1apkPe/5J6oix/kvSvpnd79N0t9K+p6Z/bWkHklvufutkt7KbgMYJ3LD7+4n3H1/dv0zSQcldUpaLmlz9rDNklY0qkkAxRvTZ34zmy/pa5L2Sprt7iek4T8QkmYV3RyAxql6rT4zmyppm6Tvu/vZaj9nmlm3pO7a2gPQKFUd+c2sTcPB3+Lu27O7B81sblafK+nkaNu6+0Z373L3riIaBlCM3PDb8CH+VUkH3X3DiNJOSWuz62slvV58ewAapZqhvm9I+p2kDzU81CdJT2n4c/8vJc2TdEzSSnc/nfNcE3KoL0/e9NmLFi1K1rdu3ZqsT5s2rWItb5gwz8DAQLKet0z2448/XrGW91Po3t7eZL2nhwGm0VQ71Jf7md/dfy+p0pPdP5amALQOzvADgiL8QFCEHwiK8ANBEX4gKMIPBMXU3RNc3jj80NBQkzpBszB1N4Akwg8ERfiBoAg/EBThB4Ii/EBQhB8IinF+YIJhnB9AEuEHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAowg8ElRt+M7vZzH5jZgfN7A9m9nh2/zNm9j9m9n727x8a3y6AouRO5mFmcyXNdff9ZjZN0nuSVkhaJemcu79U9c6YzANouGon85hUxROdkHQiu/6ZmR2U1FlfewDKNqbP/GY2X9LXJO3N7nrMzA6Y2SYzm15hm24z6zOzvro6BVCoqufwM7Opkn4r6Yfuvt3MZks6JcklPafhjwbfznkO3vYDDVbt2/6qwm9mbZJ2S/qVu28YpT5f0m53vz3neQg/0GCFTeBpZibpVUkHRwY/+yLwim9J+misTQIoTzXf9n9D0u8kfSjpcnb3U5LWSFqs4bf9RyV9N/tyMPVcHPmBBiv0bX9RCD/QeMzbDyCJ8ANBEX4gKMIPBEX4gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EFTuBJ4FOyXp4xG3Z2T3taJW7a1V+5LorVZF9vZX1T6wqb/n/9LOzfrcvau0BhJatbdW7Uuit1qV1Rtv+4GgCD8QVNnh31jy/lNatbdW7Uuit1qV0lupn/kBlKfsIz+AkpQSfjN7wMwOmdlhM+spo4dKzOyomX2YrTxc6hJj2TJoJ83soxH3dZjZHjP7c3Y56jJpJfXWEis3J1aWLvW1a7UVr5v+tt/MrpX0J0lLJfVL2idpjbv/samNVGBmRyV1uXvpY8Jm9neSzkn62ZXVkMzsXySddvcfZX84p7v7uhbp7RmNceXmBvVWaWXpf1SJr12RK14XoYwj/92SDrv7EXc/L+nnkpaX0EfLc/d3JJ2+6u7lkjZn1zdr+D9P01XorSW4+wl3359d/0zSlZWlS33tEn2Voozwd0o6PuJ2v1pryW+X9Gsze8/MustuZhSzr6yMlF3OKrmfq+Wu3NxMV60s3TKvXS0rXhetjPCPtppIKw05fN3d75D095K+l729RXV+LGmhhpdxOyFpfZnNZCtLb5P0fXc/W2YvI43SVymvWxnh75d084jbX5E0UEIfo3L3gezypKQdGv6Y0koGryySml2eLLmf/+fug+5+yd0vS/qJSnztspWlt0na4u7bs7tLf+1G66us162M8O+TdKuZLTCzyZJWS9pZQh9fYmbt2RcxMrN2Sd9U660+vFPS2uz6Wkmvl9jLX2iVlZsrrSytkl+7VlvxupSTfLKhjH+TdK2kTe7+w6Y3MQozu0XDR3tp+BePW8vszcxek7REw7/6GpT0A0n/IemXkuZJOiZppbs3/Yu3Cr0t0RhXbm5Qb5VWlt6rEl+7Ile8LqQfzvADYuIMPyAowg8ERfiBoAg/EBThB4Ii/EBQhB8IivADQf0f+UZpsMvj+h8AAAAASUVORK5CYII=\n",
 832 |       "text/plain": [
 833 |        "<matplotlib.figure.Figure at 0x7f2b78077080>"
 834 |       ]
 835 |      },
 836 |      "metadata": {},
 837 |      "output_type": "display_data"
 838 |     },
 839 |     {
 840 |      "name": "stdout",
 841 |      "output_type": "stream",
 842 |      "text": [
 843 |       "generated data\n",
 844 |       "\n",
 845 |       "------------------------------------\n",
 846 |       "\n"
 847 |      ]
 848 |     },
 849 |     {
 850 |      "data": {
 851 |       "image/png": "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\n",
 852 |       "text/plain": [
 853 |        "<matplotlib.figure.Figure at 0x7f2b802943c8>"
 854 |       ]
 855 |      },
 856 |      "metadata": {},
 857 |      "output_type": "display_data"
 858 |     },
 859 |     {
 860 |      "name": "stdout",
 861 |      "output_type": "stream",
 862 |      "text": [
 863 |       "real data\n"
 864 |      ]
 865 |     },
 866 |     {
 867 |      "data": {
 868 |       "image/png": "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\n",
 869 |       "text/plain": [
 870 |        "<matplotlib.figure.Figure at 0x7f2bdc0a73c8>"
 871 |       ]
 872 |      },
 873 |      "metadata": {},
 874 |      "output_type": "display_data"
 875 |     },
 876 |     {
 877 |      "name": "stdout",
 878 |      "output_type": "stream",
 879 |      "text": [
 880 |       "generated data\n",
 881 |       "\n",
 882 |       "------------------------------------\n",
 883 |       "\n"
 884 |      ]
 885 |     },
 886 |     {
 887 |      "data": {
 888 |       "image/png": "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\n",
 889 |       "text/plain": [
 890 |        "<matplotlib.figure.Figure at 0x7f2b72fdd5c0>"
 891 |       ]
 892 |      },
 893 |      "metadata": {},
 894 |      "output_type": "display_data"
 895 |     },
 896 |     {
 897 |      "name": "stdout",
 898 |      "output_type": "stream",
 899 |      "text": [
 900 |       "real data\n"
 901 |      ]
 902 |     },
 903 |     {
 904 |      "data": {
 905 |       "image/png": "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\n",
 906 |       "text/plain": [
 907 |        "<matplotlib.figure.Figure at 0x7f2b7f64abe0>"
 908 |       ]
 909 |      },
 910 |      "metadata": {},
 911 |      "output_type": "display_data"
 912 |     },
 913 |     {
 914 |      "name": "stdout",
 915 |      "output_type": "stream",
 916 |      "text": [
 917 |       "generated data\n",
 918 |       "\n",
 919 |       "------------------------------------\n",
 920 |       "\n"
 921 |      ]
 922 |     },
 923 |     {
 924 |      "data": {
 925 |       "image/png": "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\n",
 926 |       "text/plain": [
 927 |        "<matplotlib.figure.Figure at 0x7f2b780d6ef0>"
 928 |       ]
 929 |      },
 930 |      "metadata": {},
 931 |      "output_type": "display_data"
 932 |     },
 933 |     {
 934 |      "name": "stdout",
 935 |      "output_type": "stream",
 936 |      "text": [
 937 |       "real data\n"
 938 |      ]
 939 |     },
 940 |     {
 941 |      "data": {
 942 |       "image/png": "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\n",
 943 |       "text/plain": [
 944 |        "<matplotlib.figure.Figure at 0x7f2b7f59c780>"
 945 |       ]
 946 |      },
 947 |      "metadata": {},
 948 |      "output_type": "display_data"
 949 |     },
 950 |     {
 951 |      "name": "stdout",
 952 |      "output_type": "stream",
 953 |      "text": [
 954 |       "generated data\n",
 955 |       "\n",
 956 |       "------------------------------------\n",
 957 |       "\n"
 958 |      ]
 959 |     },
 960 |     {
 961 |      "data": {
 962 |       "image/png": "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\n",
 963 |       "text/plain": [
 964 |        "<matplotlib.figure.Figure at 0x7f2b800caeb8>"
 965 |       ]
 966 |      },
 967 |      "metadata": {},
 968 |      "output_type": "display_data"
 969 |     },
 970 |     {
 971 |      "name": "stdout",
 972 |      "output_type": "stream",
 973 |      "text": [
 974 |       "real data\n"
 975 |      ]
 976 |     },
 977 |     {
 978 |      "data": {
 979 |       "image/png": "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\n",
 980 |       "text/plain": [
 981 |        "<matplotlib.figure.Figure at 0x7f2b800dcc50>"
 982 |       ]
 983 |      },
 984 |      "metadata": {},
 985 |      "output_type": "display_data"
 986 |     },
 987 |     {
 988 |      "name": "stdout",
 989 |      "output_type": "stream",
 990 |      "text": [
 991 |       "generated data\n",
 992 |       "\n",
 993 |       "------------------------------------\n",
 994 |       "\n"
 995 |      ]
 996 |     },
 997 |     {
 998 |      "data": {
 999 |       "image/png": "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\n",
1000 |       "text/plain": [
1001 |        "<matplotlib.figure.Figure at 0x7f2b7f624c88>"
1002 |       ]
1003 |      },
1004 |      "metadata": {},
1005 |      "output_type": "display_data"
1006 |     },
1007 |     {
1008 |      "name": "stdout",
1009 |      "output_type": "stream",
1010 |      "text": [
1011 |       "real data\n"
1012 |      ]
1013 |     },
1014 |     {
1015 |      "data": {
1016 |       "image/png": "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\n",
1017 |       "text/plain": [
1018 |        "<matplotlib.figure.Figure at 0x7f2b837941d0>"
1019 |       ]
1020 |      },
1021 |      "metadata": {},
1022 |      "output_type": "display_data"
1023 |     },
1024 |     {
1025 |      "name": "stdout",
1026 |      "output_type": "stream",
1027 |      "text": [
1028 |       "generated data\n",
1029 |       "\n",
1030 |       "------------------------------------\n",
1031 |       "\n"
1032 |      ]
1033 |     }
1034 |    ],
1035 |    "source": [
1036 |     "for idx in range(test_size):\n",
1037 |     "    target = test_data_mnist[idx,0,:,:].numpy()\n",
1038 |     "    plt.imshow(target,cmap=\"gray\")\n",
1039 |     "    plt.show()\n",
1040 |     "    print(\"real data\")\n",
1041 |     "\n",
1042 |     "    img=gen_fake.cpu().data[idx,0,:,:].numpy()\n",
1043 |     "    plt.imshow(img,cmap='gray')\n",
1044 |     "    plt.show()\n",
1045 |     "    print(\"generated data\")\n",
1046 |     "    print(\"\\n------------------------------------\\n\")"
1047 |    ]
1048 |   },
1049 |   {
1050 |    "cell_type": "code",
1051 |    "execution_count": null,
1052 |    "metadata": {
1053 |     "collapsed": true
1054 |    },
1055 |    "outputs": [],
1056 |    "source": []
1057 |   }
1058 |  ],
1059 |  "metadata": {
1060 |   "kernelspec": {
1061 |    "display_name": "Python 3",
1062 |    "language": "python",
1063 |    "name": "python3"
1064 |   },
1065 |   "language_info": {
1066 |    "codemirror_mode": {
1067 |     "name": "ipython",
1068 |     "version": 3
1069 |    },
1070 |    "file_extension": ".py",
1071 |    "mimetype": "text/x-python",
1072 |    "name": "python",
1073 |    "nbconvert_exporter": "python",
1074 |    "pygments_lexer": "ipython3",
1075 |    "version": "3.6.4"
1076 |   }
1077 |  },
1078 |  "nbformat": 4,
1079 |  "nbformat_minor": 2
1080 | }
1081 | 


--------------------------------------------------------------------------------
/Mnist_version/result/gen_0_0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/result/gen_0_0.png


--------------------------------------------------------------------------------
/Mnist_version/result/gen_4485_0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/result/gen_4485_0.png


--------------------------------------------------------------------------------
/Mnist_version/result/gen_4486_0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/result/gen_4486_0.png


--------------------------------------------------------------------------------
/Mnist_version/result/gen_4487_0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/result/gen_4487_0.png


--------------------------------------------------------------------------------
/Mnist_version/saved_model/discriminator.pkl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/saved_model/discriminator.pkl


--------------------------------------------------------------------------------
/Mnist_version/saved_model/epoch_3430/discriminator.pkl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/saved_model/epoch_3430/discriminator.pkl


--------------------------------------------------------------------------------
/Mnist_version/saved_model/epoch_3430/generator.pkl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/saved_model/epoch_3430/generator.pkl


--------------------------------------------------------------------------------
/Mnist_version/saved_model/generator.pkl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GunhoChoi/AnoGAN-Pytorch/a3529efa0eb23efde70413aa398e4e0cb8f607ea/Mnist_version/saved_model/generator.pkl


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # AnoGAN-Pytorch
2 | 


--------------------------------------------------------------------------------