├── code ├── 2d_latent_space_for_test_samples.png ├── 2d_latent_space_scan_for_generation.png ├── generated_samples_with_2D_latent_space.png ├── generated_samples_with_10D_latent_space.png ├── generated_samples_with_20D_latent_space.png └── vaecnn-gluon.ipynb ├── README.md └── .gitignore /code/2d_latent_space_for_test_samples.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dingran/vae-mxnet/HEAD/code/2d_latent_space_for_test_samples.png -------------------------------------------------------------------------------- /code/2d_latent_space_scan_for_generation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dingran/vae-mxnet/HEAD/code/2d_latent_space_scan_for_generation.png -------------------------------------------------------------------------------- /code/generated_samples_with_2D_latent_space.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dingran/vae-mxnet/HEAD/code/generated_samples_with_2D_latent_space.png -------------------------------------------------------------------------------- /code/generated_samples_with_10D_latent_space.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dingran/vae-mxnet/HEAD/code/generated_samples_with_10D_latent_space.png -------------------------------------------------------------------------------- /code/generated_samples_with_20D_latent_space.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dingran/vae-mxnet/HEAD/code/generated_samples_with_20D_latent_space.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Variational autoencoders in MXNet/Gluon 2 | 3 | Implementations of variational autoencoders using MXNet/Gluon. 4 | 5 | ### References: 6 | 7 | 1. Kingma, Diederik P., and Max Welling. 8 | ["Auto-encoding variational bayes."](https://arxiv.org/abs/1312.6114) 9 | arXiv preprint arXiv:1312.6114 (2013). 10 | 2. Rezende, Danilo Jimenez, Shakir Mohamed, and Daan Wierstra. 11 | ["Stochastic backpropagation and approximate inference in deep generative models."](https://arxiv.org/abs/1401.4082) 12 | arXiv preprint arXiv:1401.4082 (2014). 13 | 14 | ### Code: 15 | 16 | - Implementation using MXNet API (i.e. mxnet.sym, mxnet.mod) [vae-mxnet.ipynb](code/vae-mxnet.ipynb) 17 | - Implementation using Gluon API (i.e. gluon.HybridBlock, autograd) [vae-gluon.ipynb](code/vae-gluon.ipynb) 18 | - CNN-based version, implemented using Gluon [vaecnn-gluon.ipynb](code/vaecnn-gluon.ipynb) 19 | 20 | ### Results: 21 | 22 | - Generated MNIST figures by randomly sampling learned latent space 23 | 24 | With 2-D latent space | With 10-D latent space | With 20-D latent space 25 | --- | --- | --- 26 | ![](code/generated_samples_with_2D_latent_space.png) | ![](code/generated_samples_with_10D_latent_space.png) |![](code/generated_samples_with_20D_latent_space.png) 27 | 28 | - Learned 2-D manifold 29 | 30 | Latent feature Z corresponding to 1000 test images | Generated images from grid scan in Z | 31 | --- | --- 32 | ![](code/2d_latent_space_for_test_samples.png) | ![](code/2d_latent_space_scan_for_generation.png) 33 | 34 | 35 | 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by .ignore support plugin (hsz.mobi) 2 | ### Python template 3 | # Byte-compiled / optimized / DLL files 4 | __pycache__/ 5 | *.py[cod] 6 | *$py.class 7 | 8 | # C extensions 9 | *.so 10 | 11 | # Distribution / packaging 12 | .Python 13 | env/ 14 | build/ 15 | develop-eggs/ 16 | dist/ 17 | downloads/ 18 | eggs/ 19 | .eggs/ 20 | lib/ 21 | lib64/ 22 | parts/ 23 | sdist/ 24 | var/ 25 | wheels/ 26 | *.egg-info/ 27 | .installed.cfg 28 | *.egg 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *,cover 49 | .hypothesis/ 50 | 51 | # Translations 52 | *.mo 53 | *.pot 54 | 55 | # Django stuff: 56 | *.log 57 | local_settings.py 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # dotenv 85 | .env 86 | 87 | # virtualenv 88 | .venv 89 | venv/ 90 | ENV/ 91 | 92 | # Spyder project settings 93 | .spyderproject 94 | 95 | # Rope project settings 96 | .ropeproject 97 | archive 98 | 99 | *.gz 100 | .idea/ 101 | .ipynb_checkpoints/ 102 | 103 | *.params 104 | code/*.json 105 | -------------------------------------------------------------------------------- /code/vaecnn-gluon.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Implementation of Variational Autoencoder in MXNet/Gluon\n", 8 | "\n", 9 | "This is the implementation using the new Gluon API, i.e. gluon.HybridBlock and autograd.\n", 10 | "\n", 11 | "Instead of using fully connected layers we used CNN (similar to the one used in DCGAN) in this implementation to parameterize recognition and generation network.\n", 12 | "\n", 13 | "Ref paper: Kingma, Diederik P., and Max Welling. [\"Auto-encoding variational bayes.\"](https://arxiv.org/abs/1312.6114) arXiv preprint arXiv:1312.6114 (2013)." 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 1, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "import time\n", 23 | "import numpy as np\n", 24 | "import mxnet as mx\n", 25 | "from tqdm import tqdm, tqdm_notebook\n", 26 | "from mxnet import nd, autograd, gluon\n", 27 | "from mxnet.gluon import nn\n", 28 | "import matplotlib.pyplot as plt\n", 29 | "%matplotlib inline\n", 30 | "data_ctx = mx.cpu()\n", 31 | "model_ctx = mx.gpu(0)\n", 32 | "mx.random.seed(1)\n", 33 | "output_fig = False" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "# Load MNIST" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 2, 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "data": { 50 | "image/png": "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\n", 51 | "text/plain": [ 52 | "" 53 | ] 54 | }, 55 | "metadata": {}, 56 | "output_type": "display_data" 57 | } 58 | ], 59 | "source": [ 60 | "mnist = mx.test_utils.get_mnist()\n", 61 | "#print(mnist['train_data'][0].shape)\n", 62 | "#plt.imshow(mnist['train_data'][0][0],cmap='Greys')\n", 63 | "\n", 64 | "n_samples = 10\n", 65 | "idx = np.random.choice(len(mnist['train_data']), n_samples)\n", 66 | "_, axarr = plt.subplots(1, n_samples, figsize=(16,4))\n", 67 | "for i,j in enumerate(idx):\n", 68 | " axarr[i].imshow(mnist['train_data'][j][0], cmap='Greys')\n", 69 | " #axarr[i].axis('off')\n", 70 | " axarr[i].get_xaxis().set_ticks([])\n", 71 | " axarr[i].get_yaxis().set_ticks([])\n", 72 | "plt.show()" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 3, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "#train_data = np.reshape(mnist['train_data'],(-1,28*28))\n", 82 | "#test_data = np.reshape(mnist['test_data'],(-1,28*28))\n", 83 | "train_data = mnist['train_data']\n", 84 | "test_data = mnist['test_data']" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 4, 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "text/plain": [ 95 | "(10000, 1, 28, 28)" 96 | ] 97 | }, 98 | "execution_count": 4, 99 | "metadata": {}, 100 | "output_type": "execute_result" 101 | } 102 | ], 103 | "source": [ 104 | "mnist['test_data'].shape" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 5, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "batch_size = 100\n", 114 | "n_batches = train_data.shape[0]/batch_size\n", 115 | "train_iter = mx.io.NDArrayIter(data={'data': train_data}, label={'label': mnist['train_label']}, batch_size = batch_size)\n", 116 | "test_iter = mx.io.NDArrayIter(data={'data': test_data}, label={'label': mnist['test_label']}, batch_size = batch_size)\n", 117 | "#train_iter = mx.io.NDArrayIter(data={'data': train_data}, batch_size = batch_size)\n", 118 | "#test_iter = mx.io.NDArrayIter(data={'data': test_data}, batch_size = batch_size)" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "# Define model" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 6, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "class Reshape(gluon.HybridBlock):\n", 135 | " def __init__(self, target_shape, **kwargs):\n", 136 | " super().__init__(**kwargs)\n", 137 | " self.target_shape = target_shape\n", 138 | "\n", 139 | " def hybrid_forward(self, F, x):\n", 140 | " #print(x.shape)\n", 141 | " return x.reshape((0, *self.target_shape)) # setting the first axis to 0 to copy over the original shape, i.e. batch_size\n", 142 | "\n", 143 | " def __repr__(self):\n", 144 | " return self.__class__.__name__\n", 145 | "\n", 146 | "\n", 147 | "class VAE(gluon.HybridBlock):\n", 148 | " def __init__(self, n_ch=np.array([4,8,16])*4, ks=[4,4,4], stride=[2,2,2], pad=[3,1,1], \n", 149 | " n_latent=3, n_layers=1, batch_size=100, act_type='relu', use_bias=True, \n", 150 | " do_batch_norm = False, **kwargs):\n", 151 | " self.soft_zero = 1e-10\n", 152 | " self.n_latent = n_latent\n", 153 | " self.batch_size = batch_size\n", 154 | " self.output = None\n", 155 | " self.mu = None\n", 156 | " # note to self: requring batch_size in model definition is sad, not sure how to deal with this otherwise though\n", 157 | " super().__init__(**kwargs)\n", 158 | "\n", 159 | " img_size =[28]\n", 160 | " with self.name_scope():\n", 161 | " self.encoder = nn.HybridSequential(prefix='encoder')\n", 162 | " for i in range(n_layers):\n", 163 | " self.encoder.add(nn.Conv2D(channels=n_ch[i], kernel_size=ks[i], strides=stride[i], padding=pad[i], \n", 164 | " activation=act_type, use_bias=use_bias))\n", 165 | " old_size = img_size[-1] + 2*pad[i]\n", 166 | " new_size = (old_size - (ks[i] - stride[i]))// stride[i]\n", 167 | " #print(new_size)\n", 168 | " img_size.append(new_size)\n", 169 | " if i < n_layers-1 and do_batch_norm:\n", 170 | " self.encoder.add(nn.BatchNorm())\n", 171 | "\n", 172 | " self.encoder.add(nn.Flatten())\n", 173 | " #self.encoder.add(nn.Dense(100, activation=act_type)) \n", 174 | " self.encoder.add(nn.Dense(n_latent*2, activation=None)) \n", 175 | " \n", 176 | " \n", 177 | " self.decoder = nn.HybridSequential(prefix='decoder')\n", 178 | " #self.decoder.add(nn.Dense(100, activation=act_type)) \n", 179 | " self.decoder.add(nn.Dense(img_size[-1]*img_size[-1]*n_ch[-1], activation=act_type))\n", 180 | " self.decoder.add(Reshape((n_ch[-1], img_size[-1], img_size[-1])))\n", 181 | " for i in range(n_layers-1, -1, -1):\n", 182 | "\n", 183 | " if i == 0:\n", 184 | " act_type = 'sigmoid'\n", 185 | " ch = 1\n", 186 | " else:\n", 187 | " ch = n_ch[i-1]\n", 188 | " \n", 189 | " self.decoder.add(nn.Conv2DTranspose(channels=ch, kernel_size=ks[i], strides=stride[i], \n", 190 | " padding=pad[i], activation=act_type, use_bias=use_bias))\n", 191 | " if i >0 and do_batch_norm:\n", 192 | " self.encoder.add(nn.BatchNorm())\n", 193 | "\n", 194 | " \n", 195 | " def hybrid_forward(self, F, x):\n", 196 | " h = self.encoder(x)\n", 197 | " #print(h)\n", 198 | " mu_lv = F.split(h, axis=1, num_outputs=2)\n", 199 | " mu = mu_lv[0]\n", 200 | " lv = mu_lv[1]\n", 201 | " self.mu = mu\n", 202 | " #eps = F.random_normal(loc=0, scale=1, shape=mu.shape, ctx=model_ctx) \n", 203 | " # this would work fine only for nd (i.e. non-hybridized block)\n", 204 | " eps = F.random_normal(loc=0, scale=1, shape=(self.batch_size, self.n_latent), ctx=model_ctx)\n", 205 | " z = mu + F.exp(0.5*lv)*eps\n", 206 | " y = self.decoder(z)\n", 207 | "\n", 208 | " y = y.reshape((0,-1))\n", 209 | " x = x.reshape((0,-1))\n", 210 | " self.output = y\n", 211 | " \n", 212 | " KL = 0.5*F.sum(1+lv-mu*mu-F.exp(lv),axis=1)\n", 213 | " logloss = F.sum(x*F.log(y+self.soft_zero)+ (1-x)*F.log(1-y+self.soft_zero), axis=1)\n", 214 | " loss = -logloss-KL\n", 215 | " \n", 216 | " return loss" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": 7, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [ 225 | "n_latent=100\n", 226 | "n_layers=3 # num of dense layers in encoder and decoder respectively\n", 227 | "model_prefix = 'vaecnn_gluon.params'\n", 228 | "\n", 229 | "net = VAE(n_latent=n_latent, n_layers=n_layers, batch_size=batch_size)" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 8, 235 | "metadata": {}, 236 | "outputs": [], 237 | "source": [ 238 | "x = nd.random.normal(shape=(100,1,28,28), ctx=model_ctx)\n", 239 | "net.collect_params().initialize(mx.init.Xavier(), ctx=model_ctx)" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 9, 245 | "metadata": {}, 246 | "outputs": [ 247 | { 248 | "data": { 249 | "text/plain": [ 250 | "(100, 1, 28, 28)" 251 | ] 252 | }, 253 | "execution_count": 9, 254 | "metadata": {}, 255 | "output_type": "execute_result" 256 | } 257 | ], 258 | "source": [ 259 | "#net.encoder(x).shape\n", 260 | "net.decoder(net.encoder(x)).shape" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": 10, 266 | "metadata": {}, 267 | "outputs": [ 268 | { 269 | "data": { 270 | "text/plain": [ 271 | "\n", 272 | "[ 546.06201172 545.53796387 544.4074707 544.19537354 545.38684082\n", 273 | " 544.65002441 544.71551514 545.89727783 544.57885742 543.54858398\n", 274 | " 544.64135742 543.77264404 545.13153076 544.36578369 545.32037354\n", 275 | " 543.809021 545.52612305 545.95800781 544.73297119 544.39874268\n", 276 | " 545.74047852 543.75219727 544.55889893 545.34753418 543.24841309\n", 277 | " 545.53546143 544.65734863 544.09979248 545.3168335 544.69390869\n", 278 | " 546.03131104 545.4463501 545.23590088 546.28057861 545.41009521\n", 279 | " 544.92681885 544.93328857 544.43426514 544.87414551 545.15942383\n", 280 | " 545.28277588 544.64105225 544.15570068 545.71075439 545.38598633\n", 281 | " 545.50579834 544.54016113 543.35552979 545.65466309 545.78479004\n", 282 | " 545.89532471 544.95196533 545.56799316 543.90716553 544.16644287\n", 283 | " 544.49456787 545.82507324 545.60534668 545.86523438 543.34423828\n", 284 | " 545.19366455 544.73553467 543.7041626 543.7723999 544.83898926\n", 285 | " 545.00488281 544.32824707 546.16003418 544.12530518 545.0111084\n", 286 | " 545.12792969 545.07617188 544.95513916 544.73693848 543.88604736\n", 287 | " 545.25732422 546.05053711 547.10754395 544.11456299 544.38763428\n", 288 | " 543.24206543 544.23150635 544.25482178 543.01385498 543.39642334\n", 289 | " 544.87512207 546.18731689 545.75134277 545.22277832 544.31976318\n", 290 | " 546.71716309 545.74285889 545.81549072 546.0269165 545.50567627\n", 291 | " 545.02563477 545.15045166 545.81072998 546.50354004 545.23431396]\n", 292 | "" 293 | ] 294 | }, 295 | "execution_count": 10, 296 | "metadata": {}, 297 | "output_type": "execute_result" 298 | } 299 | ], 300 | "source": [ 301 | "net = VAE(n_latent=n_latent, n_layers=n_layers, batch_size=batch_size)\n", 302 | "net.collect_params().initialize(mx.init.Xavier(), ctx=model_ctx)\n", 303 | "net(x)" 304 | ] 305 | }, 306 | { 307 | "cell_type": "markdown", 308 | "metadata": {}, 309 | "source": [ 310 | "# Model training" 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": 11, 316 | "metadata": {}, 317 | "outputs": [], 318 | "source": [ 319 | "net = VAE(n_latent=n_latent, n_layers=n_layers, batch_size=batch_size)\n", 320 | "net.collect_params().initialize(mx.init.Xavier(), ctx=model_ctx)\n", 321 | "net.hybridize()\n", 322 | "trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': .0005})" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 12, 328 | "metadata": {}, 329 | "outputs": [ 330 | { 331 | "data": { 332 | "application/vnd.jupyter.widget-view+json": { 333 | "model_id": "f61ebabcdb044432ac3bfe6e207d99c7", 334 | "version_major": 2, 335 | "version_minor": 0 336 | }, 337 | "text/html": [ 338 | "

Failed to display Jupyter Widget of type HBox.

\n", 339 | "

\n", 340 | " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", 341 | " that the widgets JavaScript is still loading. If this message persists, it\n", 342 | " likely means that the widgets JavaScript library is either not installed or\n", 343 | " not enabled. See the Jupyter\n", 344 | " Widgets Documentation for setup instructions.\n", 345 | "

\n", 346 | "

\n", 347 | " If you're reading this message in another frontend (for example, a static\n", 348 | " rendering on GitHub or NBViewer),\n", 349 | " it may mean that your frontend doesn't currently support widgets.\n", 350 | "

\n" 351 | ], 352 | "text/plain": [ 353 | "HBox(children=(IntProgress(value=0, description='epochs: ', max=50), HTML(value='')))" 354 | ] 355 | }, 356 | "metadata": {}, 357 | "output_type": "display_data" 358 | }, 359 | { 360 | "name": "stdout", 361 | "output_type": "stream", 362 | "text": [ 363 | "Epoch 0, Training loss 199.280682322, Validation loss 146.589102173\n", 364 | "Epoch 5, Training loss 108.088542442, Validation loss 106.836221542\n", 365 | "Epoch 10, Training loss 103.571974131, Validation loss 102.817866974\n", 366 | "Epoch 15, Training loss 101.714880193, Validation loss 101.300068817\n", 367 | "Epoch 20, Training loss 100.513956617, Validation loss 100.141811981\n", 368 | "Epoch 25, Training loss 99.6662532298, Validation loss 99.4761208344\n", 369 | "Epoch 30, Training loss 99.0791517258, Validation loss 99.0510205841\n", 370 | "Epoch 35, Training loss 98.6449058151, Validation loss 98.5340620422\n", 371 | "Epoch 40, Training loss 98.2070299784, Validation loss 98.3140554047\n", 372 | "Epoch 45, Training loss 97.8333548228, Validation loss 97.715945282\n", 373 | "\n", 374 | "Time elapsed: 248.27s\n" 375 | ] 376 | } 377 | ], 378 | "source": [ 379 | "n_epoch = 50\n", 380 | "print_period = n_epoch // 10\n", 381 | "start = time.time()\n", 382 | "\n", 383 | "training_loss = []\n", 384 | "validation_loss = []\n", 385 | "for epoch in tqdm_notebook(range(n_epoch), desc='epochs'):\n", 386 | " epoch_loss = 0\n", 387 | " epoch_val_loss = 0\n", 388 | " \n", 389 | " train_iter.reset()\n", 390 | " test_iter.reset()\n", 391 | " \n", 392 | " n_batch_train = 0\n", 393 | " for batch in train_iter:\n", 394 | " n_batch_train +=1\n", 395 | " data = batch.data[0].as_in_context(model_ctx)\n", 396 | " with autograd.record():\n", 397 | " loss = net(data)\n", 398 | " loss.backward()\n", 399 | " trainer.step(data.shape[0])\n", 400 | " epoch_loss += nd.mean(loss).asscalar()\n", 401 | " \n", 402 | " n_batch_val = 0\n", 403 | " for batch in test_iter:\n", 404 | " n_batch_val +=1\n", 405 | " data = batch.data[0].as_in_context(model_ctx)\n", 406 | " loss = net(data)\n", 407 | " epoch_val_loss += nd.mean(loss).asscalar()\n", 408 | " \n", 409 | " epoch_loss /= n_batch_train\n", 410 | " epoch_val_loss /= n_batch_val\n", 411 | " \n", 412 | " training_loss.append(epoch_loss)\n", 413 | " validation_loss.append(epoch_val_loss)\n", 414 | " \n", 415 | " if epoch % max(print_period,1) == 0:\n", 416 | " tqdm.write('Epoch %d, Training loss %s, Validation loss %s' % (epoch, epoch_loss, epoch_val_loss))\n", 417 | " \n", 418 | "end = time.time()\n", 419 | "print('Time elapsed: {:.2f}s'.format(end - start))" 420 | ] 421 | }, 422 | { 423 | "cell_type": "code", 424 | "execution_count": 13, 425 | "metadata": {}, 426 | "outputs": [], 427 | "source": [ 428 | "net.save_params(model_prefix)" 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": 14, 434 | "metadata": {}, 435 | "outputs": [ 436 | { 437 | "data": { 438 | "text/plain": [ 439 | "" 440 | ] 441 | }, 442 | "execution_count": 14, 443 | "metadata": {}, 444 | "output_type": "execute_result" 445 | }, 446 | { 447 | "data": { 448 | "image/png": "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\n", 449 | "text/plain": [ 450 | "" 451 | ] 452 | }, 453 | "metadata": {}, 454 | "output_type": "display_data" 455 | } 456 | ], 457 | "source": [ 458 | "batch_x = np.linspace(1, n_epoch, len(training_loss))\n", 459 | "plt.plot(batch_x, -1*np.array(training_loss))\n", 460 | "plt.plot(batch_x, -1*np.array(validation_loss))\n", 461 | "plt.legend(['train', 'valid'])" 462 | ] 463 | }, 464 | { 465 | "cell_type": "markdown", 466 | "metadata": {}, 467 | "source": [ 468 | "# Load model" 469 | ] 470 | }, 471 | { 472 | "cell_type": "code", 473 | "execution_count": 15, 474 | "metadata": {}, 475 | "outputs": [], 476 | "source": [ 477 | "net2 = VAE(n_latent=n_latent, n_layers=n_layers, batch_size=batch_size)\n", 478 | "net2.load_params(model_prefix, ctx=model_ctx)" 479 | ] 480 | }, 481 | { 482 | "cell_type": "markdown", 483 | "metadata": {}, 484 | "source": [ 485 | "# Visualizing reconstruction quality" 486 | ] 487 | }, 488 | { 489 | "cell_type": "code", 490 | "execution_count": 16, 491 | "metadata": {}, 492 | "outputs": [], 493 | "source": [ 494 | "test_iter.reset()\n", 495 | "test_batch = test_iter.next()\n", 496 | "net2(test_batch.data[0].as_in_context(model_ctx))\n", 497 | "result = net2.output.asnumpy()\n", 498 | "original = test_batch.data[0].asnumpy()" 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "execution_count": 17, 504 | "metadata": {}, 505 | "outputs": [ 506 | { 507 | "data": { 508 | "image/png": "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\n", 509 | "text/plain": [ 510 | "" 511 | ] 512 | }, 513 | "metadata": {}, 514 | "output_type": "display_data" 515 | } 516 | ], 517 | "source": [ 518 | "n_samples = 10\n", 519 | "idx = np.random.choice(batch_size, n_samples)\n", 520 | "_, axarr = plt.subplots(2, n_samples, figsize=(16,4))\n", 521 | "for i,j in enumerate(idx):\n", 522 | " axarr[0,i].imshow(original[j].reshape((28,28)), cmap='Greys')\n", 523 | " if i==0:\n", 524 | " axarr[0,i].set_title('original')\n", 525 | " #axarr[0,i].axis('off')\n", 526 | " axarr[0,i].get_xaxis().set_ticks([])\n", 527 | " axarr[0,i].get_yaxis().set_ticks([])\n", 528 | "\n", 529 | " axarr[1,i].imshow(result[j].reshape((28,28)), cmap='Greys')\n", 530 | " if i==0:\n", 531 | " axarr[1,i].set_title('reconstruction')\n", 532 | " #axarr[1,i].axis('off')\n", 533 | " axarr[1,i].get_xaxis().set_ticks([])\n", 534 | " axarr[1,i].get_yaxis().set_ticks([])\n", 535 | "plt.show()" 536 | ] 537 | }, 538 | { 539 | "cell_type": "markdown", 540 | "metadata": {}, 541 | "source": [ 542 | "# Visualizing latent space (when it is 2D)" 543 | ] 544 | }, 545 | { 546 | "cell_type": "code", 547 | "execution_count": 18, 548 | "metadata": {}, 549 | "outputs": [], 550 | "source": [ 551 | "n_batches = 10\n", 552 | "counter = 0\n", 553 | "results = []\n", 554 | "labels = []\n", 555 | "for batch in test_iter:\n", 556 | " net2(batch.data[0].as_in_context(model_ctx))\n", 557 | " results.append(net2.mu.asnumpy())\n", 558 | " labels.append(batch.label[0].asnumpy())\n", 559 | " counter +=1\n", 560 | " if counter >= n_batches:\n", 561 | " break" 562 | ] 563 | }, 564 | { 565 | "cell_type": "code", 566 | "execution_count": 19, 567 | "metadata": {}, 568 | "outputs": [], 569 | "source": [ 570 | "result= np.vstack(results)\n", 571 | "labels = np.hstack(labels)" 572 | ] 573 | }, 574 | { 575 | "cell_type": "code", 576 | "execution_count": 20, 577 | "metadata": {}, 578 | "outputs": [], 579 | "source": [ 580 | "if result.shape[1]==2:\n", 581 | " from scipy.special import ndtri\n", 582 | " from scipy.stats import norm\n", 583 | "\n", 584 | " fig, axarr = plt.subplots(1,2, figsize=(10,4))\n", 585 | " im=axarr[0].scatter(result[:, 0], result[:, 1], c=labels, alpha=0.6, cmap='Paired')\n", 586 | " axarr[0].set_title('scatter plot of $\\mu$')\n", 587 | " axarr[0].axis('equal')\n", 588 | " fig.colorbar(im, ax=axarr[0])\n", 589 | "\n", 590 | " im=axarr[1].scatter(norm.cdf(result[:, 0]), norm.cdf(result[:, 1]), c=labels, alpha=0.6, cmap='Paired')\n", 591 | " axarr[1].set_title('scatter plot of $\\mu$ on norm.cdf() transformed coordinates')\n", 592 | " axarr[1].axis('equal')\n", 593 | " fig.colorbar(im, ax=axarr[1])\n", 594 | " plt.tight_layout()\n", 595 | " if output_fig:\n", 596 | " plt.savefig('2d_latent_space_for_test_samples.png')" 597 | ] 598 | }, 599 | { 600 | "cell_type": "markdown", 601 | "metadata": {}, 602 | "source": [ 603 | "# Sample latent space and generate images" 604 | ] 605 | }, 606 | { 607 | "cell_type": "markdown", 608 | "metadata": {}, 609 | "source": [ 610 | "## Random sampling" 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "execution_count": 21, 616 | "metadata": {}, 617 | "outputs": [], 618 | "source": [ 619 | "n_samples = 10\n", 620 | "zsamples = nd.array(np.random.randn(n_samples*n_samples, n_latent))" 621 | ] 622 | }, 623 | { 624 | "cell_type": "code", 625 | "execution_count": 22, 626 | "metadata": {}, 627 | "outputs": [], 628 | "source": [ 629 | "images = net2.decoder(zsamples.as_in_context(model_ctx)).asnumpy()" 630 | ] 631 | }, 632 | { 633 | "cell_type": "code", 634 | "execution_count": 23, 635 | "metadata": {}, 636 | "outputs": [ 637 | { 638 | "data": { 639 | "image/png": "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\n", 640 | "text/plain": [ 641 | "" 642 | ] 643 | }, 644 | "metadata": {}, 645 | "output_type": "display_data" 646 | } 647 | ], 648 | "source": [ 649 | "canvas = np.empty((28*n_samples, 28*n_samples))\n", 650 | "for i, img in enumerate(images):\n", 651 | " x = i // n_samples\n", 652 | " y = i % n_samples\n", 653 | " canvas[(n_samples-y-1)*28:(n_samples-y)*28, x*28:(x+1)*28] = img.reshape(28, 28)\n", 654 | "plt.figure(figsize=(4, 4)) \n", 655 | "plt.imshow(canvas, origin=\"upper\", cmap=\"Greys\")\n", 656 | "plt.axis('off')\n", 657 | "plt.tight_layout()\n", 658 | "if output_fig:\n", 659 | " plt.savefig('generated_samples_with_{}D_latent_space.png'.format(n_latent))" 660 | ] 661 | }, 662 | { 663 | "cell_type": "markdown", 664 | "metadata": {}, 665 | "source": [ 666 | "## Grid scan 2D latent space" 667 | ] 668 | }, 669 | { 670 | "cell_type": "code", 671 | "execution_count": 24, 672 | "metadata": {}, 673 | "outputs": [], 674 | "source": [ 675 | "if n_latent==2: \n", 676 | " n_pts = 20\n", 677 | "\n", 678 | " idx = np.arange(0, n_pts)\n", 679 | "\n", 680 | " x = np.linspace(norm.cdf(-3), norm.cdf(3),n_pts)\n", 681 | " x = ndtri(x)\n", 682 | "\n", 683 | " x_grid = np.array(np.meshgrid(*[i for i in np.matlib.repmat(x,n_latent,1)]))\n", 684 | " id_grid = np.array(np.meshgrid(*[i for i in np.matlib.repmat(idx,n_latent,1)]))\n", 685 | "\n", 686 | " zsamples = nd.array(x_grid.reshape((n_latent, -1)).transpose())\n", 687 | " zsamples_id = id_grid.reshape((n_latent, -1)).transpose()\n", 688 | "\n", 689 | " images = net2.decoder(zsamples.as_in_context(model_ctx)).asnumpy()\n", 690 | "\n", 691 | " #plot\n", 692 | " canvas = np.empty((28*n_pts, 28*n_pts))\n", 693 | " for i, img in enumerate(images):\n", 694 | " #plt.imshow(img.reshape(28,28))\n", 695 | " x, y = zsamples_id[i]\n", 696 | " canvas[(n_pts-y-1)*28:(n_pts-y)*28, x*28:(x+1)*28] = img.reshape(28, 28)\n", 697 | " plt.figure(figsize=(6, 6)) \n", 698 | " plt.imshow(canvas, origin=\"upper\", cmap=\"Greys\")\n", 699 | " plt.axis('off')\n", 700 | " plt.tight_layout()\n", 701 | " if output_fig:\n", 702 | " plt.savefig('2d_latent_space_scan_for_generation.png')" 703 | ] 704 | } 705 | ], 706 | "metadata": { 707 | "kernelspec": { 708 | "display_name": "Python 3", 709 | "language": "python", 710 | "name": "python3" 711 | }, 712 | "language_info": { 713 | "codemirror_mode": { 714 | "name": "ipython", 715 | "version": 3 716 | }, 717 | "file_extension": ".py", 718 | "mimetype": "text/x-python", 719 | "name": "python", 720 | "nbconvert_exporter": "python", 721 | "pygments_lexer": "ipython3", 722 | "version": "3.5.2" 723 | }, 724 | "widgets": { 725 | "state": { 726 | "013831ad95a14b50989742a490b65ad0": { 727 | "views": [] 728 | }, 729 | "060dbcfa0dbf4ec79c19a6082dfcde16": { 730 | "views": [] 731 | }, 732 | "064f5c79b47748cc85671b2dfe3a7b11": { 733 | "views": [] 734 | }, 735 | "075482b08bf8473d84a539c6ed4a2cd5": { 736 | "views": [] 737 | }, 738 | "0d438ff52cc74867852a17039f872b30": { 739 | "views": [] 740 | }, 741 | "0de6820e97e64c0e9ba1713cb31270c5": { 742 | "views": [] 743 | }, 744 | "11ceed56010c4035a8e00f0e777a32ef": { 745 | "views": [] 746 | }, 747 | "128439858fca48bf896e3bc048e434c6": { 748 | "views": [] 749 | }, 750 | "17badb0485644615ace649fbf7221b2b": { 751 | "views": [] 752 | }, 753 | "252bad49b82041cf937f3957f2738138": { 754 | "views": [] 755 | }, 756 | "2757715fdbed476fae6764d36440abf4": { 757 | "views": [] 758 | }, 759 | "28b36582d56742e991cbb4eeaaaa6815": { 760 | "views": [] 761 | }, 762 | "2c15dc27263a4aeba4ad716d26a6eb51": { 763 | "views": [] 764 | }, 765 | "2c3383be9c2b42139fa75dcaa0f76362": { 766 | "views": [] 767 | }, 768 | "2d2404d2cbea46eca2df100d4a216ab0": { 769 | "views": [] 770 | }, 771 | "312a7d065faf42efa6d590abd99af6e4": { 772 | "views": [] 773 | }, 774 | "3609be49f4754b619ee5f9b8dd5655c2": { 775 | "views": [] 776 | }, 777 | "367462141a584d36b8c116e322840ec2": { 778 | "views": [] 779 | }, 780 | "3bcccfd7f2a048d1ba7277cbfef35070": { 781 | "views": [] 782 | }, 783 | "3cc84227a2994ae68724d39f91fe4888": { 784 | "views": [] 785 | }, 786 | "3d2398ca4f0444a28f20c5526cc17f60": { 787 | "views": [] 788 | }, 789 | "42d4a8624c5d43cdafe4d95b6093088d": { 790 | "views": [] 791 | }, 792 | "430e7722f893454fb6fb6d7067038a52": { 793 | "views": [] 794 | }, 795 | "45bce29afb8e45f989b2a7ce35bafc06": { 796 | "views": [] 797 | }, 798 | "4d3698d1eb7445f39af9a8551e125574": { 799 | "views": [] 800 | }, 801 | "59278d56d73b42a3b54cc5486ec9d28a": { 802 | "views": [] 803 | }, 804 | "5a88eafb8bd041df90e5b03b9dbd2930": { 805 | "views": [] 806 | }, 807 | "5cac8f55cbd447bd8e04714c0be9cfdd": { 808 | "views": [] 809 | }, 810 | "613f4b7c012547f8809bebac99130b1f": { 811 | "views": [] 812 | }, 813 | "66fe705008014e34bd1b66a97ca00a52": { 814 | "views": [] 815 | }, 816 | "693e5755d56d453ea1b30f08bd3cb264": { 817 | "views": [] 818 | }, 819 | "6ccbd5c95fbb4cd3b610be1af7b0cb28": { 820 | "views": [] 821 | }, 822 | "70bd4dc3920145df96c0ada89dd26eb7": { 823 | "views": [] 824 | }, 825 | "744afe6e043f41b4ae79c8638e8e983f": { 826 | "views": [] 827 | }, 828 | "7843ec29c508499bb945789fdb7b482c": { 829 | "views": [] 830 | }, 831 | "78d7e99ed96e463f897c738a52f30baf": { 832 | "views": [ 833 | { 834 | "cell_index": 13 835 | } 836 | ] 837 | }, 838 | "7d524cdb5a314099b9c5a4152c6b129e": { 839 | "views": [] 840 | }, 841 | "7d5f644a33f6467bba4d1b5bd1962c0f": { 842 | "views": [] 843 | }, 844 | "7e879703f4574bac9de4137d1155c8ce": { 845 | "views": [] 846 | }, 847 | "7e8d33c949fb426e81125f082b7deb7c": { 848 | "views": [] 849 | }, 850 | "81125a7384804e539de58b79c381d7fa": { 851 | "views": [] 852 | }, 853 | "81633120e61a47c49e7e7cde277d7af9": { 854 | "views": [] 855 | }, 856 | "84734c2e88a0466e9492e93747befc49": { 857 | "views": [] 858 | }, 859 | "86ed6062cea3471eb52e395764c1edb4": { 860 | "views": [ 861 | { 862 | "cell_index": 13 863 | } 864 | ] 865 | }, 866 | "94ad29c1c4644f45a4749874ddd0c1fc": { 867 | "views": [] 868 | }, 869 | "953eb61e1af74f32998d6f61967006cb": { 870 | "views": [] 871 | }, 872 | "98b9cda7c3ff48df8639759fd249bee8": { 873 | "views": [] 874 | }, 875 | "9912b3cefd69439cae64925eedf97ee3": { 876 | "views": [] 877 | }, 878 | "9989ee405297420da7ba25fc0a2068cc": { 879 | "views": [ 880 | { 881 | "cell_index": 13 882 | } 883 | ] 884 | }, 885 | "9a0de86e07334d27a052b2f4edd67ed1": { 886 | "views": [] 887 | }, 888 | "9c74970b79904db087057befbe464d16": { 889 | "views": [] 890 | }, 891 | "9d82a3bd77894311b87a19b044086018": { 892 | "views": [] 893 | }, 894 | "9d9ce67edd2f46c6969644ce18c40464": { 895 | "views": [] 896 | }, 897 | "9eb346c6adf34137a0e4e2cc5b3a9df0": { 898 | "views": [] 899 | }, 900 | "9ec367a05b8f41d69afc7923c11b632c": { 901 | "views": [] 902 | }, 903 | "9fa6d568f8a549d8811cccd8649f9ce2": { 904 | "views": [] 905 | }, 906 | "a19d63a0324e4cc2bb3af7dc331b5abc": { 907 | "views": [] 908 | }, 909 | "a3636a2cce744c75bb7d1bd672aaa1a9": { 910 | "views": [] 911 | }, 912 | "a3e4aa4b2ec94dfba8e07f2641229ed1": { 913 | "views": [] 914 | }, 915 | "a64837790ef04869a6b399251dcea040": { 916 | "views": [] 917 | }, 918 | "aa41497993db4f1e8ce8cb8e31751d52": { 919 | "views": [] 920 | }, 921 | "aab984197cee4e52b8d062bd8cfa9878": { 922 | "views": [] 923 | }, 924 | "ab33b20130ba4158b90b2c93cdb2116c": { 925 | "views": [] 926 | }, 927 | "ab3f83b6a6b84087b565c34a2a76aa36": { 928 | "views": [] 929 | }, 930 | "ab91869bd6e347b0adbcb3fb3a82db14": { 931 | "views": [ 932 | { 933 | "cell_index": 13 934 | } 935 | ] 936 | }, 937 | "b5537aa47c3d4088beb0e83b6cc35b2c": { 938 | "views": [] 939 | }, 940 | "b810da789f3442a5a93b30914e2b6cb0": { 941 | "views": [] 942 | }, 943 | "ba284efbb6444b74808d8ad20d4ab2d8": { 944 | "views": [] 945 | }, 946 | "bca4373a0d0e4741b9391e51dfe05525": { 947 | "views": [] 948 | }, 949 | "be8f818802844d00b6dec3892a93fe01": { 950 | "views": [] 951 | }, 952 | "beffdcc6f9514a30a71ec609c0133955": { 953 | "views": [] 954 | }, 955 | "bf6b616cbbc949dd874c3e0e4e49fe83": { 956 | "views": [] 957 | }, 958 | "c18c5aed11b647a6b0d4efcbd6b895e7": { 959 | "views": [] 960 | }, 961 | "c1da8befa7c9434099a6bd883e6039f7": { 962 | "views": [] 963 | }, 964 | "c5d5c7c363d5436688ed3780ccb5f437": { 965 | "views": [] 966 | }, 967 | "c623d679576c4d2199122117673c7d2d": { 968 | "views": [] 969 | }, 970 | "c6b3e5ff5206400d92b012428dc13ada": { 971 | "views": [] 972 | }, 973 | "cac058af8fe84d9090488f97eaf6e2c6": { 974 | "views": [] 975 | }, 976 | "cb4662815adb4cfd92fc21c09c62b242": { 977 | "views": [] 978 | }, 979 | "cfd34e25998f440193b51db9aa1aee1a": { 980 | "views": [] 981 | }, 982 | "d25ba13396474cfbba1355b34324f2c8": { 983 | "views": [] 984 | }, 985 | "d39bdd8023c746b4a823012e59c3e695": { 986 | "views": [] 987 | }, 988 | "d5239161f55643aa96a7f368202b65ff": { 989 | "views": [] 990 | }, 991 | "d6c0abd6d4c4438eb7a1341001800aa6": { 992 | "views": [] 993 | }, 994 | "d9e16f99be3f4a16a2a2d4afb41052a5": { 995 | "views": [] 996 | }, 997 | "da7ed38c90e7444fbd8cb05ba7aa29ba": { 998 | "views": [] 999 | }, 1000 | "db876aad73d44ec684ff8617bb216bb6": { 1001 | "views": [] 1002 | }, 1003 | "dc30ca57c7484d6aa2fe395006333eee": { 1004 | "views": [ 1005 | { 1006 | "cell_index": 13 1007 | } 1008 | ] 1009 | }, 1010 | "e0ee3a3f1333466980d7d56ebee03560": { 1011 | "views": [] 1012 | }, 1013 | "e53d57d91ae346188283343ae5aa75d7": { 1014 | "views": [] 1015 | }, 1016 | "ebe196e6565e4193b39f079243a8b71e": { 1017 | "views": [] 1018 | }, 1019 | "ec3003f4855e4b0796c6929aa07c9bdf": { 1020 | "views": [ 1021 | { 1022 | "cell_index": 13 1023 | } 1024 | ] 1025 | }, 1026 | "ed07ff00310e42f190452577f1144af3": { 1027 | "views": [] 1028 | }, 1029 | "f4218c2fd6a7434181f548e28ffbdee6": { 1030 | "views": [] 1031 | }, 1032 | "f4b6303e7c6c41bb8cb3a0f0e87dfbef": { 1033 | "views": [] 1034 | }, 1035 | "f6e60e625417416fa45c478d419e820b": { 1036 | "views": [] 1037 | }, 1038 | "f747d9c58a844bf5b5939e5f6b7f3f77": { 1039 | "views": [] 1040 | }, 1041 | "f97975725348441ebd204396e52b14ec": { 1042 | "views": [ 1043 | { 1044 | "cell_index": 13 1045 | } 1046 | ] 1047 | }, 1048 | "fc4f654f915a4bd49cdbb664ee2b74cf": { 1049 | "views": [] 1050 | }, 1051 | "fca1f6e81f9942b78671ffced0a6901e": { 1052 | "views": [] 1053 | }, 1054 | "feb02650db954c01aefdc7024eac9510": { 1055 | "views": [] 1056 | }, 1057 | "ff9730625878484bbbad310801d7b64d": { 1058 | "views": [] 1059 | } 1060 | }, 1061 | "version": "1.1.2" 1062 | } 1063 | }, 1064 | "nbformat": 4, 1065 | "nbformat_minor": 2 1066 | } 1067 | --------------------------------------------------------------------------------