diff --git a/WIP/4 - Gated_PixelCNN/gated_pixelCNN.py b/WIP/4 - Gated_PixelCNN/gated_pixelCNN.py new file mode 100644 index 0000000..5a381fb --- /dev/null +++ b/WIP/4 - Gated_PixelCNN/gated_pixelCNN.py @@ -0,0 +1,8 @@ +import random as rn +import time + +import matplotlib +import matplotlib.pyplot as plt +import numpy as np +import tensorflow as tf +from tensorflow import keras \ No newline at end of file diff --git a/WIP/4 - Gated_PixelCNN/gated_pixelcnn.ipynb b/WIP/4 - Gated_PixelCNN/gated_pixelcnn.ipynb index 9fe85e6..8fedab5 100644 --- a/WIP/4 - Gated_PixelCNN/gated_pixelcnn.ipynb +++ b/WIP/4 - Gated_PixelCNN/gated_pixelcnn.ipynb @@ -1,604 +1,602 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "view-in-github" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "accelerator": "GPU", "colab": { - "base_uri": "https://localhost:8080/", - "height": 402 + "name": "gated_pixelcnn.ipynb", + "provenance": [] }, - "colab_type": "code", - "id": "VMF0k8kyGjQ7", - "outputId": "489e26d2-3f1f-4488-92b6-d0f2801e7a2d" - }, - "outputs": [], - "source": [ - "! pip3 install tensorflow-gpu==2.0.0-rc1" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "k1uZnxh4Xz9Z" - }, - "outputs": [], - "source": [ - "import random as rn\n", - "import time\n", - "\n", - "import matplotlib\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import tensorflow as tf\n", - "from tensorflow import keras" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'2.0.0'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "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.6.8" } - ], - "source": [ - "tf.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "NN6vJl7eVnZ4" - }, - "outputs": [], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# 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)" - ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "8BnkhgCjVpJu" - }, - "outputs": [], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Loading data\n", - "(x_train, y_train), (x_test, y_test) = tf.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)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "3ne-qY7JVZaB" - }, - "outputs": [], - "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')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "3QVhnMymVrzc" - }, - "outputs": [], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Quantise the input data in q levels\n", - "q_levels = 256\n", - "x_train_quantised = quantise(x_train, q_levels)\n", - "x_test_quantised = quantise(x_test, q_levels)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 89 + "cells": [ + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "k1uZnxh4Xz9Z", + "colab": {} + }, + "source": [ + "import random as rn\n", + "import time\n", + "\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras.utils import Progbar\n", + "from tensorflow import keras\n", + "from tensorflow.keras import initializers\n", + "from tensorflow import nn" + ], + "execution_count": 0, + "outputs": [] }, - "colab_type": "code", - "id": "ZObIXqzNGwmo", - "outputId": "64cdf3d5-2f5e-4e48-9d6b-e8844e1efcb3" - }, - "outputs": [], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Creating input stream using tf.data API\n", - "batch_size = 128\n", - "train_buf = 60000\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)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "75VTDkK8VZLA" - }, - "outputs": [], - "source": [ - "class MaskedConv2D(tf.keras.layers.Layer):\n", - " \"\"\"Convolutional layers with masks for autoregressive models\n", - "\n", - " Convolutional layers with simple implementation to have masks type A and B.\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", - "\n", - " if isinstance(kernel_size, int):\n", - " kernel_size = (kernel_size, kernel_size)\n", - " self.kernel_size = kernel_size\n", - "\n", - " self.strides = strides\n", - " self.padding = padding.upper()\n", - " self.kernel_initializer = keras.initializers.get(kernel_initializer)\n", - " self.bias_initializer = keras.initializers.get(bias_initializer)\n", - "\n", - " def build(self, input_shape):\n", - " kernel_h, kernel_w = self.kernel_size\n", - "\n", - " self.kernel = self.add_weight(\"kernel\",\n", - " shape=(kernel_h,\n", - " kernel_w,\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", - " mask = np.ones(self.kernel.shape, dtype=np.float32)\n", - " if self.mask_type == 'V':\n", - " mask[kernel_h // 2:, :, :, :] = 0.\n", - " else:\n", - " mask[kernel_h // 2, kernel_w // 2 + (self.mask_type == 'B'):, :, :] = 0.\n", - " mask[kernel_h // 2 + 1:, :, :] = 0.\n", - "\n", - " self.mask = tf.constant(mask, dtype=tf.float32, name='mask')\n", - "\n", - " def call(self, input):\n", - " masked_kernel = tf.math.multiply(self.mask, self.kernel)\n", - " x = tf.nn.conv2d(input, masked_kernel, strides=[1, self.strides, self.strides, 1], padding=self.padding)\n", - " x = tf.nn.bias_add(x, self.bias)\n", - " return x\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "PTUN4s52Nu3w" - }, - "outputs": [], - "source": [ - "class GatedBlock(tf.keras.Model):\n", - " \"\"\"\"\"\"\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', filters=2 * filters, kernel_size=kernel_size)\n", - " self.horizontal_conv = MaskedConv2D(mask_type=mask_type, filters=2 * filters, kernel_size=(1, kernel_size))\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", - " horizontal_preactivation = self.horizontal_conv(h) # 1xN\n", - " vertical_preactivation = self.vertical_conv(v) # NxN\n", - " v_to_h = self.v_to_h_conv(vertical_preactivation) # 1x1\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" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "WB57YufrVxn2" - }, - "outputs": [], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Create 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=n_channel * q_levels, kernel_size=1, strides=1)(x)\n", - "\n", - "pixelcnn = tf.keras.Model(inputs=inputs, outputs=x)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "_LnzHUaqV77d" - }, - "outputs": [], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Prepare optimizer and loss function\n", - "lr_decay = 0.9999\n", - "learning_rate = 5e-2\n", - "optimizer = tf.keras.optimizers.Adam(lr=learning_rate)\n", - "\n", - "compute_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "CsAgEKVzLCJD" - }, - "outputs": [], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "@tf.function\n", - "def train_step(batch_x, batch_y):\n", - " with tf.GradientTape() as ae_tape:\n", - " logits = pixelcnn(batch_x, training=True)\n", - "\n", - " logits = tf.reshape(logits, [-1, height, width, q_levels, n_channel])\n", - " logits = tf.transpose(logits, perm=[0, 1, 2, 4, 3])\n", - "\n", - " loss = compute_loss(tf.one_hot(batch_y, q_levels), logits)\n", - "\n", - " gradients = ae_tape.gradient(loss, pixelcnn.trainable_variables)\n", - " gradients, _ = tf.clip_by_global_norm(gradients, 1.0)\n", - " optimizer.apply_gradients(zip(gradients, pixelcnn.trainable_variables))\n", - "\n", - " return loss" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "NN6vJl7eVnZ4", + "colab": {} + }, + "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": 0, + "outputs": [] }, - "colab_type": "code", - "id": "NoEPrfwQNM-s", - "outputId": "cd806f66-acff-48fe-da47-d75a742acf99" - }, - "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "EPOCH 0: ITER 0/ 469 TIME: 2.03 LOSS: 0.6414\n", - "EPOCH 0: ITER 100/ 469 TIME: 0.13 LOSS: 0.9549\n", - "EPOCH 0: ITER 200/ 469 TIME: 0.13 LOSS: 0.8991\n", - "EPOCH 0: ITER 300/ 469 TIME: 0.13 LOSS: 0.8518\n", - "EPOCH 0: ITER 400/ 469 TIME: 0.13 LOSS: 0.8543\n", - "EPOCH 0: TIME: 64.81 ETA: 12962.69\n", - "EPOCH 1: ITER 0/ 469 TIME: 0.02 LOSS: 0.9295\n", - "EPOCH 1: ITER 100/ 469 TIME: 0.13 LOSS: 0.8955\n", - "EPOCH 1: ITER 200/ 469 TIME: 0.13 LOSS: 0.9063\n", - "EPOCH 1: ITER 300/ 469 TIME: 0.13 LOSS: 0.8343\n", - "EPOCH 1: ITER 400/ 469 TIME: 0.13 LOSS: 0.8433\n", - "EPOCH 1: TIME: 62.16 ETA: 12369.32\n", - "EPOCH 2: ITER 0/ 469 TIME: 0.02 LOSS: 0.8575\n", - "EPOCH 2: ITER 100/ 469 TIME: 0.13 LOSS: 0.8659\n", - "EPOCH 2: ITER 200/ 469 TIME: 0.13 LOSS: 0.8498\n", - "EPOCH 2: ITER 300/ 469 TIME: 0.13 LOSS: 0.8268\n" - ] + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "8BnkhgCjVpJu", + "colab": {} + }, + "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": 0, + "outputs": [] }, { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mbatch_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_y\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_dataset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mstart\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mlr_decay\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0miter_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/media/kcl_1/HDD/PycharmProjects/vq-vae/venv/lib/python3.6/site-packages/tensorflow_core/python/ops/variables.py\u001b[0m in \u001b[0;36m_run_op\u001b[0;34m(a, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1077\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_run_op\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1078\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1079\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mtensor_oper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1080\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1081\u001b[0m \u001b[0mfunctools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_run_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtensor_oper\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/media/kcl_1/HDD/PycharmProjects/vq-vae/venv/lib/python3.6/site-packages/tensorflow_core/python/ops/math_ops.py\u001b[0m in \u001b[0;36mbinary_op_wrapper\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m 910\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 911\u001b[0m \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 912\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 913\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mbinary_op_wrapper_sparse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msp_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/media/kcl_1/HDD/PycharmProjects/vq-vae/venv/lib/python3.6/site-packages/tensorflow_core/python/ops/math_ops.py\u001b[0m in \u001b[0;36m_mul_dispatch\u001b[0;34m(x, y, name)\u001b[0m\n\u001b[1;32m 1204\u001b[0m \u001b[0mis_tensor_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1205\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_tensor_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1206\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgen_math_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmul\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1207\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1208\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msparse_tensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSparseTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Case: Dense * Sparse.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/media/kcl_1/HDD/PycharmProjects/vq-vae/venv/lib/python3.6/site-packages/tensorflow_core/python/ops/gen_math_ops.py\u001b[0m in \u001b[0;36mmul\u001b[0;34m(x, y, name)\u001b[0m\n\u001b[1;32m 6683\u001b[0m _result = _pywrap_tensorflow.TFE_Py_FastPathExecute(\n\u001b[1;32m 6684\u001b[0m \u001b[0m_ctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_context_handle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_ctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_thread_local_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Mul\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 6685\u001b[0;31m name, _ctx._post_execution_callbacks, x, y)\n\u001b[0m\u001b[1;32m 6686\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6687\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_FallbackException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Training loop\n", - "n_epochs = 200\n", - "n_iter = int(np.ceil(x_train_quantised.shape[0] / batch_size))\n", - "for epoch in range(n_epochs):\n", - " start_epoch = time.time()\n", - " for i_iter, (batch_x, batch_y) in enumerate(train_dataset):\n", - " start = time.time()\n", - " optimizer.lr = optimizer.lr * lr_decay\n", - " loss = train_step(batch_x, batch_y)\n", - " iter_time = time.time() - start\n", - " if i_iter % 100 == 0:\n", - " print('EPOCH {:3d}: ITER {:4d}/{:4d} TIME: {:.2f} LOSS: {:.4f}'.format(epoch,\n", - " i_iter, n_iter,\n", - " iter_time,\n", - " loss))\n", - " epoch_time = time.time() - start_epoch\n", - " print('EPOCH {:3d}: TIME: {:.2f} ETA: {:.2f}'.format(epoch,\n", - " epoch_time,\n", - " epoch_time * (n_epochs - epoch)))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 52 + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "3ne-qY7JVZaB", + "colab": {} + }, + "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": 0, + "outputs": [] }, - "colab_type": "code", - "id": "ue0vZbitSNmz", - "outputId": "0eb765cc-3a9a-4354-cd38-6316807e3748" - }, - "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "nll : 0.6348000764846802 nats\n", - "bits/dim : 0.0008096939751080104\n" - ] - } - ], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Test\n", - "test_loss = []\n", - "for batch_x, batch_y in test_dataset:\n", - " logits = pixelcnn(batch_x, training=False)\n", - " logits = tf.reshape(logits, [-1, height, width, q_levels, n_channel])\n", - " logits = tf.transpose(logits, perm=[0, 1, 2, 4, 3])\n", - "\n", - " # Calculate cross-entropy (= negative log-likelihood)\n", - " loss = compute_loss(tf.one_hot(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() / (height * width)))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 526 + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "3QVhnMymVrzc", + "colab": {} + }, + "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": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "ZObIXqzNGwmo", + "colab": {} + }, + "source": [ + "# Creating input stream using tf.data API\n", + "batch_size = 128\n", + "train_buf = 60000\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": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "75VTDkK8VZLA", + "colab": {} + }, + "source": [ + "class MaskedConv2D(keras.layers.Layer):\n", + " \"\"\"Convolutional layers with masks for Gated PixelCNN.\n", + "\n", + " Masked convolutional layers used to implement Vertical and Horizontal\n", + " stacks of the Gated PixelCNN.\n", + "\n", + " Note: This implementation is different from the normal PixelCNN.\n", + "\n", + " Arguments:\n", + " mask_type: one of `\"V\"`, `\"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", + "\n", + " if isinstance(kernel_size, int):\n", + " kernel_size = (kernel_size, kernel_size)\n", + " self.kernel_size = kernel_size\n", + "\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, kernel_w = self.kernel_size\n", + "\n", + " self.kernel = self.add_weight('kernel',\n", + " shape=(kernel_h,\n", + " kernel_w,\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", + " mask = np.ones(self.kernel.shape, dtype=np.float32)\n", + "\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.float32, 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": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "PTUN4s52Nu3w", + "colab": {} + }, + "source": [ + "class GatedBlock(tf.keras.Model):\n", + " \"\"\" Gated block of the 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) # NxN\n", + "\n", + " # Shifting feature map down to 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) # 1x1\n", + "\n", + " horizontal_preactivation = self.horizontal_conv(h) # 1xN\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" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "WB57YufrVxn2", + "colab": {} + }, + "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": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "_LnzHUaqV77d", + "colab": {} + }, + "source": [ + "# Prepare optimizer and loss function\n", + "lr_decay = 0.999995\n", + "learning_rate = 1e-3\n", + "optimizer = keras.optimizers.Adam(lr=learning_rate)\n", + "\n", + "compute_loss = keras.losses.CategoricalCrossentropy(from_logits=True)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "CsAgEKVzLCJD", + "colab": {} + }, + "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": 0, + "outputs": [] }, - "colab_type": "code", - "id": "-Ia9VXYySkuW", - "outputId": "2bce0fd7-d366-4ed6-dc42-42f519b02567" - }, - "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "NoEPrfwQNM-s", + "outputId": "52dae9be-4f84-4b91-c5ba-e2369259478e", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 591 + } + }, + "source": [ + "# Training loop\n", + "n_epochs = 100\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": 12, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Epoch 1/100\n", + "469/469 [==============================] - 176s 376ms/step - loss: 0.1096\n", + "Epoch 2/100\n", + "469/469 [==============================] - 171s 366ms/step - loss: 0.0892\n", + "Epoch 3/100\n", + "469/469 [==============================] - 171s 365ms/step - loss: 0.0864\n", + "Epoch 4/100\n", + "469/469 [==============================] - 171s 365ms/step - loss: 0.0848\n", + "Epoch 5/100\n", + "469/469 [==============================] - 171s 365ms/step - loss: 0.0837\n", + "Epoch 6/100\n", + "469/469 [==============================] - 171s 365ms/step - loss: 0.0829\n", + "Epoch 7/100\n", + " 92/469 [====>.........................] - ETA: 2:18 - loss: 0.0824" + ], + "name": "stdout" + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mprogbar\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'loss'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/utils/generic_utils.py\u001b[0m in \u001b[0;36madd\u001b[0;34m(self, n, values)\u001b[0m\n\u001b[1;32m 595\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 596\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 597\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_seen_so_far\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 598\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 599\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/utils/generic_utils.py\u001b[0m in \u001b[0;36mupdate\u001b[0;34m(self, current, values)\u001b[0m\n\u001b[1;32m 488\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_values\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mv\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mvalue_base\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue_base\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 489\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 490\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_values\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mvalue_base\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 491\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_values\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mvalue_base\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 492\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/ops/math_ops.py\u001b[0m in \u001b[0;36mbinary_op_wrapper\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m 913\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 915\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 916\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 917\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mbinary_op_wrapper_sparse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msp_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/ops/math_ops.py\u001b[0m in \u001b[0;36m_mul_dispatch\u001b[0;34m(x, y, name)\u001b[0m\n\u001b[1;32m 1199\u001b[0m \u001b[0mis_tensor_y\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1200\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_tensor_y\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1201\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgen_math_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmul\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1202\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1203\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msparse_tensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSparseTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Case: Dense * Sparse.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/ops/gen_math_ops.py\u001b[0m in \u001b[0;36mmul\u001b[0;34m(x, y, name)\u001b[0m\n\u001b[1;32m 6111\u001b[0m _result = _pywrap_tensorflow.TFE_Py_FastPathExecute(\n\u001b[1;32m 6112\u001b[0m \u001b[0m_ctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_context_handle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtld\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Mul\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtld\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mop_callbacks\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 6113\u001b[0;31m x, y)\n\u001b[0m\u001b[1;32m 6114\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6115\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_FallbackException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "ue0vZbitSNmz", + "outputId": "b4be6fad-6f16-4380-8dbd-2e01bc3e1af1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + } + }, + "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(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": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "nll : 0.08227105438709259 nats\n", + "bits/dim : 0.11869204217296468\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "-Ia9VXYySkuW", + "outputId": "924010f4-0dcb-4a82-bd1d-75c6091cadc6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 581 + } + }, + "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()" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAI0CAYAAAAdqSPKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# 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 = pixelcnn(samples)\n", - " logits = tf.reshape(logits, [-1, height, width, q_levels, n_channel])\n", - " logits = tf.transpose(logits, perm=[0, 1, 2, 4, 3])\n", - " next_sample = tf.random.categorical(logits[:, i, j, 0, :], 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()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 526 }, - "colab_type": "code", - "id": "KBuWx-FtSouR", - "outputId": "1f0ec5bc-8dbf-4df0-a24e-8f05255a6835" - }, - "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "KBuWx-FtSouR", + "outputId": "85fb1988-aeea-4695-f5e3-d5a57d28bed6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 153 + } + }, + "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()" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAABECAYAAABu1lQcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0\ndHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAADy0lEQVR4nO3cQVLkOBAF0PTEHIFeTx2C+58A7kCv\nhztoFkwHBOFy2WW7UCrfW3Y4OpSWbL5Shqm1FgAAVfz10wMAAHgk4QcAKEX4AQBKEX4AgFKEHwCg\nFOEHAChF+AEAShF+AIBShB8AoJS/t1z89PTULpfLSUM519vbW7y/v09L12SuLyLi9fX1vbX2a+ma\nzDWumcMINfbOs/ghc43W6afRa8xcX8T1Z3FT+LlcLvHy8nLcqB7o+fn55jWZ64uImKbp961rMte4\nZg4j1Ng7z+KHzDVap59GrzFzfRHXn0XHXgBAKcIPAFDKpmMvtpum+ePU1tqDRwIAROj8AADF6Pwc\n5FqH59b1FTpAo9Q6N8fZawLGNE2T99MCnR8AoBSdnwNs7fpAT0bpzO2V8T58f/dkGjvb3XvC8If1\n8Un4OcnSIvu6IDO+cNcaKRSOVMtRvt6TzOv3+9xmeCbPWI9Z5jPLOPfyzjmXYy8AoJRTOz8VPxDd\nWt/o9yO7W7uvDF2Ca/buLFtrdqc/4Oj3apajEWttbI/OCzo/AEApp3R+lhL6kem9lx3K2nFU3bn0\nMk9b+LCwhuzd6UxjvdeanydZ78O9489a7x9r369L1+29B6eEn7Uf++6VfeGPLGvQO2rcPf+NjaOC\nWtY5zuqMD317/nh4y/rq+Xm75lZ92epZ0uO7wrEXAFDKw3/VfW+a7Xmnck321jrzvs5hjzubORmf\nnzNkma+IXGP9SVlOAqrM59o65+br+1zO/V97u306PwBAKf7I4cmqpPwR7NmpzO1QsuxEtxp1TY82\nT3Myd6GXOgRz/9ZbXZnv/dHu+cD76PeOzg8AUEqazk+2bxXO/BW9nmWbp7XW1tJrB+iseRlpjjPZ\n8ht72Tt1o66xUes6osO19K3PUboPP9kf3K9GXewjM2efRnoWM1nzg+Deuel1ffe2edjLs/Ohp7/z\n59gLACil+85P1rSfddx7Za575OOgI8bTW017ZKwl45jvtfWYuXdZxnmEpVp7ug86PwBAKcIPAFCK\n8AMAlCL8AAClCD8AQCnCDwBQivADAJQi/AAApQg/AEApwg8AUIrwAwCUIvwAAKUIPwBAKcIPAFCK\n8AMAlCL8AAClCD8AQCnCDwBQivADAJQi/AAApQg/AEApwg8AUIrwAwCUMrXW1l88Tf9GxO/zhnOq\nf1prv5YuSF5fxPg13qwvQo0JjL5OI8av0Tr93+g1Jq8v4kqNm8IPAEB2jr0AgFKEHwCgFOEHAChF\n+AEAShF+AIBShB8AoBThBwAoRfgBAEoRfgCAUv4Dzge+SeXbn58AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAABECAYAAABu1lQcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0\ndHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAFPklEQVR4nO3dS27jOBAAUGowR0ivx4fI/U+Q3KF7\nPbmDZpEJbBj62qLMYr23DISAJVJMsUgpwziOBQAgi79e3QAAgDNJfgCAVCQ/AEAqkh8AIBXJDwCQ\niuQHAEhF8gMApCL5AQBSkfwAAKn8vefit7e38XK5VGpKXb9//y5fX1/D0jWR4yullM/Pz69xHH8t\nXRM5xi19WIoYW+dZ/BY5RuP0qvcYI8dXyvyzuCv5uVwu5ePj47hWnej9/X31msjxlVLKMAx/1q6J\nHOOWPixFjK3zLH6LHKNxetV7jJHjK2X+WbTtBQCkIvkBAFLZte3FfsMwvZ06juPJLQEASlH5AQCS\nUfk5yFyFZ+36DBWgXmKd6uPoMQF9GobB/LRA5QcASEXl5wB7qz7Qkl4qc8+KeB/u555IbWe/R3cY\nfhgfV5KfSpYG2e2AjDjhbtVTUthTLEe5vSeRx+9930Z4JmuMxyj9GaWdzzLn1GXbCwBIpWrlJ+MB\n0b3x9X4/oltbfUWoEsx5dmU5jqPV6QscPa9G2Rox1vp2dr6g8gMApFKl8rOUoR+ZvbeyQtnajqwr\nl1b6aQ8HC3OIXp2O1NZHbfl7EvU+PNr+qPH+2Dq/Ll337D2okvxsPez7rOgDv2dRE72j2t3yNzaO\nStSi9nFUNQ76tnx4eM/4avl5m7MWX7R4lrQ4V9j2AgBSOf1V92ez2ZZXKnOil9aZdtuHLa5spkR8\nfmqI0l+lxGrrK0XZCcjSn1vjnOqv+76c+l3PVvtUfgCAVHzksLIsWX4PnlmpTK1QoqxE9+p1TPfW\nT1MiV6GXKgRTP2strsj3/miPHPA+et5R+QEAUglT+Yl2VqHmK3oti9ZPW22NpdUKUK1+6amPI9nz\nxl70Sl2vY6zXuI6ocC2d9TlK88lP9Af3Vq+DvWf67KqnZzGSLX8IHu2bVsd3a4uHZ3l2vrX0nT/b\nXgBAKs1WfuYyxMjZf3atH/hrqS01Zf4adeQV+NYDv3t/B+fK2ActPncqPwBAKk1Ufno/HNxDDGuW\nXjnl9ZY+yLhUkev92SwldhyR275k6tXmHs7+ZFDrsPLR/d5E8jMl6gDP+gd/asBH7cPe3feLxJVI\nMv1PrMha/wK+bS8AIJWqlZ+pMmWGMjrtq1Whav1Q95TW23eUFlefzDvjWy9nud3Gm5p7evtUwb0t\n7Ty7n1V+AIBUTjnzk6na09Nq5RG38Wc6oJi1v6EVrc8zS19/f1SmOfZoKj8AQCqnv+2VJUPNEue9\niBWQZ1ZPmaqa8Apb3k6M5Ih5Ifo9uPWqWKomPyb/fKJs+y19R+TZ3wvU0/or1MRg2wsASKXZjxxC\nbUdWqVR8AK7WjgTsmXdrzK8qPwBAKio/VNf665h7/1t2q3HwmC0rUH0O22x5nlo4qyX5oYq9Zc3W\n+GN3NdePvd+j3uOLLPLc0quafTIMw+HPo20vACAVlZ8Xybqapm1W1J5B2uT/Bh5L5QcASEXlp7K9\nK+kae5uv0kscme09DN6ytXNovY7XnuaUUuKOv0dFrPhEoPIDAKSi8nOQPa/Lrl3b+qvh5HY7jqON\n0Wjt3Wtubrn/eW/3obd4Sumj4tNypVXyU8lSx651+s+AkQRxtvsEfSrBMS7bs/SHspdtoh6Sga0i\nxrp3i/zV84htLwAglWFP1jUMw7+llD/1mlPVP+M4/lq6IHh8pfQf42p8pYgxgN7HaSn9x2ic/q/3\nGIPHV8pMjLuSHwCA6Gx7AQCpSH4AgFQkPwBAKpIfACAVyQ8AkIrkBwBIRfIDAKQi+QEAUpH8AACp\n/AcUCbSNo+kQgwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } ] - }, - "metadata": {}, - "output_type": "display_data" } - ], - "source": [ - "# --------------------------------------------------------------------------------------------------------------\n", - "# Filling occluded images\n", - "occlude_start_row = 14\n", - "num_generated_images = 100\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", - "for i in range(occlude_start_row, height):\n", - " for j in range(width):\n", - " logits = pixelcnn(samples)\n", - " logits = tf.reshape(logits, [-1, height, width, q_levels, n_channel])\n", - " logits = tf.transpose(logits, perm=[0, 1, 2, 4, 3])\n", - " next_sample = tf.random.categorical(logits[:, i, j, 0, :], 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()" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "include_colab_link": true, - "name": "gated_pixelcnn.ipynb", - "provenance": [] - }, - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} + ] +} \ No newline at end of file