From 15b02285dc74400fde7248a6397ff687fbe6c923 Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Mon, 20 Jul 2020 07:57:26 +0000 Subject: [PATCH 1/8] add VAE demo --- example/probability/VAE/README.md | 0 example/probability/VAE/VAE.ipynb | 355 ++++++++++++++++++++++++++++++ 2 files changed, 355 insertions(+) create mode 100644 example/probability/VAE/README.md create mode 100644 example/probability/VAE/VAE.ipynb diff --git a/example/probability/VAE/README.md b/example/probability/VAE/README.md new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/example/probability/VAE/VAE.ipynb b/example/probability/VAE/VAE.ipynb new file mode 100644 index 000000000000..71ed7d430c3d --- /dev/null +++ b/example/probability/VAE/VAE.ipynb @@ -0,0 +1,355 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# VAE with Gluon.probability \n", + "\n", + "In this notebook, we will demonstrate how you can implement a Variational Auto-encoder(VAE) with Gluon.probability and MXNet's latest NumPy API." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import mxnet as mx\n", + "from mxnet import autograd, gluon, np, npx\n", + "from mxnet.gluon import nn\n", + "import mxnet.gluon.probability as mgp\n", + "import matplotlib.pyplot as plt\n", + "\n", + "npx.set_np()\n", + "data_ctx = mx.cpu()\n", + "model_ctx = mx.gpu(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset\n", + "\n", + "We will use MNIST here for simplicity purpose." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def load_data(batch_size):\n", + " mnist_train = gluon.data.vision.MNIST(train=True)\n", + " mnist_test = gluon.data.vision.MNIST(train=False)\n", + " num_worker = 4\n", + " transformer = gluon.data.vision.transforms.ToTensor()\n", + " return (gluon.data.DataLoader(mnist_train.transform_first(transformer),\n", + " batch_size, shuffle=True,\n", + " num_workers=num_worker),\n", + " gluon.data.DataLoader(mnist_test.transform_first(transformer),\n", + " batch_size, shuffle=False,\n", + " num_workers=num_worker))\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model definition" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class VAE(gluon.HybridBlock):\n", + " def __init__(self, n_hidden=256, n_latent=2, n_layers=1, n_output=784, act_type='relu', **kwargs):\n", + " r\"\"\"\n", + " n_hidden : number of hidden units in each layer\n", + " n_latent : dimension of the latent space\n", + " n_layers : number of layers in the encoder and decoder network\n", + " n_output : dimension of the observed data\n", + " \"\"\"\n", + " self.soft_zero = 1e-10\n", + " self.n_latent = n_latent\n", + " self.output = None\n", + " self.mu = None\n", + " super(VAE, self).__init__(**kwargs)\n", + " self.encoder = nn.HybridSequential()\n", + " for _ in range(n_layers):\n", + " self.encoder.add(nn.Dense(n_hidden, activation=act_type))\n", + " self.encoder.add(nn.Dense(n_latent*2, activation=None))\n", + " self.decoder = nn.HybridSequential()\n", + " for _ in range(n_layers):\n", + " self.decoder.add(nn.Dense(n_hidden, activation=act_type))\n", + " self.decoder.add(nn.Dense(n_output, activation='sigmoid'))\n", + " \n", + " def encode(self, x):\n", + " r\"\"\"\n", + " Given a batch of x,\n", + " return the encoder's output\n", + " \"\"\"\n", + " h = self.encoder(x)\n", + " loc_scale = np.split(h, 2, 1)\n", + " loc = loc_scale[0]\n", + " log_variance = loc_scale[1]\n", + " scale = np.exp(0.5 * log_variance)\n", + " self.loc = loc\n", + " return mgp.Normal(loc, scale)\n", + " \n", + " def decode(self, z):\n", + " r\"\"\"\n", + " Given a batch of samples from z,\n", + " return the decoder's output\n", + " \"\"\"\n", + " return self.decoder(z)\n", + "\n", + " def forward(self, x):\n", + " r\"\"\"\n", + " Given a batch of data x,\n", + " return the negative of Evidence Lower-bound,\n", + " i.e. an objective to minimize.\n", + " \"\"\"\n", + " # prior p(z)\n", + " pz = mgp.Normal(0, 1)\n", + " \n", + " # posterior q(z|x)\n", + " qz_x = self.encode(x) \n", + " \n", + " # Sampling operation qz_x.sample() is automatically reparameterized.\n", + " z = qz_x.sample() \n", + "\n", + " # Reconstruction result\n", + " y = self.decode(z) \n", + " \n", + " # Gluon.probability can help you calculate the analytical kl-divergence\n", + " # between two distribution objects.\n", + " KL = mgp.kl_divergence(qz_x, pz).sum(1)\n", + " \n", + " # We assume p(x|z) ~ Bernoulli, therefore we compute the reconstruction\n", + " # loss with binary cross entropy.\n", + " logloss = np.sum(x * np.log(y + self.soft_zero) + (1 - x)\n", + " * np.log(1 - y + self.soft_zero), axis=1)\n", + " loss = -logloss + KL\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def train(net, n_epoch, print_period, train_iter, test_iter):\n", + " net.initialize(mx.init.Xavier(), ctx=model_ctx)\n", + " net.hybridize()\n", + " trainer = gluon.Trainer(net.collect_params(), 'adam',\n", + " {'learning_rate': .001})\n", + " training_loss = []\n", + " validation_loss = []\n", + " for epoch in range(n_epoch):\n", + " epoch_loss = 0\n", + " epoch_val_loss = 0\n", + "\n", + " n_batch_train = 0\n", + " for batch in train_iter:\n", + " n_batch_train += 1\n", + " data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28)\n", + " with autograd.record():\n", + " loss = net(data)\n", + " loss.backward()\n", + " trainer.step(data.shape[0])\n", + " epoch_loss += np.mean(loss)\n", + "\n", + " n_batch_val = 0\n", + " for batch in test_iter:\n", + " n_batch_val += 1\n", + " data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28)\n", + " loss = net(data)\n", + " epoch_val_loss += np.mean(loss)\n", + "\n", + " epoch_loss /= n_batch_train\n", + " epoch_val_loss /= n_batch_val\n", + "\n", + " training_loss.append(epoch_loss)\n", + " validation_loss.append(epoch_val_loss)\n", + "\n", + " if epoch % max(print_period, 1) == 0:\n", + " print('Epoch{}, Training loss {:.2f}, Validation loss {:.2f}'.format(\n", + " epoch, float(epoch_loss), float(epoch_val_loss)))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch0, Training loss 198.47, Validation loss 165.42\n", + "Epoch5, Training loss 121.50, Validation loss 120.12\n", + "Epoch10, Training loss 114.81, Validation loss 113.73\n", + "Epoch15, Training loss 111.33, Validation loss 110.75\n", + "Epoch20, Training loss 109.57, Validation loss 109.62\n", + "Epoch25, Training loss 108.31, Validation loss 108.14\n", + "Epoch30, Training loss 107.21, Validation loss 107.25\n", + "Epoch35, Training loss 106.17, Validation loss 106.22\n", + "Epoch40, Training loss 105.49, Validation loss 106.11\n", + "Epoch45, Training loss 104.90, Validation loss 105.22\n" + ] + } + ], + "source": [ + "n_hidden = 128\n", + "n_latent = 40\n", + "n_layers = 3\n", + "n_output = 784\n", + "batch_size = 128\n", + "model_prefix = 'vae_gluon_{}d{}l{}h.params'.format(\n", + " n_latent, n_layers, n_hidden)\n", + "net = VAE(n_hidden=n_hidden, n_latent=n_latent, n_layers=n_layers,\n", + " n_output=n_output)\n", + "net.hybridize()\n", + "n_epoch = 50\n", + "print_period = n_epoch // 10\n", + "train_set, test_set = load_data(batch_size)\n", + "train(net, n_epoch, print_period, train_set, test_set)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reconstruction visualiztion\n", + "\n", + "To verify the effictiveness of our model, we first take a look at how well our model can reconstruct the data." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Grab a batch from the test set\n", + "qz_x = None\n", + "for batch in test_set:\n", + " data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28)\n", + " qz_x = net.encode(data)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_samples = 4\n", + "fig, axes = plt.subplots(nrows=num_samples, ncols=2, figsize=(4, 6), subplot_kw={'xticks': [], 'yticks': []})\n", + "axes[0, 0].set_title('Original image')\n", + "axes[0, 1].set_title('reconstruction')\n", + "for i in range(num_samples):\n", + " axes[i, 0].imshow(data[i].squeeze().reshape(28, 28).asnumpy(), cmap='gray')\n", + " axes[i, 1].imshow(net.decode(qz_x.sample())[i].reshape(28, 28).asnumpy(), cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample generation\n", + "\n", + "One of the most important difference between Variational Auto-encoder and Auto-encoder is VAE's capabilities of generating new samples.\n", + "\n", + "To achieve that, one simply needs to feed a random sample from $p(z) \\sim \\mathcal{N}(0,1)$ to the decoder network." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_samples(samples, h=5, w=10):\n", + " fig, axes = plt.subplots(nrows=h,\n", + " ncols=w,\n", + " figsize=(int(1.4 * w), int(1.4 * h)),\n", + " subplot_kw={'xticks': [], 'yticks': []})\n", + " for i, ax in enumerate(axes.flatten()):\n", + " ax.imshow(samples[i], cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_samples = 16\n", + "noise = np.random.randn(n_samples, n_latent).as_in_context(model_ctx)\n", + "dec_output = net.decode(noise).reshape(-1, 28, 28).asnumpy()\n", + "plot_samples(dec_output, 4, 4)" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 51d8c64296269acc0fa6ce756584a98620558edd Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Wed, 22 Jul 2020 06:03:46 +0000 Subject: [PATCH 2/8] minor changes --- .../convolutional_autoencoder.ipynb | 43 +++++++++++++++---- example/probability/VAE/README.md | 1 + example/probability/VAE/VAE.ipynb | 10 ++--- 3 files changed, 40 insertions(+), 14 deletions(-) diff --git a/example/autoencoder/convolutional_autoencoder.ipynb b/example/autoencoder/convolutional_autoencoder.ipynb index a49eba0fcc10..a08131300286 100644 --- a/example/autoencoder/convolutional_autoencoder.ipynb +++ b/example/autoencoder/convolutional_autoencoder.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -55,9 +55,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/train-images-idx3-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/train-images-idx3-ubyte.gz...\n", + "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/train-labels-idx1-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/train-labels-idx1-ubyte.gz...\n", + "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/t10k-images-idx3-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/t10k-images-idx3-ubyte.gz...\n", + "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/t10k-labels-idx1-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/t10k-labels-idx1-ubyte.gz...\n" + ] + } + ], "source": [ "transform = lambda x,y: (x.transpose((2,0,1)).astype('float32')/255., y)\n", "\n", @@ -73,17 +84,19 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -104,9 +117,21 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "__init__() got an unexpected keyword argument 'prefix'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnet\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgluon\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHybridSequential\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprefix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'autoencoder_'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mnet\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Encoder 1x28x28 -> 32x1x1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mencoder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgluon\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHybridSequential\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprefix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'encoder_'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mencoder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: __init__() got an unexpected keyword argument 'prefix'" + ] + } + ], "source": [ "net = gluon.nn.HybridSequential(prefix='autoencoder_')\n", "with net.name_scope():\n", @@ -535,7 +560,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/example/probability/VAE/README.md b/example/probability/VAE/README.md index e69de29bb2d1..64d5efb86564 100644 --- a/example/probability/VAE/README.md +++ b/example/probability/VAE/README.md @@ -0,0 +1 @@ +# Example of Variational Auto-encoder(VAE) implemented with MXNet's NumPy API and Gluon.probability diff --git a/example/probability/VAE/VAE.ipynb b/example/probability/VAE/VAE.ipynb index 71ed7d430c3d..b67c1a2fe1d1 100644 --- a/example/probability/VAE/VAE.ipynb +++ b/example/probability/VAE/VAE.ipynb @@ -309,14 +309,14 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEhCAYAAABRKfYcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2dd9RkVZW3n1ZyzjlLDoJkyYKwjAQdQFERYVQcB5egY8IwJhiXacYwZlijjAgqOGqDLBFUMkhuouQcmhwFhe8PvqfOqdtv0/3eN1X4Pf9Uv1V1q+vuOvee/dt7n32mPf/884QQQgij5SVT/QVCCCH0J5lAQgghtCITSAghhFZkAgkhhNCKTCAhhBBaMc9o3jxt2rShKtl6/vnnp433Z8aGYyP2Gzux4diJDV8gCiSEEEIrMoGEEEJoRSaQEEIIrRhVDmSqeMlLXpjn5ptvPgCee+45AJ555pkp+04hhNCGadO60wm91A3Ee6332Dm+fyK/TAghhMGlpxWIimPrrbcGYLfddgNg0UUXBeC4447rvHfGjBkA/P3vf5/MrxhCCK3oJeUhc6s8JAokhBBCKzKBhBBCaEVPhrBM5Cy77LIAbL/99gC89a1vBeCvf/0r0C23Riu9QghhKhiP0JX3SBPyL33pSzuvGfr3uWeffRYoRUf/+Mc/xu97jPkTQgghDCU9qUCaqETuv/9+AC677DIAnnzyySn7Tr1Ks0RwTtReiMf2YnIvhGGkqTAWWWQRAFZffXUAVlllFQA22GCDzjHrrrsuAHfffTcAv//97wG46qqrAHjiiSeAkZWI/57be0AUSAghhFb0tAJx9r3lllsAuOeeewC4/vrrgTKTDivax3gowLzzzgvAPPPM0/We5qM5o1qxGDs1VvrUU08BpTS6X5SJ9lhooYUAWHzxxQFYcMEFAXj00UcBePDBB4HiiUH/nGMvo/0di9o3Jfajx+tziSWWAOC1r30tAPvttx8A66yzDgALL7xw5xjtf9NNNwFlvM+cOROA22+/vev/qPPHTQUyp9xyFEgIIYRW9KQCcdbVi9YjdgGhnmPtPRsjHORqrKZd9KhXXHHFznvWWmstoMRKF1hgAQBe9rKXdT2OhApEpXfuuecCcMEFFwBw3333ASMrkqlWKZ4nwAorrADAPvvsA8Auu+zS9d7bbrsNKLm0K6+8svOaceOHH34YgL/97W/ArOc30nkOcw6prgJabLHFAFhuueWAYg+v40ceeQQoOcxaATbx2Bd7zyCiPbXhv/zLvwDwzne+s+v5kVqPaGffs9lmmwElB/LAAw90va8+1ootH+dEFEgIIYRW9KQC0RNec801AVhppZW6nl966aUBuOOOOzrH6JXP7czZT+jZ6mUvv/zyQPGs9913385711hjDaDEn+eff/6uY/1bj3qk+nE9k1133RWASy65BIDzzjsPgJtvvhko3jrAddddBxSPfbLQNssss0znuR122AGA/fffHyjjx3PdZpttAHjLW94CdHu3Kg/jxNpCe915551AqWzRFlDG40MPPTTL5w46jisorYfe9KY3AbDkkksCZWw8/vjjANxwww1AyWkCPPbYY0D5XbWl8XxfHySV57l6/QFstNFGAHzmM58BYPfddwfKddzMZdZjrbnuw7HrsVa1qgDNkUDJe6aZYgghhAmlpxSIs6oxfWN3Sy21FFBi1c62tdcziLmPZs5DT27bbbcF4G1vexsA6623XucYvQxtpJdhxZp/+5m11+NzPuqpWGOuvVdddVUAzj///M6xN954IzB1CkTPtP636sDcmePIipWmNwfFxuaSmnkNvbu9994bKOcNJWf0k5/8pOv/H61X10+o6lR9AN/4xjeAEkFwzJlD8/dRCdZVQdpbO6sIf/SjHwHwl7/8BRiMrRy0nWPOMQVwxBFHAKXKymtSVBXa0gorKOvlVMuXX345UOzv7/H0008D3VEbx2jWgYQQQphQelKB6LlYYWAVkLHTkWbOQYw3z67iR9VgNYtx4vo5vRA9E22p920eqa7gcr2EHrM9x84++2ygeNT33nsvUDwcmDqPUI+p7kpwxhlnAMUuhxxyCAA77bQTUNaHeGydB2qul2lWuZhb0n4+Arz85S8HYI899gCKJ/7zn/8cKON3kHDMfPzjH+8850por08Vhrk0belYrdXjpptu2vUZ5tl87yBc5443r72DDjoIgHe/+92d91hJqPLQZip8r0UrCes8UnPdjTa0etXfZSRbjraTRRRICCGEVmQCCSGE0IqeDGEZQrEsUulv6MGyTBNsUBaHDSLKV8/3wgsvBEo4yuQYlFCSpXkmzw17ucBQWxsagGJnQ1eGgpTLvj7SosGpThDXbTL8noY+HUcHHnggUMpMLZV04VtNM8Gu3Dek1WwVA2V8rr322gC85z3vAeCKK64ASghnEEpQDcNY6m1hB5TfwnH0rW99CyhhFsOrhq7qIpDtttsOKHbWZrYz6ucQljazmMPy+3e84x1Adzi5GbrSVs1CDa/zuhjGsWvxiCF/x52/j/eKOvycHQlDCCFMCj2lQJwh9RidDV2Sr3eiAjEpBKXEdxAbtmkXE2gmxvXOVBVQko+2e9braTZZ1CtRzUBRGj5n8tP/d6pVxosxklfv91ad/uAHPwCKN2tbl7pEUlu6INMFbCaLN9lkE6CMyVq9WOas9+xvoNLx9xoEPO8DDjgA6L7uHEdf/vKXAZg+fTpQCh2aC9v0yKFc26pICxD6ceuGZkGGY8uSZ8vwXRhcF3NoI8/7nHPOAeCHP/whUBLjJtvrcei/vV5VJ47zZmuZsSjiKJAQQgit6CkF0ly05YzsQrYtt9wSKG0rbr311s6xp5xyCjD5C9kmg2Y5rzkiWW211Tr/3nnnnYFZywCNHZtHufrqq4Hu2Kn21vvxsZeVx9zgedgk8he/+AVQPOB6zDQbzGlzvTo38Fl55ZWB7sVfu+22GzCrR+lnDEKzxWapvQvd6rY2Lvr7zW9+A5Q4ffO8VWxuWQ3FS/d6njFjxojH9gP+/o4z1avlutrQ3Fmt4lQeRla0pc/7WV77dSsfaS4ctPmqCrlWPDLacvwokBBCCK3oKQWi96EHZzzUBVrGlEdaYOcsXy9KGjT0/sxnaJ96O0sXttXtzetj9T70qM2Z1K/ZomS0i4p6HVWY8XUr1ObGuzXfZtWazSOvueaaznusJjI/Inrg/a7koHitjo1rr70W6D43q62aW6b66Ph17NnSBIpCNl/Vzy1LVPfet/baay+gLJZUeWiX+t5l7s3WLao1G6iq/GyDUudBVTKOUZtW+v/4Wf5m9YLsZnRjTkSBhBBCaMWUK5Day7XyxTp6H51d9RidYZ3BoXg1g0RTNejR6OFaRVR7f24Wc9dddwElvu9n6GHo7dQ2VPnpMQ3y2hpoF1fXq/axruDaeOONgVlbpZh7GSRsImmlVa0UzIc4xprKy1i8myTVm5x95StfAYoH3o+5D3Ec2ELnjW98I1Cqzry+VcT19hSuofG6feUrXwkU1WakwXtCva2117ivmStWGXqvbLZHqb9TmimGEEKYUKZcgdTKQQ9uq622AmaN5bl2wVnYjeahv1eoNmkqDz02Ky2sADKWefHFF3eOPeGEE4CiHprbW+oxj5Q/EV9rVikNQgx/vPC3MVYPs3qWzU2RBoHmymhbhddjY3bbG2uPHXfcESg5gVrpus6hX3MfdUTFe5v3M7dHcOx4PzNqUCtVbbj++usDpWJL5eE9QUa6/7l2yRyyn28Dxmaj1TZEgYQQQmjFlCsQ6+qh9IZxtnWmNIZnBYg9XvTEoczm/cpIFU96GcaIrfnWCzFOXK9wtsV6c8tavSEfzXNoSyi/hT159KiNqVqtMdpNZwYRtxg1vg2z/obmCQYpB+JvPtJWqnPCyr///M//BIoaPuqoozrvqTdG6kdGuia85mbXi6pZHQVlQzPzwqqJ5meN9P95zXv/MKLgfURFbE7ZnnpQ8jFzuzV4FEgIIYRWZAIJIYTQiikLYSn3bZAIRWIZMnHRlsljk0GGrn772992jlWODQLaRslvEs6Et00O//jHPwKlZBfm3Lq5KYGVxlDKprW/5dMeM7eydpDRXieeeCIwcgLScfuBD3wAGKzFrW3CloZU3ve+9wElLOMiOQs/2n5+r+J1ZNsgiwcMVRnC8zqvi4J8j9des+1I0051KLG5i6atTJqLQJtbPEAJISaEFUIIYUKZMgXibFh7cM56lo3qEas4VCi2O7ApHgxWG3dtomfgedu+QK/kqquuAsoe5VC8i+a+x83NbNy3e8899+wca0LdskKTcM2mioPkJc4t2k/VW3ttovr71Kc+BZTNf4bRXjU29nz/+98PFDu5kLBfS3bnhAnp0047DSgluTY8bbYbqpc0+O+mmmjud95szQ7l2ndBp0U2tihyOwOv87pV/mjvo1EgIYQQWjHlZbx1fNjyMj1tWwE024z/7ne/A+DSSy+dtO850dQloM24us34LK9VkVnOW5fxWjpqK2c9E0v5Dj74YKB4QfVGNP4WNl9rtkMZRk/aOPVhhx0GlC0F/L1qj+3MM88EymK4YV946Tg2F2T+yOvXMv1BxbFhDuToo48GyhbHm222GVAW+XqNQlG4zc3kVAvaVrVR5yxs/OnGcOeddx5QcqfNZqL1vWe013gUSAghhFZMmQIxlle3w77//vuB4uXpHetNn3XWWQB8+tOfBvpzm8vZUc/82sbz1lPbfPPNgWIfWzvbaA2KV6GXoResalHFWIGhugE4+eSTATj22GOBEkMdRk/a+PThhx8OwBFHHAEURaJ3WbeROfDAA4HRt8QeVGzdYaWlW91+9rOfBQYrb/limPOxQeL3v/99oLRi9z6nvep/W5nleDQa4+I/x1q9ANP7hrlRr3GjEaoZP8t7BYy+JVQUSAghhFZMmQLR47YiAOBnP/sZUGZGZ+7p06cDZd2DM+wgxeRHUiDmJIxh+rfbqLoRT92KwMopq6308qzqsILN/Mb3vve9zrEnnXQSUKozBqlB5dyiMjvkkEOAEr83Jq0ac9y+613v6hzb7204xgttaL7Nsej1a05g2GhuaGYExfZDdTTGvIT3QpWvSsTreaTGlc12M36Wfzc3khrLNuBRICGEEFoxbTRe/LRp0ybU5W9u9t6cSSc7Fv/888+P+56ubWyoXfQ6jJ3a/NDmk1A8FVeyNlef6v01a8Fh1uZu48F423AixqAeM5RuB8cccwxQ1uBoRysFVSa//OUvO8dOxPjslTE4J0baWMvNpvSSrWSzym+y6BcbtqG59UP9XLO5Z/P5ZnPUF2N2NowCCSGE0IopXwdSM1VKo9dpbj1pe3CrLOpKoNl5Hc0VrcO8qly0ietpoFRdWZPve8w/fe1rXwNKxdqwj1XHl/2tAA499FCgxOtPOeUUoMT6w/jh9fti+cpmPqUZ2RkLUSAhhBBakQkkhBBCK3oqhBVGx0jhp9mFpIaxJHd2KOltrbHFFlt0XnPXR99jyaVNFP/nf/4HGJ5FcLND+9iAc6ONNuq8ZmjEslQXAGc7gKmhubXDeBIFEkIIoRVRIGHo0CNzIZcLU6GUmNoq//LLLwfKYlbb7Qw7JmRteOqiXyjFHS5anTFjBhAVPIhEgYQQQmhFTy0k7DUGeQHSZNHLCwlHWoTlv31tqjc76vUx2CwRBVh++eWBUnY+1S1eet2G/UAWEoYQQhhXRpsDmQncOhFfpAdZfYI+NzYcG+Nmv5EWYfVYnL7nx+BIFT49tmCw523YB8zWhqMKYYUQQgiSEFYIIYRWZAIJIYTQikwgIYQQWpEJJIQQQisygYQQQmhFJpAQQgityAQSQgihFZlAQgghtCITSAghhFaMqpVJGoiNndhwbMR+Yyc2HDux4QtEgYQQQmhFJpAQQgityAQSwlwwbdq0zt4XIYQXyAQSQgihFdkTPQw9IymL5s6ECy64IFB23nO3vWeffbZzjHuJZIuEMF44/po7Pzo+3Yflueee6xwzmeMvCiSEEEIrMoGEEEJoRU+HsJryzUflWy3VlHA+lzBCmBPNsADAvPPOC8BCCy0EwDLLLNN1jCGrxx9/HIDHHnus81pzDA47888/PwDrrLMOAOuttx4At976wk6wl156KdBz2whPGfPNN1/n32uuuSYA++yzDwCvfe1rAVh++eWBMj7vueceAE4++eTOsSeddBIAN998MwDPPPPMhH3nKJAQQgit6EkFYsLSWXjHHXcEYKWVVgJg0UUXBWCeecrXv+GGGwC44IILALj88ssBePrppyfhGw8Get96Qk8++SQw+B51nURffPHFAdhggw0AWH/99QFYZZVVgDLOrr/+egBuu+22zrEzZ84EypgbdLvNDq/LFVdcEYCPfvSjAOywww5A8Zrf9KY3AXD33XdP9lfsKbzfbb/99p3nPvKRjwCwySabALDIIosARdU5tpZeemmgKBOAddddF4CvfOUrAFxzzTVAd6J9vIgCCSGE0IqeUiDOrhtttBEAhx9+OADbbbcdUDxjZ9Knnnqqc+wjjzwCFG9SD9Fyy2H1BmeHXs+vf/3rznM77bQTAPfddx8AW2yxRdffg4o5NShjbLXVVgNg5513BmDJJZcEZs2JPPDAA51/P/zww0AZg8M+5rTlwgsvDBQbLrbYYkDxlIdVgWiXN7/5zQB84AMf6Lxm3kg1Zx7joYce6vrb61iFAvDqV78agBkzZgBw3XXXAVEgIYQQeogpVyALLLBA59/7778/AJ/+9KcBWHnllYFSpaHicCY1Xg2wxBJLALD22msDZWZWmQy7N6gn89a3vhWAb37zm0DxBqF4zsZV6xzTIFOfp7kOK4Yca3rJt99+O1DGYj1+VTLNKsFhG3tWtekl33nnnUCxizYzz/SnP/1psr/ilKJ9vL/tvvvuACy77LKd92g7K6l+85vfAHDllVcC5Rp9wxveAHTnT1TJu+66KwA/+MEPAHj00UfH+1SiQEIIIbRjylxM46N7771357kvfelLACy33HIAPPjggwBcdNFFQKm5tzJm1VVX7RyrSnGWdZb3cZC9wbqKSOVlfPmwww4DYI899gCKd2K+aaQ2HldffTVQqmUGFcdGXcGy1VZbASWmrC2uvfZaoIwvvWnr8aFUB1qF1Yw5D+LYGwnP2+tVG3r+VvuZ6xw2HHdei9qpvt7uvfdeAI499ligqDQrI80nacvNN9+8c6zXtvfYen3JeBMFEkIIoRWTrkCMN1vf/KEPfajzmlUJxvm++tWvAnDJJZcAJefxlre8BYBtttmmc6yrW//4xz8CxVPU62l62v3oDer1aidjnB/72Mc67zGu7Hs8Tz0XK4WMoerBQIm7uvp1Iqo2egHHwlJLLQWUdUZQqq/uuusuAM466yygeIceq51XX331zrFNG9vobpDG4Oyoz61ZJWn+qNmgUpU8bPi7W9143nnnASVXBHD++ecDJfpi5wOPNTqjuqhzcY47x+xEroWLAgkhhNCKSVcgVv2Y+9Djg1Kv/KlPfQqAs88+Gygejd6eM6urzqFUKfjcE0880XWs9KPXp2qzQujQQw8F4OCDDwaKJw3Fy/O8VWZHH300AGussQZQlF+tQO644w6gVBoNKqoz8x0vf/nLO69pA73CG2+8ESj2dHX1hhtuCJR8HZSV6DfddBMw+15ujsG6B1e/t4KvFYjnoCdsJaTn63t9fdjwt/Y+ZtSkzlXcf//9QLmPNceF99EDDjgAKGMaihKePn06EAUSQgihB8kEEkIIoRWTFsIytOJiGcMHtWy74oorgLJ4RqlnaaohHEvYzj333M6xJp1MNg1CArjZbtzyPMMm2qUOH5i4VBa7cNCWLoayTLrV0rhupTCIONY23nhjoLQpqcfgZZddBsAtt9wCFHtawGGLiT333BPoHmenn346MOu2Az76O3pMvYCxGc7x9+oXajs0Q3Xatw6XQnfSeJjQVoaa/K3rkGbz/qVNvW4/97nPASX8Wt8DLAA588wzgYltlx8FEkIIoRWTnkRvtgyvG9mZUH/FK14BlM17TFz6vJ5L3QJhkJSH6MHpoajMTjzxRKAkzlQmAJ/4xCeAsvBNe2hnG7fpsdQNKU855ZQJOIupx3N14VZzc55TTz21817btZu8dLyusMIKQGk78bKXvQwodoaSrNST9PdxUaK/gZ5nnfg0KWr5uQqoH3HcOvZc8Ftf61DG87CifXysVahjVpXq+Pj4xz8OwCGHHAKUseb9D+DII48ESlHHRBZmRIGEEEJoxaQpEGdBS/psg63KgNI+XE/RBYV64JaXqjxcTFN//iDjQj9j7Zaa1ipidttX2nLD/In20qOpnxs0VLtrrbUWUMbXX//6V6AsVIWiAPQAzTO58NLP0ns23gzld1ARNpvm2bLCz65zL5Z02q57EGguumw2mXTBZXiB+vpTeVh272Jhy3ZVxqqW448/vnPsb3/7W2BytgqOAgkhhNCKSVcgeli2iHBBFpQW2ptuuilQPEYXc7nQ0NYItXoZVO95JJoLtOYG4+3NmOl3v/vdcf52vYMerzmILbfcEihVfI7B2o7Go1UHbhPgdsqOXxesqmKg/C6qPZWzi8LMkegZ1gu89MYHKYfX3B6gSbabnj2OWdsK2bZd5eEYcrta8x7QfV+caKJAQgghtGLSq7CsQDFOV7fSNr5n1ZU1z9bgD9tGR+OBXri29e/LL78cGCyPt4nemms3Xv/61wPFu7M6qN7IR6/YcWnTTzcqU01YJWW1Vn2suRBfU10025XUtvffkxG3niw8p6bSaG7SNVIblGGkzom5RsnGsY5Z1YVK+Dvf+Q4wdfmkKJAQQgitmHRXXu/DtRy//vWvO6/pHW+33XZAiT/ryekN7rLLLgCccMIJnWNn13RsWNGWVgBZxeHzVmvVq1+bq6H73ZbmIrbddlugrEA3H6RnrHcHpTrQzaHMl+jhWX1ltVathlXX5lT0Fh3zTXv2u33nhOfn5kjawbGniht0O8wJr8m6qafrPFx/ZM7Saj0rB61InapIQhRICCGEVkxZMkFvt+6HY/8mY8h6imuuuSZQqmgOPPBAoHsVsL2wBimGPBZUFvvvvz8wayWMyq/uuTQonqAenat3rfRTkagu3Bq5Xntx/fXXA0VN6D071vzbPJ11+lA86mYvqOaGUiON0ZG2Fu53PKfm5mZGC+p1XMOMKqPuRWenA2104YUXAmWLC3Nxqt26G0VT+c5OAY8HUSAhhBBakQkkhBBCK6a8HraWVSbX3AdY6WXzO0MPhrJe85rXdI41qVS39QilHNCwjuGTX/7yl0D/h61GCv00d2W87bbbALj44ouB0p7Exol1KxPbuWsnQ3yGrvxsF7vWISy3G3AXyGYIa9iS6GIIWrRhHXYZRhyH++23H1BaOUEJoZ5xxhlAaaDq84Znta3FMlDKgU24u/e6xzZDWmMZh1EgIYQQWjHpCqS5MUq9iMvEr4l1yyxtZWLi3dJJk0/154ZubA+jfbSpHnW/09xvvP63zQtt1+7iSUtwLdn1EUq5ZHM8OfYs67X013Y79Wse20xivhiDqEY8J5tXite+izPrQppBXtgq3ue23357oBS6WOQBpUnnjBkzgGIzF8XusMMOQCn9VZFAUc8WFh1zzDEAXH311UBR1eNh6yiQEEIIrZh0BeLsa6uIbbbZpvOaXp6layoN8xrNdg/GtutjwwsYB61VGsBVV10FTG7DtYnEMTFSOwzVhE04zU2Ya2s2N6yPbZbiNhWccXw9Qyil0s2Nk4adZtmyLWb23ntvoJSoQndrmEHF3M+rXvUqoGykZ04EShmvSxY8xvcutdRSQLnOazWhDd0iXCXuPXI8VV5GegghhFZMWRWW8WK3qYVZF4CJM7WtTYxZ/+EPf+i8JwqkG+OrLuLS6/jqV786Zd9pIqlzCM3qEqtPfGxTfdLcDEl71q1gVCB6i8Oel/P8Xaip7bTl5ptvDnQvcm3+RoNIc4G0f9cKxHyIlX3arDmmjCTUyk1F51YNbsTnPXI8bRsFEkIIoRWTrkCc/Ywl1y2Mt9pqK6BUGOjdWcXhe93Mxzr++nPDCxx++OFA8VjMI9kKYRgYjzr32X2Wnl+tQPy3nmRzPUrzswYdz9N1NnvssQdQFJq5kGHLGakEzM1533O7aSi5taZtmopD27quC+CUU04ByjoQj0krkxBCCD3DlLdzv/TSSzuv2a7d2KBxQGdOqwq+/vWvA931+8Pi1c0JPRZzTNZ8u/Vq3TgwjB4riqzwqre0ndPammEbo17rp512GgBvf/vbgbKGxs4AVsUNC1ZFHXvssUBRCjvttFPnPa6PU63ZPPG8884DYPr06UDJb9RNUZsbl00kUSAhhBBaMWU5EFcDn3TSSZ3XjNc7E7sOxJXoP/rRj4DScjut22dFBeLGR64DGal9e5h7mrkP27vXvdd8zrE97FVYYpx+r732Akqs/4477gBg5syZnfcOg0ozB+I6tu9973tdj/1EFEgIIYRWZAIJIYTQimmjkYzTpk2bUH2p5G8umvE7TnbI6vnnnx/3GMRk2dDSQBdrudujpYOTFSoYbxtOtP3mhOWVLmqt90S3BY8l6uNRRtyPY7DXiA3HzuxsGAUSQgihFT2lQHqNfvZcXHRp08q7774bmPyWL4OmQCabfh6DvUJsOHaiQEIIIYwrUSAvQjyXsRMFMjYyBsdObDh2okBCCCGMK6NdSDgTuHUivkgPsvoEfW5sODZiv7ETG46d2JBRhrBCCCEESQgrhBBCKzKBhBBCaEUmkBBCCK3IBBJCCKEVmUBCCCG0IhNICCGEVmQCCSGE0IpMICGEEFqRCSSEEEIrMoGEEEJoxah6YaUD5diJDcdG7Dd2YsOxExu+QBRICCGEVmQCCSGE0IpMICGEEFqRCSSEEEIrMoGEEEJoRSaQEEIIrcgEEkIIoRWj3RM99DjTpr1Qrj3//PMDsMQSSwCwzDLLALDCCisAsOSSSwJw7733do594IEHAHjwwQe7Hp955hkAsv3xizPPPC9cTssuuywAG2+8MQALLrggAOeeey4AM2fOnIJv13u85CUv+K8vfelLO88999xzXY8Zcy/gdd1r9ogCCSGE0JDph8EAAB1JSURBVIoJVyDOnD7ON998ACy88MJA8UIAnn76aQCefPJJAP7xj39M9NcbCFQbAOuttx4A++67LwCvfvWrAVhzzTW73quHp62hKJCrrroKgG9/+9sA/OUvfwGKEhk06jHoOJ1bD9j3A6y//voAfO1rXwPKb/GrX/0KgDPOOGOcvnF/o80WWWQRAFZaaaXOa9r9lltuAQZ3zM2J5n3TR9Vac3zW43Sk5yaKKJAQQgitGHcF4ky5wAILALDFFlsAsP322wPwT//0TwAsvfTSL3yBecpXcFZ97LHHgOL5/vjHPwbgnHPOAYbXK2mijTfbbLPOc0cccQQA22yzDQCLLrooUH6Xxx9/HChqr/a+/U022GADADbddFMAZsyYAQye3bWJ+SCAhRZaCChqrFZoc2LVVVcFit20/eabbw6U8T2sONa08YYbbgjAJpts0nnPQw89BMCtt946yd9u6qnVbDNSs9xyywGw/PLLA7D44osD8MgjjwDw8MMPd47929/+BpRcm68Z0RlPZRIFEkIIoRXjrkCcOXfaaScAPvjBDwLFC9Mrm3feeWf7Gc6Uq6++OlDi+L/97W8BOPLII4HirUDvVSdMJHpy2nLrrbfuvLbKKqsAxXO2yuqmm27qenzqqaeA8rtA8ZxVImuttRZQ4q69WgnSFsfqtttu23luq622AuD4448H4K9//Sswe/XgZwB87GMfA0rFm3a65pprgGLzQcAxWCvY5muev39bjfbKV74SgMMOOwwo1znAl770JWC48p9eX3UuaI899gBgxx13BGC11VYDyjWpAnFcqjqgRBlUcX/6058AOO644wC4/fbbgfGxcRRICCGEVoy7Avn73/8OwJ133gkUT9h4nMpDb6yO3bnuQI9FT9g44D777AOU2fZzn/vcLMcOA9pHW9Ze8KWXXgrAHXfcAcD1118PlMqqJ554AoCllloKKN4yFE/cXIe5KD1JPaWJiKVOBdrgox/9aOe5xRZbDICzzjoLKApkdrjOBuAVr3gFUH6fZ599FoD//u//BvrfXjDrWhevzdoOXuv33XcfMGvVlXlR1Z65PCj5qGFQIF6/qo3Pf/7zndde9rKXAUVheO01H7WTvwOUcb3iiisCJce00UYbAfCtb30LKDnmWr2MliiQEEIIrRh3BeKMaKz9u9/9LlByIuuuuy4A559/PgBnnnlm59j7778fKGsWXvva1wIlB2KsdLfddgPg1FNP7Rx7+umnd/3/g4yerB7un//8585r2kHlp9Kz6krPxQqYXXfdtXOs1TGqlpNOOqnrM5o16f3qUfv9P/nJTwJFOUBRaOaX5kSdQ6q9QCgVMlax9SPN9QdrrLEGAG9729uAsvbliiuu6Bzzox/9CCjRCMeJivaGG24AivJw3EFRLf06tuYGlcc///M/AyWSYsQFyjjUHl7PPu/Y8vepKyTNNakSza3ssMMOQFGCX/ziFwG4+OKLO8d6T5lbokBCCCG0YsJWouvxGmdzJtUrueuuu4BSMQBlNjXOevbZZwPFG3QmNcZnNQcUJTMMCsS46KOPPgoUxQDFhtrM/Ijezc477wzAQQcdBJS1C1CqNt7//vcDcO211wLlNxsUrKnff//9geKxQfHktOnsPGHtvN9++3Wea1YkufK8n+3neXrNHXjggUCJDpjD/P3vf985xjU0zdXSKpDLLrsMKLmSOg/nNT+IOD6MqKg8PP96zdEvfvELoFSeeq1rQzFqU4+xZh881eIuu+wClJzIoYceCsBRRx3VOba+l8zVOY3q3SGEEML/JxNICCGEVkxYCEv5arLHxVTKuGZ5GpSkj6Epwysmzw1tmQRSVsNgJ92aeK6G6+rElwuMLAO09cF2220HlNJJn7fFOMB73/teoJQAD5pNHWtKd5PedQsJQ6t33303MHsbGCawoKPGMFhdltmvaDMXstk2x7FnqMUy8fq1JtrScIzh6zoBbEhmEPH+9o1vfAMooSuLVGzZBPCZz3wGKCGrZjPa5rVf27y56NWiBUvSDz74YKCU7depAN87t213okBCCCG0YsLbuTuT6WXo0VjKtvLKK3fe+7rXvQ4oSR49Fr1qF3k1my5Ctxc5bNRlkOussw5QFiepRFRx2u4nP/kJAEcffXTn2HpR5yDh2LA8/F3vehdQFG2t4H7+8593PdcsWfZvy1nrBXS+55577gFKS/J+RhtZcqtC8Ho+7bTTgLlbjNZsM25JqooX+rvgYHZoQ8vGHTva0ES5r0O5FpsKuNnQ1NdrxdA8xs/y/zEKsfvuuwPdhSDeF+aWKJAQQgitmPQtbY3VNZfkw6xtiC1FbTYOM2ZYt4KvP2fQ0QtWxdWluJbsWWbZbE/uoqFjjjkGKPHoQaRZgvrlL38ZKLFoqePuem82lrQlj96yuQ+bhNbqT1Qeg6CKPQdzl6ory/PrMvy5/SzblXg9m3caVGxwuueeewJFRXgt2oSzbsc0u9xb8/m5yVNqZ5WI43O0iwZHIgokhBBCKyZdgYizcB0nPuWUU4AyY7ux0QorrACUVsZWYdVtoJtNGgcZPTnj7y4OhLJYyIWDTXsYYx6prf5Ymqr1EipTPV3bhruAq7mtb70l8Hve8x4ADj/8cKAoZsep6njLLbcEuhcP6g06tlUnqpd+3FDK73zbbbcBcOWVVwLFxl6b9bm5IK6Zz9DOtihXOV9++eWd9xhJGKRciK1yHA8qDVu+2F59btTEWCojVRyOYX/DseTqokBCCCG0YsoUiNRVBdbeO0Mbs7M6yxlcL8VqAiiqZBhi+lbEWFVk5RUUj9jWMXqO2s6qrAMOOACAE088sXPsJZdcAvTn1rUjbQdqHsiqK+2mF6fiqhWIykzvTM/adRB6zaqb+v/1vdb3+x43Pms2F+yHdTaOBceTTVAdcyO1ZFdx2VDVtkYqZsee6qVuSOnn+P82bdSPjTw9P69N73PacrLaL3kPsM2749/rvg1RICGEEFox5QqkxpnYuL0VMM6QVjHoHVqdBXPffrsfaTaZ9LxVXcaloVTJGFc13um6EFcSWwO+9tprd461GsSuAf3k5dXfVXttvPHGQFEkxoD1kK3+qbdG9j1+nl6048s8ykhVf3p0burVzLH4dz/F95uVj82N4nxeZQvlfPV0/T3My9kFwfFcK9452aafxqTnba5WJWbT0smKljj+t9lmG6Bc865Mv+6661p/dhRICCGEVvSUAhG9DGdsY4WuPHdFet2G2zijs2o/Vrw0adbgWzHl367gVTFAsZHesMe4DsRjVST1ZkqufdAj6dfW+J67Lf5VXY4bn//f//1foOSJoKiT5spzjz3++OOBouBqVIL2OtJb18PuV3vCrJuYuXbGcXXBBRfMckxTMZsDsQpLJVJviOZv109KY3Z4Ds1KyOZ2wBOFysM8la34jVw4lusNz0Z734wCCSGE0IpMICGEEFrRkyEsabZ+t/xNCVYv4jJB9Mtf/hLoz1LUJs2yXctDfV571O0kmqWihgFdrOWujoZg6vJLX+t3DBXZqt7QkolvCwtMBM9NuMTQYDPJbsgL4Atf+ELX/9fPIas50dxSYKRz1VaOQcvz//CHPwAllGWhAgxG6LnJRRddBJSycq8zw8cu5BvLudfl5Ib23QPd4hiLG04//XSg/A7NXQ5HQxRICCGEVvS0AjEBbGLt3nvvBcoMXifRLSNUndSNyfqNZrNEyyHXX399oCywdLOu2vubUxO25kK4uhxVm/V7ArO5B7ePY1nAZ0LShLy/Ub2P9TnnnAMMtvJoQzMB30weO47r9w4SFgFZeOCi1He/+90AXH311UB3Oa1jaHb2aG4wZYt4gPe///0AvP71rwdKVMJFw7Zst+R/LOM1CiSEEEIrelKBOLs2cx/GtNddd12gO37vrG7r7kFSIM1taS2d1IOo4/B6G36GKs0mix/+8IeBokDqRmpnnXUWMDhx6PE8D0sv6w2koHsTrlqNhNljtGCkBqiDqEBuvvlmoGxW5jW49dZbA6Xs+/vf/37nGFu9u9jQPJJj2oaze+21FwCHHHJI51ibzqp43Cq32bxxPJRyFEgIIYRW9KQCaTa7s9WEsUJn45Ea6Lngy9h+P8ejPb/lllsOKFv9qrJsRjd9+vTOMXrENlrUQzEeaiWXtq29Hj2lMCvrrbceULxmx1W9HeugKLeJwqpJx6A29NodVFRYP/3pT4GyFYCVkNtvvz3QvahX9WC7nRtuuAEoFZcunN5www2B7oag119/PQDf+c53ADjhhBO6PnM8VV4USAghhFb0pAIRPRQ9OysNjN/XmyHZqM3Z3fYe/bjBlOfrWhZbbViFpjd80EEHAbDvvvt2jlV52fzPPFGzou3YY48F4Nvf/nbn2H5WaxOFKtDKP38bbaUqhsGM308E5pEck8bsYTAiB00cM7a2MQfyvve9D4C9994bKJEGKNEFow3mQZsVbbZuOvXUUzvH2qLHXMd4bF07O6JAQgghtKKnFYjYlM2qBTdGqVeiu/7D1a3HHXfcZH7FCUHP4cYbbwRKLNM4qCtbXScC3XkhKDkRW0h//etfB+A3v/kN0F3BFWaPnrGK1oorV/NCFMjcYixelaF3DSWWP4gVbZ6v1+InP/lJAL75zW8C5d4FRYF47/NeYAThwgsvBEqFqjat3zsZRIGEEEJoRV8oENcyGIduetlQPEMriYw79uMWmOI5uFLXdRpusPXd734XKBVXUCpcrN5QvbglqXbqR3tMBdrJVeYqW8dZrUAGKW4/kdgbyg2/7E0G5Xrt5+t2TjTzGFby2V4dZr3HNf/ulW2Ro0BCCCG0IhNICCGEVvRFCEuJa+nphz70IaDsNQwlueR759SMrJ9otmb30ZYm11577dR8sSHCcskjjzwSKCXWg7BtwGThNWkBh8nzevyOtNf8MNK8b/XqfSwKJIQQQiumjWZmmzZt2pROgy6Kc0FhnTw2sWw523i0lXj++ednzdaPkam24WQz3jaM/cbOVNuw2Yq8ThBPxJ7og2jDyWZ2NowCCSGE0Iq+UiCTTTyXsRMFMjYyBsdObDh2okBCCCGMK6OtwpoJ3DoRX6QHWX3Ob2lFbDg2Yr+xExuOndiQUYawQgghBEkIK4QQQisygYQQQmhFJpAQQgityAQSQgihFZlAQgghtCITSAghhFZkAgkhhNCKTCAhhBBakQkkhBBCKzKBhBBCaMWoemGlA+XYiQ3HRuw3dmLDsRMbvkAUSAghhFZkAgkhhNCKTCAhhBBakQkkhBBCK0a7oVQYMKZNK7mx7A0TQhgNUSAhhBBakQkkhBBCKxLCGnDmm28+AJZZZhkAtt56awA22mgjAO66667Oe6+88koAbr31ha2eH3zwQQD+8Y9/TM6XDQOJYdL5558fgGWXXRaAv/3tbwA88MADnfcO81jrx3ByFEgIIYRWTJkCqWdb6ZdZtx9QeWywwQYAHHHEEQBss802ACy88MJA8QIB/vKXvwDws5/9DIDf/e53wHB7hU0ctyON1eaYHvbxrD0WWmghAN70pjcB8MEPfhCAv//97wD84Ac/6Bzz4x//GIBnnnlm0r7nRKMdXvKSl3Q9vvSlLwVgkUUWAWCllVbqHKPNbrzxRqCotOeee24SvvHcEwUSQgihFROuQJx95513XqDMsqutthoAq666aue9zsiPPvooAA8//DAAt9xyCwD33HMPAE8//fQEf+v+Re/GnMchhxwCwO677w4Ub0ceeeSRzr+XXnppoHiGI6nEQaQ+zwUWWAAo43LFFVcE4BWveAUAm266KVDsW9vTcTlz5kwATjrpJADOOeccoHiRw6LotKtq9zWveQ0Aa621FgDzzPPC7UdlAnDyyScD3XmRfsexsthiiwGw4IILAuX8vWZf9apXdY4xUnD33XcD8LWvfQ0o+cleIQokhBBCKyZMgTirrrHGGgC8/e1vB4onvPbaawMl1lfz1FNPdT1aDXTuuecC8KUvfQnoriDqtdjgZFJ70EsssQQAH/7whwHYd999AVh88cW7jtG2zz77bOe5J598EijKr/n5gxbTV/Gus846nec+8pGPAPDqV78aKKpMZeK4lpFs4ljU9vfffz8An/70pwH4xS9+ARR7w2CqEsfNoosuCsCSSy4JFM9b6nyHv8kgoDpdb731gKLsHUMqVf+u72GOSSM1O+64I1DuefV1O5VEgYQQQmjFhCkQPbY3vOENALz1rW8Fysyqd1JXARn31DvW+zOGuMkmmwCw2267dX0mwBVXXAEMnpc8N5hfAnjd614HFO9Xr0+P5Yknnuj6u/Zk7rvvvq5HbTloCsTzUQX/9Kc/7by28cYbA902nVu0jx6llXDm/T772c8CJVcyffr0zrHm/QaJZv5TlaUC0SOv1Ze2G4Qx57V2wQUXAGX9i+ftuam6rrnmms6xM2bMAEou5BOf+AQA9957LwB/+MMfgKmPvESBhBBCaMW4K5Bm5YXVK8bynG2Ne1588cWdY7/xjW8AsMoqqwClasPV0+ZLVDFf+MIXOse++c1v7vrcYUBbq9AA9tprL6BUfDz++ONAqea48847gVJdVHswV199NVBi9tpyqr2c8UZ1/MUvfhEoqgNmVR56iXrJKrbHHnsM6K4INOat7R3r/k7mp1ZYYYWu5wcVz9/zXn755bueH2n8asOmCu5H/O6OGa/B5joQx1ytQM4//3yg5OK0keu5vG+aH54qokBCCCG0YtwViLOunq9erLOt8T/XdliZAmUltErjzDPPBODjH/84APvss88LX/r/x1CtyYfSZ2eYFIh2MDcERemZW9LOeixLLbUUAMsttxzQXW9vXNV4/KApDz1ex4119yPlOxzH2kLv8LbbbgPgvPPOA7pzePvttx8A2267LVDGvJ+lahmW9UyevxWAPvq848tcARSb9LPymB2eU1OZqG6tyoIyzlSzXuvm04zCXHTRRcDUXatRICGEEFqRCSSEEEIrJqyMV2l/ww03ALOGlkzY1tJLmaaktWTNcIEJJcMw9SLENmWX/Y7n7+JMKMk2wzUPPfRQ1zEmKQ35XXbZZZ3XbrrpJmAwF7VBGSOGrpptXWocl4YVDMlahOCCrvXXX79zjC3yLd8Vr4UTTzwRgNNPPx3oncVg402zeaDj1AWF4vlfddVVnedMCg9iCEscW9rJv+vrbs011wRmva9577MdjCFqiw5gcm0XBRJCCKEVE6ZAnAV//etfA6Vh2rrrrguUhNqWW27ZOcYyN2dTvT494+ZMXbc9cGae6rK2yaDZJrtuSGnSzVJVF2OqAH2vTRT/7//+r3OsCzgHFRWuCwjnpoy2WXprkteS1K222qrzXm3dbE1x+eWXA3DUUUcBvduae7xoJou1lU0Em4sEaxVcFyUMOs2FuvV48Po0GuO17n3zsMMOA4p6qxXIZBIFEkIIoRUTrkDcEOWEE04A4H3vex9QvMC99967c4xxZZsmWvKratFDNn5fe5CbbbZZ1/83yDFUMYZsHBSKKtNGxkot/9Mu5qbuuOOOzrGD6hGLKuyUU04B4PWvfz1QVAYUlaKd9JpVF3qAKj0fYVZFoxf5mc98BijqeNDtLI5Fy6bNgTTbGN18882dY4bhum3SXKwKJU92zDHHAGWh9MorrwyUMl7H5VRthxsFEkIIoRUTvqGUKuKHP/whUDy4d77znUC39+dCLOP0VmE566pQrJ6p20LrTf7qV7/q+n8HkeZizUsuuaTzWjNmai5ED8UW4lYT1S3FBx3HhArkoIMOAmDXXXftvMcKLRdkak/Vr212HIMj5VFUOv/+7/8OwBlnnAEMbnXb7LAi0FYxzVi/myPV8ftBb+/yYtTjw3vd0UcfDRSbvfe97wVKqyjH8IUXXtg5tl6YOdFEgYQQQmjFhCsQ0Vt2RrVthhulQGm8aGWLXp/H6i3rpRifhtJw0Rr8QVYgoqd77bXXdp6zBYIeigqkuX2m3k69ZmEQWmjPDY6r0047DYA//vGPnddUHsaYVRzGoK3Pb24sBcVL/POf/wzAd77zHWA4xmJNc6OuZv7NcavXXK9VGvSxN7doByv23NL2wAMPBIq6Uz1vt912nWPNn0yGLaNAQgghtGLSFIjofZx99tlAWWUOpcW4qsTmc7YX33PPPYESU629QHMpetTDENtvNumDUl3lugUrX5r19W6zqccNZdW17x10b9Dzq5saWsVnjsjqvoMPPhiYtUqrttH1118PlPzeoK40nxOunlaBqIKb1UYqNavVYHgq1OYWbWY+2AjO5z//eaDk4szdweTm3KJAQgghtGLSFUiTepZ0TcLJJ58MlJi8j3p0KpTtt9++c2xzpebDDz88kV+7J9AuI/V0UundfvvtQLGdKs/HnXbaqXOMHrTHDroCeTHcfvRf//VfgeJNS7PXG8C73vUuoLRrH1aMAqyxxhrArFWTjq+zzjoLGL7qtDaozNx++R3veAdQ1iG5dTjAf/zHfwCTs01yFEgIIYRWZAIJIYTQiikPYY1Ec6c2k+U2VTTBWWPrDkMPLlIaZJrlklB2GrRthm1ObDbZDGHVxxpqGIaGlDV1MYZluiYrbZVviNRQgqFBE+YAV155Zdd7hol6AaD/tolive0ClFJzk+fDHCodLYbmzznnHKBscVG31LH1kzu8TiRRICGEEFrRkwqkiR6dSSEXIdr6BIoCsW38ZMy+U43nXJfi+pwLkFRrJjZ93UWYdSsZE+3D4hHqKbsoC+ArX/kKALvssgswawNAE8AmM90YDYa3bLeJZbs28lQpN8t3B31P+InAMeY2DCrmeiHhv/3bvwFFHU+knaNAQgghtKIvFIioRM4///yuv6GUCNpU0Rbag+wVqipWX331znN6zNrG1/RUjJWqMupGdi5IHHQFYs5D5WbZI8Buu+0GlLi9720uOjz11FOB4doA6cWocyDm12wDI46v6dOnA8OZKxorjkMXYr/xjW8EyrgF2HnnnYFy7V933XUT9n2iQEIIIbSirxSIWMVhk0WYdetRG7gNcjWWXp+NE6FUW2kHK6t8j20mzJHoDcLktoGeCrSX2wOoUlWtMKvyEL1lG9VdeumlwOCrtTY01a62s1WOC1Zju/aYi3M74DrP4dg1j2f16kREY6JAQgghtKIvFYiespuuQFEgeuCHHnooAEceeSQwmPHWkZoB6vVpj3rTLSiVMH/605+A7maWg2ijGtXYe97zHgD22WcfoHudQlN5aC/XeLz73e8GigcYZsWxp+Kznb2tioah0elE47VvtalbFAAsueSSALz97W8HSoNQq1fHU/lFgYQQQmhFXyoQPWVjewAbbrghUGrObflupdIg1pyrxOo8hrmPTTbZBCi5Dz0UG1V+9atfBbpXnQ9qTNoxse222wKlPl61NtI2qnrNrllwzVG9+VEo1DbU3sbczbtZhZXKtfHDNu+1AnFc25XDykx/h/FUz1EgIYQQWtGXCkRP+cc//nHnOSsOXGFtpc3aa68NwIwZMybxG04OenJuzQrFY2620NZD0Qscpm1W9YjtUqBnNhLmPC655BIADjjgAKBUrYWRqVuyW6nmegTXhRx33HFAGYuDqngnExWx2ydDUdrmmm6++WagKBPH8njYPwokhBBCKzKBhBBCaEVfhrCkbmRnaMZwhTLNltGWZw5iqWotRZWtKZUs+Nu7kM0kouG9OvziLnmHHHII0N3qJcwdbiHgrnnNdjAJXY0fhqK//e1vd577r//6r67XJpIokBBCCK2YNhpvYNq0aT3lOliWBrDFFlsA8Ja3vAWA448/HoCLLroIaKc8nn/++VnrO8dIr9lwohlvG7axn0rDVvarrroqUDy0ekFqryV4MwbHTmw4dmZnwyiQEEIIrehrBTLRxHMZO72gQPqZjMGxExuOnSiQEEII48poq7BmAoPbH72b1ef8llbEhmMj9hs7seHYiQ0ZZQgrhBBCkISwQgghtCITSAghhFZkAgkhhNCKTCAhhBBakQkkhBBCKzKBhBBCaEUmkBBCCK3IBBJCCKEVmUBCCCG04v8BRrgNZ0I3JNsAAAAASUVORK5CYII=\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -324,10 +324,10 @@ } ], "source": [ - "n_samples = 16\n", + "n_samples = 20\n", "noise = np.random.randn(n_samples, n_latent).as_in_context(model_ctx)\n", "dec_output = net.decode(noise).reshape(-1, 28, 28).asnumpy()\n", - "plot_samples(dec_output, 4, 4)" + "plot_samples(dec_output, 4, 5)" ] } ], From 7a79dfca5cb04c6ef1ed58e0aed897d71b4970ed Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Fri, 24 Jul 2020 08:04:14 +0000 Subject: [PATCH 3/8] change format to md --- example/probability/VAE/README.md | 1 - example/probability/VAE/VAE.ipynb | 355 --------------------------- example/probability/VAE/VAE.md | 244 ++++++++++++++++++ example/probability/VAE/VAE_11_0.png | Bin 0 -> 9062 bytes example/probability/VAE/VAE_14_0.png | Bin 0 -> 15863 bytes 5 files changed, 244 insertions(+), 356 deletions(-) delete mode 100644 example/probability/VAE/README.md delete mode 100644 example/probability/VAE/VAE.ipynb create mode 100644 example/probability/VAE/VAE.md create mode 100644 example/probability/VAE/VAE_11_0.png create mode 100644 example/probability/VAE/VAE_14_0.png diff --git a/example/probability/VAE/README.md b/example/probability/VAE/README.md deleted file mode 100644 index 64d5efb86564..000000000000 --- a/example/probability/VAE/README.md +++ /dev/null @@ -1 +0,0 @@ -# Example of Variational Auto-encoder(VAE) implemented with MXNet's NumPy API and Gluon.probability diff --git a/example/probability/VAE/VAE.ipynb b/example/probability/VAE/VAE.ipynb deleted file mode 100644 index b67c1a2fe1d1..000000000000 --- a/example/probability/VAE/VAE.ipynb +++ /dev/null @@ -1,355 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# VAE with Gluon.probability \n", - "\n", - "In this notebook, we will demonstrate how you can implement a Variational Auto-encoder(VAE) with Gluon.probability and MXNet's latest NumPy API." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import mxnet as mx\n", - "from mxnet import autograd, gluon, np, npx\n", - "from mxnet.gluon import nn\n", - "import mxnet.gluon.probability as mgp\n", - "import matplotlib.pyplot as plt\n", - "\n", - "npx.set_np()\n", - "data_ctx = mx.cpu()\n", - "model_ctx = mx.gpu(0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Dataset\n", - "\n", - "We will use MNIST here for simplicity purpose." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def load_data(batch_size):\n", - " mnist_train = gluon.data.vision.MNIST(train=True)\n", - " mnist_test = gluon.data.vision.MNIST(train=False)\n", - " num_worker = 4\n", - " transformer = gluon.data.vision.transforms.ToTensor()\n", - " return (gluon.data.DataLoader(mnist_train.transform_first(transformer),\n", - " batch_size, shuffle=True,\n", - " num_workers=num_worker),\n", - " gluon.data.DataLoader(mnist_test.transform_first(transformer),\n", - " batch_size, shuffle=False,\n", - " num_workers=num_worker))\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Model definition" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "class VAE(gluon.HybridBlock):\n", - " def __init__(self, n_hidden=256, n_latent=2, n_layers=1, n_output=784, act_type='relu', **kwargs):\n", - " r\"\"\"\n", - " n_hidden : number of hidden units in each layer\n", - " n_latent : dimension of the latent space\n", - " n_layers : number of layers in the encoder and decoder network\n", - " n_output : dimension of the observed data\n", - " \"\"\"\n", - " self.soft_zero = 1e-10\n", - " self.n_latent = n_latent\n", - " self.output = None\n", - " self.mu = None\n", - " super(VAE, self).__init__(**kwargs)\n", - " self.encoder = nn.HybridSequential()\n", - " for _ in range(n_layers):\n", - " self.encoder.add(nn.Dense(n_hidden, activation=act_type))\n", - " self.encoder.add(nn.Dense(n_latent*2, activation=None))\n", - " self.decoder = nn.HybridSequential()\n", - " for _ in range(n_layers):\n", - " self.decoder.add(nn.Dense(n_hidden, activation=act_type))\n", - " self.decoder.add(nn.Dense(n_output, activation='sigmoid'))\n", - " \n", - " def encode(self, x):\n", - " r\"\"\"\n", - " Given a batch of x,\n", - " return the encoder's output\n", - " \"\"\"\n", - " h = self.encoder(x)\n", - " loc_scale = np.split(h, 2, 1)\n", - " loc = loc_scale[0]\n", - " log_variance = loc_scale[1]\n", - " scale = np.exp(0.5 * log_variance)\n", - " self.loc = loc\n", - " return mgp.Normal(loc, scale)\n", - " \n", - " def decode(self, z):\n", - " r\"\"\"\n", - " Given a batch of samples from z,\n", - " return the decoder's output\n", - " \"\"\"\n", - " return self.decoder(z)\n", - "\n", - " def forward(self, x):\n", - " r\"\"\"\n", - " Given a batch of data x,\n", - " return the negative of Evidence Lower-bound,\n", - " i.e. an objective to minimize.\n", - " \"\"\"\n", - " # prior p(z)\n", - " pz = mgp.Normal(0, 1)\n", - " \n", - " # posterior q(z|x)\n", - " qz_x = self.encode(x) \n", - " \n", - " # Sampling operation qz_x.sample() is automatically reparameterized.\n", - " z = qz_x.sample() \n", - "\n", - " # Reconstruction result\n", - " y = self.decode(z) \n", - " \n", - " # Gluon.probability can help you calculate the analytical kl-divergence\n", - " # between two distribution objects.\n", - " KL = mgp.kl_divergence(qz_x, pz).sum(1)\n", - " \n", - " # We assume p(x|z) ~ Bernoulli, therefore we compute the reconstruction\n", - " # loss with binary cross entropy.\n", - " logloss = np.sum(x * np.log(y + self.soft_zero) + (1 - x)\n", - " * np.log(1 - y + self.soft_zero), axis=1)\n", - " loss = -logloss + KL\n", - " return loss" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def train(net, n_epoch, print_period, train_iter, test_iter):\n", - " net.initialize(mx.init.Xavier(), ctx=model_ctx)\n", - " net.hybridize()\n", - " trainer = gluon.Trainer(net.collect_params(), 'adam',\n", - " {'learning_rate': .001})\n", - " training_loss = []\n", - " validation_loss = []\n", - " for epoch in range(n_epoch):\n", - " epoch_loss = 0\n", - " epoch_val_loss = 0\n", - "\n", - " n_batch_train = 0\n", - " for batch in train_iter:\n", - " n_batch_train += 1\n", - " data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28)\n", - " with autograd.record():\n", - " loss = net(data)\n", - " loss.backward()\n", - " trainer.step(data.shape[0])\n", - " epoch_loss += np.mean(loss)\n", - "\n", - " n_batch_val = 0\n", - " for batch in test_iter:\n", - " n_batch_val += 1\n", - " data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28)\n", - " loss = net(data)\n", - " epoch_val_loss += np.mean(loss)\n", - "\n", - " epoch_loss /= n_batch_train\n", - " epoch_val_loss /= n_batch_val\n", - "\n", - " training_loss.append(epoch_loss)\n", - " validation_loss.append(epoch_val_loss)\n", - "\n", - " if epoch % max(print_period, 1) == 0:\n", - " print('Epoch{}, Training loss {:.2f}, Validation loss {:.2f}'.format(\n", - " epoch, float(epoch_loss), float(epoch_val_loss)))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch0, Training loss 198.47, Validation loss 165.42\n", - "Epoch5, Training loss 121.50, Validation loss 120.12\n", - "Epoch10, Training loss 114.81, Validation loss 113.73\n", - "Epoch15, Training loss 111.33, Validation loss 110.75\n", - "Epoch20, Training loss 109.57, Validation loss 109.62\n", - "Epoch25, Training loss 108.31, Validation loss 108.14\n", - "Epoch30, Training loss 107.21, Validation loss 107.25\n", - "Epoch35, Training loss 106.17, Validation loss 106.22\n", - "Epoch40, Training loss 105.49, Validation loss 106.11\n", - "Epoch45, Training loss 104.90, Validation loss 105.22\n" - ] - } - ], - "source": [ - "n_hidden = 128\n", - "n_latent = 40\n", - "n_layers = 3\n", - "n_output = 784\n", - "batch_size = 128\n", - "model_prefix = 'vae_gluon_{}d{}l{}h.params'.format(\n", - " n_latent, n_layers, n_hidden)\n", - "net = VAE(n_hidden=n_hidden, n_latent=n_latent, n_layers=n_layers,\n", - " n_output=n_output)\n", - "net.hybridize()\n", - "n_epoch = 50\n", - "print_period = n_epoch // 10\n", - "train_set, test_set = load_data(batch_size)\n", - "train(net, n_epoch, print_period, train_set, test_set)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Reconstruction visualiztion\n", - "\n", - "To verify the effictiveness of our model, we first take a look at how well our model can reconstruct the data." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# Grab a batch from the test set\n", - "qz_x = None\n", - "for batch in test_set:\n", - " data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28)\n", - " qz_x = net.encode(data)\n", - " break" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "num_samples = 4\n", - "fig, axes = plt.subplots(nrows=num_samples, ncols=2, figsize=(4, 6), subplot_kw={'xticks': [], 'yticks': []})\n", - "axes[0, 0].set_title('Original image')\n", - "axes[0, 1].set_title('reconstruction')\n", - "for i in range(num_samples):\n", - " axes[i, 0].imshow(data[i].squeeze().reshape(28, 28).asnumpy(), cmap='gray')\n", - " axes[i, 1].imshow(net.decode(qz_x.sample())[i].reshape(28, 28).asnumpy(), cmap='gray')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Sample generation\n", - "\n", - "One of the most important difference between Variational Auto-encoder and Auto-encoder is VAE's capabilities of generating new samples.\n", - "\n", - "To achieve that, one simply needs to feed a random sample from $p(z) \\sim \\mathcal{N}(0,1)$ to the decoder network." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_samples(samples, h=5, w=10):\n", - " fig, axes = plt.subplots(nrows=h,\n", - " ncols=w,\n", - " figsize=(int(1.4 * w), int(1.4 * h)),\n", - " subplot_kw={'xticks': [], 'yticks': []})\n", - " for i, ax in enumerate(axes.flatten()):\n", - " ax.imshow(samples[i], cmap='gray')" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEhCAYAAABRKfYcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2dd9RkVZW3n1ZyzjlLDoJkyYKwjAQdQFERYVQcB5egY8IwJhiXacYwZlijjAgqOGqDLBFUMkhuouQcmhwFhe8PvqfOqdtv0/3eN1X4Pf9Uv1V1q+vuOvee/dt7n32mPf/884QQQgij5SVT/QVCCCH0J5lAQgghtCITSAghhFZkAgkhhNCKTCAhhBBaMc9o3jxt2rShKtl6/vnnp433Z8aGYyP2Gzux4diJDV8gCiSEEEIrMoGEEEJoRSaQEEIIrRhVDmSqeMlLXpjn5ptvPgCee+45AJ555pkp+04hhNCGadO60wm91A3Ee6332Dm+fyK/TAghhMGlpxWIimPrrbcGYLfddgNg0UUXBeC4447rvHfGjBkA/P3vf5/MrxhCCK3oJeUhc6s8JAokhBBCKzKBhBBCaEVPhrBM5Cy77LIAbL/99gC89a1vBeCvf/0r0C23Riu9QghhKhiP0JX3SBPyL33pSzuvGfr3uWeffRYoRUf/+Mc/xu97jPkTQgghDCU9qUCaqETuv/9+AC677DIAnnzyySn7Tr1Ks0RwTtReiMf2YnIvhGGkqTAWWWQRAFZffXUAVlllFQA22GCDzjHrrrsuAHfffTcAv//97wG46qqrAHjiiSeAkZWI/57be0AUSAghhFb0tAJx9r3lllsAuOeeewC4/vrrgTKTDivax3gowLzzzgvAPPPM0/We5qM5o1qxGDs1VvrUU08BpTS6X5SJ9lhooYUAWHzxxQFYcMEFAXj00UcBePDBB4HiiUH/nGMvo/0di9o3Jfajx+tziSWWAOC1r30tAPvttx8A66yzDgALL7xw5xjtf9NNNwFlvM+cOROA22+/vev/qPPHTQUyp9xyFEgIIYRW9KQCcdbVi9YjdgGhnmPtPRsjHORqrKZd9KhXXHHFznvWWmstoMRKF1hgAQBe9rKXdT2OhApEpXfuuecCcMEFFwBw3333ASMrkqlWKZ4nwAorrADAPvvsA8Auu+zS9d7bbrsNKLm0K6+8svOaceOHH34YgL/97W/ArOc30nkOcw6prgJabLHFAFhuueWAYg+v40ceeQQoOcxaATbx2Bd7zyCiPbXhv/zLvwDwzne+s+v5kVqPaGffs9lmmwElB/LAAw90va8+1ootH+dEFEgIIYRW9KQC0RNec801AVhppZW6nl966aUBuOOOOzrH6JXP7czZT+jZ6mUvv/zyQPGs9913385711hjDaDEn+eff/6uY/1bj3qk+nE9k1133RWASy65BIDzzjsPgJtvvhko3jrAddddBxSPfbLQNssss0znuR122AGA/fffHyjjx3PdZpttAHjLW94CdHu3Kg/jxNpCe915551AqWzRFlDG40MPPTTL5w46jisorYfe9KY3AbDkkksCZWw8/vjjANxwww1AyWkCPPbYY0D5XbWl8XxfHySV57l6/QFstNFGAHzmM58BYPfddwfKddzMZdZjrbnuw7HrsVa1qgDNkUDJe6aZYgghhAmlpxSIs6oxfWN3Sy21FFBi1c62tdcziLmPZs5DT27bbbcF4G1vexsA6623XucYvQxtpJdhxZp/+5m11+NzPuqpWGOuvVdddVUAzj///M6xN954IzB1CkTPtP636sDcmePIipWmNwfFxuaSmnkNvbu9994bKOcNJWf0k5/8pOv/H61X10+o6lR9AN/4xjeAEkFwzJlD8/dRCdZVQdpbO6sIf/SjHwHwl7/8BRiMrRy0nWPOMQVwxBFHAKXKymtSVBXa0gorKOvlVMuXX345UOzv7/H0008D3VEbx2jWgYQQQphQelKB6LlYYWAVkLHTkWbOQYw3z67iR9VgNYtx4vo5vRA9E22p920eqa7gcr2EHrM9x84++2ygeNT33nsvUDwcmDqPUI+p7kpwxhlnAMUuhxxyCAA77bQTUNaHeGydB2qul2lWuZhb0n4+Arz85S8HYI899gCKJ/7zn/8cKON3kHDMfPzjH+8850por08Vhrk0belYrdXjpptu2vUZ5tl87yBc5443r72DDjoIgHe/+92d91hJqPLQZip8r0UrCes8UnPdjTa0etXfZSRbjraTRRRICCGEVmQCCSGE0IqeDGEZQrEsUulv6MGyTBNsUBaHDSLKV8/3wgsvBEo4yuQYlFCSpXkmzw17ucBQWxsagGJnQ1eGgpTLvj7SosGpThDXbTL8noY+HUcHHnggUMpMLZV04VtNM8Gu3Dek1WwVA2V8rr322gC85z3vAeCKK64ASghnEEpQDcNY6m1hB5TfwnH0rW99CyhhFsOrhq7qIpDtttsOKHbWZrYz6ucQljazmMPy+3e84x1Adzi5GbrSVs1CDa/zuhjGsWvxiCF/x52/j/eKOvycHQlDCCFMCj2lQJwh9RidDV2Sr3eiAjEpBKXEdxAbtmkXE2gmxvXOVBVQko+2e9braTZZ1CtRzUBRGj5n8tP/d6pVxosxklfv91ad/uAHPwCKN2tbl7pEUlu6INMFbCaLN9lkE6CMyVq9WOas9+xvoNLx9xoEPO8DDjgA6L7uHEdf/vKXAZg+fTpQCh2aC9v0yKFc26pICxD6ceuGZkGGY8uSZ8vwXRhcF3NoI8/7nHPOAeCHP/whUBLjJtvrcei/vV5VJ47zZmuZsSjiKJAQQgit6CkF0ly05YzsQrYtt9wSKG0rbr311s6xp5xyCjD5C9kmg2Y5rzkiWW211Tr/3nnnnYFZywCNHZtHufrqq4Hu2Kn21vvxsZeVx9zgedgk8he/+AVQPOB6zDQbzGlzvTo38Fl55ZWB7sVfu+22GzCrR+lnDEKzxWapvQvd6rY2Lvr7zW9+A5Q4ffO8VWxuWQ3FS/d6njFjxojH9gP+/o4z1avlutrQ3Fmt4lQeRla0pc/7WV77dSsfaS4ctPmqCrlWPDLacvwokBBCCK3oKQWi96EHZzzUBVrGlEdaYOcsXy9KGjT0/sxnaJ96O0sXttXtzetj9T70qM2Z1K/ZomS0i4p6HVWY8XUr1ObGuzXfZtWazSOvueaaznusJjI/Inrg/a7koHitjo1rr70W6D43q62aW6b66Ph17NnSBIpCNl/Vzy1LVPfet/baay+gLJZUeWiX+t5l7s3WLao1G6iq/GyDUudBVTKOUZtW+v/4Wf5m9YLsZnRjTkSBhBBCaMWUK5Day7XyxTp6H51d9RidYZ3BoXg1g0RTNejR6OFaRVR7f24Wc9dddwElvu9n6GHo7dQ2VPnpMQ3y2hpoF1fXq/axruDaeOONgVlbpZh7GSRsImmlVa0UzIc4xprKy1i8myTVm5x95StfAYoH3o+5D3Ec2ELnjW98I1Cqzry+VcT19hSuofG6feUrXwkU1WakwXtCva2117ivmStWGXqvbLZHqb9TmimGEEKYUKZcgdTKQQ9uq622AmaN5bl2wVnYjeahv1eoNmkqDz02Ky2sADKWefHFF3eOPeGEE4CiHprbW+oxj5Q/EV9rVikNQgx/vPC3MVYPs3qWzU2RBoHmymhbhddjY3bbG2uPHXfcESg5gVrpus6hX3MfdUTFe5v3M7dHcOx4PzNqUCtVbbj++usDpWJL5eE9QUa6/7l2yRyyn28Dxmaj1TZEgYQQQmjFlCsQ6+qh9IZxtnWmNIZnBYg9XvTEoczm/cpIFU96GcaIrfnWCzFOXK9wtsV6c8tavSEfzXNoSyi/hT159KiNqVqtMdpNZwYRtxg1vg2z/obmCQYpB+JvPtJWqnPCyr///M//BIoaPuqoozrvqTdG6kdGuia85mbXi6pZHQVlQzPzwqqJ5meN9P95zXv/MKLgfURFbE7ZnnpQ8jFzuzV4FEgIIYRWZAIJIYTQiikLYSn3bZAIRWIZMnHRlsljk0GGrn772992jlWODQLaRslvEs6Et00O//jHPwKlZBfm3Lq5KYGVxlDKprW/5dMeM7eydpDRXieeeCIwcgLScfuBD3wAGKzFrW3CloZU3ve+9wElLOMiOQs/2n5+r+J1ZNsgiwcMVRnC8zqvi4J8j9des+1I0051KLG5i6atTJqLQJtbPEAJISaEFUIIYUKZMgXibFh7cM56lo3qEas4VCi2O7ApHgxWG3dtomfgedu+QK/kqquuAsoe5VC8i+a+x83NbNy3e8899+wca0LdskKTcM2mioPkJc4t2k/VW3ttovr71Kc+BZTNf4bRXjU29nz/+98PFDu5kLBfS3bnhAnp0047DSgluTY8bbYbqpc0+O+mmmjud95szQ7l2ndBp0U2tihyOwOv87pV/mjvo1EgIYQQWjHlZbx1fNjyMj1tWwE024z/7ne/A+DSSy+dtO850dQloM24us34LK9VkVnOW5fxWjpqK2c9E0v5Dj74YKB4QfVGNP4WNl9rtkMZRk/aOPVhhx0GlC0F/L1qj+3MM88EymK4YV946Tg2F2T+yOvXMv1BxbFhDuToo48GyhbHm222GVAW+XqNQlG4zc3kVAvaVrVR5yxs/OnGcOeddx5QcqfNZqL1vWe013gUSAghhFZMmQIxlle3w77//vuB4uXpHetNn3XWWQB8+tOfBvpzm8vZUc/82sbz1lPbfPPNgWIfWzvbaA2KV6GXoResalHFWIGhugE4+eSTATj22GOBEkMdRk/a+PThhx8OwBFHHAEURaJ3WbeROfDAA4HRt8QeVGzdYaWlW91+9rOfBQYrb/limPOxQeL3v/99oLRi9z6nvep/W5nleDQa4+I/x1q9ANP7hrlRr3GjEaoZP8t7BYy+JVQUSAghhFZMmQLR47YiAOBnP/sZUGZGZ+7p06cDZd2DM+wgxeRHUiDmJIxh+rfbqLoRT92KwMopq6308qzqsILN/Mb3vve9zrEnnXQSUKozBqlB5dyiMjvkkEOAEr83Jq0ac9y+613v6hzb7204xgttaL7Nsej1a05g2GhuaGYExfZDdTTGvIT3QpWvSsTreaTGlc12M36Wfzc3khrLNuBRICGEEFoxbTRe/LRp0ybU5W9u9t6cSSc7Fv/888+P+56ubWyoXfQ6jJ3a/NDmk1A8FVeyNlef6v01a8Fh1uZu48F423AixqAeM5RuB8cccwxQ1uBoRysFVSa//OUvO8dOxPjslTE4J0baWMvNpvSSrWSzym+y6BcbtqG59UP9XLO5Z/P5ZnPUF2N2NowCCSGE0IopXwdSM1VKo9dpbj1pe3CrLOpKoNl5Hc0VrcO8qly0ietpoFRdWZPve8w/fe1rXwNKxdqwj1XHl/2tAA499FCgxOtPOeUUoMT6w/jh9fti+cpmPqUZ2RkLUSAhhBBakQkkhBBCK3oqhBVGx0jhp9mFpIaxJHd2KOltrbHFFlt0XnPXR99jyaVNFP/nf/4HGJ5FcLND+9iAc6ONNuq8ZmjEslQXAGc7gKmhubXDeBIFEkIIoRVRIGHo0CNzIZcLU6GUmNoq//LLLwfKYlbb7Qw7JmRteOqiXyjFHS5anTFjBhAVPIhEgYQQQmhFTy0k7DUGeQHSZNHLCwlHWoTlv31tqjc76vUx2CwRBVh++eWBUnY+1S1eet2G/UAWEoYQQhhXRpsDmQncOhFfpAdZfYI+NzYcG+Nmv5EWYfVYnL7nx+BIFT49tmCw523YB8zWhqMKYYUQQgiSEFYIIYRWZAIJIYTQikwgIYQQWpEJJIQQQisygYQQQmhFJpAQQgityAQSQgihFZlAQgghtCITSAghhFaMqpVJGoiNndhwbMR+Yyc2HDux4QtEgYQQQmhFJpAQQgityAQSwlwwbdq0zt4XIYQXyAQSQgihFdkTPQw9IymL5s6ECy64IFB23nO3vWeffbZzjHuJZIuEMF44/po7Pzo+3Yflueee6xwzmeMvCiSEEEIrMoGEEEJoRU+HsJryzUflWy3VlHA+lzBCmBPNsADAvPPOC8BCCy0EwDLLLNN1jCGrxx9/HIDHHnus81pzDA47888/PwDrrLMOAOuttx4At976wk6wl156KdBz2whPGfPNN1/n32uuuSYA++yzDwCvfe1rAVh++eWBMj7vueceAE4++eTOsSeddBIAN998MwDPPPPMhH3nKJAQQgit6EkFYsLSWXjHHXcEYKWVVgJg0UUXBWCeecrXv+GGGwC44IILALj88ssBePrppyfhGw8Get96Qk8++SQw+B51nURffPHFAdhggw0AWH/99QFYZZVVgDLOrr/+egBuu+22zrEzZ84EypgbdLvNDq/LFVdcEYCPfvSjAOywww5A8Zrf9KY3AXD33XdP9lfsKbzfbb/99p3nPvKRjwCwySabALDIIosARdU5tpZeemmgKBOAddddF4CvfOUrAFxzzTVAd6J9vIgCCSGE0IqeUiDOrhtttBEAhx9+OADbbbcdUDxjZ9Knnnqqc+wjjzwCFG9SD9Fyy2H1BmeHXs+vf/3rznM77bQTAPfddx8AW2yxRdffg4o5NShjbLXVVgNg5513BmDJJZcEZs2JPPDAA51/P/zww0AZg8M+5rTlwgsvDBQbLrbYYkDxlIdVgWiXN7/5zQB84AMf6Lxm3kg1Zx7joYce6vrb61iFAvDqV78agBkzZgBw3XXXAVEgIYQQeogpVyALLLBA59/7778/AJ/+9KcBWHnllYFSpaHicCY1Xg2wxBJLALD22msDZWZWmQy7N6gn89a3vhWAb37zm0DxBqF4zsZV6xzTIFOfp7kOK4Yca3rJt99+O1DGYj1+VTLNKsFhG3tWtekl33nnnUCxizYzz/SnP/1psr/ilKJ9vL/tvvvuACy77LKd92g7K6l+85vfAHDllVcC5Rp9wxveAHTnT1TJu+66KwA/+MEPAHj00UfH+1SiQEIIIbRjylxM46N7771357kvfelLACy33HIAPPjggwBcdNFFQKm5tzJm1VVX7RyrSnGWdZb3cZC9wbqKSOVlfPmwww4DYI899gCKd2K+aaQ2HldffTVQqmUGFcdGXcGy1VZbASWmrC2uvfZaoIwvvWnr8aFUB1qF1Yw5D+LYGwnP2+tVG3r+VvuZ6xw2HHdei9qpvt7uvfdeAI499ligqDQrI80nacvNN9+8c6zXtvfYen3JeBMFEkIIoRWTrkCMN1vf/KEPfajzmlUJxvm++tWvAnDJJZcAJefxlre8BYBtttmmc6yrW//4xz8CxVPU62l62v3oDer1aidjnB/72Mc67zGu7Hs8Tz0XK4WMoerBQIm7uvp1Iqo2egHHwlJLLQWUdUZQqq/uuusuAM466yygeIceq51XX331zrFNG9vobpDG4Oyoz61ZJWn+qNmgUpU8bPi7W9143nnnASVXBHD++ecDJfpi5wOPNTqjuqhzcY47x+xEroWLAgkhhNCKSVcgVv2Y+9Djg1Kv/KlPfQqAs88+Gygejd6eM6urzqFUKfjcE0880XWs9KPXp2qzQujQQw8F4OCDDwaKJw3Fy/O8VWZHH300AGussQZQlF+tQO644w6gVBoNKqoz8x0vf/nLO69pA73CG2+8ESj2dHX1hhtuCJR8HZSV6DfddBMw+15ujsG6B1e/t4KvFYjnoCdsJaTn63t9fdjwt/Y+ZtSkzlXcf//9QLmPNceF99EDDjgAKGMaihKePn06EAUSQgihB8kEEkIIoRWTFsIytOJiGcMHtWy74oorgLJ4RqlnaaohHEvYzj333M6xJp1MNg1CArjZbtzyPMMm2qUOH5i4VBa7cNCWLoayTLrV0rhupTCIONY23nhjoLQpqcfgZZddBsAtt9wCFHtawGGLiT333BPoHmenn346MOu2Az76O3pMvYCxGc7x9+oXajs0Q3Xatw6XQnfSeJjQVoaa/K3rkGbz/qVNvW4/97nPASX8Wt8DLAA588wzgYltlx8FEkIIoRWTnkRvtgyvG9mZUH/FK14BlM17TFz6vJ5L3QJhkJSH6MHpoajMTjzxRKAkzlQmAJ/4xCeAsvBNe2hnG7fpsdQNKU855ZQJOIupx3N14VZzc55TTz21817btZu8dLyusMIKQGk78bKXvQwodoaSrNST9PdxUaK/gZ5nnfg0KWr5uQqoH3HcOvZc8Ftf61DG87CifXysVahjVpXq+Pj4xz8OwCGHHAKUseb9D+DII48ESlHHRBZmRIGEEEJoxaQpEGdBS/psg63KgNI+XE/RBYV64JaXqjxcTFN//iDjQj9j7Zaa1ipidttX2nLD/In20qOpnxs0VLtrrbUWUMbXX//6V6AsVIWiAPQAzTO58NLP0ns23gzld1ARNpvm2bLCz65zL5Z02q57EGguumw2mXTBZXiB+vpTeVh272Jhy3ZVxqqW448/vnPsb3/7W2BytgqOAgkhhNCKSVcgeli2iHBBFpQW2ptuuilQPEYXc7nQ0NYItXoZVO95JJoLtOYG4+3NmOl3v/vdcf52vYMerzmILbfcEihVfI7B2o7Go1UHbhPgdsqOXxesqmKg/C6qPZWzi8LMkegZ1gu89MYHKYfX3B6gSbabnj2OWdsK2bZd5eEYcrta8x7QfV+caKJAQgghtGLSq7CsQDFOV7fSNr5n1ZU1z9bgD9tGR+OBXri29e/LL78cGCyPt4nemms3Xv/61wPFu7M6qN7IR6/YcWnTTzcqU01YJWW1Vn2suRBfU10025XUtvffkxG3niw8p6bSaG7SNVIblGGkzom5RsnGsY5Z1YVK+Dvf+Q4wdfmkKJAQQgitmHRXXu/DtRy//vWvO6/pHW+33XZAiT/ryekN7rLLLgCccMIJnWNn13RsWNGWVgBZxeHzVmvVq1+bq6H73ZbmIrbddlugrEA3H6RnrHcHpTrQzaHMl+jhWX1ltVathlXX5lT0Fh3zTXv2u33nhOfn5kjawbGniht0O8wJr8m6qafrPFx/ZM7Saj0rB61InapIQhRICCGEVkxZMkFvt+6HY/8mY8h6imuuuSZQqmgOPPBAoHsVsL2wBimGPBZUFvvvvz8wayWMyq/uuTQonqAenat3rfRTkagu3Bq5Xntx/fXXA0VN6D071vzbPJ11+lA86mYvqOaGUiON0ZG2Fu53PKfm5mZGC+p1XMOMKqPuRWenA2104YUXAmWLC3Nxqt26G0VT+c5OAY8HUSAhhBBakQkkhBBCK6a8HraWVSbX3AdY6WXzO0MPhrJe85rXdI41qVS39QilHNCwjuGTX/7yl0D/h61GCv00d2W87bbbALj44ouB0p7Exol1KxPbuWsnQ3yGrvxsF7vWISy3G3AXyGYIa9iS6GIIWrRhHXYZRhyH++23H1BaOUEJoZ5xxhlAaaDq84Znta3FMlDKgU24u/e6xzZDWmMZh1EgIYQQWjHpCqS5MUq9iMvEr4l1yyxtZWLi3dJJk0/154ZubA+jfbSpHnW/09xvvP63zQtt1+7iSUtwLdn1EUq5ZHM8OfYs67X013Y79Wse20xivhiDqEY8J5tXite+izPrQppBXtgq3ue23357oBS6WOQBpUnnjBkzgGIzF8XusMMOQCn9VZFAUc8WFh1zzDEAXH311UBR1eNh6yiQEEIIrZh0BeLsa6uIbbbZpvOaXp6layoN8xrNdg/GtutjwwsYB61VGsBVV10FTG7DtYnEMTFSOwzVhE04zU2Ya2s2N6yPbZbiNhWccXw9Qyil0s2Nk4adZtmyLWb23ntvoJSoQndrmEHF3M+rXvUqoGykZ04EShmvSxY8xvcutdRSQLnOazWhDd0iXCXuPXI8VV5GegghhFZMWRWW8WK3qYVZF4CJM7WtTYxZ/+EPf+i8JwqkG+OrLuLS6/jqV786Zd9pIqlzCM3qEqtPfGxTfdLcDEl71q1gVCB6i8Oel/P8Xaip7bTl5ptvDnQvcm3+RoNIc4G0f9cKxHyIlX3arDmmjCTUyk1F51YNbsTnPXI8bRsFEkIIoRWTrkCc/Ywl1y2Mt9pqK6BUGOjdWcXhe93Mxzr++nPDCxx++OFA8VjMI9kKYRgYjzr32X2Wnl+tQPy3nmRzPUrzswYdz9N1NnvssQdQFJq5kGHLGakEzM1533O7aSi5taZtmopD27quC+CUU04ByjoQj0krkxBCCD3DlLdzv/TSSzuv2a7d2KBxQGdOqwq+/vWvA931+8Pi1c0JPRZzTNZ8u/Vq3TgwjB4riqzwqre0ndPammEbo17rp512GgBvf/vbgbKGxs4AVsUNC1ZFHXvssUBRCjvttFPnPa6PU63ZPPG8884DYPr06UDJb9RNUZsbl00kUSAhhBBaMWU5EFcDn3TSSZ3XjNc7E7sOxJXoP/rRj4DScjut22dFBeLGR64DGal9e5h7mrkP27vXvdd8zrE97FVYYpx+r732Akqs/4477gBg5syZnfcOg0ozB+I6tu9973tdj/1EFEgIIYRWZAIJIYTQimmjkYzTpk2bUH2p5G8umvE7TnbI6vnnnx/3GMRk2dDSQBdrudujpYOTFSoYbxtOtP3mhOWVLmqt90S3BY8l6uNRRtyPY7DXiA3HzuxsGAUSQgihFT2lQHqNfvZcXHRp08q7774bmPyWL4OmQCabfh6DvUJsOHaiQEIIIYwrUSAvQjyXsRMFMjYyBsdObDh2okBCCCGMK6NdSDgTuHUivkgPsvoEfW5sODZiv7ETG46d2JBRhrBCCCEESQgrhBBCKzKBhBBCaEUmkBBCCK3IBBJCCKEVmUBCCCG0IhNICCGEVmQCCSGE0IpMICGEEFqRCSSEEEIrMoGEEEJoxah6YaUD5diJDcdG7Dd2YsOxExu+QBRICCGEVmQCCSGE0IpMICGEEFqRCSSEEEIrMoGEEEJoRSaQEEIIrcgEEkIIoRWj3RM99DjTpr1Qrj3//PMDsMQSSwCwzDLLALDCCisAsOSSSwJw7733do594IEHAHjwwQe7Hp955hkAsv3xizPPPC9cTssuuywAG2+8MQALLrggAOeeey4AM2fOnIJv13u85CUv+K8vfelLO88999xzXY8Zcy/gdd1r9ogCCSGE0JDph8EAAB1JSURBVIoJVyDOnD7ON998ACy88MJA8UIAnn76aQCefPJJAP7xj39M9NcbCFQbAOuttx4A++67LwCvfvWrAVhzzTW73quHp62hKJCrrroKgG9/+9sA/OUvfwGKEhk06jHoOJ1bD9j3A6y//voAfO1rXwPKb/GrX/0KgDPOOGOcvnF/o80WWWQRAFZaaaXOa9r9lltuAQZ3zM2J5n3TR9Vac3zW43Sk5yaKKJAQQgitGHcF4ky5wAILALDFFlsAsP322wPwT//0TwAsvfTSL3yBecpXcFZ97LHHgOL5/vjHPwbgnHPOAYbXK2mijTfbbLPOc0cccQQA22yzDQCLLrooUH6Xxx9/HChqr/a+/U022GADADbddFMAZsyYAQye3bWJ+SCAhRZaCChqrFZoc2LVVVcFit20/eabbw6U8T2sONa08YYbbgjAJpts0nnPQw89BMCtt946yd9u6qnVbDNSs9xyywGw/PLLA7D44osD8MgjjwDw8MMPd47929/+BpRcm68Z0RlPZRIFEkIIoRXjrkCcOXfaaScAPvjBDwLFC9Mrm3feeWf7Gc6Uq6++OlDi+L/97W8BOPLII4HirUDvVSdMJHpy2nLrrbfuvLbKKqsAxXO2yuqmm27qenzqqaeA8rtA8ZxVImuttRZQ4q69WgnSFsfqtttu23luq622AuD4448H4K9//Sswe/XgZwB87GMfA0rFm3a65pprgGLzQcAxWCvY5muev39bjfbKV74SgMMOOwwo1znAl770JWC48p9eX3UuaI899gBgxx13BGC11VYDyjWpAnFcqjqgRBlUcX/6058AOO644wC4/fbbgfGxcRRICCGEVoy7Avn73/8OwJ133gkUT9h4nMpDb6yO3bnuQI9FT9g44D777AOU2fZzn/vcLMcOA9pHW9Ze8KWXXgrAHXfcAcD1118PlMqqJ554AoCllloKKN4yFE/cXIe5KD1JPaWJiKVOBdrgox/9aOe5xRZbDICzzjoLKApkdrjOBuAVr3gFUH6fZ599FoD//u//BvrfXjDrWhevzdoOXuv33XcfMGvVlXlR1Z65PCj5qGFQIF6/qo3Pf/7zndde9rKXAUVheO01H7WTvwOUcb3iiisCJce00UYbAfCtb30LKDnmWr2MliiQEEIIrRh3BeKMaKz9u9/9LlByIuuuuy4A559/PgBnnnlm59j7778fKGsWXvva1wIlB2KsdLfddgPg1FNP7Rx7+umnd/3/g4yerB7un//8585r2kHlp9Kz6krPxQqYXXfdtXOs1TGqlpNOOqnrM5o16f3qUfv9P/nJTwJFOUBRaOaX5kSdQ6q9QCgVMlax9SPN9QdrrLEGAG9729uAsvbliiuu6Bzzox/9CCjRCMeJivaGG24AivJw3EFRLf06tuYGlcc///M/AyWSYsQFyjjUHl7PPu/Y8vepKyTNNakSza3ssMMOQFGCX/ziFwG4+OKLO8d6T5lbokBCCCG0YsJWouvxGmdzJtUrueuuu4BSMQBlNjXOevbZZwPFG3QmNcZnNQcUJTMMCsS46KOPPgoUxQDFhtrM/Ijezc477wzAQQcdBJS1C1CqNt7//vcDcO211wLlNxsUrKnff//9geKxQfHktOnsPGHtvN9++3Wea1YkufK8n+3neXrNHXjggUCJDpjD/P3vf985xjU0zdXSKpDLLrsMKLmSOg/nNT+IOD6MqKg8PP96zdEvfvELoFSeeq1rQzFqU4+xZh881eIuu+wClJzIoYceCsBRRx3VOba+l8zVOY3q3SGEEML/JxNICCGEVkxYCEv5arLHxVTKuGZ5GpSkj6Epwysmzw1tmQRSVsNgJ92aeK6G6+rElwuMLAO09cF2220HlNJJn7fFOMB73/teoJQAD5pNHWtKd5PedQsJQ6t33303MHsbGCawoKPGMFhdltmvaDMXstk2x7FnqMUy8fq1JtrScIzh6zoBbEhmEPH+9o1vfAMooSuLVGzZBPCZz3wGKCGrZjPa5rVf27y56NWiBUvSDz74YKCU7depAN87t213okBCCCG0YsLbuTuT6WXo0VjKtvLKK3fe+7rXvQ4oSR49Fr1qF3k1my5Ctxc5bNRlkOussw5QFiepRFRx2u4nP/kJAEcffXTn2HpR5yDh2LA8/F3vehdQFG2t4H7+8593PdcsWfZvy1nrBXS+55577gFKS/J+RhtZcqtC8Ho+7bTTgLlbjNZsM25JqooX+rvgYHZoQ8vGHTva0ES5r0O5FpsKuNnQ1NdrxdA8xs/y/zEKsfvuuwPdhSDeF+aWKJAQQgitmPQtbY3VNZfkw6xtiC1FbTYOM2ZYt4KvP2fQ0QtWxdWluJbsWWbZbE/uoqFjjjkGKPHoQaRZgvrlL38ZKLFoqePuem82lrQlj96yuQ+bhNbqT1Qeg6CKPQdzl6ory/PrMvy5/SzblXg9m3caVGxwuueeewJFRXgt2oSzbsc0u9xb8/m5yVNqZ5WI43O0iwZHIgokhBBCKyZdgYizcB0nPuWUU4AyY7ux0QorrACUVsZWYdVtoJtNGgcZPTnj7y4OhLJYyIWDTXsYYx6prf5Ymqr1EipTPV3bhruAq7mtb70l8Hve8x4ADj/8cKAoZsep6njLLbcEuhcP6g06tlUnqpd+3FDK73zbbbcBcOWVVwLFxl6b9bm5IK6Zz9DOtihXOV9++eWd9xhJGKRciK1yHA8qDVu+2F59btTEWCojVRyOYX/DseTqokBCCCG0YsoUiNRVBdbeO0Mbs7M6yxlcL8VqAiiqZBhi+lbEWFVk5RUUj9jWMXqO2s6qrAMOOACAE088sXPsJZdcAvTn1rUjbQdqHsiqK+2mF6fiqhWIykzvTM/adRB6zaqb+v/1vdb3+x43Pms2F+yHdTaOBceTTVAdcyO1ZFdx2VDVtkYqZsee6qVuSOnn+P82bdSPjTw9P69N73PacrLaL3kPsM2749/rvg1RICGEEFox5QqkxpnYuL0VMM6QVjHoHVqdBXPffrsfaTaZ9LxVXcaloVTJGFc13um6EFcSWwO+9tprd461GsSuAf3k5dXfVXttvPHGQFEkxoD1kK3+qbdG9j1+nl6048s8ykhVf3p0burVzLH4dz/F95uVj82N4nxeZQvlfPV0/T3My9kFwfFcK9452aafxqTnba5WJWbT0smKljj+t9lmG6Bc865Mv+6661p/dhRICCGEVvSUAhG9DGdsY4WuPHdFet2G2zijs2o/Vrw0adbgWzHl367gVTFAsZHesMe4DsRjVST1ZkqufdAj6dfW+J67Lf5VXY4bn//f//1foOSJoKiT5spzjz3++OOBouBqVIL2OtJb18PuV3vCrJuYuXbGcXXBBRfMckxTMZsDsQpLJVJviOZv109KY3Z4Ds1KyOZ2wBOFysM8la34jVw4lusNz0Z734wCCSGE0IpMICGEEFrRkyEsabZ+t/xNCVYv4jJB9Mtf/hLoz1LUJs2yXctDfV571O0kmqWihgFdrOWujoZg6vJLX+t3DBXZqt7QkolvCwtMBM9NuMTQYDPJbsgL4Atf+ELX/9fPIas50dxSYKRz1VaOQcvz//CHPwAllGWhAgxG6LnJRRddBJSycq8zw8cu5BvLudfl5Ib23QPd4hiLG04//XSg/A7NXQ5HQxRICCGEVvS0AjEBbGLt3nvvBcoMXifRLSNUndSNyfqNZrNEyyHXX399oCywdLOu2vubUxO25kK4uhxVm/V7ArO5B7ePY1nAZ0LShLy/Ub2P9TnnnAMMtvJoQzMB30weO47r9w4SFgFZeOCi1He/+90AXH311UB3Oa1jaHb2aG4wZYt4gPe///0AvP71rwdKVMJFw7Zst+R/LOM1CiSEEEIrelKBOLs2cx/GtNddd12gO37vrG7r7kFSIM1taS2d1IOo4/B6G36GKs0mix/+8IeBokDqRmpnnXUWMDhx6PE8D0sv6w2koHsTrlqNhNljtGCkBqiDqEBuvvlmoGxW5jW49dZbA6Xs+/vf/37nGFu9u9jQPJJj2oaze+21FwCHHHJI51ibzqp43Cq32bxxPJRyFEgIIYRW9KQCaTa7s9WEsUJn45Ea6Lngy9h+P8ejPb/lllsOKFv9qrJsRjd9+vTOMXrENlrUQzEeaiWXtq29Hj2lMCvrrbceULxmx1W9HeugKLeJwqpJx6A29NodVFRYP/3pT4GyFYCVkNtvvz3QvahX9WC7nRtuuAEoFZcunN5www2B7oag119/PQDf+c53ADjhhBO6PnM8VV4USAghhFb0pAIRPRQ9OysNjN/XmyHZqM3Z3fYe/bjBlOfrWhZbbViFpjd80EEHAbDvvvt2jlV52fzPPFGzou3YY48F4Nvf/nbn2H5WaxOFKtDKP38bbaUqhsGM308E5pEck8bsYTAiB00cM7a2MQfyvve9D4C9994bKJEGKNEFow3mQZsVbbZuOvXUUzvH2qLHXMd4bF07O6JAQgghtKKnFYjYlM2qBTdGqVeiu/7D1a3HHXfcZH7FCUHP4cYbbwRKLNM4qCtbXScC3XkhKDkRW0h//etfB+A3v/kN0F3BFWaPnrGK1oorV/NCFMjcYixelaF3DSWWP4gVbZ6v1+InP/lJAL75zW8C5d4FRYF47/NeYAThwgsvBEqFqjat3zsZRIGEEEJoRV8oENcyGIduetlQPEMriYw79uMWmOI5uFLXdRpusPXd734XKBVXUCpcrN5QvbglqXbqR3tMBdrJVeYqW8dZrUAGKW4/kdgbyg2/7E0G5Xrt5+t2TjTzGFby2V4dZr3HNf/ulW2Ro0BCCCG0IhNICCGEVvRFCEuJa+nphz70IaDsNQwlueR759SMrJ9otmb30ZYm11577dR8sSHCcskjjzwSKCXWg7BtwGThNWkBh8nzevyOtNf8MNK8b/XqfSwKJIQQQiumjWZmmzZt2pROgy6Kc0FhnTw2sWw523i0lXj++ednzdaPkam24WQz3jaM/cbOVNuw2Yq8ThBPxJ7og2jDyWZ2NowCCSGE0Iq+UiCTTTyXsRMFMjYyBsdObDh2okBCCCGMK6OtwpoJ3DoRX6QHWX3Ob2lFbDg2Yr+xExuOndiQUYawQgghBEkIK4QQQisygYQQQmhFJpAQQgityAQSQgihFZlAQgghtCITSAghhFZkAgkhhNCKTCAhhBBakQkkhBBCKzKBhBBCaMWoemGlA+XYiQ3HRuw3dmLDsRMbvkAUSAghhFZkAgkhhNCKTCAhhBBakQkkhBBCK0a7oVQYMKZNK7mx7A0TQhgNUSAhhBBakQkkhBBCKxLCGnDmm28+AJZZZhkAtt56awA22mgjAO66667Oe6+88koAbr31ha2eH3zwQQD+8Y9/TM6XDQOJYdL5558fgGWXXRaAv/3tbwA88MADnfcO81jrx3ByFEgIIYRWTJkCqWdb6ZdZtx9QeWywwQYAHHHEEQBss802ACy88MJA8QIB/vKXvwDws5/9DIDf/e53wHB7hU0ctyON1eaYHvbxrD0WWmghAN70pjcB8MEPfhCAv//97wD84Ac/6Bzz4x//GIBnnnlm0r7nRKMdXvKSl3Q9vvSlLwVgkUUWAWCllVbqHKPNbrzxRqCotOeee24SvvHcEwUSQgihFROuQJx95513XqDMsqutthoAq666aue9zsiPPvooAA8//DAAt9xyCwD33HMPAE8//fQEf+v+Re/GnMchhxwCwO677w4Ub0ceeeSRzr+XXnppoHiGI6nEQaQ+zwUWWAAo43LFFVcE4BWveAUAm266KVDsW9vTcTlz5kwATjrpJADOOeccoHiRw6LotKtq9zWveQ0Aa621FgDzzPPC7UdlAnDyyScD3XmRfsexsthiiwGw4IILAuX8vWZf9apXdY4xUnD33XcD8LWvfQ0o+cleIQokhBBCKyZMgTirrrHGGgC8/e1vB4onvPbaawMl1lfz1FNPdT1aDXTuuecC8KUvfQnoriDqtdjgZFJ70EsssQQAH/7whwHYd999AVh88cW7jtG2zz77bOe5J598EijKr/n5gxbTV/Gus846nec+8pGPAPDqV78aKKpMZeK4lpFs4ljU9vfffz8An/70pwH4xS9+ARR7w2CqEsfNoosuCsCSSy4JFM9b6nyHv8kgoDpdb731gKLsHUMqVf+u72GOSSM1O+64I1DuefV1O5VEgYQQQmjFhCkQPbY3vOENALz1rW8Fysyqd1JXARn31DvW+zOGuMkmmwCw2267dX0mwBVXXAEMnpc8N5hfAnjd614HFO9Xr0+P5Yknnuj6u/Zk7rvvvq5HbTloCsTzUQX/9Kc/7by28cYbA902nVu0jx6llXDm/T772c8CJVcyffr0zrHm/QaJZv5TlaUC0SOv1Ze2G4Qx57V2wQUXAGX9i+ftuam6rrnmms6xM2bMAEou5BOf+AQA9957LwB/+MMfgKmPvESBhBBCaMW4K5Bm5YXVK8bynG2Ne1588cWdY7/xjW8AsMoqqwClasPV0+ZLVDFf+MIXOse++c1v7vrcYUBbq9AA9tprL6BUfDz++ONAqea48847gVJdVHswV199NVBi9tpyqr2c8UZ1/MUvfhEoqgNmVR56iXrJKrbHHnsM6K4INOat7R3r/k7mp1ZYYYWu5wcVz9/zXn755bueH2n8asOmCu5H/O6OGa/B5joQx1ytQM4//3yg5OK0keu5vG+aH54qokBCCCG0YtwViLOunq9erLOt8T/XdliZAmUltErjzDPPBODjH/84APvss88LX/r/x1CtyYfSZ2eYFIh2MDcERemZW9LOeixLLbUUAMsttxzQXW9vXNV4/KApDz1ex4119yPlOxzH2kLv8LbbbgPgvPPOA7pzePvttx8A2267LVDGvJ+lahmW9UyevxWAPvq848tcARSb9LPymB2eU1OZqG6tyoIyzlSzXuvm04zCXHTRRcDUXatRICGEEFqRCSSEEEIrJqyMV2l/ww03ALOGlkzY1tJLmaaktWTNcIEJJcMw9SLENmWX/Y7n7+JMKMk2wzUPPfRQ1zEmKQ35XXbZZZ3XbrrpJmAwF7VBGSOGrpptXWocl4YVDMlahOCCrvXXX79zjC3yLd8Vr4UTTzwRgNNPPx3oncVg402zeaDj1AWF4vlfddVVnedMCg9iCEscW9rJv+vrbs011wRmva9577MdjCFqiw5gcm0XBRJCCKEVE6ZAnAV//etfA6Vh2rrrrguUhNqWW27ZOcYyN2dTvT494+ZMXbc9cGae6rK2yaDZJrtuSGnSzVJVF2OqAH2vTRT/7//+r3OsCzgHFRWuCwjnpoy2WXprkteS1K222qrzXm3dbE1x+eWXA3DUUUcBvduae7xoJou1lU0Em4sEaxVcFyUMOs2FuvV48Po0GuO17n3zsMMOA4p6qxXIZBIFEkIIoRUTrkDcEOWEE04A4H3vex9QvMC99967c4xxZZsmWvKratFDNn5fe5CbbbZZ1/83yDFUMYZsHBSKKtNGxkot/9Mu5qbuuOOOzrGD6hGLKuyUU04B4PWvfz1QVAYUlaKd9JpVF3qAKj0fYVZFoxf5mc98BijqeNDtLI5Fy6bNgTTbGN18882dY4bhum3SXKwKJU92zDHHAGWh9MorrwyUMl7H5VRthxsFEkIIoRUTvqGUKuKHP/whUDy4d77znUC39+dCLOP0VmE566pQrJ6p20LrTf7qV7/q+n8HkeZizUsuuaTzWjNmai5ED8UW4lYT1S3FBx3HhArkoIMOAmDXXXftvMcKLRdkak/Vr212HIMj5VFUOv/+7/8OwBlnnAEMbnXb7LAi0FYxzVi/myPV8ftBb+/yYtTjw3vd0UcfDRSbvfe97wVKqyjH8IUXXtg5tl6YOdFEgYQQQmjFhCsQ0Vt2RrVthhulQGm8aGWLXp/H6i3rpRifhtJw0Rr8QVYgoqd77bXXdp6zBYIeigqkuX2m3k69ZmEQWmjPDY6r0047DYA//vGPnddUHsaYVRzGoK3Pb24sBcVL/POf/wzAd77zHWA4xmJNc6OuZv7NcavXXK9VGvSxN7doByv23NL2wAMPBIq6Uz1vt912nWPNn0yGLaNAQgghtGLSFIjofZx99tlAWWUOpcW4qsTmc7YX33PPPYESU629QHMpetTDENtvNumDUl3lugUrX5r19W6zqccNZdW17x10b9Dzq5saWsVnjsjqvoMPPhiYtUqrttH1118PlPzeoK40nxOunlaBqIKb1UYqNavVYHgq1OYWbWY+2AjO5z//eaDk4szdweTm3KJAQgghtGLSFUiTepZ0TcLJJ58MlJi8j3p0KpTtt9++c2xzpebDDz88kV+7J9AuI/V0UundfvvtQLGdKs/HnXbaqXOMHrTHDroCeTHcfvRf//VfgeJNS7PXG8C73vUuoLRrH1aMAqyxxhrArFWTjq+zzjoLGL7qtDaozNx++R3veAdQ1iG5dTjAf/zHfwCTs01yFEgIIYRWZAIJIYTQiikPYY1Ec6c2k+U2VTTBWWPrDkMPLlIaZJrlklB2GrRthm1ObDbZDGHVxxpqGIaGlDV1MYZluiYrbZVviNRQgqFBE+YAV155Zdd7hol6AaD/tolive0ClFJzk+fDHCodLYbmzznnHKBscVG31LH1kzu8TiRRICGEEFrRkwqkiR6dSSEXIdr6BIoCsW38ZMy+U43nXJfi+pwLkFRrJjZ93UWYdSsZE+3D4hHqKbsoC+ArX/kKALvssgswawNAE8AmM90YDYa3bLeJZbs28lQpN8t3B31P+InAMeY2DCrmeiHhv/3bvwFFHU+knaNAQgghtKIvFIioRM4///yuv6GUCNpU0Rbag+wVqipWX331znN6zNrG1/RUjJWqMupGdi5IHHQFYs5D5WbZI8Buu+0GlLi9720uOjz11FOB4doA6cWocyDm12wDI46v6dOnA8OZKxorjkMXYr/xjW8EyrgF2HnnnYFy7V933XUT9n2iQEIIIbSirxSIWMVhk0WYdetRG7gNcjWWXp+NE6FUW2kHK6t8j20mzJHoDcLktoGeCrSX2wOoUlWtMKvyEL1lG9VdeumlwOCrtTY01a62s1WOC1Zju/aYi3M74DrP4dg1j2f16kREY6JAQgghtKIvFYiespuuQFEgeuCHHnooAEceeSQwmPHWkZoB6vVpj3rTLSiVMH/605+A7maWg2ijGtXYe97zHgD22WcfoHudQlN5aC/XeLz73e8GigcYZsWxp+Kznb2tioah0elE47VvtalbFAAsueSSALz97W8HSoNQq1fHU/lFgYQQQmhFXyoQPWVjewAbbrghUGrObflupdIg1pyrxOo8hrmPTTbZBCi5Dz0UG1V+9atfBbpXnQ9qTNoxse222wKlPl61NtI2qnrNrllwzVG9+VEo1DbU3sbczbtZhZXKtfHDNu+1AnFc25XDykx/h/FUz1EgIYQQWtGXCkRP+cc//nHnOSsOXGFtpc3aa68NwIwZMybxG04OenJuzQrFY2620NZD0Qscpm1W9YjtUqBnNhLmPC655BIADjjgAKBUrYWRqVuyW6nmegTXhRx33HFAGYuDqngnExWx2ydDUdrmmm6++WagKBPH8njYPwokhBBCKzKBhBBCaEVfhrCkbmRnaMZwhTLNltGWZw5iqWotRZWtKZUs+Nu7kM0kouG9OvziLnmHHHII0N3qJcwdbiHgrnnNdjAJXY0fhqK//e1vd577r//6r67XJpIokBBCCK2YNhpvYNq0aT3lOliWBrDFFlsA8Ja3vAWA448/HoCLLroIaKc8nn/++VnrO8dIr9lwohlvG7axn0rDVvarrroqUDy0ekFqryV4MwbHTmw4dmZnwyiQEEIIrehrBTLRxHMZO72gQPqZjMGxExuOnSiQEEII48poq7BmAoPbH72b1ef8llbEhmMj9hs7seHYiQ0ZZQgrhBBCkISwQgghtCITSAghhFZkAgkhhNCKTCAhhBBakQkkhBBCKzKBhBBCaEUmkBBCCK3IBBJCCKEVmUBCCCG04v8BRrgNZ0I3JNsAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n_samples = 20\n", - "noise = np.random.randn(n_samples, n_latent).as_in_context(model_ctx)\n", - "dec_output = net.decode(noise).reshape(-1, 28, 28).asnumpy()\n", - "plot_samples(dec_output, 4, 5)" - ] - } - ], - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/example/probability/VAE/VAE.md b/example/probability/VAE/VAE.md new file mode 100644 index 000000000000..244213ca36a2 --- /dev/null +++ b/example/probability/VAE/VAE.md @@ -0,0 +1,244 @@ +# VAE with Gluon.probability + +In this notebook, we will demonstrate how you can implement a Variational Auto-encoder(VAE) with Gluon.probability and MXNet's latest NumPy API. + + +```{.python .input} +import numpy as np +import mxnet as mx +from mxnet import autograd, gluon, np, npx +from mxnet.gluon import nn +import mxnet.gluon.probability as mgp +import matplotlib.pyplot as plt + +npx.set_np() +data_ctx = mx.cpu() +model_ctx = mx.gpu(0) +``` + +## Dataset + +We will use MNIST here for simplicity purpose. + + +```{.python .input} +def load_data(batch_size): + mnist_train = gluon.data.vision.MNIST(train=True) + mnist_test = gluon.data.vision.MNIST(train=False) + num_worker = 4 + transformer = gluon.data.vision.transforms.ToTensor() + return (gluon.data.DataLoader(mnist_train.transform_first(transformer), + batch_size, shuffle=True, + num_workers=num_worker), + gluon.data.DataLoader(mnist_test.transform_first(transformer), + batch_size, shuffle=False, + num_workers=num_worker)) + +``` + +## Model definition + + +```{.python .input} +class VAE(gluon.HybridBlock): + def __init__(self, n_hidden=256, n_latent=2, n_layers=1, n_output=784, act_type='relu', **kwargs): + r""" + n_hidden : number of hidden units in each layer + n_latent : dimension of the latent space + n_layers : number of layers in the encoder and decoder network + n_output : dimension of the observed data + """ + self.soft_zero = 1e-10 + self.n_latent = n_latent + self.output = None + self.mu = None + super(VAE, self).__init__(**kwargs) + self.encoder = nn.HybridSequential() + for _ in range(n_layers): + self.encoder.add(nn.Dense(n_hidden, activation=act_type)) + self.encoder.add(nn.Dense(n_latent*2, activation=None)) + self.decoder = nn.HybridSequential() + for _ in range(n_layers): + self.decoder.add(nn.Dense(n_hidden, activation=act_type)) + self.decoder.add(nn.Dense(n_output, activation='sigmoid')) + + def encode(self, x): + r""" + Given a batch of x, + return the encoder's output + """ + h = self.encoder(x) + loc_scale = np.split(h, 2, 1) + loc = loc_scale[0] + log_variance = loc_scale[1] + scale = np.exp(0.5 * log_variance) + self.loc = loc + return mgp.Normal(loc, scale) + + def decode(self, z): + r""" + Given a batch of samples from z, + return the decoder's output + """ + return self.decoder(z) + + def forward(self, x): + r""" + Given a batch of data x, + return the negative of Evidence Lower-bound, + i.e. an objective to minimize. + """ + # prior p(z) + pz = mgp.Normal(0, 1) + + # posterior q(z|x) + qz_x = self.encode(x) + + # Sampling operation qz_x.sample() is automatically reparameterized. + z = qz_x.sample() + + # Reconstruction result + y = self.decode(z) + + # Gluon.probability can help you calculate the analytical kl-divergence + # between two distribution objects. + KL = mgp.kl_divergence(qz_x, pz).sum(1) + + # We assume p(x|z) ~ Bernoulli, therefore we compute the reconstruction + # loss with binary cross entropy. + logloss = np.sum(x * np.log(y + self.soft_zero) + (1 - x) + * np.log(1 - y + self.soft_zero), axis=1) + loss = -logloss + KL + return loss +``` + +## Training + + +```{.python .input} +def train(net, n_epoch, print_period, train_iter, test_iter): + net.initialize(mx.init.Xavier(), ctx=model_ctx) + net.hybridize() + trainer = gluon.Trainer(net.collect_params(), 'adam', + {'learning_rate': .001}) + training_loss = [] + validation_loss = [] + for epoch in range(n_epoch): + epoch_loss = 0 + epoch_val_loss = 0 + + n_batch_train = 0 + for batch in train_iter: + n_batch_train += 1 + data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28) + with autograd.record(): + loss = net(data) + loss.backward() + trainer.step(data.shape[0]) + epoch_loss += np.mean(loss) + + n_batch_val = 0 + for batch in test_iter: + n_batch_val += 1 + data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28) + loss = net(data) + epoch_val_loss += np.mean(loss) + + epoch_loss /= n_batch_train + epoch_val_loss /= n_batch_val + + training_loss.append(epoch_loss) + validation_loss.append(epoch_val_loss) + + if epoch % max(print_period, 1) == 0: + print('Epoch{}, Training loss {:.2f}, Validation loss {:.2f}'.format( + epoch, float(epoch_loss), float(epoch_val_loss))) +``` + + +```{.python .input} +n_hidden = 128 +n_latent = 40 +n_layers = 3 +n_output = 784 +batch_size = 128 +model_prefix = 'vae_gluon_{}d{}l{}h.params'.format( + n_latent, n_layers, n_hidden) +net = VAE(n_hidden=n_hidden, n_latent=n_latent, n_layers=n_layers, + n_output=n_output) +net.hybridize() +n_epoch = 50 +print_period = n_epoch // 10 +train_set, test_set = load_data(batch_size) +train(net, n_epoch, print_period, train_set, test_set) +``` + + Epoch0, Training loss 198.47, Validation loss 165.42 + Epoch5, Training loss 121.50, Validation loss 120.12 + Epoch10, Training loss 114.81, Validation loss 113.73 + Epoch15, Training loss 111.33, Validation loss 110.75 + Epoch20, Training loss 109.57, Validation loss 109.62 + Epoch25, Training loss 108.31, Validation loss 108.14 + Epoch30, Training loss 107.21, Validation loss 107.25 + Epoch35, Training loss 106.17, Validation loss 106.22 + Epoch40, Training loss 105.49, Validation loss 106.11 + Epoch45, Training loss 104.90, Validation loss 105.22 + + +## Reconstruction visualiztion + +To verify the effictiveness of our model, we first take a look at how well our model can reconstruct the data. + + +```{.python .input} +# Grab a batch from the test set +qz_x = None +for batch in test_set: + data = batch[0].as_in_context(model_ctx).reshape(-1, 28 * 28) + qz_x = net.encode(data) + break +``` + + +```{.python .input} +num_samples = 4 +fig, axes = plt.subplots(nrows=num_samples, ncols=2, figsize=(4, 6), subplot_kw={'xticks': [], 'yticks': []}) +axes[0, 0].set_title('Original image') +axes[0, 1].set_title('reconstruction') +for i in range(num_samples): + axes[i, 0].imshow(data[i].squeeze().reshape(28, 28).asnumpy(), cmap='gray') + axes[i, 1].imshow(net.decode(qz_x.sample())[i].reshape(28, 28).asnumpy(), cmap='gray') +``` + + +![png](./VAE_11_0.png) + + +## Sample generation + +One of the most important difference between Variational Auto-encoder and Auto-encoder is VAE's capabilities of generating new samples. + +To achieve that, one simply needs to feed a random sample from $p(z) \sim \mathcal{N}(0,1)$ to the decoder network. + + +```{.python .input} +def plot_samples(samples, h=5, w=10): + fig, axes = plt.subplots(nrows=h, + ncols=w, + figsize=(int(1.4 * w), int(1.4 * h)), + subplot_kw={'xticks': [], 'yticks': []}) + for i, ax in enumerate(axes.flatten()): + ax.imshow(samples[i], cmap='gray') +``` + + +```{.python .input} +n_samples = 20 +noise = np.random.randn(n_samples, n_latent).as_in_context(model_ctx) +dec_output = net.decode(noise).reshape(-1, 28, 28).asnumpy() +plot_samples(dec_output, 4, 5) +``` + + +![png](./VAE_14_0.png) + diff --git a/example/probability/VAE/VAE_11_0.png b/example/probability/VAE/VAE_11_0.png new file mode 100644 index 0000000000000000000000000000000000000000..455f09e27d3faef02de9fbc0fcc66132ec81c759 GIT binary patch literal 9062 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 literal 0 HcmV?d00001 diff --git a/example/probability/VAE/VAE_14_0.png b/example/probability/VAE/VAE_14_0.png new file mode 100644 index 0000000000000000000000000000000000000000..d26173bb56aebfd2bca129c3c88eab7d87eff338 GIT binary patch literal 15863 zcmd6Oby!qwyYCuONtKqeK%_&uQLsQlx>d-y9O9QiIEseU}zA8 zp^Xj{a$CE|Bu&&D6!&+`~KAvrt$OvCD~On001Z-J-n|40Fbxf$Mp*&;8!&7 zY_ou$h+s;Ov@d{vd@no?1^<81^`QX_0LZW4KOnth{)gZfCES(u-JiMGxO-W=um+$O z?ygQQ?oRfW*F3FX!0cU|MfipIMR>2-xx2ec2?+f6_xW93*a`#!LiYjS8t~}8qPF+v zKDY`E@C7)3J^St$+qDUfE1aTLf+NGa@f=OE?7c zUe*?V=$!tCC4q(b)hcz}x6bSlmtRNY;ySysC))Ko9=VGvQai~cy>grbm98u?N18er?ML~4=-GQsr#JZ;`Nu^;i}iJzr189)MYm=1060);~s(^ z@8Q0^*|BX2vAVgP0JmsU;vI&vDGbmXXaHC!oyzlqSZ*-yIR*U(SB<7W4 zo`mK-$_&JlRnt+6wO%ceOu*sMYCuXyAtQK$IgXj@uw0p2|GKw&NRjFv-kPNnz^VRd z8>rpNcOjlE3^?NH=BrfUK`C9Z;AV{Oj@@}kvo7E_|3tcwX@3W4o8m{$rTpMz7cJki ziiq5!0mp%YLpEC>A?yB1{fR%oU$Z0(B>S$ng3pe6TzcR2X`g8*dfW1az)OoS*@E;2 z&o2YIW_})ku7NcjAU0?o+$pqJP{R*+P56le^(RNGkgA28T)=xO>~`S0*wB;Y5rhKm z={Rqe5x8xmX5x&1DqJ!Gs5;(X3=;l8#WRfd=4z` zh7hr}K?X$EwRG9?-}Q&>^}ydwue#F3y?2JucD56xLpF&J4$}1oLTYzZq1-??A3N^; zf8MBv#uSDTh3MO7##Ser!RIp};5w6*LeIr^Eq4s5&kZeD3)CO3E3D=1jCoCTBCz^a zl&MWAxRik70;?mVX!w_XH`xy+USo8DPxz5Ufg7FD)PadEbxd62QVkwh6H?k}zmjgT zcHUA|9Fo;@5E6K_Gr`U^jfRccBtil2cB63ucSI#O^>ov)5@O5;m!y#G)I+b)GJTI) z_HH|lN-BznEC2QQ=2vk@(VzEE2&|oCj(4YlQP)OFg;sk4ne9OV{CRMw*c_|A%?K+M61CT;T=?XVuO%15p=7B3d-mgfMNcM7eDub(Wzy>>D48*ON5 zj*y>~*Au>SS`Ewo&WduZNGLMert_Y<^9Zz(coOP@U6rhkUVeibKeZkc_b;6sV3 zLG6q)bKxjCY&Soo9DZ3mVb9mYs%I@|`vDWXE#iS!6kR($-P_pFyf~nvIBX=Hdm&&m zgB|iWzW$JyF*2W}EXk@h+f+s6Ct!AT^Jc-3G#MA8(|buy9R#y>;#IJ)CA=mBBr>D^#ZoLEeSV z>*x1Re@%2A-eQ^^@?E`VjEfR4LvO&X$`D&o0?LEDae`4C}!KnC`ekVFYYu^IY_ApS3lU;>OhVv8vk1yC>daOa&sJ{TUAdQ*$;kKFY;z!P9 zLEo4gQm}C2?Q+Ek6_@9LO@+t;?oyms>Bq+P1Fza?Rs}B!BvW;-E=Gy6aHE>BrPy&T z^m+g~sXlrqT&1H)uB(#CW-5HXzQveCY4X0%E1f{-4pC;4*Cpl(dj=Xi&X%oC zZ90wj(G`e+MSC%WJ|0bsg635@+x1^3UO74~5kl|vR(EuhjweawfpBq0qxkCkT1M5^ zei1uyMu-nRr%8=$HALyp=It!Gr1q}uTqTlOC8Ux7=IT~h9+(}k$3s5K`AKPzu_lm@ zZ2n9$9?5w~erexrF~mkO#H#(hZTnvnMq>t;-Oa9p&#+F&l#<4IY$=V=IT+V zI=7=XY#cuob4_ubcE7nh#J$F4Gm%S56?~PWSGb@&&Zw<{&f;&MUyupzkq>bO+ej8l z-Y|fc_e-6OgIhnypdEO_n)m>@zmOZWGMK$RaIjV!AB!HH^clRh&QQNgtRXWA@3_m{ zVGlz|iT^e5nTZWrX*R1_u3#3-eK2oJp;X#zlZ_%DTc{A@-#@^(_!GuR_-)kcI5`_o zHb2>cCkt7%fK7|=_&7?WKX;~jxO>zfe@dH8MYk-o>%hSDz=Ma~o}Z;`FNX}NDz|b7WYbNmc>fO!b4qLkvxbzc-ivDHHqScn%W)|jCU*S;t z^RkF=IIGUbH4mP?*_Im737h@|%*{gNY(gg@k5gFw27L0U;7_V|e$*SsLKOX+oOo`2 zg3;Igxm}N?pmXf^gKW+Rj z<#fY7QzxIc+JZ6w^((z~{wHwQz67G$Q?@f)I&e}Sirmbz- zg0!`2{7+n@?YH^z9ifEEFUM9De&W$(f)_efJjkwpmT)HoU!=Yo2lcfnQak77R}k2| znL&DfHyC^~n^v!vC1%e}Ei1;umj?*P`K&cFcty$nen}IU&XzD@v>+56BY)YQZGMR=w&X+AjA3U&NMR^yT|=zMBZ$NZSl?tMK@G zH^i1WRMvE}DXnAnsO=%0I-IE`G=Fb^T_w70q*E?(y}CKDA8qv~hg~N`;aBArvNEJrv&B^w9;j4v z*3Q~sBXSH_iLLL6Z2ZUxo3(wjdE$dXoCu~*`rTJ{dODO0*H{;V)rflkt1jLlx45$d zeS1OKl1bRDC$81%gJMX5|G~(FXOvD9CBd*ttIL(nmz8Q%c)&-H`J7>Pv>JIQD7HnT z?Q41c%r7>P$`a4FJ*Kyly>AGEl^<%j+K z3#UAuk6eo&rO;veu_09$@sDpb*0gl_;jgD2T*b(UulcG85ekV$G71;3bH1bl0jSa^ zVd5z#eS~W#JnqfHv!P2aA zY`2=Bc?SAttZO}d2iJvVp+=CqBatU7UiE~Ny-x&^%2p+N`Z!WCRn?eX-a?&s2AxLn zYlcz|JhrklPxh$fcFj}06}MFG9@C4NIab_bQc)k4*s^%dN)p3Ie28+0UhWX-B5Jd& zvM}?Wmk?uke*AM0D}1EbTx>!0XD%a}q>Ub(2(4h!px=YPQPQl!VE$;659^j|;&`17 z=UZHHNnUIkFTP=H(zj5yW!Uq{SN%jF6sK3&Sa))K5HvM2&$_6V;xS+V`0oEoA=!r| zwhw7`9S*l_3_Kh0-M|D{vKvW{*inY-rNyT)j$M(LnQY8e1J%RxGLz%Jy!6s zcQ=2(W~XYn{D1{QtDNp-Q29>sZv$aaPh}IEw$qqJW~R}Y|8{8#F$s^$p5@1lV#TSQ z`V+s@GRqygZ>WU;qfay5cdt%Q$)gQXz^{W4q-LR8#^oF)`E~?xWF3e0*|G(nyl1-N z1~6$Wf54<+qhh-<|LYr}^;odT(zWJ4545h$-iox?uN=v$zN|hL-q3a@H-B?IZ=vWP z%wY?-7EztWx0BqjXyk~HWGl{$rVC5|d3!JLO1(H|{#Dp$-J;3r0?WuMRHB6(YFCFT zp4)PKYCdS^Y-dB%ynWB(ZcFXU9i`a9$4!eqUs_@@o+AEn0pjBCueOU#p05MwUDLxd z`(K=WGcL~CF?ent~Xjz*+gQTNzp7Y3XOqDy9YePI-K<&T9QUTZQ5Om6_U8EGOXW@`MUW&|9NSf zOUWDqb440*>)w%ZDbjXh&j!}VVC5+mdB#WYn2~CU=seEA+B?hIBV2QN7ape$`LJT> z@*8V&jLX6n?NhZ)3_h$PI^_M99nA!9P0@&PK@O^wv1MRmy;+SI1~#@*jr z2bOznHgcIvLrmmnulnxdDUXG7zob(^Km7e|=+&2y;#*#xT=UTU;%0gycT*Vl!Gu+7 zrW)-DF5sAyFAS~mJ*g~z1T~moR17Is1n4N|!Z}h%Gd`0O(8lC1fi@ENb zu@*5@zS&>|#lL+dh= z{$HH`d@TOO>3`D3FO)z#yL4jix*V-NP{T?&PcNoIUiAja69iWkI3t}X!Zb> zKr|a7Z^IBqK_$J>B`<$Qe?ely22_sk|9DyyZwkND4I8Udwy%IfvUsxc8K@>{I}b`nW;(O6L2MUxxHJ0yKEjw_s#HZ9#jx0 z0sVlZEr`B#tWKbCXF>fj9B>A~UT3k0Z6{INM`rgL3{_z}ou2XKz-a%?3}C6KkxF4L zVFJ${A{$JY z3|L5$0^|?>HYzX$H_FYH&49Fpf|i-TV$f1yE#|dOkX^iZ{T>GJog`$RtF;+_C~C_# zo%Wh-VSi*%{}sXC1-<&KflMMcfa{nC7IM0Q;h}f*u95Q=Dc~j!R_o<~l;h2B5PdvS z*2+wqa^(~?r7UW?@&qUXVI`rpjqWFk8u6^#8v~Vfbb&7Z8;J^QBx&BAEjo)Vzpgz? z`G%z831M-Bw^mO0OKY@P%KGaFW4OOtFe7x!=Q$?ue7!hAOr&e`oBWY|N&Qp|ICS;P zbq6Z|UVuv4v6JS>1}{1RxX#4t5zJimYh)e=+;QsKtu-svJb?V}cWMBy*q{%z(@&*0 zt2SfR=?ugw$_t0Yt5X1P<>(7QW_L0eFm~@zR>($H3fuJS=q!ZZ5mWm#wcMT||)%uiG!$C`u=tzz=Mq+izv!tpha59D)(sgVLG`^B|1 zZBoNm{gIN?Q-jPGyG9munBm8|2cH&M#8|vcBZjl<##c}~ra+YJwti~XU7nkm+xG1k z@rhbk9=2j<5boFNO>Z?=K{91t%Kdz^%nq))EIo zD~7(p@^Xz%Ay@OWzD0ZZ@X;LQ!j{8rtIzBQgJ`K$p@JoZjJhlX&#TC^h3^VsHP!nb zH*&<_5cChNCw#;)9x56+g)7yI{6MGFB5$hqYqs1Z@Fll8i`AG%=A7TQOfF@04vYQ@Sp?baBLd4t>v!l6gx3d)v*9Q&3y!e~*cjOr|yTa+|<>3+ehh_ki+Nbj2N z(Z_@C>0qtG!)$dwvcS?VIc6@lH{;17xw)Nb+IMzGY1CzUJn}X(u-_a?mFBwdQ4>#2 z22+!S-==JC2YHsw19rc=fMZ@UiAIcBzQRh?G*znhRZ8w0kquUXfW3CeW~NQ%DzzOTF#H@ddYt@beq|Te&S~ z)AyxQXEfmCNC6owihi}zgQu=sR#(HXB!jH=(&;>qww_hz5A;8T%cd-u8cEBYYNo<@ z0!zGAvTf~iuCqKD?3CRZ?JVX@QWc|ABB&a29$lAddkdp7aR8SN$4}H=IXy!46#9$Dr#{0F&PsRu=-p0J1`#ztR)$vqj?SAU5 zPHj#gWw+^eV98%KgqBqqy78H|t(RhZ2DW_(d&xWU%# zXZG3dtioCL<`(5C2tC!S>=moC?T;1h8knRWQF$;OWLj0Rwc0LF&%($XT^Tl>;3#f- zvX3Qft|^tu8vpsAaL~>Em%2FjGc|n<>vCPcJme*_XC`+?V*4s~CO%xQOy-sO_O;i} zxmQ$+ImY5kXBbkYwWT=9p#Rn5UFnHEDnXCEFJ}$U4L9mva-dxJL&ht=>i7Lzc+Lp`*Y0_bJGsS;%0ADjCmTR<|&A? zf3eN;BF&WQ#-w$`&;2&=10O3tL3dWj>xvc735v6p(_-S*& zaq#_|`3Mu=^BezUMfTaa2+%}zC1?4F?& z)9Z6~GEepeDfAc>+TK(c=F!dzwYHoZ>wWY=eG3=j>_na6SC-A@QU7byrS`ZILk`8R zOg(zy$~Uxi`7!c2Oh$5>cd>jE>nXkE$Tp&CS;rWhr6O}XQ7;@@7a_8!l%Qxj$UTm$ znD9rW(pKyLfn+|yMKXy5T8c0URPv`Pa^)Bv$$V$q3!v01!>;h)tO0K%E(=)%`QHn>1fqZlA zYw(E1 zfe!#>{tsICd=$xn<%_HwcHl|XW}F)X_ZVWV11)vD4{Ic6@!$Qeu%_Q}bBN4>kuh3o zXUH!u8SJNrmC4UxvX3`PNm#pnd59sFib*wS6OeB$+L^M6Ixs#Huo`H_k~m}gHRZBmz_AMtzuDUNJoOeL&-vlq1dh6=_8Q{5D7pXQR)fkl9DZ0n$LsvmPv zmL8@$;9IlhFeV`w$;K0&_cy1qEa}&9f(3Ji>EgE}&#M4fSx16OLRvZj-DXO1U1e7A zF%&e(K+O9LCtDExEPqI54K(ct&G$Fw6&59}x*i>X8~O3hUchEW4zmZ~5835VcM4 zIPWA%dId0_?f8_mLlyj3gmg-(V%2XIVG@0GZfu>K1NIs3B7c2VOVseo{^P=*uqOS~ z^XI}IE`@!EvFZ6xcdr72BXT4oGx!4?H=_&l)3T%4mou^a4*5IxD~Y2y7N#{-Mx(8Y zu%VRb&LtF;~C{Q8AJ-;J=Yqx6rWippyX&RLZnMZ!1!r9 ze+@4H;yob%PjCUy-sJ~C^7i>37c8Ro4~M{R;i&};%6g+PlV~QGz@*2Rgg!e;@(FX~vXHsD~T zMgS=E-^zvPgM_YTJoojt{4}n&xdqi^f%x?cfZ9s{B>W1~-36gJi6kTH!5zZ9`s01T z7cZE!xvb@y9gzi!bV^u#u5$~>z?`|;hW44Aj>AWBM$QltuMSMutlzH({f02#fobHhTqpgM8ZbTy_1HiqU~nd&eN8 zBALXSDIr)M`}8;BBTl8Aum>z|L;(0NN+5#2noGk!9#7u6916GVj?_S7oe&TkbAJZd zbbN$RB#)Jc?Oh9eMQ?b4%OOwK4rU2*BjWHea4myXDP~PJPhy~K4Ue-MI1`fI`DcZABY*F3=3CXj=dczy-MPLiV@7^%{k>&pJ0wG2m1I%J5<@J$j*H z#CgQ$)DD>3osK3w%`XTdwkB->-z6({P}55Ete#D947A)(Y!K4t8Ju-Yt`9JJv)!gw zcO|fqN}7TTE7=fVx5;5%wVq;X=D}}=_a)6wB?&waZxhWXa5K)4O1;md?G^y)qksg+ zR)8vSx`Nh<-Od0>WDUXI!NdtwLz36{MOyVi@6T=bT=JsEkShw&%Ibp>lX(9=W@sCh zaxlt^rXn1EU^HO*H#6RptO0Z!APrksGwPVO98g3j2+WK#B;y(vrd1y`evRakeI%P1 z7Ml5#cz7~{{m2f71lI~hU}>imITzV;&#F$6NxDLBVh#Tkd@dvKe&cm?5*(SF$F`Dka)<->hvLk)-qMA~UCm@4!CXK& zEU#ZEC+@>jsq96O1kw4U1yHTjODDrQMy(efu7@`N1kEt`nj zB>LD)yW~~}*LSjcZec{TuVC^|B_Yj!%nqj*Ab1=mjfSg#GCD`%KXlU<*RI;aIQw~! z;9Cc32?5q(qMh*VAzQ*`W_M1}7F$tLS`HBkvZg9fl$Rr;Z3db{hC2>J$1$DKs}v22 zq^v|S<>VSUV&f;rJA|&w6Q%eKCI zjzCFcdLN}!HcK=hCJszfV*u&|HCD&RULVFi$S>Z@#b!Dy~Ot zvh*ki1|QKxex*tVNvA&RxA-)V2L0{q``T{9E4StME&`w$;f@=GYvQi`9xReMG+Bi+ zXwX9QC;h>6f|o3o*I?VF-C&W}y$UO}}XTpT<0BD4#M^j7r2t9~3v_ZM%EOb({M$tKyanY=)fFSJKn0q9jSU*5(wy z82qyjHYX;oV!Q0=6}XF7Tp367cnOj^@#VmRx;9&IYPc*ZEIx;)ePdDh5P8Hq66-CS z=yg@w$+a4M4FY9lZ@%G|rOxQPHKRrwd&t&j4z{tO)3CA#k_R`=v|~<_pwLoR*4uJ3 zG0y^pt!j#U@L{AF-4s8} z76FaLe-_SHLK|&ppAPZBxb!{d(o(5*CS!qS2Li5~=Zu#7x=s2z&u8dpqX!3s;8DY! zIeB<-C=gVuieXC}@x}z3xPkJUP*MlBpE*3sUm3nl<t!cqxNU%7{cp zse`<3?OpqUNh6_|iGoQTA%)_1<3;EyswOL)TU$1d3;eoo&SM95lWX{nbxfj|Q%)vM zj?7a3gr#PEm~Dea%YrGbp!7)x?SHnVdX2D+D|(0@d5Is9o-J-3U>L6Bh3Ye*M8aaS zCmdQXp|dVn^~YA8-c*>!KW9A~XkN87%EadHzA=`FTcqq#K}?)GUuQ|oo)6b~?JN8% z57jQ}3QP$rZnm2pUzzLD>f^+en6%&XGez_*-%7|#4}qBE%@jn1m@lk9Fim;@lH6=p344O=x}Gc9Gpc3&1=g<{rP#i4^7pkoz!77e zMnIu5hip}5Fd>R5c~L0Ri01#p+>XS~{0Z3}BOIGzj9`8$f8?HeNQE(>dT{T2NXrO> zAWoLc87vR;j9*MJI6! zK~Rb$t&FxZXs}i4eOX(tiHhEm#C;~Ds93kVCjyyJWs{Ct+@ZQc4>9nbOz*=hRcDOb zOETZe&U4$&S33J>kdy6${_^My*?KS+ zO2uV#lvCoQBJQ`p*(n5X5;N?(C&cE!5nqvyVw24j*?1>vHL=l?toCJBR9LQ=sgkp(99 zI=ui1FkezF2Lt7T^SS&&a9NgCR+@)0asr!peJBevG`7ulRP{Xuw`fRj1l51_Rou5* zkrYz2T6X~ED}06yyJR#=)0YRWqKPL#4DE><^w)KydBxq`CLh2I&EyXG9yy^-H2aR_ zL(7td;0;nW7LkeyA<}iw$fgcFjR?LY;p!pIpqy1qq=QyCOKtT%lSU7xqm9wtPA1aQ zX9Y1Gj0q3MU~-7XRkHQcYmOWH^Feq!`rN}Z`_&_+1-i8wG&rwTW)7UgGN{%@BP&#OGA$AJvp^t#N zJ&X&%%s8=fkoW3_sX5W_(`4PN9I^ZfX{K|J(~Rp9R+#a%Gki!x<{nR2r1bVQ{l_WE zDlM$XRp+9uu~mNtE;>C8ZsWXh4OA6Jw&%hFgeviHtIjO95!xVMf#i;}{JTNsHp==X zHIfD>)R-Sr_;RvQ#r^kgL#`Yz*tMzc4SFFXlzoS%O!w|PBvNtA*E`3HgP zi_A;0tFYPWiQ~kYB9{Ani?9E9(F&S$SGYI^f{UOH&wq>BLteLTzz?I!u!n-ZwJuu= ze!OSf;_Dk5n?y0_aLm(S{&1M0MUsqIv6JM8cUi1A=$qJL2BP0(SNwi1GAnwqwWkP?NVg^pF&K;@^{YA9v`IZMWAKA7>^YI3t*6HI^^qmA? zacjB^IF(|=&N)5-1Qb)jJacKv5k=s{(TZ1tE8>+JOXbZs{j(q0w%77x=?(3!1E=ZW zzu&3-F9m{yZxuKM^N%2Fm}Wm=48&8I-a6d<3|7K$@3yGikjTo*CD zKEO5oqM1&Q=#=CEr*_1W(a0}1N!Y9^@KkF47SJh)V@dUX*O)$6mg}%1TIfRw;Q2AI z(XsJk`GGZo>w4>L!ZDwB{^;V8LCXk85ooCs%p9U@%(im$JfeiO@b)+1Uoh%U$+g#N zdi@;usRl{p78JK!1!_TxP8xo@7HB%_;(LXwt#EHInEsdES^>yl&z<&DZ<;Gd z)q1Kb?w!+=e&6=aM8LTnz1u9{51~agn&(_WW6~q|$r|22;lD`RWwhY?y1w;Vs+5Tf zYAY~(iS-`0&PlH#Js#wmhU`&+Vp{cP`0Rh}Zt6JUimh){*0-r3Yc! z>60Ef5DBR|b^5_ny@wxX0~iqiwUT%l@sDN%-eZfVq_nGgh3e5WVYid#_G`AEgVR-4 z@Bk`lN7l5VNqhpj*~_&RYc0%#V`520WzlSzv97a6atA|Q1RQ$8_$CAzU?gES$IoIj z33_f8_QzK+zZAlid*WmM)<+SzWn^}B0Y2+lEMn6EJm&vHld?+$;1ktAz-}XZV0Luv z`AbysytSEm)z8zi{u%lPVG53Il2!fM8yBDmuasmuH1_|ReWER7w)=xY3XQMDEBm7s z3P!ozz-cU0+ZP{)SIC~N0+aVaS|-{E!Bf-Qa(nni4(juoipL>1)|a_*2yJxO;9>Aq z?g}sjLNQlx;qGkyGV9{;)7fvj`WCMWaHMoy6C0)=9;E3N(o#UR2-yrx_Y^FBSe0ZuEQMoVombBt@yMUFwQjh>OabSrLp`&Oud^!0~0jT}d!y@_C`6lQJUx7sAa^Np@dDgk4X7g#a zQlHf6KH^tXduAT}I!QQHGHS~UPgsnGTk97WoiUo9pbEUerVr| z(b8eC$^rZe!NAt)$#Eepk6eP3j;?_G0`6;Mg#q00J@$QHe#LOkhADK+NzH9 zPxAo;HIjg+wd0H^k5wZ|j39EPGiKnRkixvG-tzvt4@UaRSNt~ck&AG6F5S=P=kg#} zH%Bkcyrg*wOoEa;yGCsTh-YeGk#5$BoQCVU4n6n8{LK(=!EB=e_C)-rkhV~W6ANuP z_b-)}$9yNh_-DU@GF((=aqzmO+p)+p0t^u!vGKDmSwllRnB18 zJJk^uyt|iqqm>!*~U{y5hHAhp3#QB zK6hbg>e6Dkr%prcGF4u68%YY4J2)lY=}lb=$;BLvyyWZ=rA4)4&ivaKPnO`DGn(2` zc=e8|fywqWgu>ZlWU1&zx2_OIzdrG1|Js3~%j&vi-*h8ltmgqcC2b;V2enH4IF}3k z_Z5Tbpk#&VN6DW5DtA1WdW<|(%Aq05nF{u`cGeN5Dd+{h#Z1POkY3lGtA~oZ*V4a% zC>!gUTuS^8TR3P6`h6XLin6h|WN6n#8I_Aqzy`{LVtEo)o2})e4ogdFewT|gFLCpe zL-4o;MFThptmYCemTIt!0-IxuTQ1hPQ0MAqv3R8&DbMz3?>2adh$y`JnJnHgPO`$J zsD|*J!7|HU+R!<_&wkrO3I^6xnax!>O|!5Hh6z}gY|xcw`6vb09e7{kr4bjg`Cu)R znQCGlvxKcJ=hAF6rFDP#DyzFo_eO5wRl{c6sGkdU!PIh$AIl%-R`i@IsE6aJ1$R?u z3X*k$vi?czSK$`T?Kk)4?wh5D+QM`+Z4)9hr+ENDvYNhy}Op=NxGKefz}T{n^-4{V|hc{(4W3h|mPW8FfTSXRfV z{~qhAH>t+Jb)<(xL%<K-+}*45_; zGw(G#ua-eWpiiB|hA1rh(N`T9LqcLiJ%mE6t2ud~u`Z!~8vmpz(#!&SrasnKL`WDM zl6q1RW{FxRh|z+5z%{aPv+{+^cHyCelbdE`U-8xl>Ds5~&Rfq1vM*t5Nsq2GTp!*i z3MVLr9zO4=d-eur96z=Hnf$G`Bd3_(nDR#t9wwUQ#;MB-cWSuECwa{F$N(_OMK0(_ zs6f-eDKf@L8B*y~8D?E0wyu3gyxoh`PklG6L1`8fYeWRhAV1R@2 z$DfLzWU{jO5yC7joqWOE^-Cyg=6)0KL|nsUZn@aq{(_29ohWi$tD5bP5isdVsjlCH zqS3Zn3-|9^o!>`*E;P9$u|Prd8hr9K8=MOO;omL6k81<(5+Dm(_R;WPd|a`Dc&{OF z#U?J;F5_zd;HiEF%FXPlh$N+FK6V0F@7ja0Rg!R0Mw{m1Z&Rg7sQmDdw4V9<)8#JZ z*+#SgFY?d(Gx+v6SR+>t{cKP9?8vDZ_a#|tD+B;C+v^$*ozOk!%-(AQpL3fQWI~Y9 zYGOk~Tu5qJT4o*47BeHR)=Q#xP#qR31_KHNnR2G(V!dKHa7=-LD@GHwr^(eP);HcV zim5Sp728(6)+n}G4%#Inv5jr20k7AzyUx03PdwRu^*yxwu^Ud3hsxLjnu!^9ETn7z z^8uV|%ulJ{FPt%C%~sA8-2?Y}$XUKZb+UZZXbOcB93-nVJ!ibrnW(;S{nI8_(8Xwd84gYsuk_B@ko7E<)Z`MIrK zi|Z?4Ok7W#EtO@q1D|qi{+(Ff-I1ENm|N+;QBsFf{66@DYu#fD938CA*Cz{nFrI=J zP2RAFq~pyhujGTmll{U1Ea&_4)PmSm7xUpVd)XN&{Wy|SBk%8Nh7SxEu?2#z+y%RD zGRXnQdj^Zr=!b$DuT-f literal 0 HcmV?d00001 From 2b8bc638922fc1a7e7657d303f37efaf373674dd Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Fri, 24 Jul 2020 08:18:17 +0000 Subject: [PATCH 4/8] minor changes --- .../convolutional_autoencoder.ipynb | 43 ++++--------------- example/probability/VAE/VAE.md | 11 ----- 2 files changed, 9 insertions(+), 45 deletions(-) diff --git a/example/autoencoder/convolutional_autoencoder.ipynb b/example/autoencoder/convolutional_autoencoder.ipynb index a08131300286..a49eba0fcc10 100644 --- a/example/autoencoder/convolutional_autoencoder.ipynb +++ b/example/autoencoder/convolutional_autoencoder.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -55,20 +55,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/train-images-idx3-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/train-images-idx3-ubyte.gz...\n", - "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/train-labels-idx1-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/train-labels-idx1-ubyte.gz...\n", - "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/t10k-images-idx3-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/t10k-images-idx3-ubyte.gz...\n", - "Downloading /home/ubuntu/.mxnet/datasets/fashion-mnist/t10k-labels-idx1-ubyte.gz from https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/gluon/dataset/fashion-mnist/t10k-labels-idx1-ubyte.gz...\n" - ] - } - ], + "outputs": [], "source": [ "transform = lambda x,y: (x.transpose((2,0,1)).astype('float32')/255., y)\n", "\n", @@ -84,19 +73,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -117,21 +104,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "__init__() got an unexpected keyword argument 'prefix'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnet\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgluon\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHybridSequential\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprefix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'autoencoder_'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mnet\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Encoder 1x28x28 -> 32x1x1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mencoder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgluon\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHybridSequential\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprefix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'encoder_'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mencoder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: __init__() got an unexpected keyword argument 'prefix'" - ] - } - ], + "outputs": [], "source": [ "net = gluon.nn.HybridSequential(prefix='autoencoder_')\n", "with net.name_scope():\n", @@ -560,7 +535,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.6.4" } }, "nbformat": 4, diff --git a/example/probability/VAE/VAE.md b/example/probability/VAE/VAE.md index 244213ca36a2..e866464dc9c4 100644 --- a/example/probability/VAE/VAE.md +++ b/example/probability/VAE/VAE.md @@ -173,17 +173,6 @@ train_set, test_set = load_data(batch_size) train(net, n_epoch, print_period, train_set, test_set) ``` - Epoch0, Training loss 198.47, Validation loss 165.42 - Epoch5, Training loss 121.50, Validation loss 120.12 - Epoch10, Training loss 114.81, Validation loss 113.73 - Epoch15, Training loss 111.33, Validation loss 110.75 - Epoch20, Training loss 109.57, Validation loss 109.62 - Epoch25, Training loss 108.31, Validation loss 108.14 - Epoch30, Training loss 107.21, Validation loss 107.25 - Epoch35, Training loss 106.17, Validation loss 106.22 - Epoch40, Training loss 105.49, Validation loss 106.11 - Epoch45, Training loss 104.90, Validation loss 105.22 - ## Reconstruction visualiztion From 0607a3564ff766370c753418d049bea8e564bce4 Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Fri, 24 Jul 2020 08:31:28 +0000 Subject: [PATCH 5/8] add liscence --- example/probability/VAE/VAE.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/example/probability/VAE/VAE.md b/example/probability/VAE/VAE.md index e866464dc9c4..a6365a780e87 100644 --- a/example/probability/VAE/VAE.md +++ b/example/probability/VAE/VAE.md @@ -1,3 +1,21 @@ + + + + + + + + + + + + + + + + + + # VAE with Gluon.probability In this notebook, we will demonstrate how you can implement a Variational Auto-encoder(VAE) with Gluon.probability and MXNet's latest NumPy API. From 4a98f2e69568bb7dd015e6c3c2e77b86e76867fb Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Wed, 29 Jul 2020 08:53:31 +0800 Subject: [PATCH 6/8] Update VAE.md --- example/probability/VAE/VAE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/probability/VAE/VAE.md b/example/probability/VAE/VAE.md index a6365a780e87..fcd046f40bf7 100644 --- a/example/probability/VAE/VAE.md +++ b/example/probability/VAE/VAE.md @@ -18,7 +18,7 @@ # VAE with Gluon.probability -In this notebook, we will demonstrate how you can implement a Variational Auto-encoder(VAE) with Gluon.probability and MXNet's latest NumPy API. +In this example, we will demonstrate how you can implement a Variational Auto-encoder(VAE) with Gluon.probability and MXNet's latest NumPy API. ```{.python .input} From 04f052b640f74b721208629fbb1b19a66e8b34ea Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Mon, 10 Aug 2020 06:00:29 +0000 Subject: [PATCH 7/8] update vae demo --- example/probability/VAE/VAE.md | 16 ++++++++++++---- example/probability/VAE/VAE_files/VAE_11_0.png | Bin 0 -> 9062 bytes example/probability/VAE/VAE_files/VAE_14_0.png | Bin 0 -> 15863 bytes 3 files changed, 12 insertions(+), 4 deletions(-) create mode 100644 example/probability/VAE/VAE_files/VAE_11_0.png create mode 100644 example/probability/VAE/VAE_files/VAE_14_0.png diff --git a/example/probability/VAE/VAE.md b/example/probability/VAE/VAE.md index a6365a780e87..2d3b1ca3f124 100644 --- a/example/probability/VAE/VAE.md +++ b/example/probability/VAE/VAE.md @@ -29,8 +29,10 @@ from mxnet.gluon import nn import mxnet.gluon.probability as mgp import matplotlib.pyplot as plt +# Switch numpy-compatible semantics on. npx.set_np() -data_ctx = mx.cpu() + +# Set context for model context, here we choose to use GPU. model_ctx = mx.gpu(0) ``` @@ -85,12 +87,18 @@ class VAE(gluon.HybridBlock): Given a batch of x, return the encoder's output """ + # [loc_1, ..., loc_n, log(scale_1), ..., log(scale_n)] h = self.encoder(x) + + # Extract loc and log_scale from the encoder output. loc_scale = np.split(h, 2, 1) loc = loc_scale[0] - log_variance = loc_scale[1] - scale = np.exp(0.5 * log_variance) - self.loc = loc + log_scale = loc_scale[1] + + # Convert log_scale back to scale. + scale = np.exp(log_scale) + + # Return a Normal object. return mgp.Normal(loc, scale) def decode(self, z): diff --git a/example/probability/VAE/VAE_files/VAE_11_0.png b/example/probability/VAE/VAE_files/VAE_11_0.png new file mode 100644 index 0000000000000000000000000000000000000000..455f09e27d3faef02de9fbc0fcc66132ec81c759 GIT binary patch literal 9062 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 literal 0 HcmV?d00001 diff --git a/example/probability/VAE/VAE_files/VAE_14_0.png b/example/probability/VAE/VAE_files/VAE_14_0.png new file mode 100644 index 0000000000000000000000000000000000000000..d26173bb56aebfd2bca129c3c88eab7d87eff338 GIT binary patch literal 15863 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%0ADjCmTR<|&A? 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 literal 0 HcmV?d00001 From bc01860867a58be0b22bb46e7c570d97f0ed288b Mon Sep 17 00:00:00 2001 From: Xi Wang Date: Mon, 10 Aug 2020 06:04:22 +0000 Subject: [PATCH 8/8] remove unnecessary files --- example/probability/VAE/VAE_files/VAE_11_0.png | Bin 9062 -> 0 bytes example/probability/VAE/VAE_files/VAE_14_0.png | Bin 15863 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 example/probability/VAE/VAE_files/VAE_11_0.png delete mode 100644 example/probability/VAE/VAE_files/VAE_14_0.png diff --git a/example/probability/VAE/VAE_files/VAE_11_0.png b/example/probability/VAE/VAE_files/VAE_11_0.png deleted file mode 100644 index 455f09e27d3faef02de9fbc0fcc66132ec81c759..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9062 zcmbVydpwhW|Nk{}2@ zU=02o1^|f57GCf-gQ^wq0l@8h{*vhy@GE%Bt;gVFelL9sUjPsk=6plC21D1ui)a0G z&HYR~o&3;tK8}F9ou8MRr=Qzx`vWLPAK%-a9*S@UxZ?2xE`EMqs`B#x|L<^5A7^?(br=ZG)?GWe?`OUW-z|1s;p?kc#iMV+ZEj}S zpA%_CNbbG55EXvc=FIOaryCn}?nQ_SK8EN%K6JSlC#oykg;61Db#%~V9t_bcN@WS<% zX4(#IM;+Q6$e|u81hG91)d_Qbu8m3fl6g(z@;wf!dmWVaIovUwVm_Nt%~Tk-9}dbC ze77@TXXTNItmXJB-{g~x7qlymMrdxYlaJGAOv)#j7>PQLJyLCF5V=`$5m~)*4$LF6 ziqO3dg?yoWk=)M#D9(T+>Tq>N*xE!fMNPH};nMW(3!^tY>s7s$wu7zWTzANbP?#C% zWjJ;SQVXc-rXFO=?ZmWT+B*h_j<@7&Mb28j@k5#pxuDM_&; zDmxWcGwRtJ(zd6*oSHWutVg@Jk0jM@FN4fN7yw0NsEM!6A>_!Mg*}^w&U31ENMBuX zB;BpYbn-=WrE@d5D8dw?_mDeeCTyOBCQXnWsY-PH{oO->XXwd?f_xIOAq3^zc>PIOl4hQ%G{>x8yz&MYBTewVHPY(kGBU4OZ&B$qQYDD9 zaWsdZp@}=N$+OahbK4>QILRX{#eLH0SgtRJ=huR`hPXbpuC0ag)C%rT>SM6U?3&=; zI#v)Z?g$)jef(5Kc&FdV`Iw&O@QG;damWz#>d4u0;5l>}Cn(bNtG1qaGoWc$a5%Pp zK22aCF@PpcYSrGTSD1vJHb6Y7bzcN`Kd=I4Lqw;It3ka>w9 zLF*mDZfSLh-2%)g0v5p*K1(jJSP~R68OZv z5bpejwlV_OcMXSM2;Av)@wvOzmbQKwC6UTLHQtKAm<{EV3P$fmlORjSXZmJ*3$W(K zFE9DF$v}D&7RcQN>laBa4G0k1;5=owJVC+yXdf(zTB!}PFpN3;J?j~lx8;GZ}!oMhXFC@ zON+mY!sUvJ4v($A2+wjsi0Yy*8u{&>4;(!?;_HefUhcQSod_pRV~PpZRXHJWcjgXk z?s#L;Me72qjQry-Z;*~gC;@0LtU_a|ePq64 zxjVh}K07&FMGr@8t$5nZ3>DY?igIZCO4>p%F3}wNL;_*R0BB6Q(U_#@Q#O?RoX72S zM1-I)6C;~1Hmfkq>u@!rUK3s3lv6gNXH=G2 zc{{jBA-7N=S7y$4Skf^hx8zyio&tOd_Qv#$b`?z!I@A%@jNDx^H_TuU$A{_N+XhIXokjEprKKCg0v z8jm@15K4EkAy7xJbM1XvBA6=fdgm&KI8C4|R>o9+s3J zVJT4bgQ@CKm3su{**`2All&W#v=U3AS|6)D{?7GC1hJo)oGvqK6!Ls^cin}7FzCF> zpnGG|a%0lIF1Ho+k;RWi;YIg`By_(%^9jy1j-NgsOxWYFR~W5`#%H-)>Og14nJst9 zke`+oXEr8vM=C6fOvDgnW6o@%sIKVnQ`4%JuvtMbSd0`XAj=`z%5V_v>Iwd)GT2{}# z`J2A}gU|l^1=A!!OMR;9FmBW{C{5KLaG};#;b*9IYGa-_p?ylCcr)>qzsXUwj6dkR zg>%({V6(kg4{x0dC=(PPJaiZj+n zWq_^wl-e5l2~o}wHUzh1e0#Ep{EUMCl&Ls#soM}@UVbMYKhw9f)0bu_HBP^0mVMF3 z=q6<=wbVHVPo{q>M7}(s@?;-pBW3}XA0yhtN&@EX5winTzE#$xw@qrb+hsC><0dHy zE)5Z4K%|65e}hwJI`YZ24zOUJWW!dhBW$ADf12w{9R@94v(O?3Im=r8i7c@D6mU>V zi`i4KN4cIcdkrp8?s%oPqou#RSvS`$p&Sc6?J>|7U*R!m=|*8xvCuQcO(SN7Ljgad z?2Fp3H#S-9xh{3UO#2D$F6v`nv^XwZ1H<*s_5+u=+R_&t$l0k^*;cgsA_jmh2?v1_ zf&*(WW)DGPqp@kXm#4k~Wv;!2eT(bc?g}WKdm}_SSK{*ZkT_;Ij1LG{Y*$9MrQa#@ z9HKS^E&YOMrzp8wwJF`MLCsjw>egMO2x|ggaxT?+b$6txAq$MMFE&t%%-#g>o@3TQ zlGM=f*!~Ys1vwStX~(fHy|W=m8>E^a|6X9B2m~!pjoB0S)z}b28`9~egPpOoafV_c zta!dbJh{N$s*c=N>`qYI5KY9um9>~#pCmDpJZ+QTUYTY@5T&P`vbMh-)}ZZTdZd4$heG&rP=p7Z zMX!HwBt^IkR+r1g>`~;^pXqu(U08z~mCw14xG|w$?frt$1(lNbT!Se}2G2o&6lKqj z{!pjOf132#Or&SqwuhrGTPXR^{Oq$ibA8?6;0hfLG;c;q3S;S$h|?p#7nc?)?06^`6*U#Uc(WQW_ame zu?KZpp4PV0XTBW39t0s6lV!CEVICdaR8&>b1};18okpW`wLS_uBB;wmg%CCv30SAAj*r z+3&&)Z|n>e=~go$ss(Uvk72}14ZtmD-fhJt+JveAFg4V1Mqk`0<6}up^)aMZ6KlY~Rz3OnfzT>;r@HD@!OK{Za6Fsixn~?x( zxd;n+hnnf%KZ_hQ<^@}S;M8#DxqDXRjK|+f4kH)rKIqCyVviTWzL}buj@sWOxIv72 zz2EIQnIZlC?NLt8H}CMVw2P|mM2G*Fh@twUVQ{>-Jg+T-Muv~e z=USQ_<+Sge^60L|#{zXcj<|uqu21!IZNi?nj`8Rcsyg&wlVRLWpF=>el$NTQ8RQ*} zuzWxbcl+WEH*0LF`Y3k&!l^vzSO4yk{yVE|`lttaIbVdTURs(wn0*MYWx+wqcRrJh zw5fwXe-`{t)@yT79)&X-LdpZfEg(WdGo3rr;V6)G#4zoB#SX~8@wQ|@eQoq!w!}e+@+UNfF2wqP8 z7J}~lcFqXdrJwPG@d&BqH8=bLPH-ca2)LJ~zFzKGn#@hDII&x8SzQY838w1z3SaIq zxEJR!SY2iQXd4W8W%eckzcw^9)|v?QV$M|5^xfwd0s08;H~V{Uh3Dpq%U<9B!5C5| z(j9ev@>=HuLGkK^oJ&uEv#Z1RkhHRH17F7)?uE6947&Xa730}}zH!+xC5YwIbM5(Q z$grN)?a^=rUu?6F2?2+)F!=Xm9yEWt(VbemM<40GJcu6hcf`ceGghz6t~NC| z$zrYos{T{lIZmbW#C2i)b}L4l&O}EVvcRI$sj$|y7k(hH>Ld1=rlUs2pCdkYO{5H2 zgVLTlbC|MJCNl}hAqtOs?*r99otz}9&#plNyZj9ySDR77p6bc}*+OXkrK~*T&01gV zM7n|O0~A=-^*6Y6FAVs0`YW*eU${>ZZg=OJx3R6qOngl_^HkVr^`$Y^J4o4__ah?n!<`r zsdJ~q0b)tI;U5rM$mPF79{PmEJlgN0-`_NZq1Qbl9;sLl`!W=~C=?qM(rLX| z+Ut9ee5>GQMIpZ2ow5rj$zE-Oe}83k7(uP}my6xMhvyx57M{(F?b|#|aA-pBJG)O- zYlStlT*i7<1(xM4@t##b)y-BX>0vR*nc{ zjwW_Bu$zK)L{^2PB0{(`Laq@g9<5}} zOKapOvY~|1^(5H7;Hmt)>Li%S6nc1l7ESaWYru;;qn&-V{}fChi~ml_VF1dvjoaAM zyBOUB(!(HpJmz)mdNG=AePH8^7JHVFu|abN_6PlX(U7j}NmUoejD*WXxYxvP!p@F8 zUIUfhg{dCaiFxTk0{R9dxwV%C-bswOPlnjvCgLEko{jDAT4PW=!$v>L;7;5m+;Z2_ zxensuCMeZ<-0hd$5~Dix%0A{=n(DXsjdDPWNUr(0@%6Y&suvfa#a`<~wi(#C&@=f0 zX3Bd3Q27+%9jBGD{m}G@EEByyH?vU4Kegf$z4wfOzSf60t+1HFHL-1Kc5%e$rg(%k zzqXOl6Fm7G1?6qVfpyW()Ok=3ur3%RxKnS84=!-S@BZ5*DSS;(m*3kO{8N$JrR5^^x{H=dwhH`&2^p9$7!M)X1ceC&lVgo zc*0Edo z{J2xhqYbLIPkQoG1J&jRw;Sa!c>n}Nz!>q(vdm>?Y+ax;=df)GnBnJ{k|9f9Ly6-c zuJIWg{+c-yJ(22baD&lW80gihv2x21V`kR=d>+vuIe04t%bLU?b*MHj-;}m*Ff}*I z57I0bS#gdG%MACf^CkIH^m`f_^Tfk^FuxtKLGEAPOW#bx{oRDrlXiFIDB*i z{kwD7Apv`J#+#vLOv}n(Ebx)k=(SL(o651YFRi=&H0G38-M5dsO>VE;836UZHhH>E zGIaHaHW_v-MvGM`N6|ePf?CJ};eEE#Bf-f)R5zqG)ROh)vo}NUW1qoJcC}SgGz{`< zu%-epwD9c67VRbhTDL*R!>UFMsb!#90G!&Ae%LcaKf*J3-`#4CvoAVf z*K_4BbCFrwfiuIMvTdgLI;I@l=nzS1Sf?d>Xzn4pDduD#XY_Xy4>vfS#@1i0PVrpH z_5kNj^bp68EX=BAnr;tW?AUf^g|8x!5bJCqa69?bpPS=!jWc7L=7l3E{_R4Eg0Pd& zyVHV{{0P|4dE)yB;w8QFHM0nUMVN7mRw2Eg9Up z7wwyWO0%N{7k{OKZn}Msq%&vB|FI3ug|6Q?W5*s4e?i>>*QrC(sRx**n>~81%d0*b zs{@!qG`i|p(n4MS_bQDqAoyRdB<)3kNLCajW zphSiO#kkwz=F;;HibgK;IZM^v7fXoQ|LG?TJDi_QUNFLHt zL(M&R&{Fuz)!ST(Rys1Yh8h<9xg%e4R*!GT4c4I1j+iVKc(6HZAHo()aHM)w;Nmz? zU_+!f(9FLCbDq3eZO+m^qm-)`x?axbn4xm+iz*TMEs3Ea205f3!CE9 z>=+a^J3x+SGG?Y*GD3gL#;OWm6hMH6-)e2{({{9@8gGvT{e0#>OTXq10_{#-RFQR^ zY7^#AeDk(yUeGq&+jK#ITYs7C1oN3J=PpV_ZR`<~P8@1j zZ{1Pq)XuelUBdrE!mlrg_<>Fsu<~g>0%v^SldN0-8PMmwVO)r=t}d`2J>U&@(jx-u z^YtQN86!3o^5t8k5BK<>%@iX5^sv8LSVcLayV&CtP-O4Lar7VM$d!c366|4*7ymHF zv9H`33!e{%_1rYH4*2oldd*=A(;{mPgeGVzA${epiTE{FjA+-g)|EdD0dj6XDB=(j zr(Jdc_+2M_6xxH4XO?K>?)a3`x4CjUf|0*A?SAIncAU6PaIqYi3hc%8T4PRpq3RRJ zHPoV-Syk~j$QmV}JI@eZ>_7c|4AoR}^4bs(BD%5U-|10!1Nnnn1 zI{KOyJ6w)LwPo;NetdkOZFf!0d~;F+;L!BI@nr2O{+cxQ7{^?KLjnWY)^BXr2}>aV z%2mVXr};m##bOwb{>%pGWqL9;0zStcY>=ox6UBeOdOX#U;nv(=8(1pWnWDTM2i>MW zE<_B!ladP(w>>@Pc$sm1pgMpp@457>+{Hk%9TZ?7>>Bf@Z?RIlj+bDOZ9t%-%H zbc;^TWNjYj+^os|-6m((G*`w!l&GNPjS;UmRcWi5ZUV(2h}Z?0NK>1@)a8=%e@gm4 z0!B-tKj{pq>$qFqv16JTuOD5T)}!j9&esc4zIX2a^-rGv4p$ue^3OBORz0?~3tGND zV!}`<89t!rJb7la4)a;Bh@9zZV2%3icf>F z96$suB(eZ}3>>$4KhTgK`ujE_6qMW$b7E*6evDa`!r@8IKeJ5VUHbyM!oTvmob>yf zi1&BnES_Q7o{m`Cj4z%D% zssrVdr_i%j05z03<3`Ie)qW~{4cM(`_-P$ zd*Ap+r_SEzq$08XsmJ9hOF&<3pki#$M-M%dw&!PB8`g92rf|09pcujmk`wJw0`_FA z1&lcOY@6ebzzOyZ0tnWJ?V*4+h&omUV6g#p5W3(Da89}A=vX$T;e6CHBk;YB(ob=2 zkKQuGq^{t4o{n`Hq=J&f4w0@NSRzN6$1!e64u8Mtd4dtdyrPbx^=%Bg%gRt%&i=SB zV&w(~A3#qblEO)#K%s=B6*oyhjZ3XTk%9~yYl#P}{J!df=-YMLy}ze{wUnm?ITt3Qq5i8|PJ$o=yk8x``_w%Wov^t$HCUqzH0}2V?Un;EgozSQ(F{=q zO!5r;i$O31@-15ADNjxjH)cGMG!k?>cidt#00zLj^oSZL#mKOB5=wi^Vo4KUKrE66cYWUBAO3-NtOp_+$fbFBvNV0C-u@rI_6AXeauoVlcozFO*`2lK z_H<|)2|gL#+d9Rmu4*K+O=C z)wLLBIP2N3qD`4FXk0SLqg5q!*V;Pu8P$Ubn-H@p6lke>e=n~3O@9~Chef*U{a8&? z$-uHy0Pw{TcyRJfbzXDAShDo1w5}a-Pu1cZ3@|GlYIM^UO)~`Rz8>m^EAf)cqm(rT z%wUJ7M}G(`fH|AcoGe@Lk97~>_eUJmf)OG4DlHa}TwqY} zF6Cej(;y-5>i*d8*rKt%Kf(LwMFgQDVa=kYt0D7^wB=l+4ez;5pHQX{6wAqz)jk?fmr3o5znrO)cMI_05Y5&g9I zekItWt$Rl7QE7Zw(Wp9Xr=**E%F9@{px<<7dNgruJO$adZK;EA(;u~SrJ=^Mk`Kp5<0LmZt2ZRvN-~n@A zbhewhs2O`R5)P~F<%w(Wf+MRdldya>jw#Ws{JTV@dO`VGK&p2UH~QA`1@Fy7U5?tR zoxCsGE}NG+(n46Qmn^rJAusDSt;$THBAszJ@jd(|Txu$CDRJ@=I7&D1>*0YjB|kUi zS3*VfJ?dt7YfhY-u-_BKah6- diff --git a/example/probability/VAE/VAE_files/VAE_14_0.png b/example/probability/VAE/VAE_files/VAE_14_0.png deleted file mode 100644 index d26173bb56aebfd2bca129c3c88eab7d87eff338..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 15863 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%0ADjCmTR<|&A? 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