MADE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MADE (Masked Autoencoders for Distribution Estimation)\n",
    "\n",
    "Below is an implementation of [MADE](https://arxiv.org/abs/1502.03509). Like an autoencoder, this network tries to recreate the input. Unlike an autoencoder, it has a significant constraint: each pixel is only allowed to depend on the pixels that come before it. This means the second pixel depends only on the first, the third on the first and second, and so on. This is described in the paper by saying $x_d = f(x_{<d})$, where $x_{<d} = (x_1, x_2, \\dots, x_{d-1})$. This is called the *autoregressive property*, tying it to [autoregressive models](https://en.wikipedia.org/wiki/Autoregressive_model).\n",
    "\n",
    "The way this property is achieved in the model is by selectively masking weights to hide inputs and connections. Normally, the linear layer is $b+Ax$, where $b$ is the bias, $A$ is a learned matrix and $x$ is the input. For MADE, we also have a mask matrix $M$, which has only $0$s and $1$S, and use $b+(M\\odot A)x$. (The operator $\\odot$ is pointwise multiplication.) The mask construction is detailed in the paper. The important fact is that the masks are constructed in order to force the autoregressive property.\n",
    "\n",
    "The implementation of MADE here includes most of the features mentioned in the paper, including:\n",
    "* Mask recycling. To avoid the computational work of generating a mask for every batch, we instead generate the masks at creation and cycle through them. This effectively limits us to a few specific masks. In the paper, they note that more than 64 masks tends to degrade performance. In the implementation below, I store the seeds used to create the masks as part of the model. This allows us to regenerate the masks when we reload the model. We could also store the masks, but then the size of the model would then grow directly proportional to the number of masks.\n",
    "* Dynamic masks. In this situation, we change the mask every batch. It's worth noting that there is an implicit bound on the number of masks (as there are only so many mask matrices that can be chosen), and so there is a (large) finite number of masks. As noted above, this suffers from performance issues, which I have now seen for myself.\n",
    "* Direct connection layer. If we are using a deep MADE model, then this serves as a shortcut layer. This is a layer separate from the deep network that takes in the input, feeds it through this layer, and then combines it with the result of the second-to-last layer of the deep network. This combined result is then fed into the last layer. Normally, the output of the last layer would be $f(b_{n}+(M_{n}\\odot A_{n})x_{n-1})$. With a direct connection layer, the output becomes $f(b_{n}+(M_{n}\\odot A_{n})x_{n-1}+L x_0)$, where $L$ is a strictly lower triangular matrix that serves as the direct connection. The strictly lower triangularity is necessary to keep the autoregressive property.\n",
    "* Mask weights. These are weights that serves as a bias on the assigned mask. Rather than using $b+(M\\odot A)x$ as above, we use $b+(M\\odot A)x + (M \\odot Q)\\mathbf{1}$, where $Q$ is the mask weight and $\\mathbf{1}$ is a vector with $1$ for every entry. In effect, $Q$ should serve to stabilize the bias $b$ against changes that might occur from changing the mask. It's worth noting that $Q$ is necessarily the same size as $A$ in this formulation, and so it has drastic impacts on the size of the model. It also didn't seem to have positive effects on the image reconstructions, so I have left it to be false. A less memory intense version would be to use $Mq$ instead of $(M \\odot Q)\\mathbf{1}$, where $q$ is a vector instead. In this situation, $q$ would have `in_features` parameters, while $Q$ has `(in_features)*(out_features)` parameters. I haven't had a chance to determine if this is effective.\n",
    "* 'Conditional' or 'deterministic' inputs. This isn't mentioned in the paper, but I included it so that I can have an extra deterministic parameter be used as part of the input. These are not masked, and are meant to transmit high level information that will be used in the reconstruction. In a basic use case, we could provide as input a tensor holding the values for an image, and a label of the image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code\n",
    "### MADE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch as t\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.utils.data as data\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MaskedLinear(nn.Linear):\n",
    "    '''\n",
    "    Defines a masked linear layer by adding a feature mask. The mask is multiplied (element-wise) with\n",
    "    the linear weights to selectively zero out features. \n",
    "    \n",
    "    :param in_features: (int)\n",
    "    :param out_features: (int)\n",
    "    :param mask_conditioning: (bool)\n",
    "    :param bias: (bool)\n",
    "    '''\n",
    "    def __init__(self, in_features, out_features, mask_conditioning=False, bias=True):\n",
    "        super(MaskedLinear, self).__init__(in_features, out_features, bias)\n",
    "        self.mask = t.ones_like(self.weight)\n",
    "        if mask_conditioning:\n",
    "            self.mask_weight = nn.Parameter(t.Tensor(out_features, in_features))\n",
    "            nn.init.kaiming_uniform_(self.mask_weight, a=np.sqrt(5))\n",
    "        else:\n",
    "            self.register_parameter('mask_weight', None)\n",
    "            \n",
    "    def set_mask(self, new_mask):\n",
    "        assert new_mask.T.shape == self.weight.shape, \\\n",
    "            'Mask needs to be the same shape as weight, but recieved {0} and {1}'.format(new_mask.shape, self.weight.shape)\n",
    "        self.mask = t.tensor(new_mask.T, dtype=self.weight.dtype, device=self.weight.device)\n",
    "            \n",
    "    def forward(self, input):\n",
    "        mask = self.mask.to(device=input.device)\n",
    "        x = F.linear(input, mask*self.weight, self.bias)\n",
    "        if self.mask_weight is not None:\n",
    "            x += F.linear(t.ones_like(input), mask*self.mask_weight)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MADE(nn.Module):\n",
    "    '''\n",
    "    Defines a masked autoencoder using masked linear layers. \n",
    "    \n",
    "    :params layer_widths: [int], widths of each layer. The first entry should be\n",
    "        the input size. The last entry should be the output size. It is expected that\n",
    "        the output size is a multiple of the input size. If this is not possible,\n",
    "        consider setting some of the input variables to conditions.\n",
    "    :params num_masks: (int, optional) The number of masks to use. If set to 0, then\n",
    "        we generate a new mask every call during training. Otherwise, we generate\n",
    "        a fixed number of masks to cycle through during training.\n",
    "    :params in_conditions: (int, opt) Size of the variable $c$ to condition the \n",
    "        input on. If 0, then the model recreates x with no additional input. \n",
    "        Otherwise, the model expects an additional input c to be used for recreating\n",
    "        x. To clarify, if in_conditions = 0, then we construct p(x). Otherwise, we\n",
    "        construct p(x|c).\n",
    "    :params connectivity_agnostic: (Bool, opt) When true, every mask will have\n",
    "        a different connectivity. Otherwise, every mask uses the same connectivity.\n",
    "    :params order_agnostic: (Bool, opt) When true, each mask will have a\n",
    "        randomized ordering of inputs. Otherwise, the original ordering of the input\n",
    "        vector is used.\n",
    "    :params direct_connection: (Bool, opt) When true, the final output will be adjusted\n",
    "        using an extra weight matrix. In order to satisfy the autoregressive property,\n",
    "        the weight matrix is strictly lower triangular.\n",
    "    :params mask_conditioning: (Bool, opt) When true, each MaskedLinear layer will also\n",
    "        create a mask conditioning weight matrix. This weight matrix adjusts the output\n",
    "        of the layer depending on the mask. Otherwise, the layer will be a simple\n",
    "        masked linear layer. See MaskedLinear for more detail.\n",
    "    :params seeds: ([int], opt) Sets the seed used to generate the masks. These are\n",
    "        used to recreate the masks when the model is reloaded so that the masks\n",
    "        themselves do not have to be saved.\n",
    "    '''\n",
    "    def __init__(self, \n",
    "                 layer_widths, \n",
    "                 num_masks=1,\n",
    "                 in_conditions=0,\n",
    "                 connectivity_agnostic=True, \n",
    "                 order_agnostic=True,\n",
    "                 direct_connection=False,\n",
    "                 mask_conditioning=False,\n",
    "                 seeds=None):\n",
    "        assert (layer_widths[-1] % layer_widths[0]) == 0, \\\n",
    "            'layer_width[-1] should be a multiple of layer_width[0].'\n",
    "        super(MADE, self).__init__()\n",
    "        #Save parameters\n",
    "        self.in_features = layer_widths[0]\n",
    "        self.in_conditions = in_conditions\n",
    "        self.out_features = layer_widths[-1]\n",
    "        self.num_masks = num_masks        \n",
    "        self.connectivity_agnostic = connectivity_agnostic\n",
    "        self.order_agnostic = order_agnostic\n",
    "        #Store seeds used to create masks - this is more space efficient than storing the\n",
    "        #masks themselves, as each mask is as large as the weight matrix.\n",
    "        if num_masks > 0:\n",
    "            assert (seeds is None) or (len(seeds) == len(num_masks)), \\\n",
    "                'If seeds are specified, there should be a seed for every mask.'\n",
    "            if seeds is None:\n",
    "                seeds = np.frombuffer(np.random.bytes(8*num_masks), dtype='uint32')\n",
    "                seeds = t.from_numpy(seeds.astype('int64'))\n",
    "        else:\n",
    "            seeds = None\n",
    "        self.register_buffer('mask_seeds', seeds)\n",
    "        self.mask_idx = 0\n",
    "        \n",
    "        ## Construct feedforward network.\n",
    "        #get sizes\n",
    "        input_sizes, output_sizes = layer_widths[:-1], layer_widths[1:]\n",
    "        #Add number of conditions if used\n",
    "        input_sizes[0] += in_conditions\n",
    "        #make layers\n",
    "        layers = [MaskedLinear(s_in, s_out, mask_conditioning) for s_in, s_out in zip(input_sizes, output_sizes)]\n",
    "        self.layers = nn.ModuleList(layers)\n",
    "        #Add direct connection layer\n",
    "        if direct_connection:\n",
    "            self.direct = nn.Parameter(t.Tensor(layer_widths[0], layer_widths[-1]))\n",
    "            nn.init.kaiming_uniform_(self.direct, a=np.sqrt(5))\n",
    "        else:\n",
    "            self.register_parameter('direct', None)\n",
    "\n",
    "        #Generate the connectivity of the masks.\n",
    "        if not self.connectivity_agnostic:\n",
    "            #Reproducibility - if seeds are set, use first seed to generate the connectivity\n",
    "            #for all.\n",
    "            if seeds is not None:\n",
    "                seed = seeds[0]\n",
    "            else:\n",
    "                seed = None\n",
    "                \n",
    "            #If not agnostic, then use the same connectivity for all\n",
    "            self.connectivity = self.generate_connectivity(seed)\n",
    "        else:\n",
    "            #Otherwise, use a different one for each mask.\n",
    "            self.connectivity = None\n",
    "            \n",
    "        #Generate masks\n",
    "        if num_masks > 0:\n",
    "            masks = self.generate_masks()\n",
    "        else:\n",
    "            #If num_masks is negative, generate a new mask for every\n",
    "            #pass.\n",
    "            masks = None\n",
    "        self.masks = masks\n",
    "        \n",
    "    def generate_masks(self):\n",
    "        masks_list = []\n",
    "        for idx in range(self.num_masks):\n",
    "            layer_masks = self.generate_layer_masks(self.mask_seeds[idx])\n",
    "            masks_list.append(layer_masks)\n",
    "        return masks_list\n",
    "    \n",
    "    def generate_connectivity(self, seed=None):\n",
    "        rng = np.random.RandomState(seed)\n",
    "        connectivity = [rng.randint(1, self.in_features, size=self.layers[0].out_features)]\n",
    "        for layer in self.layers[1:]:\n",
    "            layer_connectivity = rng.randint(connectivity[-1].min(), self.in_features, size=layer.out_features)\n",
    "            connectivity.append(layer_connectivity)\n",
    "        return connectivity\n",
    "\n",
    "    def generate_layer_masks(self, seed=None):\n",
    "        rng = np.random.RandomState(seed)\n",
    "        m = [np.arange(self.in_features)]\n",
    "        #If it's order agnostic, we shuffle the input order.\n",
    "        if self.order_agnostic:\n",
    "            rng.shuffle(m[0])\n",
    "\n",
    "        #If it's connection agnostic, we change the connectivity.\n",
    "        if self.connectivity_agnostic:\n",
    "            connectivity = self.generate_connectivity(seed)\n",
    "        else:\n",
    "            connectivity = self.connectivity\n",
    "        m.extend(connectivity)\n",
    "\n",
    "        # construct the mask matrices\n",
    "        L = len(self.layers)\n",
    "        masks = [m[index][:,None] <= m[index+1][None,:] for index in range(L)]\n",
    "        masks.append(m[L][:,None] < m[0][None,:])\n",
    "        #First mask needs to be fixed for conditioned data\n",
    "        if self.in_conditions > 0:\n",
    "            extra_connections = np.ones((self.in_conditions, self.layers[0].out_features))\n",
    "            masks[0] = np.concatenate([masks[0], extra_connections], 0)\n",
    "        return masks\n",
    "    \n",
    "    def next_mask(self):\n",
    "        if self.num_masks == 1:\n",
    "            #We don't need to change the mask\n",
    "            return\n",
    "        elif self.num_masks == 0:\n",
    "            masks = self.generate_layer_masks()\n",
    "        else:\n",
    "            self.mask_idx = (self.mask_idx+1) % self.num_masks\n",
    "            masks = self.masks[self.mask_idx]\n",
    "        \n",
    "        for layer, mask in zip(self.layers, masks):\n",
    "            layer.set_mask(mask)\n",
    "    \n",
    "    def forward(self, input, condition=None):\n",
    "        '''\n",
    "        Does a forward pass.\n",
    "        \n",
    "        :param input: (t.Tensor)\n",
    "        :param condition: (t.Tensor)\n",
    "        '''\n",
    "        if condition is not None:\n",
    "            assert self.in_conditions == condition.shape[1], \\\n",
    "                'Expected {} conditions, but recieved condition of size {}'.format(self.in_conditions, condition.shape[1:])\n",
    "            x = t.cat([input, condition], 1)\n",
    "        else:\n",
    "            assert self.in_conditions == 0, 'This model does not use a conditioning variable.'\n",
    "            x = input\n",
    "\n",
    "        if self.training:\n",
    "            self.next_mask()\n",
    "\n",
    "        for layer in self.layers[:-1]:\n",
    "            x = F.selu(layer(x))\n",
    "        x = self.layers[-1](x)\n",
    "        if self.direct is not None:\n",
    "            #We use an additional weight matrix to augment the final output.\n",
    "            #The matrix must be strictly lower triangular in order to satisfy\n",
    "            #the autoregressive property.\n",
    "            x += F.linear(input, self.direct.tril(-1))\n",
    "        return x\n",
    "\n",
    "    def ensemble(self, input, condition=None, votes=None, reduction='none'):\n",
    "        '''\n",
    "        Run forward on each input, condition using different masks. The number\n",
    "        of votes cannot be more than the number of masks. If reduction is 'none',\n",
    "        then each mask will return an output. If it is 'mean', then only the\n",
    "        mean of the votes will be returned.\n",
    "        \n",
    "        This is useful for viewing reconstructions by the model, as the mean\n",
    "        reconstruction is typically more accurate.\n",
    "        :param input: (t.Tensor)\n",
    "        :param condition: (t.Tensor)\n",
    "        :param votes: (Int, opt) Number of different masks to cycle through\n",
    "        :param reduction: (Str, opt) Whether to return each vote or the\n",
    "            average vote.\n",
    "        '''\n",
    "        votes = votes or self.num_masks\n",
    "        assert votes > 0, 'Votes should be a positive integer.'\n",
    "        assert (votes <= self.num_masks) or (self.num_masks == 0), \\\n",
    "            'Votes cannot be more than the number of masks ({}).'.format(self.num_masks)\n",
    "        prediction = t.zeros((votes,) + input.shape, device=input.device)\n",
    "        for idx in range(votes):\n",
    "            self.next_mask()\n",
    "            prediction[idx,:] = t.sigmoid(self.forward(input, condition))\n",
    "        if reduction == 'mean':\n",
    "            return prediction.mean(0)\n",
    "        else:\n",
    "            return prediction\n",
    "        \n",
    "    def unmask(self):\n",
    "        '''\n",
    "        sets all masks to be identically 1, effectively removing all masks.\n",
    "        '''\n",
    "        for layer in self.layers:\n",
    "            mask_shape = layer.weight.shape\n",
    "            layer.set_mask(np.ones(mask_shape).T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training setup\n",
    "\n",
    "Training is done using pytorch lightning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.utils.data as data\n",
    "import torchvision.datasets as datasets\n",
    "import torchvision.transforms as transforms\n",
    "import pytorch_lightning as pl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MADE_system(pl.LightningModule):\n",
    "    def __init__(self, model, batch_size=128):\n",
    "        super(MADE_system, self).__init__()\n",
    "        self.net = model\n",
    "        self.batch_size = batch_size\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.net.forward(x)\n",
    "\n",
    "    def training_step(self, batch, batch_nb):\n",
    "        x, y = batch\n",
    "        x = x.view((-1, 28**2))\n",
    "        x_hat = self.forward(x)\n",
    "        \n",
    "        loss = BCELoss(x_hat, x)\n",
    "        \n",
    "        self.net.next_mask()\n",
    "        return {'loss': loss}\n",
    "\n",
    "    def validation_step(self, batch, batch_nb):\n",
    "        x, y = batch\n",
    "        x = x.view((-1, 28**2))\n",
    "        x_hat = self.forward(x)\n",
    "        \n",
    "        loss = BCELoss(x_hat, x)\n",
    "        \n",
    "        self.net.next_mask()\n",
    "        return {'loss': loss}\n",
    "\n",
    "    def validation_end(self, outputs):\n",
    "        # OPTIONAL\n",
    "        avg_loss = t.stack([x['loss'] for x in outputs]).mean()\n",
    "        return {'avg_loss': avg_loss}\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        # Same optimizer used in tf implementation\n",
    "        return t.optim.AdamW(self.net.parameters(), lr=0.001)\n",
    "\n",
    "    @pl.data_loader\n",
    "    def tng_dataloader(self):\n",
    "        #Set up training data. We use these to optimize our network.\n",
    "        dset = datasets.MNIST(root='./', train=True, download=False, transform=transforms.ToTensor())\n",
    "        training_set = data.Subset(dset, range(50000))\n",
    "        return data.DataLoader(training_set, batch_size=self.batch_size, num_workers=4)\n",
    "\n",
    "    @pl.data_loader\n",
    "    def val_dataloader(self):\n",
    "        #Set up validation data. We use the last 10k for training. These are never used for optimization.\n",
    "        dset = datasets.MNIST(root='./', train=True, download=False, transform=transforms.ToTensor())\n",
    "        testing_set = data.Subset(dset, range(50000+1,60000))\n",
    "        return data.DataLoader(testing_set, batch_size=self.batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def BCELoss(input, target):\n",
    "    #Implements binary cross entropy with logits that takes a batch average.\n",
    "    loss = F.binary_cross_entropy_with_logits(input, target)\n",
    "    loss = loss.mean(0)\n",
    "    return loss.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pytorch_lightning import Trainer\n",
    "from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint_callback = ModelCheckpoint(\n",
    "    filepath='./models/MADE',\n",
    "    save_best_only=True,\n",
    "    verbose=True,\n",
    "    monitor='avg_loss',\n",
    "    mode='min',\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_widths = [28**2,] + [1000]*2 + [28**2,]\n",
    "num_masks = 64\n",
    "model = MADE(layer_widths, num_masks, direct_connection=True, mask_conditioning=False)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "system = MADE_system(model, batch_size=500)\n",
    "trainer = Trainer(gpus=[0],\n",
    "                  max_nb_epochs=100,\n",
    "                  checkpoint_callback=checkpoint_callback)\n",
    "\n",
    "trainer.fit(system)\n",
    "t.save(model.state_dict(), './models/MADE.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.load_state_dict(t.load('./models/MADE.pkl', map_location='cpu'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image Reconstruction\n",
    "\n",
    "Below I show off some image reconstructions. This is because it's an effective (and pleasing) way to see what their results.\n",
    "\n",
    "### Ensemble Reconstruction\n",
    "The reconstructions performed by the MADE model using a single mask tend to be fairly noisy. This makes sense when you consider the impact of the autoregressive property. As each pixel can only depend on prior pixels, we run into an issue with the first pixel. Specifically, there is no input from the image for deciding that pixel. For any image, the first pixel will be the same. Due to the random connectivity and ordering used in training, the 'first pixel' is usually multiple pixels that get distributed around the image.\n",
    "\n",
    "To reduce the effects of noise, we can use ensembles to reconstruct an image. In this case, the ensemble is formed by running the image through the model for multiple masks. This is expensive, as it requires passing through the batch once for each mask. The result is more accurate since the initial noise from the model is diminished by taking the average. However, the ensemble will typically not be autoregressive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pylab as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def image_plot(axis, image, **kwargs):\n",
    "    axis.imshow(image.view(28,28), cmap='Greys', **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_images = 6\n",
    "\n",
    "images = datasets.MNIST(root='./', train=True, download=True, transform=transforms.ToTensor())\n",
    "test_loader = data.DataLoader(images, batch_size=n_images)\n",
    "samples = next(iter(test_loader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 24 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Set up picture\n",
    "ax_settings = {'aspect':'equal', 'xticklabels':[], 'yticklabels':[], 'xticks':[], 'yticks':[]}\n",
    "fig, ax = plt.subplots(4, n_images, subplot_kw=ax_settings, figsize=(n_images*3//2, 6))\n",
    "\n",
    "\n",
    "if num_masks == 0:\n",
    "    votes = 16\n",
    "else:\n",
    "    votes = num_masks\n",
    "\n",
    "model.cpu()\n",
    "model.eval()\n",
    "with t.no_grad():\n",
    "    images, _ = samples\n",
    "    images = images.view((n_images, 28**2))\n",
    "\n",
    "    recons = model.ensemble(images, votes=votes, reduction='none')\n",
    "\n",
    "\n",
    "    #Find the mean in latent space\n",
    "    for idx in range(n_images):\n",
    "        image_plot(ax[0, idx], images[idx, :])\n",
    "        image_plot(ax[1, idx], recons[0, idx, :])\n",
    "        image_plot(ax[2, idx], recons[:votes//4, idx, :].mean(0))\n",
    "        image_plot(ax[3, idx], recons[:, idx, :].mean(0))\n",
    "\n",
    "ax[0,-1].text(30.0, 14, 'Original')\n",
    "ax[1,-1].text(30.0, 14, 'Single mask')\n",
    "ax[2,-1].text(30.0, 14, '{} mask ensemble'.format(votes//4))\n",
    "ax[3,-1].text(30.0, 14, '{} mask ensemble'.format(votes))\n",
    "fig.suptitle('Image reconstructions by MADE ensemble')\n",
    "plt.savefig('./images/MADE-ensemble-reconstructions.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unmasked Reconstruction\n",
    "\n",
    "I was curious about was the result of unmasking each layer. Doing a forward pass at this point no longer satisfies the autoregressive property, but I was interested in seeing the result. What I expected is that it would produce images between a single mask and an ensemble. The result achieved is below. While the reconstruction is recognized, the noise is still significant and the character strokes are broader. I tested the result after changing the number of masks. I had originally expected that removing the explicit bound would reduce the noise, but it made for significantly worse results. Similarly, using very few masks also produces poor results after unmasking.\n",
    "\n",
    "The image below is created by unmasking a 64 mask MADE model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.unmask()\n",
    "#Set up picture\n",
    "ax_settings = {'aspect':'equal', 'xticklabels':[], 'yticklabels':[], 'xticks':[], 'yticks':[]}\n",
    "fig, ax = plt.subplots(2, n_images, subplot_kw=ax_settings, figsize=(n_images*3//2, 3))\n",
    "\n",
    "with t.no_grad():\n",
    "\n",
    "    recons = model(images)\n",
    "    #Find the mean in latent space\n",
    "    for idx in range(n_images):\n",
    "        image_plot(ax[0, idx], images[idx, :])\n",
    "        image_plot(ax[1, idx], t.sigmoid(recons[idx, :,]))\n",
    "fig.suptitle('Unmasking a Masked Autoencoder')\n",
    "plt.savefig('./images/MADE-unmasked-reconstructions.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Comments\n",
    "\n",
    "The reason I am interested in MADE is due to a paper on [Inverse Autoregressive Flow](https://arxiv.org/abs/1606.04934v2). The takeaway I want to emphasize is that a MADE network can be attached to a variational autoencoder in order to give it access to more flexible distributions. The autoregressive property is key to the loss estimate used for the latent variables. This is also why I add the conditional/deterministic input."
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}