From 72ea4e66ab41b14bb123abc4266ea0ed0d0fef14 Mon Sep 17 00:00:00 2001 From: Jessica Dafflon Date: Thu, 26 Aug 2021 18:41:06 -0400 Subject: [PATCH] Add Blind spot and Gated CNN code --- .../PixelCNN_Blind_spot.ipynb | 1108 +++++++++++++++++ .../pixelcnn_blind_spot.py | 650 ++++++++++ 2 files changed, 1758 insertions(+) create mode 100644 3 - PixelCNNs Blind spot and Gated PixelCNNs/PixelCNN_Blind_spot.ipynb create mode 100644 3 - PixelCNNs Blind spot and Gated PixelCNNs/pixelcnn_blind_spot.py diff --git a/3 - PixelCNNs Blind spot and Gated PixelCNNs/PixelCNN_Blind_spot.ipynb b/3 - PixelCNNs Blind spot and Gated PixelCNNs/PixelCNN_Blind_spot.ipynb new file mode 100644 index 0000000..d582176 --- /dev/null +++ b/3 - PixelCNNs Blind spot and Gated PixelCNNs/PixelCNN_Blind_spot.ipynb @@ -0,0 +1,1108 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "PixelCNN - Blind_spot", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "GDNiXfftap_W" + }, + "source": [ + "# Autoregressive models - PixelCNNs blind spot in the receptive field and how to fix it " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gU9fNJ8F2JP6" + }, + "source": [ + "In our previous notebooks, we trained a generative model to create black and white drawings of numbers and to generate coloured images. Now we are going to look into the blind splot, one of the biggested drawbacks of the PixelCNNs and how to fix it. We will also define the Gated PixelCNN and analyse its performance on the MNIST dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q6fjrw1KDC0p" + }, + "source": [ + "This implementation uses Tensorflow 2.0. We start by installing and importing the code dependencies.\n", + "\n", + "*Note: Here we are using float64 to get more precise values of the gradients and avoid false values.\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "QZxm9F41DBSG" + }, + "source": [ + "%tensorflow_version 2.x" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "w8mSPfpIdE7L" + }, + "source": [ + "import random as rn\n", + "\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import FixedLocator\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow import nn\n", + "from tensorflow.keras import initializers\n", + "from tensorflow.keras.utils import Progbar\n", + "\n", + "tf.keras.backend.set_floatx('float64')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k110FfjlDuMx" + }, + "source": [ + "Like in the previous notebooks we are defining the Convolutional layers with masks and the ResidualBlocks. The Residual block is an important building block of Oord's seminal paper that originated the PixelCNN.\n", + "\n", + "*Note: Here we removed the ReLU activations to not mess with the gradients while we are investigating them." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "q-NdMaYseHKw" + }, + "source": [ + "class ResidualBlock(keras.Model):\n", + " \"\"\"Residual blocks that compose pixelCNN\n", + "\n", + " Blocks of layers with 3 convolutional layers and one residual connection.\n", + " Based on Figure 5 from [1] where h indicates number of filters.\n", + "\n", + " Refs:\n", + " [1] - Oord, A. V. D., Kalchbrenner, N., & Kavukcuoglu, K. (2016). Pixel recurrent\n", + " neural networks. arXiv preprint arXiv:1601.06759.\n", + " \"\"\"\n", + "\n", + " def __init__(self, h):\n", + " super(ResidualBlock, self).__init__(name='')\n", + "\n", + " self.conv2a = keras.layers.Conv2D(filters=h, kernel_size=1, strides=1)\n", + " self.conv2b = MaskedConv2D(mask_type='B', filters=h, kernel_size=3, strides=1)\n", + " self.conv2c = keras.layers.Conv2D(filters=2 * h, kernel_size=1, strides=1)\n", + "\n", + " def call(self, input_tensor):\n", + "# x = nn.relu(input_tensor)\n", + "# x = self.conv2a(x)\n", + " x = self.conv2a(input_tensor)\n", + "\n", + "# x = nn.relu(x)\n", + " x = self.conv2b(x)\n", + "\n", + "# x = nn.relu(x)\n", + " x = self.conv2c(x)\n", + "\n", + " x += input_tensor\n", + " return x" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "toxhCFUEbDEH" + }, + "source": [ + "## Blind Spots" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "00dbW6maaOad" + }, + "source": [ + "As we saw above, the original PixelCNN had a problem with its masked convolution that lead to a blind spot. Given a specific pixel, the use of masked convolution was not able to capture the information of all previous pixels. As we can see on the image below, the information on *j* is never used to predict *m*; and the information on *j, n, o* are not used to predict *q*. \n", + "\n", + "![masks.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QKIiWy5z7Nnf" + }, + "source": [ + "Let's start by implementing the convolution and looking at how the blind spot propagates. You should be familiar with the class below, as we have used in the previous notebooks. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "vhhJHjj05yhN" + }, + "source": [ + "class MaskedConv2D(keras.layers.Layer):\n", + " \"\"\"Convolutional layers with masks.\n", + "\n", + " Convolutional layers with simple implementation of masks type A and B for\n", + " autoregressive models.\n", + "\n", + " Arguments:\n", + " mask_type: one of `\"A\"` or `\"B\".`\n", + " filters: Integer, the dimensionality of the output space\n", + " (i.e. the number of output filters in the convolution).\n", + " kernel_size: An integer or tuple/list of 2 integers, specifying the\n", + " height and width of the 2D convolution window.\n", + " Can be a single integer to specify the same value for\n", + " all spatial dimensions.\n", + " strides: An integer or tuple/list of 2 integers,\n", + " specifying the strides of the convolution along the height and width.\n", + " Can be a single integer to specify the same value for\n", + " all spatial dimensions.\n", + " Specifying any stride value != 1 is incompatible with specifying\n", + " any `dilation_rate` value != 1.\n", + " padding: one of `\"valid\"` or `\"same\"` (case-insensitive).\n", + " kernel_initializer: Initializer for the `kernel` weights matrix.\n", + " bias_initializer: Initializer for the bias vector.\n", + " \"\"\"\n", + "\n", + " def __init__(self,\n", + " mask_type,\n", + " filters,\n", + " kernel_size,\n", + " strides=1,\n", + " padding='same',\n", + " kernel_initializer='glorot_uniform',\n", + " bias_initializer='zeros'):\n", + " super(MaskedConv2D, self).__init__()\n", + "\n", + " assert mask_type in {'A', 'B'}\n", + " self.mask_type = mask_type\n", + "\n", + " self.filters = filters\n", + " self.kernel_size = kernel_size\n", + " self.strides = strides\n", + " self.padding = padding.upper()\n", + " self.kernel_initializer = initializers.get(kernel_initializer)\n", + " self.bias_initializer = initializers.get(bias_initializer)\n", + "\n", + " def build(self, input_shape):\n", + " self.kernel = self.add_weight('kernel',\n", + " shape=(self.kernel_size,\n", + " self.kernel_size,\n", + " int(input_shape[-1]),\n", + " self.filters),\n", + " initializer=self.kernel_initializer,\n", + " trainable=True)\n", + "\n", + " self.bias = self.add_weight('bias',\n", + " shape=(self.filters,),\n", + " initializer=self.bias_initializer,\n", + " trainable=True)\n", + "\n", + " center = self.kernel_size // 2\n", + "\n", + " mask = np.ones(self.kernel.shape, dtype=np.float64)\n", + " mask[center, center + (self.mask_type == 'B'):, :, :] = 0.\n", + " mask[center + 1:, :, :, :] = 0.\n", + "\n", + " self.mask = tf.constant(mask, dtype=tf.float64, name='mask')\n", + "\n", + " def call(self, input):\n", + " masked_kernel = tf.math.multiply(self.mask, self.kernel)\n", + " x = nn.conv2d(input,\n", + " masked_kernel,\n", + " strides=[1, self.strides, self.strides, 1],\n", + " padding=self.padding)\n", + " x = nn.bias_add(x, self.bias)\n", + " return x" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "tj1b_aLmeKl9" + }, + "source": [ + "def plot_receptive_field(model, data):\n", + " \"\"\"\n", + " This function allows the visualisation of the receptive field\n", + " \"\"\"\n", + " with tf.GradientTape() as tape:\n", + " tape.watch(data)\n", + " prediction = model(data)\n", + " loss = prediction[:,5,5,0]\n", + "\n", + " gradients = tape.gradient(loss, data)\n", + "\n", + " gradients = np.abs(gradients.numpy().squeeze())\n", + " gradients = (gradients > 0).astype('float64')\n", + " gradients[5, 5] = 0.5\n", + "\n", + " fig = plt.figure()\n", + " ax = fig.add_subplot(1, 1, 1)\n", + "\n", + " plt.xticks(np.arange(0, 10, step=1))\n", + " plt.yticks(np.arange(0, 10, step=1))\n", + " ax.xaxis.set_minor_locator(FixedLocator(np.arange(0.5, 10.5, step=1)))\n", + " ax.yaxis.set_minor_locator(FixedLocator(np.arange(0.5, 10.5, step=1)))\n", + " plt.grid(which=\"minor\")\n", + " plt.imshow(gradients, vmin=0, vmax=1)\n", + " plt.show()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "F16Dw0EkdZAN" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "height = 10\n", + "width = 10\n", + "n_channel = 1\n", + "\n", + "data = tf.random.normal((1, height, width, n_channel))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "APMjCAwveKo6" + }, + "source": [ + "# 1 layer PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs)\n", + "model = tf.keras.Model(inputs=inputs, outputs=x)\n", + "\n", + "plot_receptive_field(model, data)\n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "aUHo0N7-6IYa" + }, + "source": [ + "# 2 layer PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs)\n", + "x = ResidualBlock(h=1)(x)\n", + "\n", + "model = tf.keras.Model(inputs=inputs, outputs=x)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "RFMjAntD6Kot" + }, + "source": [ + "# 3 layer PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs)\n", + "x = ResidualBlock(h=1)(x)\n", + "x = ResidualBlock(h=1)(x)\n", + "\n", + "model = tf.keras.Model(inputs=inputs, outputs=x)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "zbsQRrol6O6W" + }, + "source": [ + "# 4 layer PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs)\n", + "x = ResidualBlock(h=1)(x)\n", + "x = ResidualBlock(h=1)(x)\n", + "x = ResidualBlock(h=1)(x)\n", + "\n", + "model = tf.keras.Model(inputs=inputs, outputs=x)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "uaDjY7gK6aBa" + }, + "source": [ + "# 5 layer PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs)\n", + "x = ResidualBlock(h=1)(x)\n", + "x = ResidualBlock(h=1)(x)\n", + "x = ResidualBlock(h=1)(x)\n", + "x = ResidualBlock(h=1)(x)\n", + "\n", + "model = tf.keras.Model(inputs=inputs, outputs=x)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "deJlu0x4cesJ" + }, + "source": [ + "## Gated Pixel CNN and the blind spot\n", + "\n", + "A big drawback of PixelCNNs is the blind spot in the receptive filed. This blind spot is a result of using a mask that gets propagated via convolution. To overcome the blind spot problem, the Gated Pixel CNN was introduced. This new model solved the blind spot by using two separate convolutions (i.e., the horizontal and the vertical stack). \n", + "While the horizontal stack consists of the pixels just before the predicted pixel, the vertical stack represents the rows above the predicted pixel.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2zK_0-Ck7_sW" + }, + "source": [ + "![stacks.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_NfGQikYfrL2" + }, + "source": [ + "Let's re-implement the `MaskedConv2D` class, but now using the horizonal and vertical stack to correct for the blind spot." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8WqV14wAeC_k" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "\n", + "class MaskedConv2D(keras.layers.Layer):\n", + " \"\"\"Convolutional layers with masks.\n", + "\n", + " Convolutional layers with simple implementation of masks type A and B for\n", + " autoregressive models.\n", + "\n", + " Arguments:\n", + " mask_type: one of `\"A\"` or `\"B\".`\n", + " filters: Integer, the dimensionality of the output space\n", + " (i.e. the number of output filters in the convolution).\n", + " kernel_size: An integer or tuple/list of 2 integers, specifying the\n", + " height and width of the 2D convolution window.\n", + " Can be a single integer to specify the same value for\n", + " all spatial dimensions.\n", + " strides: An integer or tuple/list of 2 integers,\n", + " specifying the strides of the convolution along the height and width.\n", + " Can be a single integer to specify the same value for\n", + " all spatial dimensions.\n", + " Specifying any stride value != 1 is incompatible with specifying\n", + " any `dilation_rate` value != 1.\n", + " padding: one of `\"valid\"` or `\"same\"` (case-insensitive).\n", + " kernel_initializer: Initializer for the `kernel` weights matrix.\n", + " bias_initializer: Initializer for the bias vector.\n", + " \"\"\"\n", + "\n", + " def __init__(self,\n", + " mask_type,\n", + " filters,\n", + " kernel_size,\n", + " strides=1,\n", + " padding='same',\n", + " kernel_initializer='glorot_uniform',\n", + " bias_initializer='zeros'):\n", + " super(MaskedConv2D, self).__init__()\n", + "\n", + " assert mask_type in {'A', 'B', 'V'}\n", + " self.mask_type = mask_type\n", + "\n", + " self.filters = filters\n", + " self.kernel_size = kernel_size\n", + " self.strides = strides\n", + " self.padding = padding.upper()\n", + " self.kernel_initializer = initializers.get(kernel_initializer)\n", + " self.bias_initializer = initializers.get(bias_initializer)\n", + "\n", + " def build(self, input_shape):\n", + " kernel_h = self.kernel_size\n", + " kernel_w = self.kernel_size\n", + " self.kernel = self.add_weight('kernel',\n", + " shape=(self.kernel_size,\n", + " self.kernel_size,\n", + " int(input_shape[-1]),\n", + " self.filters),\n", + " initializer=self.kernel_initializer,\n", + " trainable=True)\n", + "\n", + " self.bias = self.add_weight('bias',\n", + " shape=(self.filters,),\n", + " initializer=self.bias_initializer,\n", + " trainable=True)\n", + " mask = np.ones(self.kernel.shape, dtype=np.float64)\n", + "\n", + " # Get centre of the filter for even or odd dimensions\n", + " if kernel_h % 2 != 0:\n", + " center_h = kernel_h // 2\n", + " else:\n", + " center_h = (kernel_h - 1) // 2\n", + "\n", + " if kernel_w % 2 != 0:\n", + " center_w = kernel_w // 2\n", + " else:\n", + " center_w = (kernel_w - 1) // 2\n", + "\n", + " if self.mask_type == 'V':\n", + " mask[center_h + 1:, :, :, :] = 0.\n", + " else:\n", + " mask[:center_h, :, :] = 0.\n", + " mask[center_h, center_w + (self.mask_type == 'B'):, :, :] = 0.\n", + " mask[center_h + 1:, :, :] = 0.\n", + "\n", + " self.mask = tf.constant(mask, dtype=tf.float64, name='mask')\n", + "\n", + " def call(self, input):\n", + " masked_kernel = tf.math.multiply(self.mask, self.kernel)\n", + " x = nn.conv2d(input,\n", + " masked_kernel,\n", + " strides=[1, self.strides, self.strides, 1],\n", + " padding=self.padding)\n", + " x = nn.bias_add(x, self.bias)\n", + " return x" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "WP9iKPeueUQp" + }, + "source": [ + "class GatedBlock(tf.keras.Model):\n", + " \"\"\" Gated block that compose Gated PixelCNN.\"\"\"\n", + "\n", + " def __init__(self, mask_type, filters, kernel_size):\n", + " super(GatedBlock, self).__init__(name='')\n", + "\n", + " self.mask_type = mask_type\n", + " self.vertical_conv = MaskedConv2D(mask_type='V',\n", + " filters=2 * filters,\n", + " kernel_size=kernel_size)\n", + "\n", + " self.horizontal_conv = MaskedConv2D(mask_type=mask_type,\n", + " filters=2 * filters,\n", + " kernel_size=kernel_size)\n", + "\n", + " self.padding = keras.layers.ZeroPadding2D(padding=((1, 0), 0))\n", + " self.cropping = keras.layers.Cropping2D(cropping=((0, 1), 0))\n", + "\n", + " self.v_to_h_conv = keras.layers.Conv2D(filters=2 * filters, kernel_size=1)\n", + "\n", + " self.horizontal_output = keras.layers.Conv2D(filters=filters, kernel_size=1)\n", + "\n", + " def _gate(self, x):\n", + " tanh_preactivation, sigmoid_preactivation = tf.split(x, 2, axis=-1)\n", + " return tf.nn.tanh(tanh_preactivation) * tf.nn.sigmoid(sigmoid_preactivation)\n", + "\n", + " def call(self, input_tensor):\n", + " v = input_tensor[0]\n", + " h = input_tensor[1]\n", + "\n", + " vertical_preactivation = self.vertical_conv(v)\n", + "\n", + " # Shifting vertical stack feature map down before feed into horizontal stack to\n", + " # ensure causality\n", + " v_to_h = self.padding(vertical_preactivation)\n", + " v_to_h = self.cropping(v_to_h)\n", + " v_to_h = self.v_to_h_conv(v_to_h)\n", + "\n", + " horizontal_preactivation = self.horizontal_conv(h)\n", + "\n", + " v_out = self._gate(vertical_preactivation)\n", + "\n", + " horizontal_preactivation = horizontal_preactivation + v_to_h\n", + " h_activated = self._gate(horizontal_preactivation)\n", + " h_activated = self.horizontal_output(h_activated)\n", + "\n", + " if self.mask_type == 'A':\n", + " h_out = h_activated\n", + " elif self.mask_type == 'B':\n", + " h_out = h + h_activated\n", + "\n", + " return v_out, h_out\n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "H8TFrKacgCD_" + }, + "source": [ + "# Define the data\n", + "height = 10\n", + "width = 10\n", + "n_channel = 1\n", + "\n", + "data = tf.random.normal((1, height, width, n_channel))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "JCBEaq0pcd9y" + }, + "source": [ + "# 1 layer Gated PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs])\n", + "model = tf.keras.Model(inputs=inputs, outputs=h)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "dhFgEQI6clrA" + }, + "source": [ + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jgLy1fCyg1c2" + }, + "source": [ + "Excellent! Like we expected the block considered all the previous blocks in the same row of the analyssed pixel, and the two rows over it. The blind splot problem is fixed!\n", + "\n", + "Note that the receptive field is different from the original PixelCNN. In the original PixelCNN only one row over the analysed pixel influenced in its prediction (when using one masked convolution). In the Gated PixelCNN, the authors used a vertical stack with effective area of 2x3 per vertical convolution. This is not a problem, since the considered pixels still being the ones in past positions. We believe the main choice for this format is to implement an efficient way to apply the masked convolutions without using masking (which we will discuss in future posts).\n", + "\n", + "For the next step, we wll verify a model with 2, 3, 4, and 5 layers" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "S8TfMRxqg5tb" + }, + "source": [ + "# 2 layers Gated PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "model = tf.keras.Model(inputs=inputs, outputs=h)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "8ljKvZsrg6yx" + }, + "source": [ + "# 3 layers Gated PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "model = tf.keras.Model(inputs=inputs, outputs=h)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "kExc-22eg-MA" + }, + "source": [ + "# 4 layers Gated PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "model = tf.keras.Model(inputs=inputs, outputs=h)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "wHImyVeXhBUT" + }, + "source": [ + "# 5 layers Gated PixelCNN\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h])\n", + "model = tf.keras.Model(inputs=inputs, outputs=h)\n", + "\n", + "plot_receptive_field(model, data)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dK7J1k81hJcG" + }, + "source": [ + "As you can notice, the Gated PixelCNN does not create blind spots when adding more and more layers." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q8l736u3b-7n" + }, + "source": [ + "# Gated CNN \n", + "\n", + "We will now see how the Gated CNN works on real data (i.e., MNIST dataset). To make sure that this notebook is reproducible, we will fix the random seed.\n", + "\n", + "This implementation is similar to the PixelCNN implementation, we described on the [first notebook](https://colab.research.google.com/github/Mind-the-Pineapple/Autoregressive-models/blob/master/1%20-%20Autoregressive%20Models%20-%20PixelCNN/pixelCNN.ipynb#scrollTo=bU25WyouYYE3).\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "xlN0lIKYhuoB" + }, + "source": [ + "# Defining random seeds\n", + "random_seed = 42\n", + "tf.random.set_seed(random_seed)\n", + "np.random.seed(random_seed)\n", + "rn.seed(random_seed)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Yf6g0Mqnh2JU" + }, + "source": [ + "# Loading data\n", + "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n", + "\n", + "height = 28\n", + "width = 28\n", + "n_channel = 1\n", + "\n", + "x_train = x_train.astype('float32') / 255.\n", + "x_test = x_test.astype('float32') / 255.\n", + "\n", + "x_train = x_train.reshape(x_train.shape[0], height, width, n_channel)\n", + "x_test = x_test.reshape(x_test.shape[0], height, width, n_channel)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H3dU2Ei1h8_5" + }, + "source": [ + "\n", + "In this example, to make the probability distribution of a single pixel easier to be defined, we decide to quantitise the number of possible values that a pixel could have. Originally, in the MNIST dataset the pixels are represented by a uint8 variable, beeing able assume values between [0, 255]. In this example, we restrict the image to have only 2 different values ([0, 1])." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZS9zpZXaiBBt" + }, + "source": [ + "def quantise(images, q_levels):\n", + " \"\"\"Quantise image into q levels\"\"\"\n", + " return (np.digitize(images, np.arange(q_levels) / q_levels) - 1).astype('float32')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "GQou3cV7iCNc" + }, + "source": [ + "# Quantise the input data in q levels\n", + "q_levels = 2\n", + "x_train_quantised = quantise(x_train, q_levels)\n", + "x_test_quantised = quantise(x_test, q_levels)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iKD9dgbGiK95" + }, + "source": [ + "Using the `tensorflow.Data` API, we defined the input data streams for our model during the training and the evaluation. In these dataset, we define the inputs as the images with 2 levels normalized to be between [0, 1] and the target values are the categoricals pixels values between [0, 1]." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "t1-_yo7XiJMQ" + }, + "source": [ + "# Creating input stream using tf.data API\n", + "batch_size = 192\n", + "train_buf = 10000\n", + "\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((x_train_quantised / (q_levels - 1),\n", + " x_train_quantised.astype('int32')))\n", + "train_dataset = train_dataset.shuffle(buffer_size=train_buf)\n", + "train_dataset = train_dataset.batch(batch_size)\n", + "\n", + "test_dataset = tf.data.Dataset.from_tensor_slices((x_test_quantised / (q_levels - 1),\n", + " x_test_quantised.astype('int32')))\n", + "test_dataset = test_dataset.batch(batch_size)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mOm8Z4okiUqq" + }, + "source": [ + "### PixelCNN architecture" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pHka3SW5iYIZ" + }, + "source": [ + "# Create Gated PixelCNN model\n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "v, h = GatedBlock(mask_type='A', filters=64, kernel_size=3)([inputs, inputs])\n", + "\n", + "for i in range(7):\n", + " v, h = GatedBlock(mask_type='B', filters=64, kernel_size=3)([v, h])\n", + "\n", + "x = keras.layers.Activation(activation='relu')(h)\n", + "x = keras.layers.Conv2D(filters=128, kernel_size=1, strides=1)(x)\n", + "\n", + "x = keras.layers.Activation(activation='relu')(x)\n", + "x = keras.layers.Conv2D(filters=q_levels, kernel_size=1, strides=1)(x)\n", + "\n", + "gated_pixelcnn = tf.keras.Model(inputs=inputs, outputs=x)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gU8Zctn3icaL" + }, + "source": [ + "In this implementation we use a simple Adam optimizer with learning rate decay to train the neural network. The loss function is defined by the cross-entropy (that in this case is equivalent to minimizing the negative log-likelihood of the training data)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "lCC2yDpHifhE" + }, + "source": [ + "# Prepare optimizer and loss function\n", + "lr_decay = 0.999995\n", + "learning_rate = 1e-3\n", + "optimizer = keras.optimizers.Adam(learning_rate=learning_rate)\n", + "\n", + "compute_loss = keras.losses.CategoricalCrossentropy(from_logits=True)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JdbGc1zqiwTr" + }, + "source": [ + "\n", + "The training step is defined by the forward propagation through the model. Then, the gradients are calculated, clipped to be between [-1, 1], and applied to upgrade the PixelCNN parameters." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4-o_69bbiiO9" + }, + "source": [ + "@tf.function\n", + "def train_step(batch_x, batch_y):\n", + " with tf.GradientTape() as ae_tape:\n", + " logits = gated_pixelcnn(batch_x, training=True)\n", + "\n", + " loss = compute_loss(tf.squeeze(tf.one_hot(batch_y, q_levels)), logits)\n", + "\n", + " gradients = ae_tape.gradient(loss, gated_pixelcnn.trainable_variables)\n", + " gradients, _ = tf.clip_by_global_norm(gradients, 1.0)\n", + " optimizer.apply_gradients(zip(gradients, gated_pixelcnn.trainable_variables))\n", + "\n", + " return loss" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oihYvXrDi0Ze" + }, + "source": [ + "In this implementation, we defined the training loop with 50 epochs.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "9-D01ij3i2q2" + }, + "source": [ + "# Training loop\n", + "n_epochs = 1\n", + "n_iter = int(np.ceil(x_train_quantised.shape[0] / batch_size))\n", + "for epoch in range(n_epochs):\n", + " progbar = Progbar(n_iter)\n", + " print('Epoch {:}/{:}'.format(epoch + 1, n_epochs))\n", + "\n", + " for i_iter, (batch_x, batch_y) in enumerate(train_dataset):\n", + " optimizer.lr = optimizer.lr * lr_decay\n", + " loss = train_step(batch_x, batch_y)\n", + "\n", + " progbar.add(1, values=[('loss', loss)])" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VytiisKUi7xn" + }, + "source": [ + "To evaluate the performance of the model, we measured its negative log-likelihood (NLL) in the test set.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ysZAvORejASO" + }, + "source": [ + "# Test set performance\n", + "test_loss = []\n", + "for batch_x, batch_y in test_dataset:\n", + " logits = gated_pixelcnn(batch_x, training=False)\n", + "\n", + " # Calculate cross-entropy (= negative log-likelihood)\n", + " loss = compute_loss(tf.one_hot(np.squeeze(batch_y), q_levels), logits)\n", + "\n", + " test_loss.append(loss)\n", + "print('nll : {:} nats'.format(np.array(test_loss).mean()))\n", + "print('bits/dim : {:}'.format(np.array(test_loss).mean() / np.log(2)))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "20hQ3iOEjUNX" + }, + "source": [ + "# Test set performance\n", + "test_loss = []\n", + "for batch_x, batch_y in test_dataset:\n", + " logits = gated_pixelcnn(np.squeeze(batch_x), training=False)\n", + "\n", + " # Calculate cross-entropy (= negative log-likelihood)\n", + " loss = compute_loss(tf.one_hot(np.squeeze(batch_y), q_levels), logits)\n", + "\n", + " test_loss.append(loss)\n", + "print('nll : {:} nats'.format(np.array(test_loss).mean()))\n", + "print('bits/dim : {:}'.format(np.array(test_loss).mean() / np.log(2)))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "P2_qYR4TjXgD" + }, + "source": [ + "# Generating new images\n", + "samples = np.zeros((100, height, width, n_channel), dtype='float32')\n", + "for i in range(height):\n", + " for j in range(width):\n", + " logits = gated_pixelcnn(samples)\n", + " next_sample = tf.random.categorical(logits[:, i, j, :], 1)\n", + " samples[:, i, j, 0] = (next_sample.numpy() / (q_levels - 1))[:, 0]\n", + "\n", + "fig = plt.figure(figsize=(10, 10))\n", + "for i in range(100):\n", + " ax = fig.add_subplot(10, 10, i + 1)\n", + " ax.matshow(samples[i, :, :, 0], cmap=matplotlib.cm.binary)\n", + " plt.xticks(np.array([]))\n", + " plt.yticks(np.array([]))\n", + "plt.show()\n", + "plt.savefig('numbers1.png')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "tL8cNhDFjbOY" + }, + "source": [ + "# Filling occluded images\n", + "occlude_start_row = 14\n", + "num_generated_images = 10\n", + "samples = np.copy(x_test_quantised[0:num_generated_images, :, :, :])\n", + "samples = samples / (q_levels - 1)\n", + "samples[:, occlude_start_row:, :, :] = 0\n", + "\n", + "fig = plt.figure(figsize=(10, 10))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(1, 10, i + 1)\n", + " ax.matshow(samples[i, :, :, 0], cmap=matplotlib.cm.binary)\n", + " plt.xticks(np.array([]))\n", + " plt.yticks(np.array([]))\n", + "\n", + "for i in range(occlude_start_row, height):\n", + " for j in range(width):\n", + " logits = gated_pixelcnn(samples)\n", + " next_sample = tf.random.categorical(logits[:, i, j, :], 1)\n", + " samples[:, i, j, 0] = (next_sample.numpy() / (q_levels - 1))[:, 0]\n", + "\n", + "fig = plt.figure(figsize=(10, 10))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(1, 10, i + 1)\n", + " ax.matshow(samples[i, :, :, 0], cmap=matplotlib.cm.binary)\n", + " plt.xticks(np.array([]))\n", + " plt.yticks(np.array([]))\n", + "plt.show()\n", + "plt.savefig('numbers2.png')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LengLN21jB_R" + }, + "source": [ + "Finally, we sampled some images from the trained model. First, we sampled from scratch, then we completed images partially occluded.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "psOigzt7hF4R" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/3 - PixelCNNs Blind spot and Gated PixelCNNs/pixelcnn_blind_spot.py b/3 - PixelCNNs Blind spot and Gated PixelCNNs/pixelcnn_blind_spot.py new file mode 100644 index 0000000..906cedf --- /dev/null +++ b/3 - PixelCNNs Blind spot and Gated PixelCNNs/pixelcnn_blind_spot.py @@ -0,0 +1,650 @@ +# -*- coding: utf-8 -*- +"""PixelCNN - Blind_spot + +Automatically generated by Colaboratory. + +Original file is located at + https://colab.research.google.com/drive/1qENjDpnBADXAfLwU9rla66W51g3FX9Hn + +# Autoregressive models - PixelCNNs blind spot in the receptive field and how to fix it + +In our previous notebooks, we trained a generative model to create black and white drawings of numbers and to generate coloured images. Now we are going to look into the blind splot, one of the biggested drawbacks of the PixelCNNs and how to fix it. We will also define the Gated PixelCNN and analyse its performance on the MNIST dataset. + +This implementation uses Tensorflow 2.0. We start by installing and importing the code dependencies. + +*Note: Here we are using float64 to get more precise values of the gradients and avoid false values. +""" + +# Commented out IPython magic to ensure Python compatibility. +# %tensorflow_version 2.x + +import random as rn + +import matplotlib +import matplotlib.pyplot as plt +from matplotlib.ticker import FixedLocator +import numpy as np +import tensorflow as tf +from tensorflow import keras +from tensorflow import nn +from tensorflow.keras import initializers +from tensorflow.keras.utils import Progbar + +tf.keras.backend.set_floatx('float64') + +"""Like in the previous notebooks we are defining the Convolutional layers with masks and the ResidualBlocks. The Residual block is an important building block of Oord's seminal paper that originated the PixelCNN. + +*Note: Here we removed the ReLU activations to not mess with the gradients while we are investigating them. +""" + +class ResidualBlock(keras.Model): + """Residual blocks that compose pixelCNN + + Blocks of layers with 3 convolutional layers and one residual connection. + Based on Figure 5 from [1] where h indicates number of filters. + + Refs: + [1] - Oord, A. V. D., Kalchbrenner, N., & Kavukcuoglu, K. (2016). Pixel recurrent + neural networks. arXiv preprint arXiv:1601.06759. + """ + + def __init__(self, h): + super(ResidualBlock, self).__init__(name='') + + self.conv2a = keras.layers.Conv2D(filters=h, kernel_size=1, strides=1) + self.conv2b = MaskedConv2D(mask_type='B', filters=h, kernel_size=3, strides=1) + self.conv2c = keras.layers.Conv2D(filters=2 * h, kernel_size=1, strides=1) + + def call(self, input_tensor): +# x = nn.relu(input_tensor) +# x = self.conv2a(x) + x = self.conv2a(input_tensor) + +# x = nn.relu(x) + x = self.conv2b(x) + +# x = nn.relu(x) + x = self.conv2c(x) + + x += input_tensor + return x + +"""## Blind Spots + +As we saw above, the original PixelCNN had a problem with its masked convolution that lead to a blind spot. Given a specific pixel, the use of masked convolution was not able to capture the information of all previous pixels. As we can see on the image below, the information on *j* is never used to predict *m*; and the information on *j, n, o* are not used to predict *q*. + +![masks.png](data:image/png;base64,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) + +Let's start by implementing the convolution and looking at how the blind spot propagates. You should be familiar with the class below, as we have used in the previous notebooks. +""" + +class MaskedConv2D(keras.layers.Layer): + """Convolutional layers with masks. + + Convolutional layers with simple implementation of masks type A and B for + autoregressive models. + + Arguments: + mask_type: one of `"A"` or `"B".` + filters: Integer, the dimensionality of the output space + (i.e. the number of output filters in the convolution). + kernel_size: An integer or tuple/list of 2 integers, specifying the + height and width of the 2D convolution window. + Can be a single integer to specify the same value for + all spatial dimensions. + strides: An integer or tuple/list of 2 integers, + specifying the strides of the convolution along the height and width. + Can be a single integer to specify the same value for + all spatial dimensions. + Specifying any stride value != 1 is incompatible with specifying + any `dilation_rate` value != 1. + padding: one of `"valid"` or `"same"` (case-insensitive). + kernel_initializer: Initializer for the `kernel` weights matrix. + bias_initializer: Initializer for the bias vector. + """ + + def __init__(self, + mask_type, + filters, + kernel_size, + strides=1, + padding='same', + kernel_initializer='glorot_uniform', + bias_initializer='zeros'): + super(MaskedConv2D, self).__init__() + + assert mask_type in {'A', 'B'} + self.mask_type = mask_type + + self.filters = filters + self.kernel_size = kernel_size + self.strides = strides + self.padding = padding.upper() + self.kernel_initializer = initializers.get(kernel_initializer) + self.bias_initializer = initializers.get(bias_initializer) + + def build(self, input_shape): + self.kernel = self.add_weight('kernel', + shape=(self.kernel_size, + self.kernel_size, + int(input_shape[-1]), + self.filters), + initializer=self.kernel_initializer, + trainable=True) + + self.bias = self.add_weight('bias', + shape=(self.filters,), + initializer=self.bias_initializer, + trainable=True) + + center = self.kernel_size // 2 + + mask = np.ones(self.kernel.shape, dtype=np.float64) + mask[center, center + (self.mask_type == 'B'):, :, :] = 0. + mask[center + 1:, :, :, :] = 0. + + self.mask = tf.constant(mask, dtype=tf.float64, name='mask') + + def call(self, input): + masked_kernel = tf.math.multiply(self.mask, self.kernel) + x = nn.conv2d(input, + masked_kernel, + strides=[1, self.strides, self.strides, 1], + padding=self.padding) + x = nn.bias_add(x, self.bias) + return x + +def plot_receptive_field(model, data): + """ + This function allows the visualisation of the receptive field + """ + with tf.GradientTape() as tape: + tape.watch(data) + prediction = model(data) + loss = prediction[:,5,5,0] + + gradients = tape.gradient(loss, data) + + gradients = np.abs(gradients.numpy().squeeze()) + gradients = (gradients > 0).astype('float64') + gradients[5, 5] = 0.5 + + fig = plt.figure() + ax = fig.add_subplot(1, 1, 1) + + plt.xticks(np.arange(0, 10, step=1)) + plt.yticks(np.arange(0, 10, step=1)) + ax.xaxis.set_minor_locator(FixedLocator(np.arange(0.5, 10.5, step=1))) + ax.yaxis.set_minor_locator(FixedLocator(np.arange(0.5, 10.5, step=1))) + plt.grid(which="minor") + plt.imshow(gradients, vmin=0, vmax=1) + plt.show() + +# -------------------------------------------------------------------------------------------------------------- +height = 10 +width = 10 +n_channel = 1 + +data = tf.random.normal((1, height, width, n_channel)) + +# 1 layer PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs) +model = tf.keras.Model(inputs=inputs, outputs=x) + +plot_receptive_field(model, data) + +# 2 layer PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs) +x = ResidualBlock(h=1)(x) + +model = tf.keras.Model(inputs=inputs, outputs=x) + +plot_receptive_field(model, data) + +# 3 layer PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs) +x = ResidualBlock(h=1)(x) +x = ResidualBlock(h=1)(x) + +model = tf.keras.Model(inputs=inputs, outputs=x) + +plot_receptive_field(model, data) + +# 4 layer PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs) +x = ResidualBlock(h=1)(x) +x = ResidualBlock(h=1)(x) +x = ResidualBlock(h=1)(x) + +model = tf.keras.Model(inputs=inputs, outputs=x) + +plot_receptive_field(model, data) + +# 5 layer PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +x = MaskedConv2D(mask_type='A', filters=1, kernel_size=3, strides=1)(inputs) +x = ResidualBlock(h=1)(x) +x = ResidualBlock(h=1)(x) +x = ResidualBlock(h=1)(x) +x = ResidualBlock(h=1)(x) + +model = tf.keras.Model(inputs=inputs, outputs=x) + +plot_receptive_field(model, data) + +"""## Gated Pixel CNN and the blind spot + +A big drawback of PixelCNNs is the blind spot in the receptive filed. This blind spot is a result of using a mask that gets propagated via convolution. To overcome the blind spot problem, the Gated Pixel CNN was introduced. This new model solved the blind spot by using two separate convolutions (i.e., the horizontal and the vertical stack). +While the horizontal stack consists of the pixels just before the predicted pixel, the vertical stack represents the rows above the predicted pixel. + +![stacks.png](data:image/png;base64,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) + +Let's re-implement the `MaskedConv2D` class, but now using the horizonal and vertical stack to correct for the blind spot. +""" + +# -------------------------------------------------------------------------------------------------------------- + +class MaskedConv2D(keras.layers.Layer): + """Convolutional layers with masks. + + Convolutional layers with simple implementation of masks type A and B for + autoregressive models. + + Arguments: + mask_type: one of `"A"` or `"B".` + filters: Integer, the dimensionality of the output space + (i.e. the number of output filters in the convolution). + kernel_size: An integer or tuple/list of 2 integers, specifying the + height and width of the 2D convolution window. + Can be a single integer to specify the same value for + all spatial dimensions. + strides: An integer or tuple/list of 2 integers, + specifying the strides of the convolution along the height and width. + Can be a single integer to specify the same value for + all spatial dimensions. + Specifying any stride value != 1 is incompatible with specifying + any `dilation_rate` value != 1. + padding: one of `"valid"` or `"same"` (case-insensitive). + kernel_initializer: Initializer for the `kernel` weights matrix. + bias_initializer: Initializer for the bias vector. + """ + + def __init__(self, + mask_type, + filters, + kernel_size, + strides=1, + padding='same', + kernel_initializer='glorot_uniform', + bias_initializer='zeros'): + super(MaskedConv2D, self).__init__() + + assert mask_type in {'A', 'B', 'V'} + self.mask_type = mask_type + + self.filters = filters + self.kernel_size = kernel_size + self.strides = strides + self.padding = padding.upper() + self.kernel_initializer = initializers.get(kernel_initializer) + self.bias_initializer = initializers.get(bias_initializer) + + def build(self, input_shape): + kernel_h = self.kernel_size + kernel_w = self.kernel_size + self.kernel = self.add_weight('kernel', + shape=(self.kernel_size, + self.kernel_size, + int(input_shape[-1]), + self.filters), + initializer=self.kernel_initializer, + trainable=True) + + self.bias = self.add_weight('bias', + shape=(self.filters,), + initializer=self.bias_initializer, + trainable=True) + mask = np.ones(self.kernel.shape, dtype=np.float64) + + # Get centre of the filter for even or odd dimensions + if kernel_h % 2 != 0: + center_h = kernel_h // 2 + else: + center_h = (kernel_h - 1) // 2 + + if kernel_w % 2 != 0: + center_w = kernel_w // 2 + else: + center_w = (kernel_w - 1) // 2 + + if self.mask_type == 'V': + mask[center_h + 1:, :, :, :] = 0. + else: + mask[:center_h, :, :] = 0. + mask[center_h, center_w + (self.mask_type == 'B'):, :, :] = 0. + mask[center_h + 1:, :, :] = 0. + + self.mask = tf.constant(mask, dtype=tf.float64, name='mask') + + def call(self, input): + masked_kernel = tf.math.multiply(self.mask, self.kernel) + x = nn.conv2d(input, + masked_kernel, + strides=[1, self.strides, self.strides, 1], + padding=self.padding) + x = nn.bias_add(x, self.bias) + return x + +class GatedBlock(tf.keras.Model): + """ Gated block that compose Gated PixelCNN.""" + + def __init__(self, mask_type, filters, kernel_size): + super(GatedBlock, self).__init__(name='') + + self.mask_type = mask_type + self.vertical_conv = MaskedConv2D(mask_type='V', + filters=2 * filters, + kernel_size=kernel_size) + + self.horizontal_conv = MaskedConv2D(mask_type=mask_type, + filters=2 * filters, + kernel_size=kernel_size) + + self.padding = keras.layers.ZeroPadding2D(padding=((1, 0), 0)) + self.cropping = keras.layers.Cropping2D(cropping=((0, 1), 0)) + + self.v_to_h_conv = keras.layers.Conv2D(filters=2 * filters, kernel_size=1) + + self.horizontal_output = keras.layers.Conv2D(filters=filters, kernel_size=1) + + def _gate(self, x): + tanh_preactivation, sigmoid_preactivation = tf.split(x, 2, axis=-1) + return tf.nn.tanh(tanh_preactivation) * tf.nn.sigmoid(sigmoid_preactivation) + + def call(self, input_tensor): + v = input_tensor[0] + h = input_tensor[1] + + vertical_preactivation = self.vertical_conv(v) + + # Shifting vertical stack feature map down before feed into horizontal stack to + # ensure causality + v_to_h = self.padding(vertical_preactivation) + v_to_h = self.cropping(v_to_h) + v_to_h = self.v_to_h_conv(v_to_h) + + horizontal_preactivation = self.horizontal_conv(h) + + v_out = self._gate(vertical_preactivation) + + horizontal_preactivation = horizontal_preactivation + v_to_h + h_activated = self._gate(horizontal_preactivation) + h_activated = self.horizontal_output(h_activated) + + if self.mask_type == 'A': + h_out = h_activated + elif self.mask_type == 'B': + h_out = h + h_activated + + return v_out, h_out + +# Define the data +height = 10 +width = 10 +n_channel = 1 + +data = tf.random.normal((1, height, width, n_channel)) + +# 1 layer Gated PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs]) +model = tf.keras.Model(inputs=inputs, outputs=h) + +plot_receptive_field(model, data) + +"""Excellent! Like we expected the block considered all the previous blocks in the same row of the analyssed pixel, and the two rows over it. The blind splot problem is fixed! + +Note that the receptive field is different from the original PixelCNN. In the original PixelCNN only one row over the analysed pixel influenced in its prediction (when using one masked convolution). In the Gated PixelCNN, the authors used a vertical stack with effective area of 2x3 per vertical convolution. This is not a problem, since the considered pixels still being the ones in past positions. We believe the main choice for this format is to implement an efficient way to apply the masked convolutions without using masking (which we will discuss in future posts). + +For the next step, we wll verify a model with 2, 3, 4, and 5 layers +""" + +# 2 layers Gated PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +model = tf.keras.Model(inputs=inputs, outputs=h) + +plot_receptive_field(model, data) + +# 3 layers Gated PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +model = tf.keras.Model(inputs=inputs, outputs=h) + +plot_receptive_field(model, data) + +# 4 layers Gated PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +model = tf.keras.Model(inputs=inputs, outputs=h) + +plot_receptive_field(model, data) + +# 5 layers Gated PixelCNN +inputs = keras.layers.Input(shape=(height, width, n_channel)) +v, h = GatedBlock(mask_type='A', filters=1, kernel_size=3)([inputs, inputs]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +v, h = GatedBlock(mask_type='B', filters=1, kernel_size=3)([v, h]) +model = tf.keras.Model(inputs=inputs, outputs=h) + +plot_receptive_field(model, data) + +"""As you can notice, the Gated PixelCNN does not create blind spots when adding more and more layers. + +# Gated CNN + +We will now see how the Gated CNN works on real data (i.e., MNIST dataset). To make sure that this notebook is reproducible, we will fix the random seed. + +This implementation is similar to the PixelCNN implementation, we described on the [first notebook](https://colab.research.google.com/github/Mind-the-Pineapple/Autoregressive-models/blob/master/1%20-%20Autoregressive%20Models%20-%20PixelCNN/pixelCNN.ipynb#scrollTo=bU25WyouYYE3). +""" + +# Defining random seeds +random_seed = 42 +tf.random.set_seed(random_seed) +np.random.seed(random_seed) +rn.seed(random_seed) + +# Loading data +(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() + +height = 28 +width = 28 +n_channel = 1 + +x_train = x_train.astype('float32') / 255. +x_test = x_test.astype('float32') / 255. + +x_train = x_train.reshape(x_train.shape[0], height, width, n_channel) +x_test = x_test.reshape(x_test.shape[0], height, width, n_channel) + +""" +In this example, to make the probability distribution of a single pixel easier to be defined, we decide to quantitise the number of possible values that a pixel could have. Originally, in the MNIST dataset the pixels are represented by a uint8 variable, beeing able assume values between [0, 255]. In this example, we restrict the image to have only 2 different values ([0, 1]).""" + +def quantise(images, q_levels): + """Quantise image into q levels""" + return (np.digitize(images, np.arange(q_levels) / q_levels) - 1).astype('float32') + +# Quantise the input data in q levels +q_levels = 2 +x_train_quantised = quantise(x_train, q_levels) +x_test_quantised = quantise(x_test, q_levels) + +"""Using the `tensorflow.Data` API, we defined the input data streams for our model during the training and the evaluation. In these dataset, we define the inputs as the images with 2 levels normalized to be between [0, 1] and the target values are the categoricals pixels values between [0, 1].""" + +# Creating input stream using tf.data API +batch_size = 192 +train_buf = 10000 + +train_dataset = tf.data.Dataset.from_tensor_slices((x_train_quantised / (q_levels - 1), + x_train_quantised.astype('int32'))) +train_dataset = train_dataset.shuffle(buffer_size=train_buf) +train_dataset = train_dataset.batch(batch_size) + +test_dataset = tf.data.Dataset.from_tensor_slices((x_test_quantised / (q_levels - 1), + x_test_quantised.astype('int32'))) +test_dataset = test_dataset.batch(batch_size) + +"""### PixelCNN architecture""" + +# Create Gated PixelCNN model +inputs = keras.layers.Input(shape=(height, width, n_channel)) +v, h = GatedBlock(mask_type='A', filters=64, kernel_size=3)([inputs, inputs]) + +for i in range(7): + v, h = GatedBlock(mask_type='B', filters=64, kernel_size=3)([v, h]) + +x = keras.layers.Activation(activation='relu')(h) +x = keras.layers.Conv2D(filters=128, kernel_size=1, strides=1)(x) + +x = keras.layers.Activation(activation='relu')(x) +x = keras.layers.Conv2D(filters=q_levels, kernel_size=1, strides=1)(x) + +gated_pixelcnn = tf.keras.Model(inputs=inputs, outputs=x) + +"""In this implementation we use a simple Adam optimizer with learning rate decay to train the neural network. The loss function is defined by the cross-entropy (that in this case is equivalent to minimizing the negative log-likelihood of the training data).""" + +# Prepare optimizer and loss function +lr_decay = 0.999995 +learning_rate = 1e-3 +optimizer = keras.optimizers.Adam(learning_rate=learning_rate) + +compute_loss = keras.losses.CategoricalCrossentropy(from_logits=True) + +""" +The training step is defined by the forward propagation through the model. Then, the gradients are calculated, clipped to be between [-1, 1], and applied to upgrade the PixelCNN parameters.""" + +@tf.function +def train_step(batch_x, batch_y): + with tf.GradientTape() as ae_tape: + logits = gated_pixelcnn(batch_x, training=True) + + loss = compute_loss(tf.squeeze(tf.one_hot(batch_y, q_levels)), logits) + + gradients = ae_tape.gradient(loss, gated_pixelcnn.trainable_variables) + gradients, _ = tf.clip_by_global_norm(gradients, 1.0) + optimizer.apply_gradients(zip(gradients, gated_pixelcnn.trainable_variables)) + + return loss + +"""In this implementation, we defined the training loop with 50 epochs. + + +""" + +# Training loop +n_epochs = 1 +n_iter = int(np.ceil(x_train_quantised.shape[0] / batch_size)) +for epoch in range(n_epochs): + progbar = Progbar(n_iter) + print('Epoch {:}/{:}'.format(epoch + 1, n_epochs)) + + for i_iter, (batch_x, batch_y) in enumerate(train_dataset): + optimizer.lr = optimizer.lr * lr_decay + loss = train_step(batch_x, batch_y) + + progbar.add(1, values=[('loss', loss)]) + +"""To evaluate the performance of the model, we measured its negative log-likelihood (NLL) in the test set. + + +""" + +# Test set performance +test_loss = [] +for batch_x, batch_y in test_dataset: + logits = gated_pixelcnn(batch_x, training=False) + + # Calculate cross-entropy (= negative log-likelihood) + loss = compute_loss(tf.one_hot(np.squeeze(batch_y), q_levels), logits) + + test_loss.append(loss) +print('nll : {:} nats'.format(np.array(test_loss).mean())) +print('bits/dim : {:}'.format(np.array(test_loss).mean() / np.log(2))) + +# Test set performance +test_loss = [] +for batch_x, batch_y in test_dataset: + logits = gated_pixelcnn(np.squeeze(batch_x), training=False) + + # Calculate cross-entropy (= negative log-likelihood) + loss = compute_loss(tf.one_hot(np.squeeze(batch_y), q_levels), logits) + + test_loss.append(loss) +print('nll : {:} nats'.format(np.array(test_loss).mean())) +print('bits/dim : {:}'.format(np.array(test_loss).mean() / np.log(2))) + +# Generating new images +samples = np.zeros((100, height, width, n_channel), dtype='float32') +for i in range(height): + for j in range(width): + logits = gated_pixelcnn(samples) + next_sample = tf.random.categorical(logits[:, i, j, :], 1) + samples[:, i, j, 0] = (next_sample.numpy() / (q_levels - 1))[:, 0] + +fig = plt.figure(figsize=(10, 10)) +for i in range(100): + ax = fig.add_subplot(10, 10, i + 1) + ax.matshow(samples[i, :, :, 0], cmap=matplotlib.cm.binary) + plt.xticks(np.array([])) + plt.yticks(np.array([])) +plt.show() +plt.savefig('numbers1.png') + +# Filling occluded images +occlude_start_row = 14 +num_generated_images = 10 +samples = np.copy(x_test_quantised[0:num_generated_images, :, :, :]) +samples = samples / (q_levels - 1) +samples[:, occlude_start_row:, :, :] = 0 + +fig = plt.figure(figsize=(10, 10)) + +for i in range(10): + ax = fig.add_subplot(1, 10, i + 1) + ax.matshow(samples[i, :, :, 0], cmap=matplotlib.cm.binary) + plt.xticks(np.array([])) + plt.yticks(np.array([])) + +for i in range(occlude_start_row, height): + for j in range(width): + logits = gated_pixelcnn(samples) + next_sample = tf.random.categorical(logits[:, i, j, :], 1) + samples[:, i, j, 0] = (next_sample.numpy() / (q_levels - 1))[:, 0] + +fig = plt.figure(figsize=(10, 10)) + +for i in range(10): + ax = fig.add_subplot(1, 10, i + 1) + ax.matshow(samples[i, :, :, 0], cmap=matplotlib.cm.binary) + plt.xticks(np.array([])) + plt.yticks(np.array([])) +plt.show() +plt.savefig('numbers2.png') + +"""Finally, we sampled some images from the trained model. First, we sampled from scratch, then we completed images partially occluded. + + +""" +