Full Code of zalandoresearch/pytorch-vq-vae for AI

Repository: zalandoresearch/pytorch-vq-vae
Branch: master
Commit: b98fde9a8f8f
Files: 5
Total size: 332.2 KB

Directory structure:
gitextract_hyb010v0/

├── .gitignore
├── LICENSE
├── README.md
├── requirements.txt
└── vq-vae.ipynb

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/

# Translations
*.mo
*.pot

# Django stuff:
*.log
local_settings.py
db.sqlite3

# Flask stuff:
instance/
.webassets-cache

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
target/

# Jupyter Notebook
.ipynb_checkpoints

# pyenv
.python-version

# celery beat schedule file
celerybeat-schedule

# SageMath parsed files
*.sage.py

# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

# Spyder project settings
.spyderproject
.spyproject

# Rope project settings
.ropeproject

# mkdocs documentation
/site

# mypy
.mypy_cache/

data/


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2018 Zalando Research

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# pytorch-vq-vae
PyTorch implementation of VQ-VAE by Aäron van den Oord et al.

## Requirements

```
$ pip3 install -r requirements.txt
```

## Notebook

See [vq-vae.ipynb](https://nbviewer.jupyter.org/github/zalandoresearch/pytorch-vq-vae/blob/master/vq-vae.ipynb)


================================================
FILE: requirements.txt
================================================
torch
torchvision
matplotlib
numpy
scipy
six
umap-learn



================================================
FILE: vq-vae.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [VQ-VAE](https://arxiv.org/abs/1711.00937) by  [Aäron van den Oord](https://twitter.com/avdnoord) et al. in PyTorch\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Variational Auto Encoders (VAEs) can be thought of as what all but the last layer of a neural network is doing, namely feature extraction or seperating out the data. Thus given some data we can think of using a neural network for representation generation. \n",
    "\n",
    "Recall that the goal of a generative model is to estimate the probability distribution of high dimensional data such as images, videos, audio or even text by learning the underlying structure in the data as well as the dependencies between the different elements of the data. This is very useful since we can then use this representation to generate new data with similar properties. This way we can also learn useful features from the data in an unsupervised fashion.\n",
    "\n",
    "The VQ-VAE uses a discrete latent representation mostly because many important real-world objects are discrete. For example in images we might have categories like \"Cat\", \"Car\", etc. and it might not make sense to interpolate between these categories. Discrete representations are also easier to model since each category has a single value whereas if we had a continous latent space then we will need to normalize this density function and learn the dependencies between the different variables which could be very complex.\n",
    "\n",
    "### Code\n",
    "\n",
    "I have followed the code from the TensorFlow implementation by the author which you can find here [vqvae.py](https://github.com/deepmind/sonnet/blob/master/sonnet/python/modules/nets/vqvae.py) and [vqvae_example.ipynb](https://github.com/deepmind/sonnet/blob/master/sonnet/examples/vqvae_example.ipynb). \n",
    "\n",
    "Another PyTorch implementation is found at [pytorch-vqvae](https://github.com/ritheshkumar95/pytorch-vqvae).\n",
    "\n",
    "\n",
    "## Basic Idea\n",
    "\n",
    "The overall architecture is summarized in the diagram below:\n",
    "\n",
    "![](images/vq-vae.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by defining a latent embedding space of dimension `[K, D]` where `K` are the number of embeddings and `D` is the dimensionality of each latent embeddng vector, i.e. $e_i \\in \\mathbb{R}^{D}$. The model is comprised of an encoder and a decoder. The encoder will map the input to a sequence of discrete latent variables, whereas the decoder will try to reconstruct the input from these latent sequences. \n",
    "\n",
    "More preciesly, the model will take in batches of RGB images,  say $x$, each of size 32x32 for our example, and pass it through a ConvNet encoder producing some output $E(x)$, where we make sure the channels are the same as the dimensionality of the latent embedding vectors. To calculate the discrete latent variable we find the nearest embedding vector and output it's index. \n",
    "\n",
    "The input to the decoder is the embedding vector corresponding to the index which is passed through the decoder to produce the reconstructed image. \n",
    "\n",
    "Since the nearest neighbour lookup has no real gradient in the backward pass we simply pass the gradients from the decoder to the encoder  unaltered. The intuition is that since the output representation of the encoder and the input to the decoder share the same `D` channel dimensional space, the gradients contain useful information for how the encoder has to change its output to lower the reconstruction loss.\n",
    "\n",
    "## Loss\n",
    "\n",
    "The total loss is actually composed of three components\n",
    "\n",
    "1. **reconstruction loss**: which optimizes the decoder and encoder\n",
    "1. **codebook loss**: due to the fact that gradients bypass the embedding, we use a dictionary learning algorithm  which uses an $l_2$  error to move the embedding vectors $e_i$ towards the encoder output\n",
    "1. **commitment loss**:  since the volume of the embedding space is dimensionless, it can grow arbirtarily if the embeddings $e_i$ do not train as fast as  the encoder parameters, and thus we add a commitment loss to make sure that the encoder commits to an embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip3 install -U -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy.signal import savgol_filter\n",
    "\n",
    "\n",
    "from six.moves import xrange\n",
    "\n",
    "import umap\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.optim as optim\n",
    "\n",
    "import torchvision.datasets as datasets\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.utils import make_grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "training_data = datasets.CIFAR10(root=\"data\", train=True, download=True,\n",
    "                                  transform=transforms.Compose([\n",
    "                                      transforms.ToTensor(),\n",
    "                                      transforms.Normalize((0.5,0.5,0.5), (1.0,1.0,1.0))\n",
    "                                  ]))\n",
    "\n",
    "validation_data = datasets.CIFAR10(root=\"data\", train=False, download=True,\n",
    "                                  transform=transforms.Compose([\n",
    "                                      transforms.ToTensor(),\n",
    "                                      transforms.Normalize((0.5,0.5,0.5), (1.0,1.0,1.0))\n",
    "                                  ]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_variance = np.var(training_data.data / 255.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vector Quantizer Layer\n",
    "\n",
    "This layer takes a tensor to be quantized. The channel dimension will be used as the space in which to quantize. All other dimensions will be flattened and will be seen as different examples to quantize.\n",
    "\n",
    "The output tensor will have the same shape as the input.\n",
    "\n",
    "As an example for a `BCHW` tensor of shape `[16, 64, 32, 32]`, we will first convert it to an `BHWC` tensor of shape `[16, 32, 32, 64]` and then reshape it into `[16384, 64]` and all `16384` vectors of size `64`  will be quantized independently. In otherwords, the channels are used as the space in which to quantize. All other dimensions will be flattened and be seen as different examples to quantize, `16384` in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VectorQuantizer(nn.Module):\n",
    "    def __init__(self, num_embeddings, embedding_dim, commitment_cost):\n",
    "        super(VectorQuantizer, self).__init__()\n",
    "        \n",
    "        self._embedding_dim = embedding_dim\n",
    "        self._num_embeddings = num_embeddings\n",
    "        \n",
    "        self._embedding = nn.Embedding(self._num_embeddings, self._embedding_dim)\n",
    "        self._embedding.weight.data.uniform_(-1/self._num_embeddings, 1/self._num_embeddings)\n",
    "        self._commitment_cost = commitment_cost\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        # convert inputs from BCHW -> BHWC\n",
    "        inputs = inputs.permute(0, 2, 3, 1).contiguous()\n",
    "        input_shape = inputs.shape\n",
    "        \n",
    "        # Flatten input\n",
    "        flat_input = inputs.view(-1, self._embedding_dim)\n",
    "        \n",
    "        # Calculate distances\n",
    "        distances = (torch.sum(flat_input**2, dim=1, keepdim=True) \n",
    "                    + torch.sum(self._embedding.weight**2, dim=1)\n",
    "                    - 2 * torch.matmul(flat_input, self._embedding.weight.t()))\n",
    "            \n",
    "        # Encoding\n",
    "        encoding_indices = torch.argmin(distances, dim=1).unsqueeze(1)\n",
    "        encodings = torch.zeros(encoding_indices.shape[0], self._num_embeddings, device=inputs.device)\n",
    "        encodings.scatter_(1, encoding_indices, 1)\n",
    "        \n",
    "        # Quantize and unflatten\n",
    "        quantized = torch.matmul(encodings, self._embedding.weight).view(input_shape)\n",
    "        \n",
    "        # Loss\n",
    "        e_latent_loss = F.mse_loss(quantized.detach(), inputs)\n",
    "        q_latent_loss = F.mse_loss(quantized, inputs.detach())\n",
    "        loss = q_latent_loss + self._commitment_cost * e_latent_loss\n",
    "        \n",
    "        quantized = inputs + (quantized - inputs).detach()\n",
    "        avg_probs = torch.mean(encodings, dim=0)\n",
    "        perplexity = torch.exp(-torch.sum(avg_probs * torch.log(avg_probs + 1e-10)))\n",
    "        \n",
    "        # convert quantized from BHWC -> BCHW\n",
    "        return loss, quantized.permute(0, 3, 1, 2).contiguous(), perplexity, encodings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also implement a slightly modified version  which will use exponential moving averages to update the embedding vectors instead of an auxillary loss. This has the advantage that the embedding updates are independent of the choice of optimizer for the encoder, decoder and other parts of the architecture. For most experiments the EMA version trains faster than the non-EMA version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VectorQuantizerEMA(nn.Module):\n",
    "    def __init__(self, num_embeddings, embedding_dim, commitment_cost, decay, epsilon=1e-5):\n",
    "        super(VectorQuantizerEMA, self).__init__()\n",
    "        \n",
    "        self._embedding_dim = embedding_dim\n",
    "        self._num_embeddings = num_embeddings\n",
    "        \n",
    "        self._embedding = nn.Embedding(self._num_embeddings, self._embedding_dim)\n",
    "        self._embedding.weight.data.normal_()\n",
    "        self._commitment_cost = commitment_cost\n",
    "        \n",
    "        self.register_buffer('_ema_cluster_size', torch.zeros(num_embeddings))\n",
    "        self._ema_w = nn.Parameter(torch.Tensor(num_embeddings, self._embedding_dim))\n",
    "        self._ema_w.data.normal_()\n",
    "        \n",
    "        self._decay = decay\n",
    "        self._epsilon = epsilon\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        # convert inputs from BCHW -> BHWC\n",
    "        inputs = inputs.permute(0, 2, 3, 1).contiguous()\n",
    "        input_shape = inputs.shape\n",
    "        \n",
    "        # Flatten input\n",
    "        flat_input = inputs.view(-1, self._embedding_dim)\n",
    "        \n",
    "        # Calculate distances\n",
    "        distances = (torch.sum(flat_input**2, dim=1, keepdim=True) \n",
    "                    + torch.sum(self._embedding.weight**2, dim=1)\n",
    "                    - 2 * torch.matmul(flat_input, self._embedding.weight.t()))\n",
    "            \n",
    "        # Encoding\n",
    "        encoding_indices = torch.argmin(distances, dim=1).unsqueeze(1)\n",
    "        encodings = torch.zeros(encoding_indices.shape[0], self._num_embeddings, device=inputs.device)\n",
    "        encodings.scatter_(1, encoding_indices, 1)\n",
    "        \n",
    "        # Quantize and unflatten\n",
    "        quantized = torch.matmul(encodings, self._embedding.weight).view(input_shape)\n",
    "        \n",
    "        # Use EMA to update the embedding vectors\n",
    "        if self.training:\n",
    "            self._ema_cluster_size = self._ema_cluster_size * self._decay + \\\n",
    "                                     (1 - self._decay) * torch.sum(encodings, 0)\n",
    "            \n",
    "            # Laplace smoothing of the cluster size\n",
    "            n = torch.sum(self._ema_cluster_size.data)\n",
    "            self._ema_cluster_size = (\n",
    "                (self._ema_cluster_size + self._epsilon)\n",
    "                / (n + self._num_embeddings * self._epsilon) * n)\n",
    "            \n",
    "            dw = torch.matmul(encodings.t(), flat_input)\n",
    "            self._ema_w = nn.Parameter(self._ema_w * self._decay + (1 - self._decay) * dw)\n",
    "            \n",
    "            self._embedding.weight = nn.Parameter(self._ema_w / self._ema_cluster_size.unsqueeze(1))\n",
    "        \n",
    "        # Loss\n",
    "        e_latent_loss = F.mse_loss(quantized.detach(), inputs)\n",
    "        loss = self._commitment_cost * e_latent_loss\n",
    "        \n",
    "        # Straight Through Estimator\n",
    "        quantized = inputs + (quantized - inputs).detach()\n",
    "        avg_probs = torch.mean(encodings, dim=0)\n",
    "        perplexity = torch.exp(-torch.sum(avg_probs * torch.log(avg_probs + 1e-10)))\n",
    "        \n",
    "        # convert quantized from BHWC -> BCHW\n",
    "        return loss, quantized.permute(0, 3, 1, 2).contiguous(), perplexity, encodings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder & Decoder Architecture\n",
    "\n",
    "The encoder and decoder architecture is based on a ResNet and is implemented below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Residual(nn.Module):\n",
    "    def __init__(self, in_channels, num_hiddens, num_residual_hiddens):\n",
    "        super(Residual, self).__init__()\n",
    "        self._block = nn.Sequential(\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(in_channels=in_channels,\n",
    "                      out_channels=num_residual_hiddens,\n",
    "                      kernel_size=3, stride=1, padding=1, bias=False),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(in_channels=num_residual_hiddens,\n",
    "                      out_channels=num_hiddens,\n",
    "                      kernel_size=1, stride=1, bias=False)\n",
    "        )\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return x + self._block(x)\n",
    "\n",
    "\n",
    "class ResidualStack(nn.Module):\n",
    "    def __init__(self, in_channels, num_hiddens, num_residual_layers, num_residual_hiddens):\n",
    "        super(ResidualStack, self).__init__()\n",
    "        self._num_residual_layers = num_residual_layers\n",
    "        self._layers = nn.ModuleList([Residual(in_channels, num_hiddens, num_residual_hiddens)\n",
    "                             for _ in range(self._num_residual_layers)])\n",
    "\n",
    "    def forward(self, x):\n",
    "        for i in range(self._num_residual_layers):\n",
    "            x = self._layers[i](x)\n",
    "        return F.relu(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self, in_channels, num_hiddens, num_residual_layers, num_residual_hiddens):\n",
    "        super(Encoder, self).__init__()\n",
    "\n",
    "        self._conv_1 = nn.Conv2d(in_channels=in_channels,\n",
    "                                 out_channels=num_hiddens//2,\n",
    "                                 kernel_size=4,\n",
    "                                 stride=2, padding=1)\n",
    "        self._conv_2 = nn.Conv2d(in_channels=num_hiddens//2,\n",
    "                                 out_channels=num_hiddens,\n",
    "                                 kernel_size=4,\n",
    "                                 stride=2, padding=1)\n",
    "        self._conv_3 = nn.Conv2d(in_channels=num_hiddens,\n",
    "                                 out_channels=num_hiddens,\n",
    "                                 kernel_size=3,\n",
    "                                 stride=1, padding=1)\n",
    "        self._residual_stack = ResidualStack(in_channels=num_hiddens,\n",
    "                                             num_hiddens=num_hiddens,\n",
    "                                             num_residual_layers=num_residual_layers,\n",
    "                                             num_residual_hiddens=num_residual_hiddens)\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        x = self._conv_1(inputs)\n",
    "        x = F.relu(x)\n",
    "        \n",
    "        x = self._conv_2(x)\n",
    "        x = F.relu(x)\n",
    "        \n",
    "        x = self._conv_3(x)\n",
    "        return self._residual_stack(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(self, in_channels, num_hiddens, num_residual_layers, num_residual_hiddens):\n",
    "        super(Decoder, self).__init__()\n",
    "        \n",
    "        self._conv_1 = nn.Conv2d(in_channels=in_channels,\n",
    "                                 out_channels=num_hiddens,\n",
    "                                 kernel_size=3, \n",
    "                                 stride=1, padding=1)\n",
    "        \n",
    "        self._residual_stack = ResidualStack(in_channels=num_hiddens,\n",
    "                                             num_hiddens=num_hiddens,\n",
    "                                             num_residual_layers=num_residual_layers,\n",
    "                                             num_residual_hiddens=num_residual_hiddens)\n",
    "        \n",
    "        self._conv_trans_1 = nn.ConvTranspose2d(in_channels=num_hiddens, \n",
    "                                                out_channels=num_hiddens//2,\n",
    "                                                kernel_size=4, \n",
    "                                                stride=2, padding=1)\n",
    "        \n",
    "        self._conv_trans_2 = nn.ConvTranspose2d(in_channels=num_hiddens//2, \n",
    "                                                out_channels=3,\n",
    "                                                kernel_size=4, \n",
    "                                                stride=2, padding=1)\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        x = self._conv_1(inputs)\n",
    "        \n",
    "        x = self._residual_stack(x)\n",
    "        \n",
    "        x = self._conv_trans_1(x)\n",
    "        x = F.relu(x)\n",
    "        \n",
    "        return self._conv_trans_2(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train\n",
    "\n",
    "We use the hyperparameters from the author's code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 256\n",
    "num_training_updates = 15000\n",
    "\n",
    "num_hiddens = 128\n",
    "num_residual_hiddens = 32\n",
    "num_residual_layers = 2\n",
    "\n",
    "embedding_dim = 64\n",
    "num_embeddings = 512\n",
    "\n",
    "commitment_cost = 0.25\n",
    "\n",
    "decay = 0.99\n",
    "\n",
    "learning_rate = 1e-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_loader = DataLoader(training_data, \n",
    "                             batch_size=batch_size, \n",
    "                             shuffle=True,\n",
    "                             pin_memory=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "validation_loader = DataLoader(validation_data,\n",
    "                               batch_size=32,\n",
    "                               shuffle=True,\n",
    "                               pin_memory=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(nn.Module):\n",
    "    def __init__(self, num_hiddens, num_residual_layers, num_residual_hiddens, \n",
    "                 num_embeddings, embedding_dim, commitment_cost, decay=0):\n",
    "        super(Model, self).__init__()\n",
    "        \n",
    "        self._encoder = Encoder(3, num_hiddens,\n",
    "                                num_residual_layers, \n",
    "                                num_residual_hiddens)\n",
    "        self._pre_vq_conv = nn.Conv2d(in_channels=num_hiddens, \n",
    "                                      out_channels=embedding_dim,\n",
    "                                      kernel_size=1, \n",
    "                                      stride=1)\n",
    "        if decay > 0.0:\n",
    "            self._vq_vae = VectorQuantizerEMA(num_embeddings, embedding_dim, \n",
    "                                              commitment_cost, decay)\n",
    "        else:\n",
    "            self._vq_vae = VectorQuantizer(num_embeddings, embedding_dim,\n",
    "                                           commitment_cost)\n",
    "        self._decoder = Decoder(embedding_dim,\n",
    "                                num_hiddens, \n",
    "                                num_residual_layers, \n",
    "                                num_residual_hiddens)\n",
    "\n",
    "    def forward(self, x):\n",
    "        z = self._encoder(x)\n",
    "        z = self._pre_vq_conv(z)\n",
    "        loss, quantized, perplexity, _ = self._vq_vae(z)\n",
    "        x_recon = self._decoder(quantized)\n",
    "\n",
    "        return loss, x_recon, perplexity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(num_hiddens, num_residual_layers, num_residual_hiddens,\n",
    "              num_embeddings, embedding_dim, \n",
    "              commitment_cost, decay).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate, amsgrad=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.train()\n",
    "train_res_recon_error = []\n",
    "train_res_perplexity = []\n",
    "\n",
    "for i in xrange(num_training_updates):\n",
    "    (data, _) = next(iter(training_loader))\n",
    "    data = data.to(device)\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    vq_loss, data_recon, perplexity = model(data)\n",
    "    recon_error = F.mse_loss(data_recon, data) / data_variance\n",
    "    loss = recon_error + vq_loss\n",
    "    loss.backward()\n",
    "\n",
    "    optimizer.step()\n",
    "    \n",
    "    train_res_recon_error.append(recon_error.item())\n",
    "    train_res_perplexity.append(perplexity.item())\n",
    "\n",
    "    if (i+1) % 100 == 0:\n",
    "        print('%d iterations' % (i+1))\n",
    "        print('recon_error: %.3f' % np.mean(train_res_recon_error[-100:]))\n",
    "        print('perplexity: %.3f' % np.mean(train_res_perplexity[-100:]))\n",
    "        print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_res_recon_error_smooth = savgol_filter(train_res_recon_error, 201, 7)\n",
    "train_res_perplexity_smooth = savgol_filter(train_res_perplexity, 201, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'iteration')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = plt.figure(figsize=(16,8))\n",
    "ax = f.add_subplot(1,2,1)\n",
    "ax.plot(train_res_recon_error_smooth)\n",
    "ax.set_yscale('log')\n",
    "ax.set_title('Smoothed NMSE.')\n",
    "ax.set_xlabel('iteration')\n",
    "\n",
    "ax = f.add_subplot(1,2,2)\n",
    "ax.plot(train_res_perplexity_smooth)\n",
    "ax.set_title('Smoothed Average codebook usage (perplexity).')\n",
    "ax.set_xlabel('iteration')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## View Reconstructions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.eval()\n",
    "\n",
    "(valid_originals, _) = next(iter(validation_loader))\n",
    "valid_originals = valid_originals.to(device)\n",
    "\n",
    "vq_output_eval = model._pre_vq_conv(model._encoder(valid_originals))\n",
    "_, valid_quantize, _, _ = model._vq_vae(vq_output_eval)\n",
    "valid_reconstructions = model._decoder(valid_quantize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "(train_originals, _) = next(iter(training_loader))\n",
    "train_originals = train_originals.to(device)\n",
    "_, train_reconstructions, _, _ = model._vq_vae(train_originals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show(img):\n",
    "    npimg = img.numpy()\n",
    "    fig = plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n",
    "    fig.axes.get_xaxis().set_visible(False)\n",
    "    fig.axes.get_yaxis().set_visible(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show(make_grid(valid_reconstructions.cpu().data)+0.5, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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