diff --git a/2 - Modelling data with multiple channels/PixelCNN_RGB.ipynb b/2 - Modelling data with multiple channels/PixelCNN_RGB.ipynb new file mode 100644 index 0000000..19816c8 --- /dev/null +++ b/2 - Modelling data with multiple channels/PixelCNN_RGB.ipynb @@ -0,0 +1,1278 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "accelerator": "GPU", + "colab": { + "name": "PixelCNN - RGB.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "s3cIDeAvE-0F", + "colab_type": "text" + }, + "source": [ + "# Autoregressive models - PixelCNN for multiple layers\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kYCEpIQ0Zz_e", + "colab_type": "text" + }, + "source": [ + "In our previous notebook, we trained a generative model to create black and white drawings of numbers by learning the manifold distribution of the MNIST dataset. Now we are going to create a generative model with a similar architecture that is able to generate coloured images and is trained on the CIFAR10 dataset - a commonly used dataset for machine learning research which is composed of natural images of 10 different classes: airplanes, birds, cars, cats, deers, dogs, frogs, horses, ships and trucks. Besides having 3 channels of colour instead of one, these images are more complex and diverse than the hand-written numbers of the MNIST dataset, so it is more challenging for the model to learn the manifold that generates these images. Let's see how it fares." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lseHg6XMUCUv", + "colab_type": "text" + }, + "source": [ + "This implementation uses Tensorflow 2.0. We start by installing and importing the code dependencies." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "cpSh3dRh_JKQ", + "colab": {} + }, + "source": [ + "%tensorflow_version 2.x" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "zgXBspaF_rDT", + "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 import keras" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q8oU7ULGUM9k", + "colab_type": "text" + }, + "source": [ + "To allow for reproducible results we fix a random seed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "k7th6eFNAZfA", + "colab": {} + }, + "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)" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vVfzwWmiUTBI", + "colab_type": "text" + }, + "source": [ + "The original CIFAR10 dataset has 255 different intensity values for each sub-pixel. We use the `quantisize` function to define the number intensity values we are using and control for the complexity of the problem." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "drtl9dwsAQMq", + "colab": {} + }, + "source": [ + "def quantisize(images, q_levels):\n", + " \"\"\"Digitize image into q levels\"\"\"\n", + " return (np.digitize(images, np.arange(q_levels) / q_levels) - 1).astype('float32')" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NBueIhzJUtJw", + "colab_type": "text" + }, + "source": [ + "# Masked Convolution for sub-pixels\n", + "In the PixelCNN we use masks to control for the information the model has access when processing the data of a central pixel. The convolutional filter naturally considers all the pixels around it, so we use masks to block the information from the pixels that come after the central pixel in our pre-defined ordering.\n", + "\n", + "When we are working with more than 1 channel (coloured images have 3), we need to make sure the sub-pixels don't have access to information yet to be processed. We need to adapt our masks to the information of future sub-pixels when processing each sub-pixel at a time. To do so, we ajust the `build` function in the `MaskedConv2D` class in order to block the central pixel's information for yet unseen sub-pixels just as is pictured in the red squares of the following image:\n", + "\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "rWRqRdt5AIyg", + "colab": {} + }, + "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", + " input_n_channels=3):\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 = keras.initializers.get(kernel_initializer)\n", + " self.bias_initializer = keras.initializers.get(bias_initializer)\n", + " self.input_n_channels = input_n_channels\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", + " center = self.kernel_size // 2\n", + " mask = np.ones(self.kernel.shape, dtype=np.float32)\n", + " mask[center, center + 1:, :, :] = 0\n", + " mask[center + 1:, :, :, :] = 0\n", + "\n", + " for i in range(self.input_n_channels):\n", + " for j in range(self.input_n_channels):\n", + " if (self.mask_type == 'A' and i >= j) or (self.mask_type == 'B' and i > j):\n", + " mask[center, center, i::self.input_n_channels, j::self.input_n_channels] = 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,\n", + " masked_kernel,\n", + " strides=[1, self.strides, self.strides, 1],\n", + " padding=self.padding)\n", + " x = tf.nn.bias_add(x, self.bias)\n", + " return x" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9XmLBiDmXQzk", + "colab_type": "text" + }, + "source": [ + "The Residual block is an important building block of Oord's seminal paper that originated the PixelCNN." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "a_ljhq0FALQo", + "colab": {} + }, + "source": [ + "class ResidualBlock(tf.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\n", + " recurrent neural networks. arXiv preprint arXiv:1601.06759.\n", + " \"\"\"\n", + "\n", + " def __init__(self, h):\n", + " super(ResidualBlock, self).__init__(name='')\n", + "\n", + " self.conv2a = MaskedConv2D(mask_type='B', filters=h//2, kernel_size=1, strides=1)\n", + " self.conv2b = MaskedConv2D(mask_type='B', filters=h//2, kernel_size=7, strides=1)\n", + " self.conv2c = MaskedConv2D(mask_type='B', filters=h, kernel_size=1, strides=1)\n", + "\n", + " def call(self, input_tensor):\n", + " x = tf.nn.relu(input_tensor)\n", + " x = self.conv2a(x)\n", + "\n", + " x = tf.nn.relu(x)\n", + " x = self.conv2b(x)\n", + "\n", + " x = tf.nn.relu(x)\n", + " x = self.conv2c(x)\n", + "\n", + " x += input_tensor\n", + " return x" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hFG22G87XsRs", + "colab_type": "text" + }, + "source": [ + "# Overfitting to 2 examples\n", + "\n", + "Generating natural-looking coloured images is challenging. To make sure the implementation is sound and learning is happening, we start by learning an easier problem. We do so, by overfitting the generative model to just 2 examples - a frog and a truck. In this case, if everything is working correctly, the model will memorize the two examples and replicate them with near perfect accuracy, instead of generalizing for different unseen examples, which is what happens when there is no overfitting." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "ACyt8q_pAep_", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "outputId": "978fc16f-ebbe-4c40-cab7-fb86fb8caeb5" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Loading data\n", + "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()\n", + "\n", + "height = 32\n", + "width = 32\n", + "n_channel = 3\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)\n", + "\n", + "x_train_overfit = np.tile(x_train[:2], 25000)\n", + "x_train_overfit = x_train_overfit.reshape(2,32,32,25000,3)\n", + "x_train_overfit = np.transpose(x_train_overfit, (0,3,1,2,4)).reshape(50000,32,32,3)\n", + "x_test_overfit = x_train_overfit" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n", + "170500096/170498071 [==============================] - 3s 0us/step\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "FrgFLyZ7AhuO", + "colab": {} + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Quantisize the input data in q levels\n", + "q_levels = 128\n", + "x_train_quantised_of = quantisize(x_train_overfit, q_levels)\n", + "x_test_quantised_of = quantisize(x_test_overfit, q_levels)" + ], + "execution_count": 62, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "P1ass4f8YIve", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 240 + }, + "outputId": "711ff837-945b-4321-de0e-3e951cec7e4f" + }, + "source": [ + "# Check the first samples\n", + "print('Training examples')\n", + "fig,ax = plt.subplots(1, 10, figsize=(15, 10), dpi=80)\n", + "for i in range(10):\n", + " ax[i].imshow(x_train_quantised_of[i*5000]/(q_levels-1))\n", + "[x.axis('off') for x in ax]\n", + "plt.show()\n", + "print('Testing examples')\n", + "fig,ax = plt.subplots(1, 10, figsize=(15, 10), dpi=80)\n", + "for i in range(10):\n", + " ax[i].imshow(x_test_quantised_of[i*5000]/(q_levels-1))\n", + "[x.axis('off') for x in ax]\n", + "plt.show()" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Training examples\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "stream", + "text": [ + "Testing examples\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "RNa7rI0nAkzb", + "colab": {} + }, + "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_of / (q_levels - 1),\n", + " x_train_quantised_of.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_of / (q_levels - 1),\n", + " x_test_quantised_of.astype('int32')))\n", + "test_dataset = test_dataset.batch(batch_size)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "vHpl6p45AtGz", + "colab": {} + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Create PixelCNN model\n", + "n_filters = 120 \n", + "inputs = keras.layers.Input(shape=(height, width, n_channel))\n", + "x = MaskedConv2D(mask_type='A', filters=n_filters, kernel_size=7)(inputs)\n", + "\n", + "for i in range(15):\n", + " x = keras.layers.Activation(activation='relu')(x)\n", + " x = ResidualBlock(h=n_filters)(x)\n", + "\n", + "x = keras.layers.Activation(activation='relu')(x)\n", + "x = MaskedConv2D(mask_type='B', filters=n_filters, kernel_size=1)(x) \n", + "x = keras.layers.Activation(activation='relu')(x)\n", + "x = MaskedConv2D(mask_type='B', filters=n_channel * q_levels, kernel_size=1)(x) # shape [N,H,W,DC]\n", + "\n", + "pixelcnn = tf.keras.Model(inputs=inputs, outputs=x)" + ], + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "qK0rhyk8A1si", + "colab": {} + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Prepare optimizer and loss function\n", + "lr_decay = 0.9999\n", + "learning_rate = 5e-3 #5\n", + "optimizer = tf.keras.optimizers.Adam(lr=learning_rate)\n", + "\n", + "compute_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)" + ], + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "Gn2RvQ3tA3j2", + "colab": {} + }, + "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" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AijXTWMj66Gg", + "colab_type": "text" + }, + "source": [ + "We train the model for 10 epochs and we can see in no time the loss function dropping to almost 0. When the model generates new examples, it will show almost identical images to the two it was presented during training." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gn3_TpDP64g0", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 884 + }, + "outputId": "b4b9e042-0a25-4bb9-a7b2-898438e78498" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Training loop\n", + "\n", + "n_epochs = 10\n", + "val_error = []\n", + "n_iter = int(np.ceil(x_train_quantised_of.shape[0] / batch_size))\n", + "for epoch in range(n_epochs):\n", + "\n", + " start_epoch = time.time()\n", + " for i_iter, (batch_x, batch_y) in enumerate(train_dataset):\n", + "\n", + " start = time.time()\n", + " optimizer.lr = optimizer.lr * lr_decay\n", + " loss = train_step(batch_x, batch_y)\n", + " val_error.append(loss)\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)))" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "text": [ + "EPOCH 0: ITER 0/ 391 TIME: 11.56 LOSS: 4.8524\n", + "EPOCH 0: ITER 100/ 391 TIME: 1.00 LOSS: 3.4277\n", + "EPOCH 0: ITER 200/ 391 TIME: 1.01 LOSS: 2.4261\n", + "EPOCH 0: ITER 300/ 391 TIME: 1.01 LOSS: 1.4569\n", + "EPOCH 0: TIME: 409.76 ETA: 4097.59\n", + "EPOCH 1: ITER 0/ 391 TIME: 0.22 LOSS: 1.0011\n", + "EPOCH 1: ITER 100/ 391 TIME: 1.01 LOSS: 0.5937\n", + "EPOCH 1: ITER 200/ 391 TIME: 1.01 LOSS: 0.3431\n", + "EPOCH 1: ITER 300/ 391 TIME: 1.01 LOSS: 0.3064\n", + "EPOCH 1: TIME: 396.34 ETA: 3567.05\n", + "EPOCH 2: ITER 0/ 391 TIME: 0.22 LOSS: 0.2177\n", + "EPOCH 2: ITER 100/ 391 TIME: 1.01 LOSS: 0.2410\n", + "EPOCH 2: ITER 200/ 391 TIME: 1.01 LOSS: 0.1268\n", + "EPOCH 2: ITER 300/ 391 TIME: 1.00 LOSS: 0.1524\n", + "EPOCH 2: TIME: 395.96 ETA: 3167.71\n", + "EPOCH 3: ITER 0/ 391 TIME: 0.22 LOSS: 0.0689\n", + "EPOCH 3: ITER 100/ 391 TIME: 1.01 LOSS: 0.0449\n", + "EPOCH 3: ITER 200/ 391 TIME: 1.00 LOSS: 0.0476\n", + "EPOCH 3: ITER 300/ 391 TIME: 1.00 LOSS: 0.0387\n", + "EPOCH 3: TIME: 395.65 ETA: 2769.57\n", + "EPOCH 4: ITER 0/ 391 TIME: 0.22 LOSS: 0.0423\n", + "EPOCH 4: ITER 100/ 391 TIME: 1.01 LOSS: 0.0302\n", + "EPOCH 4: ITER 200/ 391 TIME: 1.00 LOSS: 0.0301\n", + "EPOCH 4: ITER 300/ 391 TIME: 1.00 LOSS: 0.0341\n", + "EPOCH 4: TIME: 395.39 ETA: 2372.32\n", + "EPOCH 5: ITER 0/ 391 TIME: 0.22 LOSS: 0.0351\n", + "EPOCH 5: ITER 100/ 391 TIME: 1.00 LOSS: 0.0355\n", + "EPOCH 5: ITER 200/ 391 TIME: 1.01 LOSS: 0.0176\n", + "EPOCH 5: ITER 300/ 391 TIME: 1.00 LOSS: 0.0278\n", + "EPOCH 5: TIME: 395.45 ETA: 1977.26\n", + "EPOCH 6: ITER 0/ 391 TIME: 0.22 LOSS: 0.0193\n", + "EPOCH 6: ITER 100/ 391 TIME: 1.01 LOSS: 0.0223\n", + "EPOCH 6: ITER 200/ 391 TIME: 1.01 LOSS: 0.0187\n", + "EPOCH 6: ITER 300/ 391 TIME: 1.00 LOSS: 0.0140\n", + "EPOCH 6: TIME: 395.13 ETA: 1580.52\n", + "EPOCH 7: ITER 0/ 391 TIME: 0.22 LOSS: 0.0163\n", + "EPOCH 7: ITER 100/ 391 TIME: 1.01 LOSS: 0.0169\n", + "EPOCH 7: ITER 200/ 391 TIME: 1.01 LOSS: 0.0130\n", + "EPOCH 7: ITER 300/ 391 TIME: 1.00 LOSS: 0.0103\n", + "EPOCH 7: TIME: 395.25 ETA: 1185.76\n", + "EPOCH 8: ITER 0/ 391 TIME: 0.22 LOSS: 0.0250\n", + "EPOCH 8: ITER 100/ 391 TIME: 1.00 LOSS: 0.0212\n", + "EPOCH 8: ITER 200/ 391 TIME: 1.00 LOSS: 0.0105\n", + "EPOCH 8: ITER 300/ 391 TIME: 1.00 LOSS: 0.0133\n", + "EPOCH 8: TIME: 395.32 ETA: 790.63\n", + "EPOCH 9: ITER 0/ 391 TIME: 0.22 LOSS: 0.0179\n", + "EPOCH 9: ITER 100/ 391 TIME: 1.00 LOSS: 0.0149\n", + "EPOCH 9: ITER 200/ 391 TIME: 1.00 LOSS: 0.0093\n", + "EPOCH 9: ITER 300/ 391 TIME: 1.01 LOSS: 0.0042\n", + "EPOCH 9: TIME: 395.11 ETA: 395.11\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6OEhuDRj7XYk", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 578 + }, + "outputId": "f852f353-0915-45df-9d89-198bc6c0f390" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Generating new images\n", + "samples = np.zeros((9, height, width, n_channel), dtype='float32')\n", + "for i in range(height):\n", + " for j in range(width):\n", + " for k in range(n_channel):\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, k, :], 1)\n", + " samples[:, i, j, k] = (next_sample.numpy() / (q_levels - 1))[:, 0]\n", + " \n", + "\n", + "fig = plt.figure(figsize=(10, 10))\n", + "for i in range(9):\n", + " ax = fig.add_subplot(3, 3, i+1)\n", + " ax.imshow(samples[i, :, :, :])\n", + " plt.xticks(np.array([]))\n", + " plt.yticks(np.array([]))\n", + "plt.show()" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wmjiLLrJN9aM", + "colab_type": "text" + }, + "source": [ + "Now, if our test set contains images that were not the two that the model overfit to, the loss will be large as the model is not able to recreate the unseen image. It is only able to recreate the two memorized images." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mc0URDgg7Kvv", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "outputId": "79723e63-c659-49e5-853d-cffab9528ed6" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Test\n", + "x_train_quantised = quantisize(x_train, q_levels)\n", + "x_test_quantised = quantisize(x_test, q_levels)\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)\n", + "\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)))" + ], + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "text": [ + "nll : 126.13430786132812 nats\n", + "bits/dim : 0.12317803502082825\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZHgM05AvOI77", + "colab_type": "text" + }, + "source": [ + "A similar result is obtained if we try to use the model to predict half of an occluded image. All the model is able to do is present the two examples it has seen. Let's then try to make the model learn the manifold distribution of the whole CIFAR10 dataset and create unseen examples of natural images." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "xtgp2L8BOIVy", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 246 + }, + "outputId": "9e48c8ac-e84e-4b4d-e118-cf21bfbaa955" + }, + "source": [ + " # Filling occluded images\n", + " occlude_start_row = 16\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=(20, 20))\n", + "\n", + " for i in range(10):\n", + " ax = fig.add_subplot(1, 10, i + 1)\n", + " ax.matshow(samples[i, :, :, :], 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", + " for k in range(n_channel):\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, k, :], 1)\n", + " samples[:, i, j, k] = (next_sample.numpy() / (q_levels - 1))[:, 0]\n", + "\n", + " fig = plt.figure(figsize=(20, 20))\n", + "\n", + " for i in range(10):\n", + " ax = fig.add_subplot(1, 10, i + 1)\n", + " ax.matshow(samples[i, :, :, :], cmap=matplotlib.cm.binary)\n", + " plt.xticks(np.array([]))\n", + " plt.yticks(np.array([]))\n", + " plt.show()\n" + ], + "execution_count": 23, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAABzCAYAAAAi/f8/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2dT4gkWX7fX0ZFx8Tm5qZyc1KppLa2XBRFu2maZmiG9jAehmYsxCILYYQQwhj7YB+FTwYfjJGPPvksfFiELIzxP4RZg9iVFzEMw7IaN03TNE3TtEulokinc9O5qdjYmOioSB8yMn6ft52xMz2TtZs7/n4u8zonMvLF+x+vft/3bS2XSyeEEEIIIYQQQgghdovg550BIYQQQgghhBBCCPEy2rQRQgghhBBCCCGE2EG0aSOEEEIIIYQQQgixg2jTRgghhBBCCCGEEGIH0aaNEEIIIYQQQgghxA6iTRshhBBCCCGEEEKIHUSbNkIIIYQQQgghhBA7iDZthBBCCCGEEEIIIXYQbdoIIYQQQgghhBBC7CDhq1z8lS+Fy9e70UufB63WxuuXy+XGdCtobfy8Ce/2S+4z4Z4tpDflpSFfP/FLuMY+LTde4d/T+y1+ebm5bPht3qfk71b3+eGPCvfjjy+bbvRKvP7668uvf/3rL+fzC8knl/3PkocPH06Xy+Uvb+NeX/ml/vL10ddW/8DjFMWLOr0sreW+9tprdXov3KvTLZQR+xn7NEvRb/92/71gc1m3NtynuCzwPeQl4LUNY4r76f38J/9HeWl5ZF4C/FbJTueNUzbWrK8+OztzP/jBdCt98Stf6Sxff72/yk8YW96QT5bPJfJWogybxiS/Pl9+lpf/0cCG7rJs6ENevX2KezflpWls8tpTq6m9YI5gWyiyOv302fOt9cVrUbiM41X/Cvbst18Ul3X68tLSbJPhNatft4d0Q3/iBJGn9jy8Poqv2cfelzm/rdJ7Ib73GpYDLa8y8LF9flnY50Vh7ZHdqfNla9f8H4tFUqevvYb84v4vcrunQ19c94nsR5nLP8630he77deWv9JtO+ec+zGeJUk/RhYsD19GGe95jczq1lvz7G3++5g3Pnl1jnLGPS9RhsuqrII9q7cC1xYvUH7IS9DQP9jROdbwuf21jSU5voSYX/IXbBeb+/QPf5xtb17cay0H11Z5uYbHvNbwyHvBEmmOLahHXN/QLRyq0Wv/TV/m+Ln+brm5aJ0LbM29/PKX7Xt//dd1ukC+XmDNuYd5IscSchlw3MGYhfYTIt1CuuQQXxVCUjqXlY2L3Vfitfi1Zbvz5Zf/R9P7RNNapcU+t3mW9N4bAjwj+xnrpdw8zyyXq++Wy839vxFv6bH5naDpPaop3TRe+8+EBuutH4ut9cUgCJbrsXrJOsJvx5GNo7/81W6dvraHfPMNDO9//njSsBZtqIJXeQO4ROfOMCd9jLFt75r1UTQpF8f2+Zc4v7JvNeTrU3WmDW1m/IMfunmSbqUvfvWrX11+7Wv71U9xTESaY8Yexiq+y3IOu8Q7Cp64vES62DwvFstLfG5t4bK0z9dcu2Zt61po6Qif+4vOzc8XcKwES67FXtg6gXnh3LmHcTZ/YWXAsmFTP/1ff7WxL77Sps3r3cj9/t//m+tfqj+PIrsNM5nneZ0uihzXW8UWDRl2gXWIgLnMO/iHXRNFtoANHPOz/h27tig4OPM3sfgp7DkyXMNpoPQzbFnEc5fl5o4a4Ls5Pk+xzkqrAeLf/Y8Lty2+/vWvu+985zvOOX+hzXrbWcqGjxuy7i1OvariPxpuegVBaKPR6C+3da/XR19zv/8H/231D9TjdDqu03lmfeL4+KRO93o2OYao9yhCOticDlmkRVqnO23r0yGafOh9d5WezWf1Z90O8oJxJNzQh51zrijzjZ8TtuU0sTyGyFgc28ukN04hzWuCamx4797f3vyjn4HXX++7f/Ev/7lzzrnO4Hr9eRuL9G7XxrsFBqJ0MUXeMJ7h/iz7OIyQRgV9imZeYuxc/wAnGo6DLOMg+OTf8T72Fs3FS9eu7sn2as8UBdgccPZ5gDaVTh/X6Xu//jtb64tx/Jp782/dWP0y2vME7Xw2m9fpbGH9sj9C++/37aboi2zoRWLlcnbfnifEH1MOT0aWN3TYsgiRXn3eG1i57R/b7wchr7XfDFHmixnGnfGkTudohG/fvWH3yez6b3/7/Tp9cHRg+cX9L85sLAvb1g867VWZ/cV3/sJti1/ptt2/+UfvOeecezKxZ3n/wXP8brtOv3nd8tzjBISNtBxtOOpwLLHruXkVYYHPtcgitTFsnmFtUfXpuGP1Nkvt/4/xHA5l38UGMTtggX6ccBxs2/Xe2gkV3cFYOUA7PkO7SHFP8q2HT7bWFwfXAvevvr6qp1HH8jeKMfZjbdmN7ZpexwojCFDOXMCjirinmKQYm3P0uZL3RD/GPWfVog9V543jZdfaWnHnzTq9eP/P6/QEQ+04t0z2E5snTudY32Kcch3rW2O0tV5m6Qifpxin1xs7//2Hm8frz0K782X33t/9Oy99zjmHa1dvjeE4P1h/9daCeG8IIryXxJbOUBk56rPIOS7yPWZ1fYY1Ed95vBczwGmOfYvpvOD6pNj4ecnGyPcMlE3WsM5hWU7H0631xb1gz/V/aTUWFOg4Acro1uGwTv+T3/5GnR718D7lmFcbZ7KM7y92z268+Z2r6VXToyovXjvHfP30zMaz52OsY4f7dTpEn7+JeeLmsT2rSzHue+vbl7JSpTdf5K3DqvQ//td/6LbF17627/7Lf/r3zjl/nZw7y3+eW/kMOlYOaJ4uy61+ZjOb10v0xWSO/jfH+zzqc1bY74Z451gkC7u+KqvRyMp7NLQ10QHryvEPHpv77nq9scov+iXm4vPxaZ2eJ7bW62Bs7XZsPDob2zt9ive0wB7P/cN/8Hsb++IrbdosXcvl1eBXOvyVDw0ndpbJABUShpy8GjKAa3IsCIp886AcYmHDl0l/JMyqvLBx43ew2C+Qzrn5hA2cwOv59jtcHHMSKfki4v3lkIMs/hqF5wu8h9oOrVbLe7H6WbGVTaGGFzk2KG8wLoON1/DlMPgUmzZNE66fhYa/pH6K734W9oKg3igJsDGYpRjIMFDyfaAdb+43LAu25xizirfZiMkjwvWRd72xbneR92K/uS683+Q7EXY1eW++wJfehg//AoznxvWcjNh32zE3Ala0GqIKPwtLF7iyXP1GEdiLTo7FZhFgPI3wUpVhdOdExkBItL0cY2XGsQqPyMmXL+0ZXkTX5Rl55cfFE8Yyb4Nt82YLF6f+xirqCnnp93p1OsZk6m1ceQ0Dk3LCDf/t0dprubB6KY+Hlr8OynM2swVef2T5GGGDZZ55BWBJPH+KeucGZrdrZTEYYiMIG1iLORb81eqgM7C2xv5c4qWl5B9c2ixczJFYwIRov33kKw1sYZUubGyaXNiLZRttgwuqdtfKNa9ekLcZKNra26s33PKzs/rzN28c1el+DxtHnEKxkeZie/YeNmoY5cUNyRhjMce/Ai/MXW8X/OWNlQDXOiwA+TKA1Zrj1okXN13yc/tyMrN643zWxYKU9cY1UgcTDzfl3RXNi1+JnLt3WOUv4tiPlwO01QCDhbdsRP4yrEW5Ec3+gvc6l/Dlmy9hfHzkOam+m6BiCs55iY0dz8d/Vqd7eHHCUOAtLXmfTmdQp59h0+bh3F6ievgu3pv9F0tv02b1P5oiYz8LLWfzRdmwAeHR1Jb4udf0uHmBeRR9i/MoNzXYe7x3oKq/cHPIfyHkHMm7cZx9+Y8jVQbwOdvu5o0af81Zbrw+bJiPt8qqIl/KB+eN2dzGFvbLbtfmxQR1lGRYd6BOc/Rjbkh1sdHuvfc0bACuN8KD2Ma2uI3xLMU74tjq/xSbOUcjW8sd7NsGATf9ufDmWFtw/dTU3NkemPcqm62mKN3PQCtwLqomuxDvGW2HcuAfEjDgtTE/FNiESfGHigDrif7Ayq3E52zPh4PjOs0oJq5X27129fuWR/+dg0+IssdgySjm0vH9wO4TYf057NvmXL9nz1GUdh9u4MxmVga9yNY23QE20xv4BQivEEIIIYQQQgghhPj/D23aCCGEEEIIIYQQQuwgr6iTWVpoL8J+XMHbUPOJUL7YPw2m/pxnZFADjnCmAkG8JfXCkF95YfZeSGAVtoh4xxKagBQayTE0ddQlJwh/ZoghtZMRQka70IDHEcPdUB7ILUO7GKhYVGG52wt2Wx1YdlWSnZ/GNn7Tk6Z57WZzyH5G3bMX74ow2MZty1fL78+6TFtu6cKq/VMaEnnpYmM6DnmN3TNDmH0ADXIcQq5DCY1jmCYPRcUYgDwH1Y8xv64hlJfhxDn09NOphaGOEE7pqUmizZID1jWfO2fa08pv+nx7moyWW9ZlyLGMutkysHKNockYQAseLKyuOtBK80yjglINSIwoIQi8EG5KVRFOXtWXF5rapHBy/EfD2Q75y+G9P/llzgVtyE+8cd4rP6Z5/dX8jaK1t+fCSgbEUPMOpEFt6K9HB9ZuGUK8QBi4F8rN/oSwXbbPTofnjlBCiDMA0I+yfBWWXhYmmeBZO7Ox6bLZnwaH8cbPc8ipYpw/w3ZSZhibU/Zvew726RjnOeWou/HpSg9++eLlwwc/K0vXckVVzgOEN1MXn6N+8gVD9jFuRpbnkrJdSqI8OcLmMH0sFTzZIlvzWnLOMb/A2D5FwSaQ3vGMAJ6jw3x10P46PN+GMii3GX8esc8Dr11eTV+MWkt3UJ1TwjVhhnJOKb3H2tWT5PO7PAkAv0XZfII1CI638c534hEB3vlB1X0yhuc3tQu0owXksh38PlvXFGPHedf67mO039OZ1dexN49CIs05yZO0ruVR22PpbD3VeBaMV8aUZmKeY1lB4hfhHKOQ59hklDJYT+v0rEQTyDrzhPKoSlbDd5Vy8zrHm9/zzcdMeOeW8HAQysUa5mtPBs51L+XeDecAnZ1t7/xM4r/v2L/mmM8upiYDfOOGyaMoQ2TfzQNbx7i2pRcJznXE3NLrUe5OLSjT1TVYZ/QpA23bfMAzBr9//36d5lmIPcxnPA/LU7wiV95RGTzX1Vtj8R0Ya4Pqu9uU8O8FoevE/eq3NrfhTvulrznnnIvw3pChnXPczBbUhGJ9ktl329g7CKAhTRdWPqOR1X9Urr6b4n0+Qh/mEQtlhDUXJaBYQ2bo51x/4jXfDfq2jqL8cpHa+8p6zeWcv8bgeYyf5hgRRdoIIYQQQgghhBBC7CDatBFCCCGEEEIIIYTYQV5JHtVaLl24DtVj9DbCgWKc0u/dneHxnm+wJSmJ4HZSjJDH0ZFZ4y7m5joxnT6v01HIcKNVOkcYbFra/39yZvcoI5z6HCI0G6HnCWxcLyaw9kLIcYHQ8sOhhWUNEJ7Kcgo8WVidrENot3oaeKu18WT+XwQ87yiv3dDRyK569tzaxBBh7iXCvYewJ42jzbKeXaTllnVYPMNnQzq2USpFm0uEIfo2s5RTOaRZLnQvgPwmYxu2vkObyXYVTxj6mkikLUkbvI8QelpA4tG/a/anEcaIJkcshp7y88BzXqBcZ/N3t8XS7bnCdav8UL6J0Hyc2O+56WCM67ZRP/e/X6fzqYV+7t8y62U3xcn/EFx0UHALyKx8M+3VbwV9uFrlbHN2bYb40ZCSROjRFh3MHXNIcg5v1ukUci668NAZJS7RjlFmlMWGTXYMn5O98JrrDVfjywLzQ4y44S6ch3pwl6BjDJ0JYjqI0emC7kCU2aB5zsaoO0r8YIu57mx+O4K0hza3npFVg/yZbiQMz6ftPMLGR4fmqnFwcFin9w9snM4wCJ2fntfpNFu1k3K5vT65XC7ruWMIe9A4puwA0ouUclA4ZrAvUrbBthpvlrJFnmwJa44EjmF45PWYt1hgHcImjvpJEspaKcemYx+du4weXE86GGe5XqPcZ76wdkb5Y69Dt7er6YsvLpduWoXFZ3SGwrOlnpbWnmeBfLP9Z5Sqcd1BKTbSKfsr8uCF33OcLNfyqM3/n1IZmrctkJc51recS1JoMs6hFaGbyxDjZY8yf64BPKMiyrx+Pn/39aRm7IqexbU978XYHOGO4djH/pqiojO0W7qkwcTOWy+tHRZpCV54Rzk0OafxPWDzsRFdzyWHMmMez4Br+K7V4ILaJN26Oihl5hEGdsX52N7FEshtU8p6oT1sUx7ftTGqRHnNJib3ivHe14P0NvSGg5fbc8RxBOvfHtrOwcjkMUcn5nDURR5DrJe9+dWza6dcnWMHM0mZ0ssOYkFre30yCPZcu/3THY3KBpmeJ6HqQL62sLpK0F8yzH8XY5MVHRzYWoFjNOVG+1NK+FfyuDYmw+Mjc3eiNLu3D+erwNZueUK5KeY/tA86Q/E4Cc+dDjbiaWrz9KBn+YlCK5sEstUmFGkjhBBCCCGEEEIIsYNo00YIIYQQQgghhBBiB3lF9ygjCHsbP2eYLF1icoTqRmHTCeuURyE8CWHSb/3qr9Xpjz78sE5fICw9RahoUZ0kfXpuoXen5xZqHfUQpn1sYW0uhjwKIbRhx8LgisxCmRiG18bJ0Oc4yTzDs466VgZtOmVBulIX3/YMa35u7lHbIESIMw0MUmgM5ggvG08pVbD6HCA00nex2Oxw1ogXhvqzpdUyKR1VH5REMTw+8MJw4UCDnOeUnjBMs0vHEDoZILSQFYIY/oSh+5VchmHABX6TbjRzhMTO4NjQDplfhzTkNw1hwJQiFCgburNQ2uE5Pqzvv9xiZwSeEwQlWgWlFGxlCCt1Fr4alda23cCkJilO6c9Pn9o9IX5C9LBLos3h0/181RZyT8fJ0GdIuyArDeC0EFJuMMJzjK2/dgLLu+tizGV9Io++Uw/noM1ywW0StJyLqnbZRfscjhDWm9n8Qw0s3RPoIsCQbJY/nbz4NAuOdZA5ZTFCgfs2Z3cqqW6Ce6foiyXcrtjR0jmklZ6GEmHrkIVFASRiQ0vfeANyPZQZ2yCi/10bodN33r7tnHPu//yVPfPnZ+lMqmC/NZvbfMLn5dhDuVOH8ig61xWw2ED/puuXp4hBXVA2VUI2sM7vENK7CO3j6MBkINPc2l/OzNPSBCRzSIUiSBi76FueVMO+S5kxG6knQ7iiCfOFC9xFFc6e4Nk6kBvmGItS6DNShMSXdDihVIpOXZw7kYfck1MYEa4vuDauCo/34FCV4x+h16bgfDWwsSbuW+j9Ygw3oBmcF/FbCe5/hH4f0sIMbTxIrlg2vFzaOP+Ka1XO60zTCYsSlySBfCG3tYpLeY19t83+imYetSsnT0jTcrjlBaXN0ZSYxtBbYaryrqEMyoPznH8WxcZruP7hMQI59X9bZlM39/xC8WwXExvPZ5BK55C5pWh73X2WI1yasL6nzGo8tXsu4JTYQZsfVLLvmMddYExN8c7Hhxvu23pl/9jkvo79iXVaQv5MjRh+i+vosiFNl6O1XLncqpebUTZI3JraJ98JJhMbex4/eVynZ3A+pTPXFGPVeMI+ZfWWYk317Cld4FZzF+VRjwZcK9jcNjq0tnJ8gxJTo4+5I8Jcm0HuFHCsRD3TSZFzel5Cwg7JcbvJigso0kYIIYQQQgghhBBiB9GmjRBCCCGEEEIIIcQO8kryqNIFLg9WYX7zFKd1I+yn18Gp615Y58thXNVNLem5u+A0foQhffdbf1Knx3O7zwQhjKfnFgp1Vp0aH0DuVIYWqjhE6H2EsPIwZog3HDACu2YKWcUIDhgZpB2npyaPmiEkL8R9jgYIb2bIYxUGF7Suxj3q85wa7xmxfCol0eb9Qf8Q+82h1+tw7ukM4Y1ww0gZvo9wyABhbZ4zACLQGNzLQPErMrfYGq2WM/couo8xfDunYwhdkXjqOZ1eICVB+fNzr+8COol44cc47f2sCm303OPQeA7gADCdWnjkw4cP6/Ttm+YqREkM5Zex23ySewZHpChk2DAkiSHC6BGGunai2Ka0cLm0EFLP2aEhvDlnGSP/PUpmIIlqD4/qdOEQ+k35wsAC5VNIXEJIldgZkvW4OKIrAuQDyG8HoZ45w9BxvxDhwwH6dIjnCJCvAi5RdMqhbKBguK4n//jMauCfyuXlpclJ8PznZ6d1uk33mildaiCJQr4ThIcHKCPPsQl5oJPU4NBC7ts9m+vaCBtf16k3FSeb750gbH2O9M275uQ4QHsgcUjHDrgw9C1fKSUNqMceHCf6h3D5qdyUgr3tDdKtIKgdm3LIYSYTOFQM7RkjOKP5Em9Lcgz1Isi9f1BWmvEi+y2ET3MeW1Sh1z3kq4/+cQy3ygJj4hTt76CP9Q/GhRmcMUP0IUosPGcaPCvDvWlOyGLyZKhb5IUL3LhaWyWc0adWttmCkhjMebhP4I1p9nnujTP4H3RYbHCp41rDm0WClxKeW4wnf0YhRlhDFrfeqNPPIbOcYG7oYf5IFiYt6Hcs74cYIzpwPuHz0ZVp7Ry4VUHGcmlSj4bptsmlhk5DXBfRLShJrG2Xga0JKHGgrNaT4uP+FLStc9OObcyiY2kcYj5Duwy8dySDEhg+K6WNfl9E+4PFWUYpDdoCJeFXJY9qOXvXaBqpOVePsb4/n1j7HPYo2cN6CHUxwJgTwe1o1rH7jM/tXWyS2hgYop0M91fjYZdzJTouj18I4Ia3D8dBzrmT+WaH4Q7khiHdBDEuei6MlgVPIh0VXMeuPm9du+augqChFv33NsrKIJnG+3S7bQX66DHGIcxjAfpLUXA9h/GJDmA8cqW6ZoFxfgFZN9/tTk/tPWNyYfe496v2Pt/tURKJ+sntmbLC2kUO2VaGNdV0Zm2OKrgQa5tBB9K6Bnb81VQIIYQQQgghhBDi/0+0aSOEEEIIIYQQQgixg7xSjGqxbLlJdSL6LLcwwPc//PM6ffO6hSzdu2mht32E8/NUad+BACFOPEsfoYrPT0/r9CzD9W3LTwinoKBXnSTds//PE6h5Mn+3D6cL3GMytrC6xQwOJwgnpoPE2czCo8IOTsSupFrOOXc2tnCqEcLGY1bJWtqxRceasiwtxLMhlLtsDPHm6doMDeYPbN4HDBr+leQMCbd7xiFDz1b1f4Gw7gndLXAHRIO6FKGME7irnLfNUeHmdXMMOz4y1wXPgcjT8OFJmGyQizWFFH5eWsvShVU4PU/XDyA1SFFGDtfQGSFEyGZEmRXznVs5lryPb1uFj5EHSBsnk9V3N8k0nHOuRPuinCZG6CPDTe8/MtlUO7b7nMAFzgsrhTwqZjfjCe8cp/jl6kR6t7x0W6XKduE5Xr38/1ef02EKYfLPntXp7P4Hdbp4k2Mox1ZIPxG+mTkrh84F5Dkxx9myyhYkE4j17A4wDl9AYpVY2YdD1D9c/UK0i2xqdRtCtlpeN3lchnZB+V8E55ewaCjXLXJZlm5RjamUTJw+sGfYPzR3F84tPUjIoFp0c4Tzei4SCI/v4D7Hb1hY7eAEYcZ0uEN6fLpqz+dPzEmxDznSzVu36/RHj2zemk+tHju4nuNfzrBouC3EkaXbkBfFDvM16mvQs/XDo0f36/STxyv3s/SvKVX4fAR7oetUv/fs+Wn9OZ2AYoR405nGtekMZUn2izYkbgX6IuWsZUKnKtyzYW7OqxD/BcPlMeL1MSbeObKynEM2VVIZgbEvjeg0Q9cjyIZSSkvsd9soD299R8ntFdlHZS9K97haWzE83zM9LDdLTyhL5fyXNVwfeO49m91UeA2nE8pC1uXC+deVDPe3jynlcHCDO0MdfQ/tl+vVGwMbFzookGPcv41xNPTKj7KjDVKDLeqjlm5Zy4O49mLb9+vBPk9m1ibpQIPTEVz/AH0x5JEFmwVsnqsb3h0oJ+xWc2SADhVEHCv5O9Y/kpTSX7pd2W96Dp/Q6lFNSem056CF9TXHo7Jh3b1NWs6GrsJzrNvsuppApjXD4uv6oa3nuF4pg4Z+iXtyjowxLs0gv2+jHqfV/HZ6bv+f83WaWrn1h/Zud/3E3BD7Axtrk9Tuwz4dOMyddGrlIAHJswvYNjbLmNcuxHtXJI9qOhqAZc82NpvSscme5ej4zTr9EPP6aN8kZn2MbX28l/P4C7r6UZK2bv8Zj8SAVCpDH4ogvZ8vbC307Jn13UN7LfTaXEgnObiAUlrMOSibU8pm72a9nqX7bY5Bm1GkjRBCCCGEEEIIIcQOok0bIYQQQgghhBBCiB3kleRRrb3XXNhdhaqlM4RERRYmNkvh+gRnjC5CukqGYDI0DGGDGb6Lg//dNLHvtnsWTtUbWHh4Wlq40cCt7hMgtDlHXrJksTF9OLQQtxThcxNKURwcLWaUjSAkCiec081osrAQqou5PeDRYEPY5xZDT4uydPMqbKzjhTEjZJQuNdjWa3JXCjzJUNM+YLnxkvEY4fl9C9+NIcnIK/lKG5+NEIJIEoQv0rElhwSGJ9AzJLNoCHH25FENYZgeP4Ot0MA5F9f5ouMYXZQgpcAj9NDtA4QNxqh3OjAFKNMA5RjRmQfh2TlCBTuQQfSq+j3FKf7Pzyz99Nl36/Rsav2DdZQVjy0vCPEu4Ahx64a52vzmr3+jTu+PrM3kMZyh0EfzxPLThftDsJZHXb5w26LVarmwameeE0uDVIph0h2cRF+cm9yvi36cXNiz5LGFjzqMW26MMOF9jJFdygPRp6rw5MiTJyI0e2q/GbFvYbyLZghlxXzhTiwMev7cJDl09euObJyPGPOOsFUqPihDyK9IH1WWpUurfsEwdcoqOvvW9mJKHxBOzDBjuktMIXFgyO/xraM6ffSGya8yupqgeBcXVmdPP3zknHMugYS0fZ1jntV5F2HgMecD9H9M1657QPcayInhtsG5Jyw5jqDdIfz5+VObJybPV232xcefHEr8aVkuly6rQvhPz6ztHR0d1ekM0ghPGuNJGCEN4zOi4ChJirw5B+WJvBUokw5cUtZtreQyDv2f40UIiR0d257P0F8h1ePQzucO6XCGcZMOVxHm6YBSRa4xiqvpiy8uSzep1mKUinkLXdRXzNB+XBI2aJ9Z11y7hg3rAt4nRtnRJW3tvJV7kimksY4JSowLkJM+gYT/+bMn9vsZ53cbg06wBupgTZvTNbct28QAACAASURBVCmD5NSbhxqcDrfFclmvQZvvTqkBHTNRi2jzKZ0jc0rPsC7EfUIu+fBbnpMspX+VnCdGvaUY+2ZY47fpEAMn2yjaLL1LMP57BnMFBt0G2C5D3J/Om3Sb2iZf+Urb3bt3xznn3MMHj+rPZ5C4R3AXvPfeu3X6zruWhjrJJWc2D9D1ivVOR64eZDMnJyf4XTw/jxSoxrQE0h6Oy957AdoL+zbnRc7vna693xyMbK3jHW/AdxZMFOPxaZ2mdM6bY6oxuNX62cZicN1Cx6YpnCZ7cIvMc67brNyOju2aGyemSepBhkRZ7YMnJq0/H+P9u7qGY1N/CLdKOgzj96/fsDq5uLD2+v77JuF66807dbqLI1k4vnThyFhgHRXC7vQC4/XFU0v34s3vtUSRNkIIIYQQQgghhBA7iDZthBBCCCGEEEIIIXaQV5JHxV/6srtx+65zzrnz71kIZgcuD3ffulun26GFGeeQHjH0s4RkqCgt3Kg7tPCoBw/NHYW/tX9oTiIuYAgVT0lfhWjlcMChFIjhvo/g9tFFmBpD0NoI1b+AtIDuLyFChRnatUAY3nxm6dOxhQvuj0zyFa6DpFvb00e19kIXVmF6hadx8rwN8DlPt98cLvtpTp9vuoKnjTMk1OG31g4rdCVhjGC74XR3tgk+nhe+jSLwysPL8ObwaMqmwo1X/+R9tkf+ce7OKic1ugUsIHdg2V5AQjOHdVKCfjmEPK3jhSTaQ+QIQ2U7Z59KEJKdBX6wuHPOnV1YWOPzcwuhTBC2HPcgTaI8AHfrINz34vSppS+sX77/wYd1+ibkNwOEzWaQViULy1t+0xwBkvkqn9nHH7ttEbRaLq7KsKQegTZCDNOmSwaePXnTnH66oYVvpnCjoUteQOss9KkQkpyULhjIc1FJAjhuZgzrxrUpw9ORF0rm+N0I/bjftbmgZNuCtIMx7DEdbpAHP+9X0xmDIHDtaoxKptZ+Rgc2hx2h7fViuL7A6eUCaYbzRgixzUf2+cENmysC1kEGaQUK4/lHFlqeVi4rN25bvm68Ze39AmHoXUh7btw16WHQhWNQz8aOsA3nnRzucXBzodjWG1MZap3Yc08mVq5XUY15/sKdVbLN0dCkZl57hqNdx3N0wrxIuQ1dhyBJDCF+yhFO7jkWRpRZWDkw3H4t96OUimXWwzzXRpen9K5PR6EBQsjh/DaDA2COPt3DfBHR6QSE3vjfYIu3VVquqOYZShbChomYYyoNrShrYpg9Zaze9cHmzwvUY4GyjjHurqXgCY8NQJruXVTHLPD5BOMOHYy6WKiNMC8PMcdQ3sr+lzVUXVBS5nU11PXSUMYx5Xho3EcH1nfnU3tXePLsI7tRwX5ptCEh7kJ66/VvKhHx3bR6v6A0h5LIArqmJIX0F3MB5U4h3pGiGOMCGkCE4yQijB0Fnq9gDdG1F/01jDf33c/LV/td9zu/u5Kn37tnjkGPHpnEnY58d99+u053If0rcxxhgfX9ORwu2x2ba0cHtnbkuDTAkQptjIEzzEvT6p2usFt4sF4orZkvLI9xD85/aA8x2ikdVpkuCrifzadIW5vh+2inC7l49aytLb4vNtEkCeZ7W4y1Woh6mIzpKmXMZ1a3H37vFD9mybfuWD1TirWYwxm2Xl+i/1F6jvXJbIG1FfLe7eN3IJWbwxnK4QiBEGvabtfGkQR1OJ5A2ge5ZAmZ7XRs1zehSBshhBBCCCGEEEKIHUSbNkIIIYQQQgghhBA7yCvJo4K9vToM+ujYwqRxyLw7PLYTugeI251XUg7n/JC9tEB43Lt/D/excLqj2/bd+/cf1Ol+x8LDLxA+HSL0OgpffsQEJz3PcTJ7v4NTv3E9jQ4GcNJgqPAUbi6MHesi5J+hdXQzen5uYVMDhNZdP1h9d+n2XnqGz8r0Bz9w3/yjP179A8/FcqI05uTYwu/evG1ytLAp6pmRcrymIWycjlFRzNPwIZuoQusGfbqb8FT8hvrGyfQZ6moOJxumE5xqn3syK3uoQd/CWU8geehEDV3pirZFkx8l7oMPv1f9BsqF7jVw9zgdmzzKc8BAuo+wPjp10TGGp7f78ihIa3CqfwgZ0tqSZDyDhAuNpA1JDAOvc8gSWMoZ+hBDEt+6c8vysqDzjtXp2Zl9/vz5c7senf0M4Zrr0+F/+CMGqH8+KKspUN5FiZPwPXkiOywkmyMrtwXKagKpHEN58xTh3ijRfG7fpbtJhLa9jranwqq5/WECQD0v8PtQfrg25E7dAzhseKqKBolFYz+j08kVyaPCPRdX7gjRbLMMuIPQ+3bX6u4YTmdjOKmNESY7wnj8Bsbgg5FJAVi+bWiinj4yafH0zMLAh8ereezGW3a/Tt/y1cP41+3a78dDG689pwv018kzy/vhdZuj04AuRNRb0BHJPp5OIOmc2T1jyAK2R8utRxfPIQkuaUOMZd5wX26WtSSQBLI/ddAu2pAB5Bh7EjhqUUJYQpoStyuZMySraQqnGYTsDzE+0u2Rrk8hpApxF/eEhLUdbg5556Tihctz3oe0K2qaLz83LRdW88zLwtw1kIlQ+tTgCOZLvDZLQSPKtSm9hYSwRL+nJWpRNXrKWhJInMoQbQSynXnB8cXmgKMj1GNhbYAOYgsOzSklepSZbpZN+Qu7NduTZOwFe/W6OY43yw78tJVJD+kHH32vTodnkMoFnBMoa+NvmZSGS8o45hoekqf5qqwKjHHe6QPsKgXXP7jewb0NY1zMNRTddlPIMzhwYrxwXKM5woX61cyLe+Ge6/VX9dGBM91gSJdYus5Z3QV05gq4NqJTGFyfMmvnSQLZmCfdxhwJiVGeWXpe5WeRwJGzB6k2no/vfzw2gO1iMMCRHz17vgKi1ggLbM6jSWZzHteECdZV8znWgWv3z9bSbRMbzzevvUpv3LTP5wusQ57bO+4U60zWLeeTecJ1pKUfP7W5aJHQkdpYz4d8V8lzzLmctzDOsj3FEdbUga2zShzQ0McRLnGb76606rXf7fWsjfa6ds8u3nsi7z6bUaSNEEIIIYQQQgghxA6iTRshhBBCCCGEEEKIHeTVYlRbey6IVuFBFxNzj3rjDhyjEAIaIMQMkWQuRGjs2ZmFDL3TO7KL2hZ61G1bOFWMUNEYEgGeJs9wv4P9VRjS4+cWJs6Q4AVCmI8OTNp1/YaFjc8goeoglInuUYyFpKvCAvIM7/T7tt2HrhTPzq082lVo34tie+GLZbmsHZYoAaKsCIoh16bT1w1zF8kcXZ/seq8eeHp3gzSh27cw1MCTOyC0rapPhuPz2gZ1ljs9M9nLxcTqaobTwFNIbMqMIY72fJThHBxauP/hobVRxstfkWGUR5p97B48Wz0fXQ9Kz3UC8iG4u7COKNObJgzVNeikUCCckNqqEPIoxz6aIpy4cgFgf/JtKSyZwxErQfh2jtDQA4TZDnqQYaTWh2aQVfR7lsc3b5uE6hzSsXlqmXhyDkeOSjLx4nJ7oaetVqsO4eS4SfkmQzwLOlMwxJ+h9OyXkMlQ8uE5KuUYW6Nw4/UcG9ZjWFls7iuerMobkiHJYLvh5wX7PDKJe8aeXQld7nh1098iruZvFEGr5eKqjOiqR9lKyTEcY1ubUtSbJpX66P3v1+knF9Y+b79j8xLM1lw4t/v34VQ0cjbP3Lxu9x9cX8mj6HqQop8NjxCyC3kUIpVdH1KBZw9M2nUOGdY7N6yflQEdE+w+HC+KwiafEuMXy68Mtz/CFpeXbjpb/fbk/LT+/DbqhOMm+02bUh+6HlLWQMk23EIytOEFpWG4PoRjZdyxttOvnCYjON7RaSqBBCfE3JYxJNxzQLHr5wg9n8Kl46AHJzeMU6Xnnkk3GsgfICEKrujPhUHL1CF043plD6sGyUjpSWvgokSHO6QnKFOuXSOuXSsJSffQQuaPjkweOoJLaoj1UvrBB3U6R12P4fx28fi+fU4ZbWhtM8TRAj1IarmWKDwZ2cvruuUWFRlx/Jq7UY1VHRwv0EE/oAMo3yfoEjqDtNE1SAJT9Ispnr3XsfLsQHJFSbgnGavXOcgAJYNYz4QhJzHKMzBf8HOMdyHXVnCV6tARle5enqsU2m6D29Q2abUCF4VVO8eYE2M9yTGBUqkQsqaMDj8oI8qsKL/yJNGUk6Fq6ELFeW9RSUrphko8eRTLEGm+U7Z7lH/ReYp6ObQNtlO4HFEKx3XPHHLYTroqg8tye/W5vCxdUZVV4PUzytdQV1gLfvjBozpdYh6YwzmJzrezGV48+X4H2dLz51gT8GqUZ159l65yBaSkaVK+dK1zziULHreA/hTbmHs2gQtq18YXGJO5HiRxbYwXt+685TbyinOhIm2EEEIIIYQQQgghdhBt2gghhBBCCCGEEELsIK/mHhXsuaiSYjAMKvNcASxOqN22EMwOTwlH2H4ntO/+4b/9Zp3+zd/9PctkYqHXPGmb4f9HxxZaOplZOPmsClUbDS1fM4RB5cj78YnJo05OLCz6/gMLMV0ghJJOLQyPY+hdDyePF6WFU3URZsywyBChcueV/Cp/sb1wt37vq+53fuu3V/dFWGAbzhEB5Qhe6LclF3CmoFQigkyGofclwunYXuiGwTA7hk2uJSJeGGyDHMKrB4QJ0qWDdVKi7GO4B8zhAnOOcPmTI2sjdORhDV2VLwa5XDq3PpydIaBthtKjLg4OLd88JX0ytr41hWxsODKXtGhgMrBkbqHUDBXv9U2eFOHkdTrLpZWTRdyxcaHIIQVCf2b4Mx0A8tj61t07FjZ+HaHlGaQLp8+tDJ4/eVyn337zdp0+PLDvnj08td9C3teh4mW5TXmUPRtDZ9twjvEkGXQWYBg7Q4whgxsitNw1SAVI6DaHvG5y4PNA2DXlUQW/5v0+JFRebjBGoC14Ti7l5t/y5BYYU5iF8Io0GaEL3Khy+zhNKQGiuwTGPIyXJdr5wfWjOn1xelanx1OU176N01M4wwzh1NAtrP/1MR6cvPeefb6/aicLSAmTAE5rkCZFFwg3hz4qiXENxsKTOyajjQfW16eQRaZ0vonY1jge10mvfpNklefL8tJtix8uEvft767kJvt00UIfmkJimyIE/vDQxsou3R88gxZ73tnC7lNQ4jawcehw/w37rbm1nQs43RWVhKnryacs71yflJDQZpwvGZ4+sbbw6Kn9Dsdw36Rmc38qGqQXdCosg6uZJVtu6eJqnOR4Rrkn3SvLcPMzUB1VemsNpPHdRb5ZhtI5MXngjfd+rU73D2xODdZOSXBE4nqiKK1OZ5C/Hd+1cPt3ML8//p5JK/8ADkofwsG127Ex4t1jm0cdJOXF1NbRnOsphzdHvu3Ni9euXXP7lfQvpKSOslpKj/BdqlAp2c5zzjlY60JCkcKhx3PEQVOdQG4dtSmhWKULdJYIkhDPYRFjaxhunpcTyNb5zkNlaIwxJQpt3ncNc2rJpbw3Z18NLWfriDimfAl9MeccTrm9Xc15lO8pcWzPvHapWt0H7x1eR7bkAk6xEx6dUEl0mF+6+/A4haDBVY7PtJjbPME2SJmrN6awfjGu++58kLpi/TyerNYML17gCIPPSfHihZufr94R2niHbsMJi657BfYFTo5sXixKq5PHT2wdMJuZlPP+9+1dZLRv4xmPf6DDIgvOky2u2xckZZQn8n2bjsV0mu2hzmM4jc1xJEqCd8R337UxdDDE+wqlh1tafyrSRgghhBBCCCGEEGIH0aaNEEIIIYQQQgghxA7yiu5RLeeqcEWGB1MOROeAZMbQIAsxipyFpo16tm/09Ik5PF2cW9qlFqZ5CqnKnZG5Vh0cmTzjfGJhWcmzVd76CHfr9CzM6/lzu9/+voWsziH/YUjWeAp5iOXQk8qkWYb/gTB/XO+ddl5amF8Eh418ugoXW27xaP7lcunKKkyPDkxsCJ2IJ9RbfWaZlUmKMjlFGfJk/sOjI7vm3OrwW3/6Z3U6DygFsXQbv9upQs67CB/uIX3njkldBji5+wSyl8BtlmHlqCuGUGc4mX4frgv7B9bOGAadwtWow1DQK9oWbQV7LqrqaTi054whNZhOLfQwTTY7KWQIFewO7dkOIAPrQE7WHVjfogtUQZkbOkYGCV5auY3kBfqHo7TS7hGjDYa4Zoh6H8Kdhc897EOugHtOz0xywjY7giPHYmLh5HTqyKu2Ubbc1mi1nAurwuIzxggJn08QSgo3vumF1W2va/m8ddPC8SO0w4yyJYRssq4CTx6Fz4PgpTTDjksvxJuh3JsdWAJPGsEwYbhkMDydzldIxwiX3+z14FyAOOviivpieXnpkioMmk6AHFQXCKWlleIQbnQBQnVvvW1j2u3s2K7BfJJNbR4dcuzkcyI8ewwHxTBYzXVdzMsBQphjygng9lC7gTjnphfWNk8gI8pQGxkc6Sh1WCQ2j+ZwFhn17P4M4ac0dn+46t+nz60/fF6yvHCPzlZ5Oji8U39OByi6tHVOrE66kN7SLdJzVcOzTDO0YTipjOCA14GENJ2e1ukQ64MH9x+s7gfJxtG+zVt5QbmB/SblVAnG8DnDySEhKfHcYzrsUNLpKQXQ8CFRoWyKsuRtEjjzqyo3qxe8fzStgejUV3rSBMz5aM+dYziz3ba+Gx1ZO5mENo8+fGrj96QKuc/gdrRIrG/PZjamzDGfvvnWm3X6n/6ze5aXdyy/H71lEqr/+ud/WqenC+s7w661mbuQWaWo64AyZs9VasUWzaNcy7Xqcd6rQkwnlB14klxcPxrZev7xI2vPRWZ3HcD2JRpSvoK6xVo9L63/UYZduyrS9S2CqyfksV7Lh9Ql8Nym7N48TmAAOVcJqRzXVHQp838KbRf9L8muyu906YLquAcuBSgJ41qE71l4fE/OMsCaLMvh/IP1bQgLR87HlGVTahdh7uxU68s25IOjfRuXxzhOgM5m3lEJnvUljsFocO+iFizA/NrtWL/sdm2c5hyzyQVsucXeWF5eusV6XKK7F9oq33cv4FzXbXMMhRy6Tdmi1RuVRJQzkV4PRzUkVg4JxrN1O+d60jvyI6b8mfOTzaOTCztKodvn0Rp2/WBkY34bEyAlx8EVSPIVaSOEEEIIIYQQQgixg2jTRgghhBBCCCGEEGIHeTV51HJZx7nxxOj9gYVxtRFC9d2HdhJ9H6FhJ31IYmKEYYcWgjmZnNbpMrMwqMPjozodQELTRojnAGGR09nqnosFnZ7skQaQe1DaRdkIQzGzhpDnJveoAiHKffwW5TqUREUIniwr14BrDQ4Hn4X5DxfuT7717dX9EXYZQJ7RiXhyuoV4Hl23ch0gZGwwOqzTfMYYoWfzJ6d1+tFjyHYoiaBLDPLcre5zcmi/89ZdC2GnQ0qHp/TjJjnqk+FrKU6Rp6tEjBC+HkL2xzg9nG5LbVxP5yV+vk329kLXq2R+lIBkOaVHVqDrU/Gd8x3QArp9IZ789MLCQLvoO3Te4nd5anyANkzJ0zrMuIQMwzcRsbZAlwD2iQM4u7Rx73SBekzxfOjrx5B8PXliY9P16xbmyBjN8YWFXEaVK1N5ud1Q4nX0ZBgyNBphv5BpTqdWJ/O55e3pQ3MLefLgwzp9cmIn2h8hzT7KbXu2f19CwPwG3n+r3L/0PM79hISq2FxuQYMzVelZ72y8pNG1ypOt0pHqiiQZLgicq5xERgdWtuyLXhg4+spsbCG5wyMbX/t9zKkzK6McMtM2wu9zymrhwLS/j2sQtp2fr8axCT4rGyQ07dj6POfIIaStXU+WaX0xP7W061u/b+M+IbU1+JxR5kfXTWZydLgqp/H//r9uW4Rh6EaVtJaywgmexZMQQzbltSs4l4RYn9AxKsOdRnCMovRsfm5Sznxm/b4HecSNyu3ywWPIByDxZgR+jrYYQe6RQu69QLukVMF/vs3OGJQqBg3XcL0UbHFNQ1quVbtG5d7AxeRmNx5eNMfE4cumrH67N0yKWhxa+/z+xNrM/NTktiWk44/gAnZWyRbbqLAh1lcXWGdQTv7uvXfrdJJY3bU7JiF59zd+q05/77GF/J+emVTyEdpaBKcWBxfILiQQPUg01+vebcqjyqW1v5xiIk4JdODjdx3L0Mrh6OCoTj8/fVqnQ9Tu8BBSSFofIguem9yM64zKsYxSYkpzPSc5SA8d3AYbfJwoFeF6qcDScgEZagHJK7q0S+BstcA7SgrJ3TZpBS0XVvOC5xjLuRrPFmLdM8Xaq8DRA/sH1s9Ox9YvuFZL0s3luL9vYy0bTY517/5wNX724ZTENhh3sf6ELJZlyDoaYY72LemwTsfvRwHnRcvD/ohHMcCRD2vgtXTsWtgkFn91yqVzWdV4C6xVCrSfMST803OsUfHOEaAcAmdz4Z033q7TuYM7FfYR8gzSTMwb/T4dcVk+q3zyuA0eIdDDuNDHMRjJwsbEcW7PUeBYELrDjcf2HvvgIWTDWBv0cRTLPhwDKclrXuBuRpE2QgghhBBCCCGEEDuINm2EEEIIIYQQQgghdpBXkke1Wi0XVSF/vQ5PYKYDBULwEAaICE836MB1AOFdJcIuTy9O6/QI4UYM80ekkvv+Rxb6eT62sKz1Cdx0NXr0zMJBffeSzaH0CU4g7yFsnSGPFxML+erD+YHR/+02JB8MjyrgwgPXgOFwFX4XXttz2yJNf+w+uv/IOeeHj+UIAYsQ6n4XDgWn5xYONoVxx61bVicR5EApYjNDhLu9AbenLKMziRXW9WMLg7x5cyVf2YczVBdlWeJ3zhDCN5kjfBJh4Amcz+aQR+X5ZiejCHn3JHFoI2200VvOyqOLz7dJq9VyQVV/dK4KGdZN+ZLnJGJhnWzzEUIYBwM6mVhZxyiLLk+TZ0gmJTLoo2tZWq/LU/dxLVxKQqRLOFd08TMlHBMKXE+bIMoZ25D6naKdPH52atfDESLHALN2ECkvL91VwFBqlvGNGzfq9Elg4ZXpwsI3H92/X6cffGTh+B+8b+Pck8eP6vT1m2/YPa9bW+31rX+x/YfBJp3BJ4d05uXmMGhSlgy1x+cbfvGnw29QrkUJ66e60SsT7AUu7q3adATXkRhSCo5tdPKZQ4Y4HMGZjmHwC8hW4CSTlJvH1y5kqTHnnxEkPVWINaW8lAbSjSMJ6QBFZyDMZ5gXD3qWZp9+9sTmjz4kpBlCnpOUMkv2CUjEKinvNl0yvvKl19w7t1bzDOeWjx6YlOLmdZPnMhyb8wDHG84bMdYEI4xDfTrUoY8sLqzvFqnVRQ/OeINKTjfYt886kPIuFpzTIdWCxJdSJkrfODC3ub7j/IJ1QqfDeR9SwA3uJs45F5VX+PfCdRvFb9MZkjJQZoNzYYr6jSlZwLpkhjp9/MjG1zlkM5SiFn24CbHvVuVItyYHSWLUs/nyBsbuu+/dq9MZndYSS9++Y/KDe+99o07/x//wx/ZbaL8Pnz2p0x309SHmd5Zfu5KObHNoLctLt4DEeU3YJNnlNWiTlLK8ddecZjuQLU6n1hce3TfJWgdHOOwfWL1FMY8v4No1qH7fvhdEXFvBUZTKmNzTfOGZ6DRklySZjf9cry0KuPniXIAsh5svJFRcd3uLtK3Scq7qO3y3IwGlQaXlNcU7XIr+dP3E2n9/YN+Fat8tUq41KKeBSyj6WnoOZ7/J6sVmNISEnEoWSI+LYvN7YUB3LL5TcKz1jsEINqZjtJlOm0eQWLpDuVYlafbdOT8nS1d3br5DJzgy4QLySj5vjvesMrTPT2wZ69LSxrZnp5gvMc/QnWpxDmljAMdKvL+uZemci/mOdDHBy6sNd65EHyoaJMFxBCfFC7v+fIh21mM/tvXdG3fsu3ffsnW9zyfPi4q0EUIIIYQQQgghhNhBtGkjhBBCCCGEEEIIsYO8chzVepdnNLRQboYtlghl4knfH0HuNEdYUxlA+jCwkKheF+Hk8WZ5VAcnM3/zm39UpynLWaSz6jP7nYine/cRSjizMK80Yl4sv0+eWnjWGBKLRcLTo+HCgdPmKfmIIPkIUgvXGnUstKoXVyGXW9xaK/LcTc9PnXO+Q8k+XE9u3rZTuSmVevzAXGqGCP3uIPRxAoebDsLAB127/je/Ya4HDM/u8fqB1e1stirn01M73Xs+t3A4hoEzbG8OWduM7kII02a4f4SwWT9fztKIw+wPETZL6RvSCeUHWyQMr9USJjrzMPS3LO35Q0g1hkM7RT9A2DPD+RkKSWmC5/pB2YxvMWS/y5DzKuSZznNsX9SvpAvrW+eodygrPSeVIaQ9cUz3BISh0imrbXU3gSPPIWQbXYQuL6r77AUttz2WtcOS58ZEBwovbc/bG1iM6Tv3LM8nJ0d1+oP3/7xOnz6Hu8J968cL9Itbty30+BAn3YcRZXZVODylT5QbOMC47oamwn9QhuXJozwNnSXp2Of9rKfP23zPbVKWpUurscYPq7UkJQWUWIaUk2IciyGJCDH/vH3vXp3+PmRxH3xk6dtwQ6MLzWL6ssPBAebxFJKEGaSlGcPN0f/GGOvbkIUdnljobwCpzDHq63RmsoSwa+MRw5hPnz5D2uKY94/eWd17i/NiFO6540q+cjGxsSeju5bj/IB5I+IYZ+M9Hfs6GJ8oN2LfijAW9w/hgDmxcubcElbjX4iyp8SKTjfsQynmiNGBlf0c6ya6J5Z00sQ6qo25kM4sdOo8u7B6JsGrLz0/FctWq5aycvxpktPkGBVyyJ36I+tDWWbXzNFf7p/CdQnriH6f6xhLn9NBDun1OilAmQ8Oj+r0vTdN2vOr3/gNu2bf5Hp0hqNrGeW+lFndumkS9fEzO1pghvpNIXMc3jK3ziEkOrPKuXCb7lFLt3RFJT0K3eZ5kXI3yokjrFUKOl5BNvjee7b+fPLEnv27H8KlCxKzbky5p43RlJOuu66XF/Q/qqCoME0pfUVd8aKA6yKM0SHun0FzlSY2ftFiin2u14bkL6D+Z8tUVcY1t///sb7BXN3GO+IcR0bwGfqQgrmiCAAABG1JREFUivKdL+5grEMbmOKIhADPfAhX2kW0Gq9mcOwbHsJ5COW2wPh+hPGPErYZfvP0mdXjMdwQQ6xXPWkV5HfzhbVNSqK66NP1ULbFJSqMMV0PLo9nOCrj/kcf1ekc/fX6yMrk+k0bTym9/89/at+dz/m8dv/J2Ob+FLJtHinA9+z1O423zqKTG6XNBfsf5gsMO23cO8V9ksTayMUF3YbtuTsR+mhq88Xxsc3vwxH2Qz7FIlWRNkIIIYQQQgghhBA7SGu5/PR75K1Wa5sb6uIVWC6XW9k/VR3+XPmfy+XyzU++7JNRPf78UF/8QqC++AVAffELgfriFwD1xS8E6otfANQXvxBs7IuKtBFCCCGEEEIIIYTYQbRpI4QQQgghhBBCCLGDaNNGCCGEEEIIIYQQYgfRpo0QQgghhBBCCCHEDqJNGyGEEEIIIYQQQogdRJs2QgghhBBCCCGEEDuINm2EEEIIIYQQQgghdhBt2gghhBBCCCGEEELsINq0EUIIIYQQQgghhNhBtGkjhBBCCCGEEEIIsYNo00YIIYQQQgghhBBiB9GmjRBCCCGEEEIIIcQOok0bIYQQQgghhBBCiB1EmzZCCCGEEEIIIYQQO4g2bYQQQgghhBBCCCF2EG3aCCGEEEIIIYQQQuwg2rQRQgghhBBCCCGE2EG0aSOEEEIIIYQQQgixg2jTRgghhBBCCCGEEGIH0aaNEEIIIYQQQgghxA6iTRshhBBCCCGEEEKIHUSbNkIIIYQQQgghhBA7iDZthBBCCCGEEEIIIXYQbdoIIYQQQgghhBBC7CDatBFCCCGEEEIIIYTYQbRpI4QQQgghhBBCCLGDaNNGCCGEEEIIIYQQYgfRpo0QQgghhBBCCCHEDqJNGyGEEEIIIYQQQogdRJs2QgghhBBCCCGEEDuINm2EEEIIIYQQQgghdhBt2gghhBBCCCGEEELsINq0EUIIIYQQQgghhNhBtGkjhBBCCCGEEEIIsYNo00YIIYQQQgghhBBiB9GmjRBCCCGEEEIIIcQOok0bIYQQQgghhBBCiB1EmzZCCCGEEEIIIYQQO4g2bYQQQgghhBBCCCF2EG3aCCGEEEIIIYQQQuwg2rQRQgghhBBCCCGE2EG0aSOEEEIIIYQQQgixg2jTRgghhBBCCCGEEGIH0aaNEEIIIYQQQgghxA6iTRshhBBCCCGEEEKIHUSbNkIIIYQQQgghhBA7iDZthBBCCCGEEEIIIXaQ8BWvnzrn/vIqMiJ+Kn9ji/dSHf78UD3+4qM6/GKgevzFR3X4xUD1+IuP6vCLgerxFx/V4ReDjfXYWi6XP+uMCCGEEEIIIYQQQohPQPIoIYQQQgghhBBCiB1EmzZCCCGEEEIIIYQQO4g2bYQQQgghhBBCCCF2EG3aCCGEEEIIIYQQQuwg2rQRQgghhBBCCCGE2EG0aSOEEEIIIYQQQgixg2jTRgghhBBCCCGEEGIH0aaNEEIIIYQQQgghxA6iTRshhBBCCCGEEEKIHeT/AWkozm3SejIAAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "569IYExS7tBw", + "colab_type": "text" + }, + "source": [ + "# Generalizing CIFAR10 images\n", + "\n", + "Now we will be using 100000 different images of the 10 classes presented in CIFAR10. For now, this is a challenge for our current implementation of the PixelCNN. To facilitate the model's training we are reducing the number of intensity values of each sub-pixel - from 256 to 8. This means the images will have less resolution." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0ZspFdiC77Zg", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 240 + }, + "outputId": "b0f75f22-09b4-4410-bc61-2cb422417618" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Quantisize the input data in q levels\n", + "q_levels = 8\n", + "x_train_quantised = quantisize(x_train, q_levels)\n", + "x_test_quantised = quantisize(x_test, q_levels)\n", + "\n", + "# Check the first samples\n", + "print('Training examples')\n", + "fig,ax = plt.subplots(1, 10, figsize=(15, 10), dpi=80)\n", + "for i in range(10):\n", + " ax[i].imshow(x_train_quantised[i]/(q_levels-1))\n", + "[x.axis('off') for x in ax]\n", + "plt.show()\n", + "print('Testing examples')\n", + "fig,ax = plt.subplots(1, 10, figsize=(15, 10), dpi=80)\n", + "for i in range(10):\n", + " ax[i].imshow(x_test_quantised[i]/(q_levels-1))\n", + "[x.axis('off') for x in ax]\n", + "plt.show()\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": 11, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Training examples\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "stream", + "text": [ + "Testing examples\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N7K_2ao0aczs", + "colab_type": "text" + }, + "source": [ + "We train the model for 20 epochs." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "IbIowQotA91c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "1c11773c-bb81-4ee2-c118-105beaa59555" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Training loop\n", + "pixelcnn = tf.keras.Model(inputs=inputs, outputs=x)\n", + "\n", + "n_epochs = 20\n", + "val_error = []\n", + "n_iter = int(np.ceil(x_train_quantised.shape[0] / batch_size))\n", + "for epoch in range(n_epochs):\n", + "\n", + " start_epoch = time.time()\n", + " for i_iter, (batch_x, batch_y) in enumerate(train_dataset):\n", + "\n", + " start = time.time()\n", + " optimizer.lr = optimizer.lr * lr_decay\n", + " loss = train_step(batch_x, batch_y)\n", + " val_error.append(loss)\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)))" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "text": [ + "EPOCH 0: ITER 0/ 391 TIME: 11.04 LOSS: 2.0768\n", + "EPOCH 0: ITER 100/ 391 TIME: 0.92 LOSS: 1.1606\n", + "EPOCH 0: ITER 200/ 391 TIME: 0.93 LOSS: 0.9095\n", + "EPOCH 0: ITER 300/ 391 TIME: 0.92 LOSS: 0.7589\n", + "EPOCH 0: TIME: 375.12 ETA: 7502.38\n", + "EPOCH 1: ITER 0/ 391 TIME: 0.20 LOSS: 0.6693\n", + "EPOCH 1: ITER 100/ 391 TIME: 0.92 LOSS: 0.6433\n", + "EPOCH 1: ITER 200/ 391 TIME: 0.92 LOSS: 0.5806\n", + "EPOCH 1: ITER 300/ 391 TIME: 0.93 LOSS: 0.5253\n", + "EPOCH 1: TIME: 364.26 ETA: 6920.88\n", + "EPOCH 2: ITER 0/ 391 TIME: 0.21 LOSS: 0.5504\n", + "EPOCH 2: ITER 100/ 391 TIME: 0.92 LOSS: 0.5570\n", + "EPOCH 2: ITER 200/ 391 TIME: 0.93 LOSS: 0.5388\n", + "EPOCH 2: ITER 300/ 391 TIME: 0.93 LOSS: 0.5375\n", + "EPOCH 2: TIME: 365.10 ETA: 6571.84\n", + "EPOCH 3: ITER 0/ 391 TIME: 0.21 LOSS: 0.5209\n", + "EPOCH 3: ITER 100/ 391 TIME: 0.93 LOSS: 0.5560\n", + "EPOCH 3: ITER 200/ 391 TIME: 0.93 LOSS: 0.5015\n", + "EPOCH 3: ITER 300/ 391 TIME: 0.93 LOSS: 0.5159\n", + "EPOCH 3: TIME: 365.68 ETA: 6216.59\n", + "EPOCH 4: ITER 0/ 391 TIME: 0.21 LOSS: 0.5077\n", + "EPOCH 4: ITER 100/ 391 TIME: 0.92 LOSS: 0.5205\n", + "EPOCH 4: ITER 200/ 391 TIME: 0.92 LOSS: 0.5353\n", + "EPOCH 4: ITER 300/ 391 TIME: 0.92 LOSS: 0.4964\n", + "EPOCH 4: TIME: 363.95 ETA: 5823.15\n", + "EPOCH 5: ITER 0/ 391 TIME: 0.21 LOSS: 0.5137\n", + "EPOCH 5: ITER 100/ 391 TIME: 0.92 LOSS: 0.4984\n", + "EPOCH 5: ITER 200/ 391 TIME: 0.91 LOSS: 0.4987\n", + "EPOCH 5: ITER 300/ 391 TIME: 0.92 LOSS: 0.4963\n", + "EPOCH 5: TIME: 362.37 ETA: 5435.51\n", + "EPOCH 6: ITER 0/ 391 TIME: 0.20 LOSS: 0.4949\n", + "EPOCH 6: ITER 100/ 391 TIME: 0.91 LOSS: 0.4774\n", + "EPOCH 6: ITER 200/ 391 TIME: 0.91 LOSS: 0.5056\n", + "EPOCH 6: ITER 300/ 391 TIME: 0.92 LOSS: 0.4893\n", + "EPOCH 6: TIME: 362.62 ETA: 5076.63\n", + "EPOCH 7: ITER 0/ 391 TIME: 0.21 LOSS: 0.4844\n", + "EPOCH 7: ITER 100/ 391 TIME: 0.92 LOSS: 0.4754\n", + "EPOCH 7: ITER 200/ 391 TIME: 0.92 LOSS: 0.4857\n", + "EPOCH 7: ITER 300/ 391 TIME: 0.93 LOSS: 0.4626\n", + "EPOCH 7: TIME: 364.51 ETA: 4738.60\n", + "EPOCH 8: ITER 0/ 391 TIME: 0.20 LOSS: 0.4919\n", + "EPOCH 8: ITER 100/ 391 TIME: 0.92 LOSS: 0.4631\n", + "EPOCH 8: ITER 200/ 391 TIME: 0.92 LOSS: 0.4713\n", + "EPOCH 8: ITER 300/ 391 TIME: 0.92 LOSS: 0.4944\n", + "EPOCH 8: TIME: 364.26 ETA: 4371.16\n", + "EPOCH 9: ITER 0/ 391 TIME: 0.20 LOSS: 0.4843\n", + "EPOCH 9: ITER 100/ 391 TIME: 0.93 LOSS: 0.5249\n", + "EPOCH 9: ITER 200/ 391 TIME: 0.92 LOSS: 0.4806\n", + "EPOCH 9: ITER 300/ 391 TIME: 0.92 LOSS: 0.4903\n", + "EPOCH 9: TIME: 363.69 ETA: 4000.62\n", + "EPOCH 10: ITER 0/ 391 TIME: 0.21 LOSS: 0.4931\n", + "EPOCH 10: ITER 100/ 391 TIME: 0.92 LOSS: 0.5169\n", + "EPOCH 10: ITER 200/ 391 TIME: 0.92 LOSS: 0.4670\n", + "EPOCH 10: ITER 300/ 391 TIME: 0.92 LOSS: 0.4655\n", + "EPOCH 10: TIME: 364.21 ETA: 3642.13\n", + "EPOCH 11: ITER 0/ 391 TIME: 0.21 LOSS: 0.4645\n", + "EPOCH 11: ITER 100/ 391 TIME: 0.92 LOSS: 0.4682\n", + "EPOCH 11: ITER 200/ 391 TIME: 0.92 LOSS: 0.4538\n", + "EPOCH 11: ITER 300/ 391 TIME: 0.92 LOSS: 0.4945\n", + "EPOCH 11: TIME: 362.94 ETA: 3266.47\n", + "EPOCH 12: ITER 0/ 391 TIME: 0.21 LOSS: 0.4558\n", + "EPOCH 12: ITER 100/ 391 TIME: 0.92 LOSS: 0.4477\n", + "EPOCH 12: ITER 200/ 391 TIME: 0.92 LOSS: 0.4608\n", + "EPOCH 12: ITER 300/ 391 TIME: 0.92 LOSS: 0.4734\n", + "EPOCH 12: TIME: 363.36 ETA: 2906.87\n", + "EPOCH 13: ITER 0/ 391 TIME: 0.21 LOSS: 0.4973\n", + "EPOCH 13: ITER 100/ 391 TIME: 0.91 LOSS: 0.4853\n", + "EPOCH 13: ITER 200/ 391 TIME: 0.92 LOSS: 0.4587\n", + "EPOCH 13: ITER 300/ 391 TIME: 0.92 LOSS: 0.4731\n", + "EPOCH 13: TIME: 363.12 ETA: 2541.84\n", + "EPOCH 14: ITER 0/ 391 TIME: 0.21 LOSS: 0.4683\n", + "EPOCH 14: ITER 100/ 391 TIME: 0.92 LOSS: 0.4840\n", + "EPOCH 14: ITER 200/ 391 TIME: 0.92 LOSS: 0.4608\n", + "EPOCH 14: ITER 300/ 391 TIME: 0.92 LOSS: 0.4581\n", + "EPOCH 14: TIME: 362.97 ETA: 2177.81\n", + "EPOCH 15: ITER 0/ 391 TIME: 0.21 LOSS: 0.5594\n", + "EPOCH 15: ITER 100/ 391 TIME: 0.92 LOSS: 0.4678\n", + "EPOCH 15: ITER 200/ 391 TIME: 0.92 LOSS: 0.4537\n", + "EPOCH 15: ITER 300/ 391 TIME: 0.92 LOSS: 0.4717\n", + "EPOCH 15: TIME: 363.99 ETA: 1819.94\n", + "EPOCH 16: ITER 0/ 391 TIME: 0.21 LOSS: 0.4713\n", + "EPOCH 16: ITER 100/ 391 TIME: 0.93 LOSS: 0.4655\n", + "EPOCH 16: ITER 200/ 391 TIME: 0.92 LOSS: 0.4656\n", + "EPOCH 16: ITER 300/ 391 TIME: 0.94 LOSS: 0.4442\n", + "EPOCH 16: TIME: 364.10 ETA: 1456.41\n", + "EPOCH 17: ITER 0/ 391 TIME: 0.21 LOSS: 0.4783\n", + "EPOCH 17: ITER 100/ 391 TIME: 0.93 LOSS: 0.4557\n", + "EPOCH 17: ITER 200/ 391 TIME: 0.92 LOSS: 0.4707\n", + "EPOCH 17: ITER 300/ 391 TIME: 0.92 LOSS: 0.4606\n", + "EPOCH 17: TIME: 364.32 ETA: 1092.96\n", + "EPOCH 18: ITER 0/ 391 TIME: 0.21 LOSS: 0.4742\n", + "EPOCH 18: ITER 100/ 391 TIME: 0.92 LOSS: 0.4463\n", + "EPOCH 18: ITER 200/ 391 TIME: 0.93 LOSS: 0.4634\n", + "EPOCH 18: ITER 300/ 391 TIME: 0.92 LOSS: 0.4656\n", + "EPOCH 18: TIME: 364.42 ETA: 728.83\n", + "EPOCH 19: ITER 0/ 391 TIME: 0.21 LOSS: 0.4879\n", + "EPOCH 19: ITER 100/ 391 TIME: 0.93 LOSS: 0.4759\n", + "EPOCH 19: ITER 200/ 391 TIME: 0.93 LOSS: 0.4709\n", + "EPOCH 19: ITER 300/ 391 TIME: 0.92 LOSS: 0.4728\n", + "EPOCH 19: TIME: 364.72 ETA: 364.72\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q9J4FaGoahQj", + "colab_type": "text" + }, + "source": [ + "We can now see that the model has a good result also on the test set when presented with unseen images. This is a good pointer that the model has been successful in learning the dataset images manifold." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "D8EWJD75BDED", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "outputId": "42bdaedd-1bc1-4b80-cd8b-5a80121254c0" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Test\n", + "\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)))\n" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "text": [ + "nll : 0.4649888575077057 nats\n", + "bits/dim : 0.00045409068115986884\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "VM8G7OzMhEq5", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 246 + }, + "outputId": "bc6fb04c-1fdc-481c-f6a9-5ca2f012c196" + }, + "source": [ + "# Filling occluded images\n", + "occlude_start_row = 16\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=(20, 20))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(1, 10, i + 1)\n", + " ax.matshow(samples[i, :, :, :], 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", + " for k in range(n_channel):\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, k, :], 1)\n", + " samples[:, i, j, k] = (next_sample.numpy() / (q_levels - 1))[:, 0]\n", + "\n", + "fig = plt.figure(figsize=(20, 20))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(1, 10, i + 1)\n", + " ax.matshow(samples[i, :, :, :], cmap=matplotlib.cm.binary)\n", + " plt.xticks(np.array([]))\n", + " plt.yticks(np.array([]))\n", + "plt.show()" + ], + "execution_count": 17, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "deJgSHmOBGfk", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 578 + }, + "outputId": "21918116-a742-4376-f48a-72bb969d0294" + }, + "source": [ + "# --------------------------------------------------------------------------------------------------------------\n", + "# Generating new images\n", + "samples = np.zeros((25, height, width, n_channel), dtype='float32')\n", + "for i in range(height):\n", + " for j in range(width):\n", + " for k in range(n_channel):\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, k, :], 1)\n", + " samples[:, i, j, k] = (next_sample.numpy() / (q_levels - 1))[:, 0]\n", + " \n", + "\n", + "fig = plt.figure(figsize=(10, 10))\n", + "for i in range(25):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.imshow(samples[i, :, :, :])\n", + " plt.xticks(np.array([]))\n", + " plt.yticks(np.array([]))\n", + "plt.show()" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wAMhjHLAa-S9", + "colab_type": "text" + }, + "source": [ + "We can see that the images present natural colours and patterns, sometimes identifying what might be a horse or a truck. Since Oord's paper in 2016, there has been a lot of progress in the implementation of the PixelCNN, with each iteration generating more and more realistic looking images. In our next blogposts and notebooks we are going to address these new tricks and changes in order to create better images. So stay tuned!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cqy9SYuxbv0L", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file