05_Attend-Infer-Repeat.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "CANVAS_SIZE = 50                      # canvas in which 0/1/2 MNIST digits are put\n",
    "MNIST_SIZE = 24                       # size of original MNIST digits (resized)\n",
    "WINDOW_SIZE = MNIST_SIZE              # patch size (in one dimension) of what-VAE\n",
    "Z_WHAT_HIDDEN_DIM = 400               # hidden dimension of what-VAE\n",
    "Z_WHAT_DIM = 20                       # latent dimension of what-VAE\n",
    "FIXED_VAR = 0.6**2                    # fixed variance of Gaussian decoder\n",
    "Z_PRES_DIM = 1                        # latent dimension of z_pres\n",
    "Z_WHERE_DIM = 3                       # latent dimension of z_where\n",
    "RNN_HIDDEN_STATE_DIM = 256            # hidden state dimension of RNN\n",
    "P_PRES_INIT = [2.]                    # initialization p_pres (sigmoid -> 0.8)\n",
    "MU_WHERE_INIT = [3.0, 0., 0.]         # initialization z_where mean\n",
    "LOG_VAR_WHERE_INIT = [-3.,-3.,-3.]    # initialization z_where log var\n",
    "Z_DIM = Z_PRES_DIM + Z_WHERE_DIM + Z_WHAT_DIM \n",
    "N = 3                                 # number of inference steps\n",
    "EPS = 1e-32                           # numerical stability\n",
    "PRIOR_MEAN_WHERE = [3., 0., 0.]       # prior for mean of z_i_where\n",
    "PRIOR_VAR_WHERE = [0.1**2, 1., 1.]    # prior for variance of z_i_where\n",
    "PRIOR_P_PRES = [0.01]                 # prior for p_i_pres of z_i_pres\n",
    "BETA = 0.5                            # hyperparameter to scale KL div\n",
    "OMEGA_DIM = Z_PRES_DIM + 2*Z_WHERE_DIM + 2*Z_WHAT_DIM\n",
    "EPOCHS = 50                           # number of training epochs\n",
    "BATCH_SIZE = 64  \n",
    "LEARNING_RATE = 1e-4                  # learning rate of model\n",
    "BASE_LEARNING_RATE = 1e-2             # learning rate of neural baseline\n",
    "EPOCHS_TO_SAVE_MODEL = [1, 10, EPOCHS]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import os\n",
    "import numpy as np\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import TensorDataset\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Bernoulli\n",
    "from livelossplot import PlotLosses, outputs\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "if not os.path.exists('results'):\n",
    "    os.makedirs('results')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_dataset(num_images, SEED=1):\n",
    "    \"\"\"generates multiple MNIST dataset with 0, 1 or 2 non-overlaping digits\n",
    "\n",
    "    Args:\n",
    "        num_images (int): number of images inside dataset\n",
    "\n",
    "    Returns:\n",
    "        multiple_MNIST (torch dataset)\n",
    "    \"\"\"\n",
    "    data = torch.zeros([num_images, 1, CANVAS_SIZE, CANVAS_SIZE])\n",
    "\n",
    "    original_MNIST = datasets.MNIST('.', train=True, download=True,\n",
    "        transform=transforms.Compose([\n",
    "          transforms.Resize(size=(MNIST_SIZE, MNIST_SIZE)),\n",
    "          transforms.ToTensor()]))\n",
    "    # sample random digits and positions\n",
    "    np.random.seed(SEED)\n",
    "    pos_positions = np.arange(int(MNIST_SIZE/2),CANVAS_SIZE - int(MNIST_SIZE/2))\n",
    "\n",
    "    mnist_indices = np.random.randint(len(original_MNIST), size=(num_images, 2))\n",
    "    num_digits = np.random.randint(3, size=(num_images))\n",
    "    positions_0 = np.random.choice(pos_positions, size=(num_images, 2),\n",
    "                                   replace=True)\n",
    "\n",
    "    for i_data in range(num_images):\n",
    "        if num_digits[i_data] > 0:\n",
    "            # add random digit at random position\n",
    "            random_digit = original_MNIST[mnist_indices[i_data][0]][0]\n",
    "            x_0, y_0 = positions_0[i_data][0], positions_0[i_data][1]\n",
    "            x = [x_0-int(MNIST_SIZE/2), x_0+int(MNIST_SIZE/2)]\n",
    "            y = [y_0-int(MNIST_SIZE/2), y_0+int(MNIST_SIZE/2)]\n",
    "            data[i_data,:,y[0]:y[1],x[0]:x[1]] += random_digit\n",
    "            if num_digits[i_data] == 2:\n",
    "                # add second non overlaping random digit\n",
    "                random_digit = original_MNIST[mnist_indices[i_data][1]][0]\n",
    "                impos_x_pos = np.arange(x_0-int(MNIST_SIZE/2),\n",
    "                                        x_0+int(MNIST_SIZE/2))\n",
    "                impos_y_pos = np.arange(y_0-int(MNIST_SIZE/2),\n",
    "                                        y_0+int(MNIST_SIZE/2))\n",
    "                x_1 = np.random.choice(np.setdiff1d(pos_positions, impos_x_pos),\n",
    "                                       size=1)[0]\n",
    "                y_1 = np.random.choice(np.setdiff1d(pos_positions, impos_y_pos),\n",
    "                                       size=1)[0]\n",
    "                x = [x_1-int(MNIST_SIZE/2), x_1+int(MNIST_SIZE/2)]\n",
    "                y = [y_1-int(MNIST_SIZE/2), y_1+int(MNIST_SIZE/2)]\n",
    "                data[i_data,:,y[0]:y[1],x[0]:x[1]] += random_digit\n",
    "    labels = torch.from_numpy(num_digits)\n",
    "    return TensorDataset(data.type(torch.float32), labels)\n",
    "  \n",
    "train_dataset = generate_dataset(num_images=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1260x180 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_samples = 7\n",
    "fig = plt.figure(figsize=(n_samples*2.5, 2.5))\n",
    "i_samples = np.random.choice(range(len(train_dataset)), \n",
    "                             n_samples, replace=False)\n",
    "for counter, i_sample in enumerate(i_samples):\n",
    "    img, label = train_dataset[i_sample]\n",
    "    \n",
    "    plt.subplot(1, n_samples, counter + 1)\n",
    "    plt.imshow(transforms.ToPILImage()(img), cmap='gray')\n",
    "    plt.axis('off')\n",
    "    plt.title(str(label.numpy()), fontsize=16, y=-0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VAE(nn.Module):\n",
    "    \"\"\"simple VAE class with a Gaussian encoder (mean and diagonal variance\n",
    "    structure) and a Gaussian decoder with fixed variance\n",
    "\n",
    "    Attributes:\n",
    "        encoder (nn.Sequential): encoder network for mean and log_var\n",
    "        decoder (nn.Sequential): decoder network for mean (fixed var)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super(VAE, self).__init__()\n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Linear(WINDOW_SIZE**2, Z_WHAT_HIDDEN_DIM),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(Z_WHAT_HIDDEN_DIM, Z_WHAT_DIM*2),\n",
    "        )\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.Linear(Z_WHAT_DIM, Z_WHAT_HIDDEN_DIM),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(Z_WHAT_HIDDEN_DIM, WINDOW_SIZE**2),\n",
    "        )\n",
    "        return\n",
    "\n",
    "    def forward(self, x_att_i):\n",
    "        z_what_i, mu_E_i, log_var_E_i = self.encode(x_att_i)\n",
    "        x_tilde_att_i = self.decode(z_what_i)\n",
    "        return x_tilde_att_i, z_what_i, mu_E_i, log_var_E_i\n",
    "\n",
    "    def encode(self, x_att_i):\n",
    "        batch_size = x_att_i.shape[0]\n",
    "        # get encoder distribution parameters\n",
    "        out_encoder = self.encoder(x_att_i.view(batch_size, -1))\n",
    "        mu_E_i, log_var_E_i = torch.chunk(out_encoder, 2, dim=1)\n",
    "        # sample noise variable for each batch\n",
    "        epsilon = torch.randn_like(log_var_E_i)\n",
    "        # get latent variable by reparametrization trick\n",
    "        z_what_i = mu_E_i + torch.exp(0.5*log_var_E_i) * epsilon\n",
    "        return z_what_i, mu_E_i, log_var_E_i\n",
    "\n",
    "    def decode(self, z_what_i):\n",
    "        # get decoder distribution parameters \n",
    "        x_tilde_att_i = self.decoder(z_what_i) \n",
    "        # force output to be positive (EPS for numerical stability)\n",
    "        x_tilde_att_i = (x_tilde_att_i + EPS).abs()\n",
    "        # reshape to [1, WINDOW_SIZE, WINDOW_SIZE] (input shape)\n",
    "        x_tilde_att_i = x_tilde_att_i.view(-1, 1, WINDOW_SIZE, WINDOW_SIZE)\n",
    "        return x_tilde_att_i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN(nn.Module):\n",
    "    \n",
    "    def __init__(self, baseline_net=False):\n",
    "        super(RNN, self).__init__()\n",
    "        self.baseline_net = baseline_net\n",
    "        INPUT_SIZE = CANVAS_SIZE**2 + RNN_HIDDEN_STATE_DIM + Z_DIM\n",
    "        if baseline_net:\n",
    "            OUTPUT_SIZE = (RNN_HIDDEN_STATE_DIM + 1)\n",
    "        else:\n",
    "            OUTPUT_SIZE = (RNN_HIDDEN_STATE_DIM + Z_PRES_DIM + 2*Z_WHERE_DIM)\n",
    "        output_layer = nn.Linear(RNN_HIDDEN_STATE_DIM, OUTPUT_SIZE)\n",
    "        \n",
    "        self.fc_rnn = nn.Sequential(\n",
    "            nn.Linear(INPUT_SIZE, RNN_HIDDEN_STATE_DIM),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(RNN_HIDDEN_STATE_DIM, RNN_HIDDEN_STATE_DIM),\n",
    "            nn.ReLU(),\n",
    "            output_layer\n",
    "        )\n",
    "        if not baseline_net:            \n",
    "            # initialize distribution parameters\n",
    "            output_layer.weight.data[0:7] = nn.Parameter(\n",
    "                torch.zeros(Z_PRES_DIM+2*Z_WHERE_DIM, RNN_HIDDEN_STATE_DIM)\n",
    "            )\n",
    "            output_layer.bias.data[0:7] = nn.Parameter(\n",
    "                torch.tensor(P_PRES_INIT + MU_WHERE_INIT + LOG_VAR_WHERE_INIT)\n",
    "            )\n",
    "        return\n",
    "    \n",
    "    def forward(self, x, z_im1, h_im1):\n",
    "        batch_size = x.shape[0]\n",
    "        rnn_input = torch.cat((x.view(batch_size, -1), z_im1, h_im1), dim=1)\n",
    "        rnn_output = self.fc_rnn(rnn_input)\n",
    "        if self.baseline_net:\n",
    "            baseline_value_i = rnn_output[:, 0:1]\n",
    "            h_i = rnn_output[:, 1::]\n",
    "            return baseline_value_i, h_i\n",
    "        else:\n",
    "            omega_i = rnn_output[:, 0:(Z_PRES_DIM+2*Z_WHERE_DIM)]\n",
    "            h_i = rnn_output[:, (Z_PRES_DIM+2*Z_WHERE_DIM)::]\n",
    "            # omega_i[:, 0] corresponds to z_pres probability\n",
    "            omega_i[:, 0] = torch.sigmoid(omega_i[:, 0])\n",
    "            return omega_i, h_i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AIR(nn.Module):\n",
    "    \n",
    "    PRIOR_MEAN_Z_WHERE = nn.Parameter(torch.tensor(PRIOR_MEAN_WHERE), \n",
    "                                      requires_grad=False)\n",
    "    PRIOR_VAR_Z_WHERE = nn.Parameter(torch.tensor(PRIOR_VAR_WHERE), \n",
    "                                     requires_grad=False)\n",
    "    PRIOR_P_Z_PRES = nn.Parameter(torch.tensor(PRIOR_P_PRES),\n",
    "                                  requires_grad=False)\n",
    "    \n",
    "    expansion_indices = torch.LongTensor([1, 0, 2, 0, 1, 3])\n",
    "    target_rectangle = torch.tensor(\n",
    "      [[-1., -1., 1., 1., -1.], \n",
    "       [-1., 1., 1., -1, -1.], \n",
    "       [1., 1., 1., 1., 1.]]\n",
    "    ).view(1, 3, 5)\n",
    "    \n",
    "    def __init__(self):\n",
    "        super(AIR, self).__init__()\n",
    "        self.vae = VAE()\n",
    "        self.rnn = RNN()\n",
    "        self.baseline = RNN(True)\n",
    "        return\n",
    "    \n",
    "    def compute_loss(self, x):\n",
    "        \"\"\"compute the loss of AIR (essentially a VAE loss)\n",
    "        assuming the following prior distributions for the latent variables\n",
    "        \n",
    "            z_where ~ N(PRIOR_MEAN_WHERE, PRIOR_VAR_WHERE)\n",
    "            z_what ~ N([0, 1])\n",
    "            z_pres ~ Bern(p_pres)\n",
    "        \n",
    "        and a \n",
    "        \n",
    "            Gaussian decoder with fixed diagonal var (FIXED_VAR)\n",
    "        \"\"\"\n",
    "        batch_size = x.shape[0]\n",
    "        results = self.forward(x, True)\n",
    "        # kl_div for z_pres (between two Bernoulli distributions)\n",
    "        q_z_pres = results['all_prob_pres']\n",
    "        P_Z_PRES = AIR.PRIOR_P_Z_PRES.expand(q_z_pres.shape).to(x.device)\n",
    "        kl_div_pres = AIR.bernoulli_kl(q_z_pres, P_Z_PRES).sum(axis=2)\n",
    "        # kl_div for z_what (standard VAE regularization term)\n",
    "        q_z_what = [results['all_mu_what'], results['all_log_var_what']]\n",
    "        P_MU_WHAT = torch.zeros_like(results['all_mu_what'])\n",
    "        P_VAR_WHAT = torch.ones_like(results['all_log_var_what'])\n",
    "        P_Z_WHAT = [P_MU_WHAT, P_VAR_WHAT]\n",
    "        kl_div_what = AIR.gaussian_kl(q_z_what, P_Z_WHAT).sum(axis=2)\n",
    "        # kl_div for z_where (between two Gaussian distributions)\n",
    "        q_z_where = [results['all_mu_where'], results['all_log_var_where']]\n",
    "        P_MU_WHERE=AIR.PRIOR_MEAN_Z_WHERE.expand(results['all_mu_where'].shape)\n",
    "        P_VAR_WHERE=AIR.PRIOR_VAR_Z_WHERE.expand(results['all_mu_where'].shape)\n",
    "        P_Z_WHERE = [P_MU_WHERE.to(x.device), P_VAR_WHERE.to(x.device)]\n",
    "        kl_div_where = AIR.gaussian_kl(q_z_where, P_Z_WHERE).sum(axis=2)\n",
    "        # sum all kl_divs and use delayed mask to zero out irrelevants\n",
    "        delayed_mask = results['mask_delay']\n",
    "        kl_div = (kl_div_pres + kl_div_where + kl_div_what) * delayed_mask\n",
    "        # negative log-likelihood for Gaussian decoder (no gradient for z_pres)\n",
    "        factor = 0.5 * (1/FIXED_VAR)\n",
    "        nll = factor * ((x - results['x_tilde'])**2).sum(axis=(1,2,3))\n",
    "        # REINFORCE estimator for nll (gradient for z_pres)\n",
    "        baseline_target = nll.unsqueeze(1)\n",
    "        reinforce_term = ((baseline_target - results['baseline_values']\n",
    "                           ).detach()\n",
    "                          *results['z_pres_likelihood']*delayed_mask).sum(1)            \n",
    "        # baseline model loss\n",
    "        baseline_loss = ((results['baseline_values'] - \n",
    "                          baseline_target.detach())**2 * delayed_mask).sum(1)\n",
    "        loss = dict()\n",
    "        loss['kl_div'] = BETA*kl_div.sum(1).mean()\n",
    "        loss['nll'] = nll.mean()\n",
    "        loss['reinforce'] = reinforce_term.mean()\n",
    "        loss['baseline'] = baseline_loss.mean()\n",
    "        return loss, results\n",
    "      \n",
    "    def forward(self, x, save_attention_rectangle=False):\n",
    "        batch_size = x.shape[0]        \n",
    "        # initializations\n",
    "        all_z = torch.empty((batch_size, N, Z_DIM), device=x.device)\n",
    "        z_pres_likelihood = torch.empty((batch_size, N), device=x.device)\n",
    "        mask_delay = torch.empty((batch_size, N), device=x.device)\n",
    "        all_omega = torch.empty((batch_size, N, OMEGA_DIM), device=x.device)\n",
    "        all_x_tilde = torch.empty((batch_size, N, CANVAS_SIZE, CANVAS_SIZE),\n",
    "                                 device=x.device)\n",
    "        baseline_values = torch.empty((batch_size, N), device=x.device)\n",
    "        \n",
    "        z_im1 = torch.ones((batch_size, Z_DIM)).to(x.device)\n",
    "        h_im1 = torch.zeros((batch_size, RNN_HIDDEN_STATE_DIM)).to(x.device)\n",
    "        h_im1_b = torch.zeros((batch_size, RNN_HIDDEN_STATE_DIM)).to(x.device)\n",
    "        if save_attention_rectangle:\n",
    "            attention_rects = torch.empty((batch_size, N, 2, 5)).to(x.device)\n",
    "        for i in range(N):\n",
    "            z_im1_pres = z_im1[:, 0:1]\n",
    "            # mask_delay is used to zero out all steps AFTER FIRST z_pres = 0\n",
    "            mask_delay[:, i] = z_im1_pres.squeeze(1)\n",
    "            # obtain parameters of sampling distribution and hidden state\n",
    "            omega_i, h_i = self.rnn(x, z_im1, h_im1)\n",
    "            # baseline version\n",
    "            baseline_i, h_i_b = self.baseline(x.detach(), z_im1.detach(), \n",
    "                                              h_im1_b)\n",
    "            # set baseline 0 if z_im1_pres = 0\n",
    "            baseline_value = (baseline_i * z_im1_pres).squeeze()\n",
    "            # extract sample distributions parameters from omega_i\n",
    "            prob_pres_i = omega_i[:, 0:1]\n",
    "            mu_where_i = omega_i[:, 1:4]\n",
    "            log_var_where_i = omega_i[:, 4:7]\n",
    "            # sample from distributions to obtain z_i_pres and z_i_where\n",
    "            z_i_pres_post = Bernoulli(probs=prob_pres_i)\n",
    "            z_i_pres = z_i_pres_post.sample() * z_im1_pres\n",
    "            # likelihood of sampled z_i_pres (only if z_im_pres = 1)\n",
    "            z_pres_likelihood[:, i] = (z_i_pres_post.log_prob(z_i_pres) * \n",
    "                                       z_im1_pres).squeeze(1)\n",
    "            # get z_i_where by reparametrization trick\n",
    "            epsilon_w = torch.randn_like(log_var_where_i)\n",
    "            z_i_where = mu_where_i + torch.exp(0.5*log_var_where_i)*epsilon_w\n",
    "            # use z_where and x to obtain x_att_i\n",
    "            x_att_i = AIR.image_to_window(x, z_i_where)\n",
    "            # put x_att_i through VAE\n",
    "            x_tilde_att_i, z_i_what, mu_what_i, log_var_what_i = \\\n",
    "                self.vae(x_att_i)\n",
    "            # create image reconstruction\n",
    "            x_tilde_i = AIR.window_to_image(x_tilde_att_i, z_i_where)\n",
    "            # update im1 with current versions\n",
    "            z_im1 = torch.cat((z_i_pres, z_i_where, z_i_what), 1)\n",
    "            h_im1 = h_i\n",
    "            h_im1_b = h_i_b\n",
    "            # put all distribution parameters into omega_i\n",
    "            omega_i = torch.cat((prob_pres_i, mu_where_i, log_var_where_i,\n",
    "                                 mu_what_i, log_var_what_i), 1)\n",
    "            # store intermediate results\n",
    "            all_z[:, i:i+1] = z_im1.unsqueeze(1)\n",
    "            all_omega[:, i:i+1] = omega_i.unsqueeze(1)\n",
    "            all_x_tilde[:, i:i+1] = x_tilde_i\n",
    "            baseline_values[:, i] = baseline_value\n",
    "            # for nice visualization\n",
    "            if save_attention_rectangle:\n",
    "                attention_rects[:, i] = (AIR.get_attention_rectangle(z_i_where)\n",
    "                                         *z_i_pres.unsqueeze(1)) \n",
    "        # save results in dict (easy accessibility)\n",
    "        results = dict()\n",
    "        # fixes Z_PRES_DIM = 1 and Z_WHERE_DIM = 3\n",
    "        results['z_pres_likelihood'] = z_pres_likelihood\n",
    "        results['all_z_pres'] = all_z[:, :, 0:1]\n",
    "        results['mask_delay'] = mask_delay\n",
    "        results['all_prob_pres'] = all_omega[:, :, 0:1]\n",
    "        results['all_z_where'] = all_z[:, :, 1:4]\n",
    "        results['all_mu_where'] =  all_omega[:, :, 1:4]\n",
    "        results['all_log_var_where'] = all_omega[:, :, 4:7]\n",
    "        results['all_z_what'] = all_z[:, :, 4::]\n",
    "        results['all_mu_what'] =  all_omega[:, :, 7:7+Z_WHAT_DIM]\n",
    "        results['all_log_var_what'] = all_omega[:, :, 7+Z_WHAT_DIM::]\n",
    "        results['baseline_values'] = baseline_values\n",
    "        if save_attention_rectangle:\n",
    "            results['attention_rects'] = attention_rects\n",
    "        # compute reconstructed image (take only x_tilde_i with z_i_pres=1)\n",
    "        results['x_tilde_i'] = all_x_tilde\n",
    "        x_tilde = (all_z[:, :, 0:1].unsqueeze(2) * all_x_tilde).sum(axis=1,\n",
    "                                                              keepdim=True)\n",
    "        results['x_tilde'] = x_tilde\n",
    "        # compute counts as identified objects (sum z_i_pres)\n",
    "        results['counts'] = results['all_z_pres'].sum(1).to(dtype=torch.long)\n",
    "        return results\n",
    "      \n",
    "    @staticmethod\n",
    "    def image_to_window(x, z_i_where):\n",
    "        grid_shape = (z_i_where.shape[0], 1, WINDOW_SIZE, WINDOW_SIZE)\n",
    "        z_i_where_inv = AIR.invert_z_where(z_i_where)\n",
    "        x_att_i = AIR.spatial_transform(x, z_i_where_inv, grid_shape)\n",
    "        return x_att_i\n",
    "    \n",
    "    @staticmethod\n",
    "    def window_to_image(x_tilde_att_i, z_i_where):\n",
    "        grid_shape = (z_i_where.shape[0], 1, CANVAS_SIZE, CANVAS_SIZE)\n",
    "        x_tilde_i = AIR.spatial_transform(x_tilde_att_i, z_i_where, grid_shape)\n",
    "        return x_tilde_i\n",
    "    \n",
    "    @staticmethod\n",
    "    def spatial_transform(x, z_where, grid_shape):\n",
    "        theta_matrix = AIR.z_where_to_transformation_matrix(z_where)\n",
    "        grid = F.affine_grid(theta_matrix, grid_shape, align_corners=False)\n",
    "        out = F.grid_sample(x, grid, align_corners=False)\n",
    "        return out\n",
    "    \n",
    "    @staticmethod\n",
    "    def z_where_to_transformation_matrix(z_i_where):\n",
    "        \"\"\"taken from\n",
    "        https://github.com/pyro-ppl/pyro/blob/dev/examples/air/air.py\n",
    "        \"\"\"\n",
    "        batch_size = z_i_where.shape[0]\n",
    "        out = torch.cat((z_i_where.new_zeros(batch_size, 1), z_i_where), 1)\n",
    "        ix = AIR.expansion_indices\n",
    "        if z_i_where.is_cuda:\n",
    "            ix = ix.cuda()\n",
    "        out = torch.index_select(out, 1, ix)\n",
    "        theta_matrix = out.view(batch_size, 2, 3)\n",
    "        return theta_matrix\n",
    "    \n",
    "    @staticmethod\n",
    "    def invert_z_where(z_where):\n",
    "        z_where_inv = torch.zeros_like(z_where)\n",
    "        scale = z_where[:, 0:1] + 1e-9\n",
    "        z_where_inv[:, 1:3] = -z_where[:, 1:3] / scale\n",
    "        z_where_inv[:, 0:1] = 1 / scale\n",
    "        return z_where_inv\n",
    "    \n",
    "    @staticmethod\n",
    "    def get_attention_rectangle(z_i_where):\n",
    "        batch_size = z_i_where.shape[0]\n",
    "        z_i_where_inv = AIR.invert_z_where(z_i_where)\n",
    "        theta_matrix = AIR.z_where_to_transformation_matrix(z_i_where_inv)\n",
    "        target_rectangle = AIR.target_rectangle.expand(batch_size, 3, \n",
    "                                                       5).to(z_i_where.device)\n",
    "        source_rectangle_normalized = torch.matmul(theta_matrix,\n",
    "                                                   target_rectangle)\n",
    "        # remap into absolute values\n",
    "        source_rectangle = 0 + (CANVAS_SIZE/2)*(source_rectangle_normalized + 1)\n",
    "        return source_rectangle\n",
    "    \n",
    "    @staticmethod\n",
    "    def bernoulli_kl(q_probs, p_probs):\n",
    "        # https://github.com/pytorch/pytorch/issues/15288\n",
    "        p1 = p_probs\n",
    "        p0 = 1 - p1\n",
    "        q1 = q_probs\n",
    "        q0 = 1 - q1  \n",
    "\n",
    "        logq1 = (q1 + EPS).log()\n",
    "        logq0 = (q0 + EPS).log()\n",
    "        logp1 = (p1).log()\n",
    "        logp0 = (p0).log()\n",
    "        \n",
    "        kl_div_1 = q1*(logq1 - logp1)\n",
    "        kl_div_0 = q0*(logq0 - logp0)\n",
    "        return kl_div_1 + kl_div_0\n",
    "    \n",
    "    @staticmethod\n",
    "    def gaussian_kl(q, p):\n",
    "        # https://pytorch.org/docs/stable/_modules/torch/distributions/kl.html\n",
    "        mean_q, log_var_q = q[0], q[1]\n",
    "        mean_p, var_p = p[0], p[1]\n",
    "        \n",
    "        var_ratio = log_var_q.exp()/var_p\n",
    "        t1 = (mean_q - mean_p).pow(2)/var_p\n",
    "        return -0.5 * (1 + var_ratio.log() - var_ratio - t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(air, dataset):\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    print('Device: {}'.format(device))\n",
    "\n",
    "    data_loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True,\n",
    "                             num_workers=4)\n",
    "    optimizer = torch.optim.Adam([{'params': list(air.rnn.parameters()) +\n",
    "                                   list(air.vae.parameters()),\n",
    "                                   'lr': LEARNING_RATE,},\n",
    "                                  {'params': air.baseline.parameters(),\n",
    "                                   'lr': BASE_LEARNING_RATE}])\n",
    "    air.to(device)\n",
    "\n",
    "    # prettify livelossplot\n",
    "    def custom(ax: plt.Axes, group: str, x_label: str):\n",
    "        ax.legend()\n",
    "        if group == 'accuracy':\n",
    "            ax.set_ylim(0, 1)\n",
    "        elif group == 'loss base':\n",
    "            ax.set_ylim(0, 300)\n",
    "\n",
    "    matplot = [outputs.MatplotlibPlot(after_subplot=custom,max_cols=3)]\n",
    "    losses_plot = PlotLosses(groups={'loss model':['KL div','NLL','REINFORCE'],\n",
    "                                     'loss base': ['baseline'],\n",
    "                                     'accuracy': ['count accuracy']},\n",
    "                             outputs=matplot)\n",
    "    for epoch in range(1, EPOCHS+1):\n",
    "        avg_kl_div, avg_nll, avg_reinforce, avg_base, avg_acc = 0, 0, 0, 0, 0\n",
    "        for x, label in data_loader:\n",
    "            air.zero_grad()\n",
    "\n",
    "            losses, results = air.compute_loss(x.to(device, non_blocking=True))\n",
    "            loss  = (losses['kl_div'] + losses['nll'] + losses['reinforce']\n",
    "                     +losses['baseline'])\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            # compute accuracy\n",
    "            label = label.unsqueeze(1).to(device)\n",
    "            acc = (results['counts']==label).sum().item()/len(results['counts'])\n",
    "            # update epoch means\n",
    "            avg_kl_div += losses['kl_div'].item() / len(data_loader)\n",
    "            avg_nll += losses['nll'].item() / len(data_loader)\n",
    "            avg_reinforce += losses['reinforce'].item() / len(data_loader)\n",
    "            avg_base += losses['baseline'].item() / len(data_loader)\n",
    "            avg_acc += acc / len(data_loader)\n",
    "\n",
    "        if epoch in EPOCHS_TO_SAVE_MODEL:  # save model\n",
    "            torch.save(air, f'./results/checkpoint_{epoch}.pth')\n",
    "        losses_plot.update({'KL div': avg_kl_div,\n",
    "                            'NLL': avg_nll,\n",
    "                            'REINFORCE': avg_reinforce,\n",
    "                            'baseline': avg_base,\n",
    "                            'count accuracy': avg_acc}, current_step=epoch)\n",
    "        losses_plot.send()\n",
    "    print(f'Accuracy after Training {avg_acc:.2f} (on training dataset)')\n",
    "    torch.save(air, f'./results/checkpoint_{epoch}.pth')\n",
    "    trained_air = air\n",
    "    return trained_air"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x576 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy after Training 1.00 (on training dataset)\n"
     ]
    }
   ],
   "source": [
    "air_model = AIR()\n",
    "train_dataset = generate_dataset(num_images=10000, SEED=np.random.randint(1000))\n",
    "trained_air = train(air_model, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 28 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_results(dataset):\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    n_samples = 7\n",
    "\n",
    "    i_samples = np.random.choice(range(len(dataset)), n_samples, replace=False)\n",
    "    colors_rect = ['red', 'green', 'yellow']\n",
    "    num_rows = len(EPOCHS_TO_SAVE_MODEL) + 1\n",
    "\n",
    "    fig = plt.figure(figsize=(14, 8))\n",
    "    for counter, i_sample in enumerate(i_samples):\n",
    "        orig_img = dataset[i_sample][0]\n",
    "        # data\n",
    "        ax = plt.subplot(num_rows, n_samples, 1 + counter)\n",
    "        plt.imshow(orig_img[0].numpy(), cmap='gray', vmin=0, vmax=1)\n",
    "        plt.axis('off')\n",
    "        if counter == 0:\n",
    "            ax.annotate('Data', xy=(-0.05, 0.5), xycoords='axes fraction',\n",
    "                        fontsize=14, va='center', ha='right', rotation=90)\n",
    "        for j, epoch in enumerate(EPOCHS_TO_SAVE_MODEL):\n",
    "            trained_air = torch.load(f'./results/checkpoint_{epoch}.pth')\n",
    "            trained_air.to(device)\n",
    "\n",
    "            results = trained_air(orig_img.unsqueeze(0).to(device), True)\n",
    "\n",
    "            attention_recs = results['attention_rects'].squeeze(0)\n",
    "            x_tilde = torch.clamp(results['x_tilde'][0], 0 , 1)\n",
    "\n",
    "            ax = plt.subplot(num_rows, n_samples, 1 + counter + n_samples*(j+1))\n",
    "            plt.imshow(x_tilde[0].cpu().detach().numpy(), cmap='gray',\n",
    "                       vmin=0, vmax=1)\n",
    "            plt.axis('off')\n",
    "            # show attention windows\n",
    "            for step_counter, step in enumerate(range(N)):\n",
    "                rect = attention_recs[step].detach().cpu().numpy()\n",
    "                if rect.sum() > 0:  # valid rectangle\n",
    "                    plt.plot(rect[0], rect[1]-0.5,\n",
    "                             color=colors_rect[step_counter])\n",
    "            if counter == 0:\n",
    "                # compute accuracy\n",
    "                data_loader = DataLoader(dataset, batch_size=BATCH_SIZE)\n",
    "                avg_acc = 0\n",
    "                for batch, label in data_loader:\n",
    "                    label = label.unsqueeze(1).to(device)\n",
    "                    r = trained_air(batch.to(device))\n",
    "                    acc = (r['counts']==label).sum().item()/len(r['counts'])\n",
    "                    avg_acc += acc / len(data_loader)\n",
    "                # annotate plot\n",
    "                ax.annotate(f'Epoch {epoch}\\n Acc {avg_acc:.2f}',\n",
    "                            xy=(-0.05, 0.5), va='center',\n",
    "                            xycoords='axes fraction', fontsize=14,  ha='right',\n",
    "                            rotation=90)\n",
    "    return\n",
    "\n",
    "\n",
    "test_dataset = generate_dataset(num_images=300, SEED=2)\n",
    "plot_results(test_dataset)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}