CapsuleNet_tf2_MNIST.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "language": "python",
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      },
      "file_extension": ".py",
      "pygments_lexer": "ipython3",
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "version": "3.6.3",
      "name": "python"
    },
    "colab": {
      "name": "CapsuleNet on MNIST.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bklooste/tensorflowcollab/blob/master/CapsuleNet_tf2_MNIST.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "7f4c4917-22fb-4b10-879e-51c600e6c3af",
        "_uuid": "9b086e5ec535ad75eada3ca72bf5e6534251074f",
        "id": "LQnu9movo8xz",
        "colab_type": "text"
      },
      "source": [
        "# Overview\n",
        "\n",
        "The new model CapsuleNet proposed by Sara Sabour (and Geoffry Hinton) claims to deliver state of the art results on [MNIST](https://arxiv.org/abs/1710.09829). The kernel aims to create and train the model using the Kaggle Dataset and then make a submission to see where it actually ends up. Given the constraint of using a Kaggle Kernel means it can't be trained as long as we would like or with GPU's but IMHO if a model can't be reasonably well trained in an hour on a 28x28 dataset, that model probably won't be too useful in the immediate future.\n",
        "\n",
        "## Implementation Details\n",
        "\n",
        "* Keras implementation of CapsNet in Hinton's paper Dynamic Routing Between Capsules.\n",
        "* Code adapted from https://github.com/XifengGuo/CapsNet-Keras/blob/master/capsulenet.py\n",
        "*  Author: Xifeng Guo, E-mail: `guoxifeng1990@163.com`, Github: `https://github.com/XifengGuo/CapsNet-Keras`\n",
        "*     The current version maybe only works for TensorFlow backend. Actually it will be straightforward to re-write to TF code.\n",
        "*     Adopting to other backends should be easy, but I have not tested this. \n",
        "\n",
        "Result:\n",
        "    Validation accuracy > 99.5% after 20 epochs. Still under-fitting.\n",
        "    About 110 seconds per epoch on a single GTX1070 GPU card\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "e30e2e10-a909-485d-be9d-dc6f592911a7",
        "_uuid": "c7e569699c6d067cd9fdf9c77299775e399b2ef3",
        "id": "qWnuqFe2o8x2",
        "colab_type": "code",
        "outputId": "5da50037-4aa3-47db-83e1-42db3eae5305",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "import numpy as np\n",
        "#from keras.preprocessing.image import ImageDataGenerator\n",
        "#from keras import callbacks\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import callbacks\n",
        "#from keras.utils.vis_utils import plot_model\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "\n",
        "print(tf.__version__)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.2.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "9776fd57-44e0-4211-a7a5-c7e647a10704",
        "_uuid": "f4b5499a472b312d5c5f0274ad429567aced6841",
        "id": "xYHeLw1do8x5",
        "colab_type": "text"
      },
      "source": [
        "# Capsule Layers \n",
        "Here is the implementation of the necessary layers for the CapsuleNet. These are not optimized yet and can be made significantly more performant. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "167d39ca-ee32-4eec-a83b-86194252b14f",
        "_uuid": "90c180a9a8c20e3fb8a93c3eb42588927cfcd6b6",
        "id": "dQti96GTo8x5",
        "colab_type": "code",
        "outputId": "73dd133a-5bc2-47f2-ea08-c4de4c135fdb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "import tensorflow.keras.backend as K\n",
        "from tensorflow.keras import initializers, layers\n",
        "\n",
        "\n",
        "class Length(layers.Layer):\n",
        "    \"\"\"\n",
        "    Compute the length of vectors. This is used to compute a Tensor that has the same shape with y_true in margin_loss.\n",
        "    Using this layer as model's output can directly predict labels by using `y_pred = np.argmax(model.predict(x), 1)`\n",
        "    inputs: shape=[None, num_vectors, dim_vector]\n",
        "    output: shape=[None, num_vectors]\n",
        "    \"\"\"\n",
        "    def call(self, inputs, **kwargs):\n",
        "        return tf.sqrt(tf.reduce_sum(tf.square(inputs), -1) + K.epsilon())\n",
        "\n",
        "    def compute_output_shape(self, input_shape):\n",
        "        return input_shape[:-1]\n",
        "\n",
        "    def get_config(self):\n",
        "        config = super(Length, self).get_config()\n",
        "        return config\n",
        "\n",
        "\n",
        "class Mask(layers.Layer):\n",
        "    \"\"\"\n",
        "    Mask a Tensor with shape=[None, num_capsule, dim_vector] either by the capsule with max length or by an additional \n",
        "    input mask. Except the max-length capsule (or specified capsule), all vectors are masked to zeros. Then flatten the\n",
        "    masked Tensor.\n",
        "    For example:\n",
        "        ```\n",
        "        x = keras.layers.Input(shape=[8, 3, 2])  # batch_size=8, each sample contains 3 capsules with dim_vector=2\n",
        "        y = keras.layers.Input(shape=[8, 3])  # True labels. 8 samples, 3 classes, one-hot coding.\n",
        "        out = Mask()(x)  # out.shape=[8, 6]\n",
        "        # or\n",
        "        out2 = Mask()([x, y])  # out2.shape=[8,6]. Masked with true labels y. Of course y can also be manipulated.\n",
        "        ```\n",
        "    \"\"\"\n",
        "    def call(self, inputs, **kwargs):\n",
        "        if type(inputs) is list:  # true label is provided with shape = [None, n_classes], i.e. one-hot code.\n",
        "            assert len(inputs) == 2\n",
        "            inputs, mask = inputs\n",
        "        else:  # if no true label, mask by the max length of capsules. Mainly used for prediction\n",
        "            # compute lengths of capsules\n",
        "            x = tf.sqrt(tf.reduce_sum(tf.square(inputs), -1))\n",
        "            # generate the mask which is a one-hot code.\n",
        "            # mask.shape=[None, n_classes]=[None, num_capsule]\n",
        "            mask = tf.one_hot(indices=tf.argmax(x, 1), depth=x.shape[1])\n",
        "\n",
        "        # inputs.shape=[None, num_capsule, dim_capsule]\n",
        "        # mask.shape=[None, num_capsule]\n",
        "        # masked.shape=[None, num_capsule * dim_capsule]\n",
        "        masked = K.batch_flatten(inputs * tf.expand_dims(mask, -1))\n",
        "        return masked\n",
        "\n",
        "    def compute_output_shape(self, input_shape):\n",
        "        if type(input_shape[0]) is tuple:  # true label provided\n",
        "            return tuple([None, input_shape[0][1] * input_shape[0][2]])\n",
        "        else:  # no true label provided\n",
        "            return tuple([None, input_shape[1] * input_shape[2]])\n",
        "\n",
        "    def get_config(self):\n",
        "        config = super(Mask, self).get_config()\n",
        "        return config\n",
        "\n",
        "\n",
        "def squash(vectors, axis=-1):\n",
        "    \"\"\"\n",
        "    The non-linear activation used in Capsule. It drives the length of a large vector to near 1 and small vector to 0\n",
        "    :param vectors: some vectors to be squashed, N-dim tensor\n",
        "    :param axis: the axis to squash\n",
        "    :return: a Tensor with same shape as input vectors\n",
        "    \"\"\"\n",
        "    s_squared_norm = tf.reduce_sum(tf.square(vectors), axis, keepdims=True)\n",
        "    scale = s_squared_norm / (1 + s_squared_norm) / tf.sqrt(s_squared_norm + K.epsilon())\n",
        "    return scale * vectors\n",
        "\n",
        "\n",
        "class CapsuleLayer(layers.Layer):\n",
        "    \"\"\"\n",
        "    The capsule layer. It is similar to Dense layer. Dense layer has `in_num` inputs, each is a scalar, the output of the\n",
        "    neuron from the former layer, and it has `out_num` output neurons. CapsuleLayer just expand the output of the neuron\n",
        "    from scalar to vector. So its input shape = [None, input_num_capsule, input_dim_capsule] and output shape = \\\n",
        "    [None, num_capsule, dim_capsule]. For Dense Layer, input_dim_capsule = dim_capsule = 1.\n",
        "    :param num_capsule: number of capsules in this layer\n",
        "    :param dim_capsule: dimension of the output vectors of the capsules in this layer\n",
        "    :param routings: number of iterations for the routing algorithm\n",
        "    \"\"\"\n",
        "    def __init__(self, num_capsule, dim_capsule, routings=3,\n",
        "                 kernel_initializer='glorot_uniform',\n",
        "                 **kwargs):\n",
        "        super(CapsuleLayer, self).__init__(**kwargs)\n",
        "        self.num_capsule = num_capsule\n",
        "        self.dim_capsule = dim_capsule\n",
        "        self.routings = routings\n",
        "        self.kernel_initializer = initializers.get(kernel_initializer)\n",
        "\n",
        "    def build(self, input_shape):\n",
        "        assert len(input_shape) >= 3, \"The input Tensor should have shape=[None, input_num_capsule, input_dim_capsule]\"\n",
        "        self.input_num_capsule = input_shape[1]\n",
        "        self.input_dim_capsule = input_shape[2]\n",
        "\n",
        "        # Transform matrix, from each input capsule to each output capsule, there's a unique weight as in Dense layer.\n",
        "        self.W = self.add_weight(shape=[self.num_capsule, self.input_num_capsule,\n",
        "                                        self.dim_capsule, self.input_dim_capsule],\n",
        "                                 initializer=self.kernel_initializer,\n",
        "                                 name='W')\n",
        "\n",
        "        self.built = True\n",
        "\n",
        "    def call(self, inputs, training=None):\n",
        "        # inputs.shape=[None, input_num_capsule, input_dim_capsule]\n",
        "        # inputs_expand.shape=[None, 1, input_num_capsule, input_dim_capsule, 1]\n",
        "        inputs_expand = tf.expand_dims(tf.expand_dims(inputs, 1), -1)\n",
        "\n",
        "        # Replicate num_capsule dimension to prepare being multiplied by W\n",
        "        # inputs_tiled.shape=[None, num_capsule, input_num_capsule, input_dim_capsule, 1]\n",
        "        inputs_tiled = tf.tile(inputs_expand, [1, self.num_capsule, 1, 1, 1])\n",
        "\n",
        "        # Compute `inputs * W` by scanning inputs_tiled on dimension 0.\n",
        "        # W.shape=[num_capsule, input_num_capsule, dim_capsule, input_dim_capsule]\n",
        "        # x.shape=[num_capsule, input_num_capsule, input_dim_capsule, 1]\n",
        "        # Regard the first two dimensions as `batch` dimension, then\n",
        "        # matmul(W, x): [..., dim_capsule, input_dim_capsule] x [..., input_dim_capsule, 1] -> [..., dim_capsule, 1].\n",
        "        # inputs_hat.shape = [None, num_capsule, input_num_capsule, dim_capsule]\n",
        "        inputs_hat = tf.squeeze(tf.map_fn(lambda x: tf.matmul(self.W, x), elems=inputs_tiled))\n",
        "\n",
        "        # Begin: Routing algorithm ---------------------------------------------------------------------#\n",
        "        # The prior for coupling coefficient, initialized as zeros.\n",
        "        # b.shape = [None, self.num_capsule, 1, self.input_num_capsule].\n",
        "        b = tf.zeros(shape=[inputs.shape[0], self.num_capsule, 1, self.input_num_capsule])\n",
        "\n",
        "        assert self.routings > 0, 'The routings should be > 0.'\n",
        "        for i in range(self.routings):\n",
        "            # c.shape=[batch_size, num_capsule, 1, input_num_capsule]\n",
        "            c = tf.nn.softmax(b, axis=1)\n",
        "\n",
        "            # c.shape = [batch_size, num_capsule, 1, input_num_capsule]\n",
        "            # inputs_hat.shape=[None, num_capsule, input_num_capsule, dim_capsule]\n",
        "            # The first two dimensions as `batch` dimension,\n",
        "            # then matmal: [..., 1, input_num_capsule] x [..., input_num_capsule, dim_capsule] -> [..., 1, dim_capsule].\n",
        "            # outputs.shape=[None, num_capsule, 1, dim_capsule]\n",
        "            outputs = squash(tf.matmul(c, inputs_hat))  # [None, 10, 1, 16]\n",
        "\n",
        "            if i < self.routings - 1:\n",
        "                # outputs.shape =  [None, num_capsule, 1, dim_capsule]\n",
        "                # inputs_hat.shape=[None, num_capsule, input_num_capsule, dim_capsule]\n",
        "                # The first two dimensions as `batch` dimension, then\n",
        "                # matmal:[..., 1, dim_capsule] x [..., input_num_capsule, dim_capsule]^T -> [..., 1, input_num_capsule].\n",
        "                # b.shape=[batch_size, num_capsule, 1, input_num_capsule]\n",
        "                b += tf.matmul(outputs, inputs_hat, transpose_b=True)\n",
        "        # End: Routing algorithm -----------------------------------------------------------------------#\n",
        "\n",
        "        return tf.squeeze(outputs)\n",
        "\n",
        "    def compute_output_shape(self, input_shape):\n",
        "        return tuple([None, self.num_capsule, self.dim_capsule])\n",
        "\n",
        "    def get_config(self):\n",
        "        config = {\n",
        "            'num_capsule': self.num_capsule,\n",
        "            'dim_capsule': self.dim_capsule,\n",
        "            'routings': self.routings\n",
        "        }\n",
        "        base_config = super(CapsuleLayer, self).get_config()\n",
        "        return dict(list(base_config.items()) + list(config.items()))\n",
        "\n",
        "\n",
        "def PrimaryCap(inputs, dim_capsule, n_channels, kernel_size, strides, padding):\n",
        "    \"\"\"\n",
        "    Apply Conv2D `n_channels` times and concatenate all capsules\n",
        "    :param inputs: 4D tensor, shape=[None, width, height, channels]\n",
        "    :param dim_capsule: the dim of the output vector of capsule\n",
        "    :param n_channels: the number of types of capsules\n",
        "    :return: output tensor, shape=[None, num_capsule, dim_capsule]\n",
        "    \"\"\"\n",
        "    output = layers.Conv2D(filters=dim_capsule*n_channels, kernel_size=kernel_size, strides=strides, padding=padding,\n",
        "                           name='primarycap_conv2d')(inputs)\n",
        "    outputs = layers.Reshape(target_shape=[-1, dim_capsule], name='primarycap_reshape')(output)\n",
        "    return layers.Lambda(squash, name='primarycap_squash')(outputs)\n",
        "\n",
        "\n",
        "\"\"\"\n",
        "# The following is another way to implement primary capsule layer. This is much slower.\n",
        "# Apply Conv2D `n_channels` times and concatenate all capsules\n",
        "def PrimaryCap(inputs, dim_capsule, n_channels, kernel_size, strides, padding):\n",
        "    outputs = []\n",
        "    for _ in range(n_channels):\n",
        "        output = layers.Conv2D(filters=dim_capsule, kernel_size=kernel_size, strides=strides, padding=padding)(inputs)\n",
        "        outputs.append(layers.Reshape([output.get_shape().as_list()[1] ** 2, dim_capsule])(output))\n",
        "    outputs = layers.Concatenate(axis=1)(outputs)\n",
        "    return layers.Lambda(squash)(outputs)\n",
        "\"\"\""
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\n# The following is another way to implement primary capsule layer. This is much slower.\\n# Apply Conv2D `n_channels` times and concatenate all capsules\\ndef PrimaryCap(inputs, dim_capsule, n_channels, kernel_size, strides, padding):\\n    outputs = []\\n    for _ in range(n_channels):\\n        output = layers.Conv2D(filters=dim_capsule, kernel_size=kernel_size, strides=strides, padding=padding)(inputs)\\n        outputs.append(layers.Reshape([output.get_shape().as_list()[1] ** 2, dim_capsule])(output))\\n    outputs = layers.Concatenate(axis=1)(outputs)\\n    return layers.Lambda(squash)(outputs)\\n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "7cd17730-22b6-4ac3-a612-31f18902fa78",
        "_uuid": "61c38c7ee701bb3ee2190263cf907fcdbe40dca2",
        "id": "UDdQcGoko8x8",
        "colab_type": "text"
      },
      "source": [
        "# Build the Model\n",
        "Here we use the layers to build up the model. The model is a bit different from a standard $X\\rightarrow y$  model, it is $(X,y)\\rightarrow (y,X)$ meaning it attempts to predict the class from the image, and then at the same time, using the same capsule reconstruct the image from the class. The approach appears very cGAN-like where the task of reconstructing better helps the model 'understand' the image data better."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "bc101123-d53c-4c2e-a187-101c434885da",
        "_uuid": "2497453eb1895f624ad84617dd98c230f5640304",
        "id": "HCMIciV0o8x9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras import layers, models, optimizers\n",
        "from tensorflow.keras import backend as K\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "K.set_image_data_format('channels_last')\n",
        "\n",
        "def CapsNet(input_shape, n_class, routings, batch_size):\n",
        "    \"\"\"\n",
        "    A Capsule Network on MNIST.\n",
        "    :param input_shape: data shape, 3d, [width, height, channels]\n",
        "    :param n_class: number of classes\n",
        "    :param routings: number of routing iterations\n",
        "    :param batch_size: size of batch\n",
        "    :return: Two Keras Models, the first one used for training, and the second one for evaluation.\n",
        "            `eval_model` can also be used for training.\n",
        "    \"\"\"\n",
        "    x = layers.Input(shape=input_shape, batch_size=batch_size)\n",
        "\n",
        "    # Layer 1: Just a conventional Conv2D layer\n",
        "    conv1 = layers.Conv2D(filters=256, kernel_size=9, strides=1, padding='valid', activation='relu', name='conv1')(x)\n",
        "\n",
        "    # Layer 2: Conv2D layer with `squash` activation, then reshape to [None, num_capsule, dim_capsule]\n",
        "    primarycaps = PrimaryCap(conv1, dim_capsule=8, n_channels=32, kernel_size=9, strides=2, padding='valid')\n",
        "\n",
        "    # Layer 3: Capsule layer. Routing algorithm works here.\n",
        "    digitcaps = CapsuleLayer(num_capsule=n_class, dim_capsule=16, routings=routings, name='digitcaps')(primarycaps)\n",
        "\n",
        "    # Layer 4: This is an auxiliary layer to replace each capsule with its length. Just to match the true label's shape.\n",
        "    # If using tensorflow, this will not be necessary. :)\n",
        "    out_caps = Length(name='capsnet')(digitcaps)\n",
        "\n",
        "    # Decoder network.\n",
        "    y = layers.Input(shape=(n_class,))\n",
        "    masked_by_y = Mask()([digitcaps, y])  # The true label is used to mask the output of capsule layer. For training\n",
        "    masked = Mask()(digitcaps)  # Mask using the capsule with maximal length. For prediction\n",
        "\n",
        "    # Shared Decoder model in training and prediction\n",
        "    decoder = models.Sequential(name='decoder')\n",
        "    decoder.add(layers.Dense(512, activation='relu', input_dim=16 * n_class))\n",
        "    decoder.add(layers.Dense(1024, activation='relu'))\n",
        "    decoder.add(layers.Dense(np.prod(input_shape), activation='sigmoid'))\n",
        "    decoder.add(layers.Reshape(target_shape=input_shape, name='out_recon'))\n",
        "\n",
        "    # Models for training and evaluation (prediction)\n",
        "    train_model = models.Model([x, y], [out_caps, decoder(masked_by_y)])\n",
        "    eval_model = models.Model(x, [out_caps, decoder(masked)])\n",
        "\n",
        "    # manipulate model\n",
        "    noise = layers.Input(shape=(n_class, 16))\n",
        "    noised_digitcaps = layers.Add()([digitcaps, noise])\n",
        "    masked_noised_y = Mask()([noised_digitcaps, y])\n",
        "    manipulate_model = models.Model([x, y, noise], decoder(masked_noised_y))\n",
        "    return train_model, eval_model, manipulate_model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "c6d84e5a-c33c-40c8-89c3-aba3454f7025",
        "_uuid": "9f27c6b0623ebffb6c8a24579f9dd4e321d6b1c2",
        "id": "LS09Ic7qo8x_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def margin_loss(y_true, y_pred):\n",
        "    \"\"\"\n",
        "    Margin loss for Eq.(4). When y_true[i, :] contains not just one `1`, this loss should work too. Not test it.\n",
        "    :param y_true: [None, n_classes]\n",
        "    :param y_pred: [None, num_capsule]\n",
        "    :return: a scalar loss value.\n",
        "    \"\"\"\n",
        "    # return tf.reduce_mean(tf.square(y_pred))\n",
        "    L = y_true * tf.square(tf.maximum(0., 0.9 - y_pred)) + \\\n",
        "        0.5 * (1 - y_true) * tf.square(tf.maximum(0., y_pred - 0.1))\n",
        "\n",
        "    return tf.reduce_mean(tf.reduce_sum(L, 1))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "6f168849-f8f9-4241-9ba8-59abc59573f1",
        "_uuid": "d21637e677fca5be415b2ff2e8a94ef7db2ea8a1",
        "id": "oa3i75Dao8yC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# define model\n",
        "#(input_shape, n_class, routings, batch_size):\n",
        "#model = CapsNet(input_shape=[28, 28, 1],\n",
        "#                n_class=10,\n",
        "#                routings=3,batch_size=100)\n",
        "#model.summary()\n",
        "#try:\n",
        "#    plot_model(model, to_file='model.png', show_shapes=True)\n",
        "#except Exception as e:\n",
        "#    print('No fancy plot {}'.format(e))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "7d75c4e0-ffca-45fc-8acc-620fe2825f82",
        "_uuid": "3e810fabad89045b7f4b51fe8540164f90e7698c",
        "id": "LjrtUDsVo8yE",
        "colab_type": "text"
      },
      "source": [
        "# Load MNIST Data\n",
        "Here we load and reformat the Kaggle contest data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-JBMdPcyZrla",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "169b7f78-12c7-4fed-886e-60024fe59339",
        "_uuid": "02b7db879a533e7bfb3116522bebf3867b23498c",
        "id": "0zSuXAxxo8yQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from matplotlib import pyplot as plt\n",
        "from PIL import Image\n",
        "import csv\n",
        "import math\n",
        "import pandas\n",
        "\n",
        "def combine_images(generated_images, height=None, width=None):\n",
        "    num = generated_images.shape[0]\n",
        "    if width is None and height is None:\n",
        "        width = int(math.sqrt(num))\n",
        "        height = int(math.ceil(float(num)/width))\n",
        "    elif width is not None and height is None:  # height not given\n",
        "        height = int(math.ceil(float(num)/width))\n",
        "    elif height is not None and width is None:  # width not given\n",
        "        width = int(math.ceil(float(num)/height))\n",
        "\n",
        "    shape = generated_images.shape[1:3]\n",
        "    image = np.zeros((height*shape[0], width*shape[1]),\n",
        "                     dtype=generated_images.dtype)\n",
        "    for index, img in enumerate(generated_images):\n",
        "        i = int(index/width)\n",
        "        j = index % width\n",
        "        image[i*shape[0]:(i+1)*shape[0], j*shape[1]:(j+1)*shape[1]] = \\\n",
        "            img[:, :, 0]\n",
        "    return image\n",
        "\n",
        "def plot_log(filename, show=True):\n",
        "\n",
        "    data = pandas.read_csv(filename)\n",
        "\n",
        "    fig = plt.figure(figsize=(4,6))\n",
        "    fig.subplots_adjust(top=0.95, bottom=0.05, right=0.95)\n",
        "    fig.add_subplot(211)\n",
        "    for key in data.keys():\n",
        "        if key.find('loss') >= 0 and not key.find('val') >= 0:  # training loss\n",
        "            plt.plot(data['epoch'].values, data[key].values, label=key)\n",
        "    plt.legend()\n",
        "    plt.title('Training loss')\n",
        "\n",
        "    fig.add_subplot(212)\n",
        "    for key in data.keys():\n",
        "        if key.find('acc') >= 0:  # acc\n",
        "            plt.plot(data['epoch'].values, data[key].values, label=key)\n",
        "    plt.legend()\n",
        "    plt.title('Training and validation accuracy')\n",
        "\n",
        "    # fig.savefig('result/log.png')\n",
        "    if show:\n",
        "        plt.show()    \n",
        "\n",
        "def test(model, data, args):\n",
        "    x_test, y_test = data\n",
        "    y_pred, x_recon = model.predict(x_test, batch_size=100)\n",
        "    print('-' * 30 + 'Begin: test' + '-' * 30)\n",
        "    print('Test acc:', np.sum(np.argmax(y_pred, 1) == np.argmax(y_test, 1)) / y_test.shape[0])\n",
        "\n",
        "    img = combine_images(np.concatenate([x_test[:50], x_recon[:50]]))\n",
        "    image = img * 255\n",
        "    Image.fromarray(image.astype(np.uint8)).save(args.save_dir + \"/real_and_recon.png\")\n",
        "    print()\n",
        "    print('Reconstructed images are saved to %s/real_and_recon.png' % args.save_dir)\n",
        "    print('-' * 30 + 'End: test' + '-' * 30)\n",
        "    plt.imshow(plt.imread(args.save_dir + \"/real_and_recon.png\"))\n",
        "    plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "e698ab37-4e74-43e6-b35b-a0507449d916",
        "_uuid": "c0374dabdf452026e3f231ffe689b5dd9f99288b",
        "id": "TZJyVmido8yK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train(model, data, args):\n",
        "    \"\"\"\n",
        "    Training a CapsuleNet\n",
        "    :param model: the CapsuleNet model\n",
        "    :param data: a tuple containing training and testing data, like `((x_train, y_train), (x_test, y_test))`\n",
        "    :param args: arguments\n",
        "    :return: The trained model\n",
        "    \"\"\"\n",
        "    # unpacking the data\n",
        "    (x_train, y_train), (x_test, y_test) = data\n",
        "\n",
        "    # callbacks\n",
        "    log = callbacks.CSVLogger(args.save_dir + '/log.csv')\n",
        "    checkpoint = callbacks.ModelCheckpoint(args.save_dir + '/weights-{epoch:02d}.h5', monitor='val_capsnet_accuracy',\n",
        "                                           save_best_only=True, save_weights_only=True, verbose=1)\n",
        "    lr_decay = callbacks.LearningRateScheduler(schedule=lambda epoch: args.lr * (args.lr_decay ** epoch))\n",
        "\n",
        "    # compile the model\n",
        "    model.compile(optimizer=optimizers.Adam(lr=args.lr),\n",
        "                  loss=[margin_loss, 'mse'],\n",
        "                  loss_weights=[1., args.lam_recon],\n",
        "                  metrics={'capsnet': 'accuracy'})\n",
        "\n",
        "    \"\"\"\n",
        "    # Training without data augmentation:\n",
        "    model.fit([x_train, y_train], [y_train, x_train], batch_size=args.batch_size, epochs=args.epochs,\n",
        "              validation_data=[[x_test, y_test], [y_test, x_test]], callbacks=[log, tb, checkpoint, lr_decay])\n",
        "    \"\"\"\n",
        "\n",
        "    # Begin: Training with data augmentation ---------------------------------------------------------------------#\n",
        "    def train_generator(x, y, batch_size, shift_fraction=0.):\n",
        "        train_datagen = ImageDataGenerator(width_shift_range=shift_fraction,\n",
        "                                           height_shift_range=shift_fraction)  # shift up to 2 pixel for MNIST\n",
        "        generator = train_datagen.flow(x, y, batch_size=batch_size)\n",
        "        while 1:\n",
        "            x_batch, y_batch = generator.next()\n",
        "            yield (x_batch, y_batch), (y_batch, x_batch)\n",
        "\n",
        "    # Training with data augmentation. If shift_fraction=0., no augmentation.\n",
        "    model.fit(train_generator(x_train, y_train, args.batch_size, args.shift_fraction),\n",
        "              steps_per_epoch=int(y_train.shape[0] / args.batch_size),\n",
        "              epochs=args.epochs,\n",
        "              validation_data=((x_test, y_test), (y_test, x_test)), batch_size=args.batch_size,\n",
        "              callbacks=[log, checkpoint, lr_decay])\n",
        "        \n",
        "    # End: Training with data augmentation -----------------------------------------------------------------------#\n",
        "\n",
        "    model.save_weights(args.save_dir + '/trained_model.h5')\n",
        "    print('Trained model saved to \\'%s/trained_model.h5\\'' % args.save_dir)\n",
        "\n",
        "    plot_log(args.save_dir + '/log.csv', show=True)\n",
        "\n",
        "    return model\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_EKbfeEhiYkr",
        "colab_type": "code",
        "outputId": "2c7bb18a-fcdc-44c1-8d91-2ae9be8488f0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "import argparse\n",
        "import os\n",
        "\n",
        "parser = argparse.ArgumentParser(description=\"Capsule Network on MNIST.\")\n",
        "parser.add_argument('--epochs', default=10, type=int)\n",
        "parser.add_argument('--batch_size', default=500, type=int)\n",
        "parser.add_argument('--lr', default=0.001, type=float,\n",
        "                        help=\"Initial learning rate\")\n",
        "parser.add_argument('--lr_decay', default=0.9, type=float,\n",
        "                        help=\"The value multiplied by lr at each epoch. Set a larger value for larger epochs\")\n",
        "parser.add_argument('--lam_recon', default=0.392, type=float,\n",
        "                        help=\"The coefficient for the loss of decoder\")\n",
        "parser.add_argument('-r', '--routings', default=1, type=int,\n",
        "                        help=\"Number of iterations used in routing algorithm. should > 0\")\n",
        "parser.add_argument('--shift_fraction', default=0.1, type=float,\n",
        "                        help=\"Fraction of pixels to shift at most in each direction.\")\n",
        "parser.add_argument('--debug', action='store_true',\n",
        "                        help=\"Save weights by TensorBoard\")\n",
        "parser.add_argument('--save_dir', default='./result')\n",
        "parser.add_argument('-t', '--testing', action='store_true',\n",
        "                        help=\"Test the trained model on testing dataset\")\n",
        "parser.add_argument('--digit', default=5, type=int,\n",
        "                        help=\"Digit to manipulate\")\n",
        "parser.add_argument('-w', '--weights', default=None,\n",
        "                        help=\"The path of the saved weights. Should be specified when testing\")\n",
        "args, unknown = parser.parse_known_args()\n",
        "print(args)\n",
        "\n",
        "if not os.path.exists(args.save_dir):\n",
        "    os.makedirs(args.save_dir)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Namespace(batch_size=500, debug=False, digit=5, epochs=10, lam_recon=0.392, lr=0.001, lr_decay=0.9, routings=1, save_dir='./result', shift_fraction=0.1, testing=False, weights=None)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "9dbcd67c-8f99-4d8b-8cf7-480d8dc069a4",
        "_uuid": "526436cc40013621251285812ba95725d4a6d749",
        "id": "7UfmktlEo8yF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def load_mnist():\n",
        "    # the data, shuffled and split between train and test sets\n",
        "    from tensorflow.keras.datasets import mnist\n",
        "    (x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "\n",
        "    x_train = x_train.reshape(-1, 28, 28, 1).astype('float32') / 255.\n",
        "    x_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255.\n",
        "    y_train = to_categorical(y_train.astype('float32'))\n",
        "    y_test = to_categorical(y_test.astype('float32'))\n",
        "\n",
        "    # data_slice = 10000\n",
        "    # x_train = x_train[:data_slice,:]\n",
        "    # y_train = y_train[:data_slice,:]\n",
        "    # x_test = x_test[:data_slice,:]\n",
        "    # y_test = y_test[:data_slice,:]\n",
        "\n",
        "    return (x_train, y_train), (x_test, y_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l-i3c_UESE2P",
        "colab_type": "code",
        "outputId": "dedac7c8-475a-41ff-c571-39dd3a4d5419",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 510
        }
      },
      "source": [
        " # load data\n",
        "(x_train, y_train), (x_test, y_test) = load_mnist()\n",
        "\n",
        "    # define model\n",
        "model, eval_model, manipulate_model = CapsNet(input_shape=x_train.shape[1:],\n",
        "                                                  n_class=len(np.unique(np.argmax(y_train, 1))),\n",
        "                                                  routings=args.routings,\n",
        "                                                  batch_size=args.batch_size)\n",
        "model.summary()"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"model_3\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_4 (InputLayer)            [(500, 28, 28, 1)]   0                                            \n",
            "__________________________________________________________________________________________________\n",
            "conv1 (Conv2D)                  (500, 20, 20, 256)   20992       input_4[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "primarycap_conv2d (Conv2D)      (500, 6, 6, 256)     5308672     conv1[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "primarycap_reshape (Reshape)    (500, 1152, 8)       0           primarycap_conv2d[0][0]          \n",
            "__________________________________________________________________________________________________\n",
            "primarycap_squash (Lambda)      (500, 1152, 8)       0           primarycap_reshape[0][0]         \n",
            "__________________________________________________________________________________________________\n",
            "digitcaps (CapsuleLayer)        (500, 10, 16)        1474560     primarycap_squash[0][0]          \n",
            "__________________________________________________________________________________________________\n",
            "input_5 (InputLayer)            [(None, 10)]         0                                            \n",
            "__________________________________________________________________________________________________\n",
            "mask_3 (Mask)                   (500, 160)           0           digitcaps[0][0]                  \n",
            "                                                                 input_5[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "capsnet (Length)                (500, 10)            0           digitcaps[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "decoder (Sequential)            multiple             1411344     mask_3[0][0]                     \n",
            "==================================================================================================\n",
            "Total params: 8,215,568\n",
            "Trainable params: 8,215,568\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "2fda2834-7c9e-4ed6-b322-0b9e86415201",
        "_uuid": "07bbb33aaa1c7ec875798359e300bbcdba374659",
        "id": "8NCOZGHlo8yM",
        "colab_type": "code",
        "outputId": "2293c1b5-bde2-45aa-ae80-b3bd45b186a1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "#train(model=model, data=((x_train, y_train), (x_test[:60], y_test[:60])), \n",
        " #     epoch_size_frac = 0.5) # do 10% of an epoch (takes too long)\n",
        "train(model=model, data=((x_train, y_train), (x_test, y_test)), args=args)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8458 - capsnet_loss: 0.8094 - decoder_loss: 0.0928 - capsnet_accuracy: 0.0896\n",
            "Epoch 00001: val_capsnet_accuracy improved from -inf to 0.08180, saving model to ./result/weights-01.h5\n",
            "120/120 [==============================] - 178s 1s/step - loss: 0.8458 - capsnet_loss: 0.8094 - decoder_loss: 0.0928 - capsnet_accuracy: 0.0896 - val_loss: 0.8364 - val_capsnet_loss: 0.8094 - val_decoder_loss: 0.0688 - val_capsnet_accuracy: 0.0818 - lr: 0.0010\n",
            "Epoch 2/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8337 - capsnet_loss: 0.8094 - decoder_loss: 0.0618 - capsnet_accuracy: 0.0948\n",
            "Epoch 00002: val_capsnet_accuracy improved from 0.08180 to 0.09000, saving model to ./result/weights-02.h5\n",
            "120/120 [==============================] - 177s 1s/step - loss: 0.8337 - capsnet_loss: 0.8094 - decoder_loss: 0.0618 - capsnet_accuracy: 0.0948 - val_loss: 0.8364 - val_capsnet_loss: 0.8094 - val_decoder_loss: 0.0689 - val_capsnet_accuracy: 0.0900 - lr: 9.0000e-04\n",
            "Epoch 3/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8336 - capsnet_loss: 0.8094 - decoder_loss: 0.0617 - capsnet_accuracy: 0.1047\n",
            "Epoch 00003: val_capsnet_accuracy improved from 0.09000 to 0.10810, saving model to ./result/weights-03.h5\n",
            "120/120 [==============================] - 178s 1s/step - loss: 0.8336 - capsnet_loss: 0.8094 - decoder_loss: 0.0617 - capsnet_accuracy: 0.1047 - val_loss: 0.8364 - val_capsnet_loss: 0.8094 - val_decoder_loss: 0.0689 - val_capsnet_accuracy: 0.1081 - lr: 8.1000e-04\n",
            "Epoch 4/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8336 - capsnet_loss: 0.8094 - decoder_loss: 0.0618 - capsnet_accuracy: 0.1145\n",
            "Epoch 00004: val_capsnet_accuracy did not improve from 0.10810\n",
            "120/120 [==============================] - 176s 1s/step - loss: 0.8336 - capsnet_loss: 0.8094 - decoder_loss: 0.0618 - capsnet_accuracy: 0.1145 - val_loss: 0.8364 - val_capsnet_loss: 0.8094 - val_decoder_loss: 0.0688 - val_capsnet_accuracy: 0.0991 - lr: 7.2900e-04\n",
            "Epoch 5/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8520 - capsnet_loss: 0.8278 - decoder_loss: 0.0617 - capsnet_accuracy: 0.1077\n",
            "Epoch 00005: val_capsnet_accuracy improved from 0.10810 to 0.22710, saving model to ./result/weights-05.h5\n",
            "120/120 [==============================] - 176s 1s/step - loss: 0.8520 - capsnet_loss: 0.8278 - decoder_loss: 0.0617 - capsnet_accuracy: 0.1077 - val_loss: 0.5584 - val_capsnet_loss: 0.5318 - val_decoder_loss: 0.0679 - val_capsnet_accuracy: 0.2271 - lr: 6.5610e-04\n",
            "Epoch 6/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.2836 - capsnet_loss: 0.2612 - decoder_loss: 0.0572 - capsnet_accuracy: 0.6894\n",
            "Epoch 00006: val_capsnet_accuracy improved from 0.22710 to 0.95260, saving model to ./result/weights-06.h5\n",
            "120/120 [==============================] - 178s 1s/step - loss: 0.2836 - capsnet_loss: 0.2612 - decoder_loss: 0.0572 - capsnet_accuracy: 0.6894 - val_loss: 0.1029 - val_capsnet_loss: 0.0807 - val_decoder_loss: 0.0567 - val_capsnet_accuracy: 0.9526 - lr: 5.9049e-04\n",
            "Epoch 7/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.1112 - capsnet_loss: 0.0903 - decoder_loss: 0.0533 - capsnet_accuracy: 0.9326\n",
            "Epoch 00007: val_capsnet_accuracy improved from 0.95260 to 0.96850, saving model to ./result/weights-07.h5\n",
            "120/120 [==============================] - 177s 1s/step - loss: 0.1112 - capsnet_loss: 0.0903 - decoder_loss: 0.0533 - capsnet_accuracy: 0.9326 - val_loss: 0.0747 - val_capsnet_loss: 0.0530 - val_decoder_loss: 0.0555 - val_capsnet_accuracy: 0.9685 - lr: 5.3144e-04\n",
            "Epoch 8/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0836 - capsnet_loss: 0.0639 - decoder_loss: 0.0501 - capsnet_accuracy: 0.9546\n",
            "Epoch 00008: val_capsnet_accuracy improved from 0.96850 to 0.97600, saving model to ./result/weights-08.h5\n",
            "120/120 [==============================] - 177s 1s/step - loss: 0.0836 - capsnet_loss: 0.0639 - decoder_loss: 0.0501 - capsnet_accuracy: 0.9546 - val_loss: 0.0598 - val_capsnet_loss: 0.0387 - val_decoder_loss: 0.0537 - val_capsnet_accuracy: 0.9760 - lr: 4.7830e-04\n",
            "Epoch 9/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0711 - capsnet_loss: 0.0526 - decoder_loss: 0.0472 - capsnet_accuracy: 0.9634\n",
            "Epoch 00009: val_capsnet_accuracy improved from 0.97600 to 0.98040, saving model to ./result/weights-09.h5\n",
            "120/120 [==============================] - 177s 1s/step - loss: 0.0711 - capsnet_loss: 0.0526 - decoder_loss: 0.0472 - capsnet_accuracy: 0.9634 - val_loss: 0.0538 - val_capsnet_loss: 0.0335 - val_decoder_loss: 0.0517 - val_capsnet_accuracy: 0.9804 - lr: 4.3047e-04\n",
            "Epoch 10/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0631 - capsnet_loss: 0.0457 - decoder_loss: 0.0442 - capsnet_accuracy: 0.9687\n",
            "Epoch 00010: val_capsnet_accuracy improved from 0.98040 to 0.98210, saving model to ./result/weights-10.h5\n",
            "120/120 [==============================] - 176s 1s/step - loss: 0.0631 - capsnet_loss: 0.0457 - decoder_loss: 0.0442 - capsnet_accuracy: 0.9687 - val_loss: 0.0500 - val_capsnet_loss: 0.0305 - val_decoder_loss: 0.0496 - val_capsnet_accuracy: 0.9821 - lr: 3.8742e-04\n",
            "Trained model saved to './result/trained_model.h5'\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAARIAAAG0CAYAAAD+cqjQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXxU5dn/8c+Vyb7vLMlAQEFlSxAQFIG6i/tSaq0VsVUfa92KS/WhKlp5agu1Lj8fUauIrRbpU+u+tFYpWDe2QFiVnSCQyUL2bWbu3x9nEiYhyySZyWS53q/XvGbmzD1nrpkk35xzz33uI8YYlFKqK0KCXYBSqvfTIFFKdZkGiVKqyzRIlFJdpkGilOoyDRKlVJdpkCgAROQDEbnO3207WMP3RCTf3+tVgRca7AJU54lIhdfdaKAWcHnu/5cx5lVf12WMmRmItqp/0CDpxYwxsQ23RWQPcIMx5uPm7UQk1Bjj7M7aVP+iuzZ9UMMugoj8UkQOAUtEJElE3hURh4iUeG5nej1nhYjc4Lk9R0Q+E5FFnra7RWRmJ9sOE5GVIlIuIh+LyDMi8mcf38dJntc6IiKbReQSr8cuEJEtnvUeEJG7PctTPe/tiIgUi8gqEdHf8wDTD7jvGggkA0OBm7B+1ks894cA1cD/a+P5k4HtQCrwO+BFEZFOtH0N+BpIAeYD1/pSvIiEAe8A/wDSgduAV0XkBE+TF7F23+KAMcAnnuV3AflAGjAA+G9AjwMJMA2SvssNPGSMqTXGVBtjiowxfzPGVBljyoEFwIw2nr/XGPOCMcYFLAUGYf1h+txWRIYAk4AHjTF1xpjPgLd9rH8KEAs85nnuJ8C7wNWex+uBUSISb4wpMcas81o+CBhqjKk3xqwyekBZwGmQ9F0OY0xNwx0RiRaR50Rkr4iUASuBRBGxtfL8Qw03jDFVnpuxHWw7GCj2Wgaw38f6BwP7jTFur2V7gQzP7SuBC4C9IvJvETnVs3whsAP4h4jsEpH7fHw91QUaJH1X8//CdwEnAJONMfHAdM/y1nZX/OEgkCwi0V7L7D4+9zvA3qx/YwhwAMAYs9oYcynWbs+bwHLP8nJjzF3GmOHAJcBcETmri+9DtUODpP+Iw+oXOSIiycBDgX5BY8xeYA0wX0TCPVsNF/v49K+AKuBeEQkTke95nrvMs65rRCTBGFMPlGHtyiEiF4nI8Z4+mlKsr8PdLb+E8hcNkv7jCSAKKAS+BD7spte9BjgVKAIeBV7HGu/SJmNMHVZwzMSq+X+B2caYbZ4m1wJ7PLtpN3teB2AE8DFQAXwB/K8x5lO/vRvVItF+KNWdROR1YJsxJuBbRKr76BaJCigRmSQix4lIiIicD1yK1aeh+hAd2aoCbSDwBtY4knzgZ8aY9cEtSfmb7toopbpMd22UUl2mQaKU6rKg9ZGkpqaarKysYL28UqoT1q5dW2iMSWu+PGhBkpWVxZo1a4L18kqpThCRvS0t110bpVSXaZAopbpMg0Qp1WU6IE31CPX19eTn51NTU9N+YxVwkZGRZGZmEhYW5lN7DRLVI+Tn5xMXF0dWVhatT8SmuoMxhqKiIvLz8xk2bJhPz9EgUU2U1ZWxp3QPe8r2sKd0D/vK93Hx8IuZYW9rMrWuq6mp0RDpIUSElJQUHA6Hz8/p8UHy6lbrjArp0emkRaWRFp1GWlQa4bbwIFfWe9W76zlQfqAxLPaU7WF36W72lO2huKa4sZ1NbIRICEdqjgQ8SAANkR6koz+LHh8kSzYt4XDV4WOWJ0YkkhadRnpUemO4eN9Pj04nJSqFsBDf9vH6GmMMxTXF7C3b2xgYu8t2s6d0D/nl+Ti9zk6RFJFEVkIWMzJnkJWQRVZ8FlkJWdhj7fx29W95d9e7uNwubCGtzcqo+rseHyT/+P4/OFJ7BEeVg4KqAgqrCymoKsBRbd13VDn49si3FFUX4TKuY56fHJl8NGSi00mNSm0SNmlRaUSFRQXhnfmHMYaCqoImWxcNoVFeV97YLiwkjKHxQzk+8XjOHnp2Y1hkxWeREJHQ6vrHpo7l9e2vs6dsD8clHtcdb6nfW7FiBeHh4Zx22mmttpk/fz6xsbHcfffd3VhZ63p8kIRICMmRySRHJnNC8gmttnO5XZTUluCochwNmWqHdb/KQUF1AduLt1NUU4Tb9N2Z99Kj0slKyGJm1swmWxeDYwZ3aotibNpYAPIK8zRIusmKFSuIjY1tM0h6mh4fJL6yhdhIjUolNSqVkzip1XYut4vimmIKqgsat3JqXe3O/NdpxpiA7/snRyY3hkZMWEyn1mGMwVFey05HJbsKK9jlqGSXo4I9RRWED4gmz5HHZcdf5ufKe5ZXXnmFRYsWISKMGzeOH/zgBzz66KPU1dWRkpLCq6++yoABA5g/fz47d+5kx44dFBYWcu+993LjjTdy8OBBrrrqKsrKynA6nTz77LNMmzaN2NhY7rjjDt59912ioqJ46623GDBgAA6Hg5tvvpl9+/YB8MQTT5CRkcHixYux2Wz8+c9/5umnn2batGlt1p2bm8vNN99MVVUVxx13HC+99BJJSUk89dRTLF68mNDQUEaNGsWyZcv497//zR133AFY/SArV64kLi6uy59dnwkSX9lCbFafSnSaNdVOP1Nd52J3YdOw2FVYyW5HJeW1R/tNIsNCGJYaS3mNC1vdEPIK87qtxoff2cyW78r8us5Rg+N56OLRrT6+efNmHn30UT7//HNSU1MpLi5GRPjyyy8REf74xz/yu9/9jt///vcAbNy4kS+//JLKykrGjx/PhRdeyF/+8hfOO+885s2bh8vloqrKOgtHZWUlU6ZMYcGCBdx777288MIL/OpXv+KOO+7gF7/4Baeffjr79u3jvPPOY+vWrdx8880d2m2ZPXs2Tz/9NDNmzODBBx/k4Ycf5oknnuCxxx5j9+7dREREcOTIEQAWLVrEM888w9SpU6moqCAyMrKLn6yl3wVJf+B2Gw6W1Vgh4RUWuxyVHDhS3aRtRmIUw9NiuOLkDIanxTI8LYbhabEMio8kJET4n/e38qdtg/kmbCU1zhoiQ/3zi9fTfPLJJ8yaNYvU1FQAkpOTycvL46qrruLgwYPU1dU1GVNx6aWXEhUVRVRUFGeccQZff/01kyZN4ic/+Qn19fVcdtll5OTkABAeHs5FF10EwIQJE/jnP/8JwMcff8yWLVsa11lWVkZFhfd54dtXWlrKkSNHmDHD+lbtuuuuY9asWQCMGzeOa665hssuu4zLLrO2JqdOncrcuXO55ppruOKKK8jMzGx13R3hU5B45tp8ErABfzTGPNbs8SFYZ1hL9LS5zxjzvj8KXLevhDpn3+3T6Cpj4LAnNHZ6wmJPYSXV9Uc7nmPCbRyXHsukrCSuSrNbYZEay7DUGKLC2+43ybEn8tK6DEKNk23F28hJzwn0W2pzy6E73XbbbcydO5dLLrmEFStWMH/+/MbHmu+uigjTp09n5cqVvPfee8yZM4e5c+cye/ZswsLCGtvbbDacTmvLz+128+WXX/ptq6C59957j5UrV/LOO++wYMEC8vLyuO+++7jwwgt5//33mTp1Kh999BEnnnhil1+r3SDxnIntGeAcrDk3V4vI28aYLV7NfgUsN8Y8KyKjgPeBrC5XB9z22vpj/ouqY4UIZCZFMzwthlOHp3i2LGI4Li2W9LiITvfTZNsTcdVY57TKK8zrliAJhjPPPJPLL7+cuXPnkpKSQnFxMaWlpWRkWCf2W7p0aZP2b731Fvfffz+VlZWsWLGCxx57jL1795KZmcmNN95IbW0t69atY/bs2a2+5rnnnsvTTz/NPffcA1h9HTk5OcTFxVFW5tuuXUJCAklJSaxatYpp06bxpz/9iRkzZuB2u9m/fz9nnHEGp59+OsuWLaOiooKioiLGjh3L2LFjWb16Ndu2beueIAFOAXYYY3YBiMgyrJnAvYPEAPEN7w3rLGl+8dTV46l1Hvu1rjoqNTaCoSnRRIT6f5zH4IRIUqPSgBTyHN3XT9LdRo8ezbx585gxYwY2m43x48czf/58Zs2aRVJSEmeeeSa7d+9ubD9u3DjOOOMMCgsLeeCBBxg8eDBLly5l4cKFhIWFERsbyyuvvNLmaz711FP8/Oc/Z9y4cTidTqZPn87ixYu5+OKL+f73v89bb73lU2fr0qVLGztbhw8fzpIlS3C5XPz4xz+mtLQUYwy33347iYmJPPDAA3z66aeEhIQwevRoZs6c6ZfPr93Jn0Xk+8D5xpgbPPevxTrt461ebQZhnTU+CYgBzjbGrG1hXTcBNwEMGTJkwt69Lc6RonqYG5auYX3tk6SnFPLBlR8E5DW2bt3KSSe1/m1bT9LTxnAESks/ExFZa4yZ2Lytv6YRuBp42RiTiXVi5z81O2crAMaY540xE40xE9PSjpmtTfVQ44ckUn5kEPkV+ZTUlAS7HNUD+bJrc4CmJ37O9Czz9lPgfABjzBciEgmkAgX+KFIFV3ZmIq5VR/tJpmdOb+cZfZt3p2ugLViwgL/+9a9Nls2aNYt58+Z1Ww2+8CVIVgMjRGQYVoD8EPhRszb7gLOAl0XkJCAS8P3QQdWjjbMn4KrOQAhhU+Gmfh8k3WnevHk9LjRa0u6ujTHGCdwKfARsxfp2ZrOIPCIil3ia3QXcKCIbgL8Ac4yeeavPiI8M47jUZCLNoG4dmKZ6D5/GkXjGhLzfbNmDXre3AFP9W5rqSXLsSXzsyGRT4aZuGfaveheds1X5JMeeQFX5YI7UHiG/PD/Y5ageRoNE+STHnoSr+miHq1LeNEiUT04cFEeoaxA2wvtFkMyfP59Fixb16HW//PLL3Hrrre037AYaJMonYbYQxgxOItzVvUcCKxqPzenJ9Ohf5bMcexLbdg5ia9hX1LvrAzeN5Qf3wSE/h9XAsTDzsTabLFiwgKVLl5Keno7dbmfChAns3LmTn//85zgcDqKjo3nhhRc48cQTOXz4MDfffDO7du0C4Nlnn+W0007j8ccf56WXXgLghhtu4M4772x13UCr658zZw6RkZGsX7+eqVOn8vjjj7dZ+549e/jJT35CYWEhaWlpLFmyhCFDhvDXv/6Vhx9+GJvNRkJCAitXrmTz5s1cf/311NXV4Xa7+dvf/saIESO69PFqkCifZdsTeGWjHVvSKr4p+YbRKT3jKF1/WLt2LcuWLSM3Nxen08nJJ5/MhAkTuOmmm1i8eDEjRozgq6++4pZbbuGTTz7h9ttvZ8aMGfz973/H5XJRUVHB2rVrWbJkCV999RXGGCZPntx4AF1L6wZaXT9Yp+j4/PPPsdnaP4bqtttu47rrruO6667jpZde4vbbb+fNN9/kkUce4aOPPiIjI6NxTpLFixdzxx13cM0111BXV4fL1fVj2TRIlM/G25Nw1VjzV2xybApckLSz5RAIq1at4vLLLyc6OhqASy65hJqaGj7//PPG+T0Aamut2fQ++eSTxoPyGv7bf/bZZ1x++eXExFiz1F1xxRWsWrUKt9t9zLoBKioqWl0/WCNYfQkRgC+++II33ngDgGuvvZZ7770XsOYfmTNnDj/4wQ+44oorADj11FNZsGAB+fn5XHHFFV3eGgENEtUB9uQoEsMHEEI8eYV5XMVVwS4poNxuN4mJieTm5gZl/Q2B1BWLFy/mq6++4r333mPChAmsXbuWH/3oR0yePJn33nuPCy64gOeee44zzzyzS6+jna3KZyJCTmYi0s1TL3aH6dOn8+abb1JdXU15eTnvvPMO0dHRDBs2rPFYF2MMGzZsAOCss87i2WefBcDlclFaWsq0adN48803qaqqorKykr///e9MmzatxXUDxMfHt7r+jjrttNNYtmwZAK+++mrj1AM7d+5k8uTJPPLII6SlpbF//3527drF8OHDuf3227n00kvZuHFj5z84Dw0S1SHZ9kTKSgexu7Tp6S56u5NPPpmrrrqK7OxsZs6cyaRJkwDrj/LFF18kOzub0aNH89ZbbwHw5JNP8umnnzJ27FgmTJjAli1bOPnkk5kzZw6nnHIKkydP5oYbbmD8+PGtrrut9XfU008/zZIlSxg3bhx/+tOfePLJJwG45557GDt2LGPGjOG0004jOzub5cuXM2bMGHJycti0aVObky/5qt35SAJl4sSJZs2aNUF5bdV5K7YX8NPlrxI95CVeOPcFpgya4pf19qb5SPqLYMxHovqJ7MxEXNWeDtfCTUGuRvUU2tmqOiQpJpyspFQqGdCnp17sSZYsWdK4q9Jg6tSpPPPMM0Gq6FgaJKrDsu2J/Lskk7zCPD0SuBtcf/31XH/99cEuo026a6M6LMeeSGXZYBzVjhZP8K76Hw0S1WHZ9sTGI4G1n0SBBonqhFGD4rE5MwjBxsbCro9BUL2fBonqsMgwGycNTCbCbe9TWySxsbHBLqHX0iBRnZJjT6SqfDCbCzfjcusJzPo7DRLVKdmZidRUZFLlrGJX6a5gl+NXxhjuuecexowZw9ixY3n99dcBOHjwINOnTycnJ4cxY8awatUqXC4Xc+bMaWz7hz/8IcjVB4d+/as6JWfI0XMCbyrcxIikrh9B2uC3X/+WbcXb/LY+gBOTT+SXp/zSp7ZvvPEGubm5bNiwgcLCQiZNmsT06dN57bXXOO+885g3bx4ul4uqqipyc3M5cOAAmzZZu3gNh+r3N7pFojplWEoMsSEDCCW6zx3A99lnn3H11Vdjs9kYMGAAM2bMYPXq1UyaNIklS5Ywf/588vLyiIuLY/jw4ezatYvbbruNDz/8kPj4+PZfoA/SLRLVKSEhQo49ma31/j8S2Ncth+42ffp0Vq5cyXvvvcecOXOYO3cus2fPZsOGDXz00UcsXryY5cuXN86Q1p/oFonqtOzMRCrKBvNtybdUO6uDXY7fTJs2jddffx2Xy4XD4WDlypWccsop7N27lwEDBnDjjTdyww03sG7dOgoLC3G73Vx55ZU8+uijrFu3LtjlB4VukahOy7EnUr86kzDjYlvxNsanjw92SX5x+eWX88UXX5CdnY2I8Lvf/Y6BAweydOlSFi5cSFhYGLGxsbzyyiscOHCA66+/HrfbDcBvfvObIFcfHBokqtOy7Ym4PSNcNzo29vogqaioAKwJnBYuXMjChQubPN4wJ2pz/XUrxJvu2qhOS4uLYHBcOhGk9KmBaarjNEhUl+R4jrvpa9/cqI7RIFFdkmO3OlwPVByguKY42OWoINEgUV1i9ZP4Z8a0YE37qY7V0Z+FT0EiIueLyHYR2SEi97XS5gciskVENovIax2qQvVaYzLioS4TIYSNjs4fCRwZGUlRUZGGSQ9gjKGoqIjIyEifn9PutzYiYgOeAc4B8oHVIvK2MWaLV5sRwP3AVGNMiYikd7h61StFh4cyMj2VQjO4S1skmZmZ5Ofn43A4/Fid6qzIyEgyMzN9bu/L17+nADuMMbsARGQZcCmwxavNjcAzxpgSAGNMgc8VqF4vx57Iu99ldGnqxbCwMIYNGxaA6lR38GXXJgPY73U/37PM20hgpIj8R0S+FJHz/VWg6vnG2xOpqcigrK6MfeX7gl2OCgJ/dbaGAiOA7wFXAy+ISGLzRiJyk4isEZE1ugnbd3hPvahfA/dPvgTJAcDudT/Ts8xbPvC2MabeGLMb+AYrWJowxjxvjJlojJmYlpbW2ZpVD3N8eixRZhA2InRgWj/lS5CsBkaIyDARCQd+CLzdrM2bWFsjiEgq1q5O35rtRrXKFiKMzUwmzGnXc930U+0GiTHGCdwKfARsBZYbYzaLyCMicomn2UdAkYhsAT4F7jHGFAWqaNXz5NiTqCgbzNbirdS76oNdjupmPh20Z4x5H3i/2bIHvW4bYK7novqhHHsCf1yXSai7nm9KvmF06uhgl6S6kY5sVX6RY0/CVT0EQE9R0Q/pNALKLwYmRJIWnY6LBO1w7Yd0i0T5zXh7EqZWjwTujzRIlN9k2xOpKB3M7tLdlNWVBbsc1Y00SJTf5NiPnqJic+HmIFejupMGifKbsRkJuGv8M6WA6l00SJTfxEWGMSI1jUgzUL+56Wc0SJRfZWcmUluZQZ4jT+cW6Uc0SJRf5QxJpLoig6KaIg5XHQ52OaqbaJAov8rOPHokcFdmTFO9iwaJ8qsTBsYR7soghFDtcO1HNEiUX4XZQhgzOIUwV6Z2uPYjGiTK73LsiVSWZ7C5cDNOtzPY5ahuoEGi/C7bnkh9ZSY1rhp2leq0NP2BBonyO2uEqzUwTSc66h80SJTfZSZFkRQ2mFCi9QC+fkKDRPmdiDDenkRI3RD95qaf0CBRAZHtOSfwt0e+paq+KtjlqADTIFEBkWNPxFltx23cbC3eGuxyVIBpkKiAyM7038nFVc+nQaICIiE6jGFJAwknRYfK9wMaJCpgsu2JOKvsukXSD2iQqIDJsSdSVT6Y7yq/o7C6MNjlqADSIFEBk21PxO05Eli3Svo2DRIVMCcNisNWb0cI0YFpfZwGiQqYiFAbowalEu4erFskfZwGiQqoHHsi1eUZ5BXm4TbuYJejAkSDRAVUjj2RuspMyuvK2Ve2L9jlqADRIFEBle11rhvtJ+m7NEhUQGWlRBMbkoGNCA2SPkyDRAWUiJBjT8ZWr0cC92U+BYmInC8i20Vkh4jc10a7K0XEiMhE/5WoersceyIVZYPYVryNOlddsMtRAdBukIiIDXgGmAmMAq4WkVEttIsD7gC+8neRqnfLsSfgqrZT765ne/H2YJejAsCXLZJTgB3GmF3GmDpgGXBpC+1+DfwWqPFjfaoP8D7XjfaT9E2+BEkGsN/rfr5nWSMRORmwG2Pe82Ntqo9IiY0gI34gYSRokPRRXe5sFZEQ4HHgLh/a3iQia0RkjcPh6OpLq15kvD0ZU61HAvdVvgTJAcDudT/Ts6xBHDAGWCEie4ApwNstdbgaY543xkw0xkxMS0vrfNWq18nOTKCyPIM9ZXsorS0NdjnKz3wJktXACBEZJiLhwA+BtxseNMaUGmNSjTFZxpgs4EvgEmPMmoBUrHql8UMScXlmTNtcuDnI1Sh/azdIjDFO4FbgI2ArsNwYs1lEHhGRSwJdoOobRg9OQOq0w7WvCvWlkTHmfeD9ZssebKXt97peluprIsNsnDggnUNmoPaT9EE6slV1m+zMRGorMthYuBFjTLDLUX6kQaK6TY49kZrKTIprijlYeTDY5Sg/0iBR3SbHrgPT+ioNEtVtjkuLJdpkEkKYnly8j9EgUd0mJEQYl5lCqDNTt0j6GA0S1a0aTlGxpWgLTrcz2OUoP9EgUd0q255IfVUmNa4adh7ZGexylJ9okKhuNV47XPskDRLVrdLjIxkQnUEoMTowrQ/RIFHdbrw9CWrtbCzUk4v3FRokqttl2xOpLMtgZ8lOquqrgl2O8gMNEtXtcjynqHDjZnORHgncF2iQqG43NiMBU2NNKaD9JH2DBonqdjERoYxMHUS4SdVvbvoIDRIVFNmZidRVZepQ+T5Cg0QFRc6QRGoqMjhUdQhHlc7f29tpkKigyM5MxO0ZmKb9JL2fBokKipEDYgl32RFCyHXkBrsc1UUaJCooQm0hjM1II8o5imXblrG/bH/7T1I9lgaJCpoceyIl+y4hREK4/7P79WjgXkyDRAVNjj2Rutp4Zo+YywbHBl7MezHYJalO0iBRQZNtTwQgun4SM4fNZPGGxXrOm15Kg0QFzeCESAbGR/L2hu+4f9I8UqJSuG/VfVQ7q4NdmuogDRIVNCLC3eedwNq9Jbz2pYMFpy9gT9kefr/m98EuTXWQBokKqitPzuDCsYP4wz+/Idp1IrNHzeb17a+zMn9lsEtTHaBBooJKRFhw+RhSYyO44/X13Djm54xIGsGD/3mQ4priYJenfKRBooIuMTqcx3+QzS5HJQs/3MlvTv8NZXVlPPz5w3pGvl5Cg0T1CKcdn8qN04bx6lf72H8okTtOvoNP9n/CmzveDHZpygcaJKrHuPu8EzhpUDy//NtGzrf/gFMGnsJjXz/G/nId9drTaZCoHiMi1MaTP8yhotbJfX/L49Gpj2ITG/+96r911GsPp0GiepSRA+K4f+aJfLrdwcd5tcybMo9cRy4vbXop2KWpNvgUJCJyvohsF5EdInJfC4/PFZEtIrJRRP4lIkP9X6rqL647LYvpI9N49L2tnBA7nZlZM3k291kd9dqDtRskImIDngFmAqOAq0VkVLNm64GJxphxwP8Bv/N3oar/EBEWfX8cMRGh3LEsl3sn/reOeu3hfNkiOQXYYYzZZYypA5YBl3o3MMZ8aoxpOK/Al0Cmf8tU/U16fCSPXTGWzd+V8ceVh3TUaw/nS5BkAN7d5vmeZa35KfBBV4pSCuDc0QO5+hQ7z63cibvq+MZRr6vyVwW7NNWMXztbReTHwERgYSuP3yQia0RkjcOh83Sq9v3qwlEMTY7mruW5XHfiz6xRr58/SElNSbBLU158CZIDgN3rfqZnWRMicjYwD7jEGFPb0oqMMc8bYyYaYyampaV1pl7Vz8REhPLED8dzuLyWX7/7Lb85/TeU1pYy//P5Ouq1B/ElSFYDI0RkmIiEAz8E3vZuICLjgeewQqTA/2Wq/izHnsidZ43gnQ3fsXVvLLePv11HvfYw7QaJMcYJ3Ap8BGwFlhtjNovIIyJyiafZQiAW+KuI5IrI262sTqlOueWM45k4NIkH3tzEGYO+r6NeexgJ1ubhxIkTzZo1a4Ly2qp32l9cxcwnVzFqUDx/uCaLWe9cyXGJx7Hk/CWEhoQGu7x+QUTWGmMmNl+uI1tVr2FPjubhS0bz9Z5i3lxTqaNeexANEtWrXHFyBheOsyZCsodP1VGvPYQGiepVRIT/uWwsaXER3Lksl7kT7tNRrz2ABonqdRKiw/j9rGx2F1Xy1D8P6KjXHkCDRPVK1kRIw3ntq32UlWTpqNcg0yBRvdZd545klGcipKtH3KSjXoNIg0T1Wg0TIVXWOnng79sbR70+/IXO9drdNEhUrzbCayKkr7ZHcPv42/nXvn/pqNdupkGier3rTstixsg0Fry3lVNTL2fSwEk66rWbaZCoXk9EWDjLmgjpF69v5KEpv8YmNuZ9Nk/neu0mGiSqT0iPsyZC2tpSyIoAACAASURBVHKwjNc+L2PelHmsL1ivo167iQaJ6jMaJkJ6fuUuks2UxlGvH+/9mKr6qvZXoDpND9pTfUpVnZMLn/qMmnoXy3+Ww43/uoYDFQewiY0Tkk8gJy2H8enjyUnPYWDMwGCX2+u0dtCeBonqczbsP8KVz37O+WMG8tj3R5LryGV9wXpyC3LJK8xrHEo/MGYg49OsUMlJz2Fk0kg9irgdrQWJfmqqz8m2J3Ln2SNY9I9vOOukdC4ffzqnZ5wOgNPtZHvJdnILcsktyGVdwTo+2GNNMRwdGs3YtLGNWy3j0sYRFx4XzLfSa/T8LZI3/gsiYmHYdMiaBtHJgS9O9Xout+Gq575g+6Fy3rjlNEYMaD0QDlUeYn3B+satlu0l23EbN4JwfNLxTbZaMmMzEZFufCc9S+/ctTEGlv0Idv0b6isBgYFjYNgMK1SGngaR8d1Sr+p99hdXccGTqyivdTI4IZLxQ5IYPySR8UMSGT04gcgwW4vPq6qvIq8wrzFYNjg2UFFfAUBqVCo5aVaojE8fz0nJJxFmC+vOtxVUvTNIGrjq4cA62L0Sdv8b9n8NrloQGwweb22tDJsO9skQHh3YwlWvsreokk+2FbB+3xHW7y9hf7HVPxJmE04aFM94e2JjwAxJjm5xa8PldrGzdGfj7tD6gvXkV+QDEGGLYEj8ENKj0kmPTictOo0B0QNIi0ojPSad9Kh0kiOTsYW0HFq9Te8OkubqayD/a0+wrIQDa8HtBFs4ZE46GiwZEyE03L+Fq17NUV5L7v4jrNtXwvp9JWzML6WqzgVAcky4J1iscBmXmUBcZMtbG44qBxscG8gtyGV/+X4KqgooqCqgsKYQt3E3aWsTGylRKUcDJjq98dIQPOnR6cSGxfb43aa+FSTN1ZbDvi+trZXdq+DgBsBAWDQMmXI0WAZmg037l9VRTpebbw5XsH5/ibXVsq+EnY5KAERgZHpc4+7Q+CFJHJ8WS0hI63/sLreLopoiHFUODlcdbrwuqCrAUe1oDJyyurJjnhsVGmWFS7OwSYpMIj48/uglwroOt3X/P8m+HSTNVZfAnv8c3WJxbLWWRyRY/SoNwZI+CkJ0TJ5qqrSqntx8K1TW7ztC7v4jlFbXAxAXEUp241ZLIjn2JJJjOv4HXe2sprCqsEnINARPQ9gUVBVQ565rdR2RtsgmweLL7bjwOOLD44kMjezUZ9O/gqS5igLYs+posBTvspZHp1idton2tp9/jJ69+dmujm4+28IhLMrawguNtK7DoppeQqOOtgnztOkjnZBut2F3UWXjFsv6fUfYdqgMt+dPJzkmnLTYCNLivC6xEaTHRzRZnhAV1qFdF2MMpbWllNSWUFZXRlltGWV1ZZTXlTe533jxul9ZX9nmusNDwhvD5dysc/l5zs99qql/B0lzR/Z7gmWVdV1V5PtzO/x5GXpW8HSwfmPAVdfx5wGEhHoFjFcAhTYPoUhPQHmuQyOOLmu8HWE9r8n9ZtdhUWCL6JatzKo6J3n5pazff4T8kioKympxVNTiKK+loLyWOqf7mOeE20JIjQ0nLT6yxeBJi4sg3XO/tW+UfOV0O1sOnBbC5+QBJ3PtqGt9Wq8Gieo8Y8BZC85qqG92aVxWZXWC11eB03NdX310WZO23pcqz7prjr6GOfaPsENs4U1DxhZu3fa+PmZZmBVCTR4Pb2FZa+sJa7xvbGFUOEMorDY4qgyHqwwFFS4cFXU4yo8GjqO8hqLKuhb/N8VFhjYGTFJ0OLGRocRGhBIfGUpsZChxkWHERoQSF9lwOXo/Jjy0zX6crtCRrarzRDxbFJEQlRT413M5rUBpEjA1zW7XesKpeZtmoVRfY21RuWrB6XVdf8Ra7mzhsYb2nSRAnOcyzPuBhuBpCJ2YcEx8OC4JpZ4w6rBRZ0KpcduodtuoctmoKgmhqjDEuu22UeUMoY4wHNj4zoRSRxj1hFLnudSbUOolFFtoBLawCMIiIggNiyQ8wrpEREQSGRlJZEQ0kVFRREVFkjUwhfHDB3XpR6ZBonoeWyjY4iAiiMPTjbHGLzUPl2OCp9bTrqGN9+26FpbXe55j3RZXHaGuOkJd9US5vNdVc0xbXHWYhvU5a5H2djednks71iScB79Y3qWPS4NEqZaIWLs2oeEQEexijmqyw+JyNguq2mZh1RBKzcLOWYfLWUttTQ21tdUclzqyy3VpkCjVW9lCPeOiOj6a2+Z5lr/GgesgCqVUl2mQKKW6TINEKdVlGiRKqS7TIFFKdZkGiVKqy4I2RF5EHMBeH5unAoUBLCfQtP7g0vr9Z6gxJq35wqAFSUeIyJqWxvf3Flp/cGn9gae7NkqpLtMgUUp1WW8JkueDXUAXaf3BpfUHWK/oI1FK9Wy9ZYtEKdWD9eggEZHzRWS7iOwQkfuCXU9HiIhdRD4VkS0isllE7gh2TZ0hIjYRWS8i7wa7lo4SkUQR+T8R2SYiW0Xk1GDX1BEi8gvP784mEfmLiHRuxuZu0GODRERswDPATGAUcLWIjApuVR3iBO4yxowCpgA/72X1N7gD2BrsIjrpSeBDY8yJQDa96H2ISAZwOzDRGDMG68j/Hwa3qtb12CABTgF2GGN2GWPqgGXApUGuyWfGmIPGmHWe2+VYv8QZwa2qY0QkE7gQ+GOwa+koEUkApgMvAhhj6owxR4JbVYeFAlEi0jDpyHdBrqdVPTlIMoD9Xvfz6WV/iA1EJAsYD3wV3Eo67AngXqCLszEHxTDAASzx7Jr9UURigl2Ur4wxB4BFwD7gIFBqjPlHcKtqXU8Okj5BRGKBvwF3GmOOPb1aDyUiFwEFxpi1wa6lk0KBk4FnjTHjgUqg1/SziUgS1hb4MGAwECMiPw5uVa3ryUFyAPA+c1WmZ1mvISJhWCHyqjHmjWDX00FTgUtEZA/WbuWZIvLn4JbUIflAvjGmYSvw/7CCpbc4G9htjHEYY+qBN4DTglxTq3pykKwGRojIMBEJx+poejvINflMrFOqvQhsNcY8Hux6OsoYc78xJtMYk4X12X9ijOmx/xGbM8YcAvaLyAmeRWcBW4JYUkftA6aISLTnd+ksenBncY+d/NkY4xSRW4GPsHqsXzLGbA5yWR0xFbgWyBORXM+y/zbGvB/Emvqb24BXPf+IdgHXB7kenxljvhKR/wPWYX0DuJ4ePMJVR7YqpbqsJ+/aKKV6CQ0SpVSXaZAopbpMg6QVIvKBiFzn77bBJCJ7ROTsAKzXiMjxntuLReQBX9p24nWuEZEeOyirP+tTna0iUuF1NxqoBVye+/9ljHm1+6vqOTxjQm4wxnzs5/UaYIQxZoe/2npGA+8GwowxPpwKWwVTj/36tzOMMbENt9v6oxGRUP3lVD1FX/h97Be7NiLyPRHJF5FfisghrOMvkkTkXRFxiEiJ53am13NWiMgNnttzROQzEVnkabtbRGZ2su0wEVkpIuUi8rGIPNPaiFEfa/y1iPzHs75/iEiq1+PXisheESkSkXltfD6TReSQ54jrhmWXi8hGz+1TROQLETkiIgdF5P95xma0tK6XReRRr/v3eJ7znYj8pFnbCz3HwZSJyH4Rme/18ErP9RERqRCRUxs+W6/nnyYiq0Wk1HN9mtdjbX42Hfyck0Vkiec9lIjIm16PXSoiuZ73sFNEzvcsb7IbKSLzG37OIpLl2cX7qYjsAz7xLP+r5+dQ6vkdGe31/CgR+b3n51nq+R2LEpH3ROS2Zu9no4hc3tJ7DZR+ESQeA4FkYChwE9Z7X+K5PwSoBv5fG8+fDGzHOjXA74AXRUQ60fY14GsgBZiPNWitNb7U+COsgVbpQDhwN4BYUxY861n/YM/rZdICzzDySuDMZut9zXPbBfzC835OxRpleUsbdeOp4XxPPecAI7CGfXurBGYDiVhHGf9MRC7zPDbdc51ojIk1xnzRbN3JwHvAU5739jjwnoikNHsPx3w2LWjvc/4T1q7yaM+6/uCp4RTgFeAez3uYDuxp7fNowQzgJOA8z/0PsD6ndKyBaN674ouACVjD5JM5ejDlUqBxxLGIZGMd3PpeB+roOmNMn7xg/UDP9tz+HlAHRLbRPgco8bq/AmvXCGAO1pQGDY9FAwYY2JG2WL+kTiDa6/E/A3/28T21VOOvvO7fgjX/BsCDwDKvx2I8n8HZraz7UazRwwBxWH/kQ1tpeyfwd6/7Bjjec/tl4FHP7ZeAx7zajfRu28J6nwD+4Lmd5Wkb6vX4HOAzz+1rga+bPf8LYE57n01HPmdgENYfbFIL7Z5rqLet3z/P/fkNP2ev9za8jRoSPW0SsIKuGshuoV0kUILV7wRW4Pxvd/+99actEocxpqbhjljHMDzn2VQsw9qUTvTevG/mUMMNY0yV52ZsB9sOBoq9lkHTqRKa8LHGQ163q7xqGuy9bmNMJVDU2mthbX1cISIRwBXAOmPMXk8dIz2b+4c8dfwP1tZJe5rUQLMTonl2qT717FKUAjf7uN6GdTc/wdpemk410dpn00Q7n7Md62dW0sJT7cBOH+ttSeNnI9ZMdI95do/KOLplk+q5RLb0Wp7f6deBH4tICHA11hZUt+pPQdL866m7gBOAycaYeI5uSre2u+IPB4FkEYn2WmZvrTFdq/Gg97o9r5nSWmNjzBasP8SZNN2tAWsXaRvWf7144L87UwPWFpm317AOxLQbYxKAxV7rbe/rxO+wdkW8DaFzR4i39Tnvx/qZJbbwvP3Aca2ssxJra7TBwBbaeL/HH2FNG3A21lZIllcNhUBNG6+1FLgGa5ezyjTbDewO/SlImovD2lw84tnffijQL+j5D78GmC8i4WLNIXpxgGr8P+AiETnd0zH6CO3/vF/DmlpxOvDXZnWUARUiciLwMx9rWA7MEZFRniBrXn8c1n/7Gk9/w4+8HnNg7VIMb2Xd7wMjReRHIhIqIldhTcnZmbllW/2cjTEHsfou/tfTKRsmIg1B8yJwvYicJSIhIpLh+XwAcoEfetpPBL7vQw21WFuN0VhbfQ01uLF2Ex8XkcGerZdTPVuPeILDDfyeIGyNQP8OkieAKKy0/xL4sJte9xqsDssirH6J17F+gVrS6RqNdaT0z7HC4SDWfnR+O0/7C1YH4CfGGO9zzd6N9UdeDrzgqdmXGj7wvIdPgB2ea2+3AI+ISDlWn85yr+dWAQuA/4j1bdGUZusuAi7C2poowup8vKhZ3b5q73O+FqjH2iorwOojwhjzNVZn7h+AUuDfHN1KegBrC6IEeJimW3gteQVri/AA1nQHXzZ7/G4gD2t6jWLgtzT9+30FGIvV59bt+tSAtN5IRF4HthljAr5FpPouEZkN3GSMOT0Yr9+ft0iCQkQmichxnk3h87H2i99s73lKtcaz23gLQZyvRIOk+w3E+mqyAmsMxM+MMeuDWpHqtUTkPKz+pMO0v/sUuDp010Yp1VW6RaKU6jINEqVUlwXt6N/U1FSTlZUVrJdXSnXC2rVrC40xac2XtxskIvIS1vf1BcY6B2nzxwXrHKsXYA1DnmM8p6psS1ZWFmvWrPGldqVUDyEizQ9LAHzbtXkZOL+Nx2diHbE4Auuo2mc7WpxSqndrN0iMMSuxRtK15lLgFWP5Eutgp0H+KlAp1fP5o7O1z5zsWynVOd36rY2I3CQia0RkjcPh6M6XVkoFkD+CxOeTfRtjnjfGTDTGTExLO6bjVynVS/nj69+3gVtFZBnWFIOlnkOvlVKtcbvBVQv11eCsBWfN0Ut9w+1acFaDywnGBW4XuL1uG7d13+1qe1mTxz3rcLuPLhsyBSb9tEtvx5evf/+CNVVhqojkY83VEAZgjFmMNS/EBViHiVfRi07UrFSrjLH+mGvKoLYcaptfe27XlHnCwCsQmgeBs7aFcKgLbP0SAmKDkFAIsXluh1j3xdZ0WXzXvxtpN0iMMVe387jBmvdCqZ7DGKgphdJ8qCry+uMvh9rSpvdrylp+zO3DGSJsERAeDaFREBoBoZEQFmldh8dAdIq1PMzr8YZLQ7vQiKPPP6ZdBNjCrWBoEgpe101uh3pCpOkEdm63ocbporrORXW9i5p6F9V1bqrqnCTHhDOiix93nzqvjepHXE4oP2gFRel+zyXfuhzx3K4rb/35tgiIiLMukfEQEQ+JdogYZd1ueCwiDiITvO7HN70ObfGsHJ1W63RRWl1PWXU9pdVOysrrqaxzUl3n+eOvr6W6zk11vYvqOqd1Xe/2etzV9Lbnfq3T3eprfn9CJotmZXepbg0S1TPVlB0NhuZBUZoPZd9Z+/jeopIhIROSh8PwGdbt+AyISfOEhXcARASkbGMM1fUuyqqdlFbXH3Mpa3bduLzGuq6pb/0P3ltEaAhR4TaiwqxLZJit8X5SdLjndoj1mFe7qHBPW6/7AxMiu/y+NUhUcOWvhT2rmgXFfmu3xFtIqBUKCXYYOtUKiUS7dZ1gtx6LaG1Sf/+prnOx01HBjoIKvi0oZ0dBBQXltU3Cod7V9tQccZGhJESFNV6OS4u1bkdb9+Ojwoj3ahMbEdokKCLDbNhCAjlHecdpkKjgMQb+8kOoLLB2HxKGWKEw5FSvoPCERewAqw+gm1TUOq2wOFzuCQ0rOPJLqmmYwic0RBiaEs3gxCgGJ0Y1/uHHR4Y1CYrG5VGhxEWG9bgQ8AcNEhU85YesEDnvN3BquyfuC4jSqnq+LSi3guKwFRY7Cyr4rrTxFEiE20IYnhZDjj2JWRPsHJ8ey4j0WIamxBAeqjNxgAaJCqbDm6zrQV3r6GuPMYaiyjq+PVzBjgLvLYwKHOVHJ/CPCrNxXHoMk4enNIbFiAFx2JOiCLVpYLRFg0QFz6GN1vWA0W236yRjDA+9vZl3NnxHSVV94/LYiFCOT4/leyPTGDEglhHpcRyfHktGYhQhfXC3oztokKjgObQJEodAVEsnseu6T7cX8MoXezl31AAmD0/xbGHEMjA+ktbP/646Q4NEBc+hPBgwNiCrdrrc/Ob9bQxLjeGZa04mTHdNAko/XRUcdZVQtAMGBiZIlq/J59uCCn55/okaIt1AP2EVHAVbAQMDj5m9s8sqa508/s9vmDg0ifNGD/D7+tWxNEhUcBzKs64DsEXy3MpdFFbUMu/Ck7QvpJtokKjgOLzJc3zL0PbbdmS1ZTW8sHIXF44bxPghSX5dt2qdBokKjkN5MGDMMUepdtXj//gGp9vNL8870a/rVW3TIFHdz+2Gw5v93j+y7VAZy9fu57pTsxiSEu3Xdau2aZCo7leyG+oq/N4/8pv3txEXEcqtZx7v1/Wq9mmQqO7XMDR+gP+2SFZ96+Df3zi4/awRJEb7d44Q1T4NEtX9DuVZs3iln+SX1bnchgXvbcWeHMW1p/q381b5RoNEdb9DmyB1pDWtoB+8sS6fbYfKufe8E4kI7b6pBtRRGiSq+zV8Y+MH1XUuFv1jO9n2RC4apyd4DBYNEtW9qoqhLN9vHa0vfraLw2W1zLtAB58FkwaJ6l4NHa1++OrXUV7Lsyt2cu6oAZwyLLnL61Odp0GiutehhiAZ1+VVPfmvb6h1urlvpg4+CzYNEtW9Dm+CmHSITe/SanYUVPCXr/dzzeQhDE8L/KTPqm0aJKp7Hdrol/6Rxz7YRnSYjdvP6uqpnZQ/aJCo7uOsA8f2LvePfLGziI+3HuZnZxxHSmxgzk+jOkaDRHWfwm+sc952oX/E7Tb8z/tbGZwQyU+mDvNjcaorfAoSETlfRLaLyA4Rua+Fx4eIyKcisl5ENorIBf4vVfV6fhga/87G78g7UMrd551AZJgOPusp2g0SEbEBzwAzgVHA1SIyqlmzXwHLjTHjgR8C/+vvQlUfcCjPOuduSucOqqupd/G7D7czenA8l+Vk+Lk41RW+bJGcAuwwxuwyxtQBy4BLm7UxQLzndgLwnf9KVH3GoTwYMApsnZtzfOnnezhwpJp5F5ykp43oYXwJkgxgv9f9fM8yb/OBH4tIPvA+cJtfqlN9hzFdGhpfUlnH//t0B2eckMZpx6f6uTjVVf7qbL0aeNkYkwlcAPxJRI5Zt4jcJCJrRGSNw+Hw00urXqH8IFQXd7qj9alPvqWy1sn9F/jniGHlX74EyQHA7nU/07PM20+B5QDGmC+ASOCYfxvGmOeNMRONMRPT0tI6V7HqnQ51fmj87sJK/vTFXq6aNISRA+L8XJjyB1+CZDUwQkSGiUg4Vmfq283a7APOAhCRk7CCRDc51FFdOD3n7z7cRnhoCL84Rwef9VTtBokxxgncCnwEbMX6dmaziDwiIpd4mt0F3CgiG4C/AHOMMSZQRate6PAma8b4yIQOPW3t3mI+2HSI/5p+HOlxkQEqTnWVT93nxpj3sTpRvZc96HV7CzDVv6WpPuVQXoeHxhtjzXyWHhfBjdN18FlPpiNbVeDVVULRzg4HyQebDrFu3xHuOnck0eF6muqeTINEBd7hLVin5/Q9SOqcbn774TZOGBDH9yfY23+CCioNEhV4hz2n5+zAGJI/f7mXvUVV3H/Bidh08FmPp0GiAu9QHkQkQOIQn5qXVtXz1CffMm1EKjNG6jCB3kCDRAXeoU3W+BEf51R9ZsUOSqvruX+mzsPaW2iQqMBqOD2nj7s1+4urePk/e7jy5ExGDY5v/wmqR9AgUYFVshvqK33uaF340XZCQuCuc0cGuDDlTxokKrAOeTpafRgav2H/Ed7e8B03nD6cQQn+OXmW6h4aJCqwDuWB2CCt7YPtjDEseH8rKTHh/NeM4d1UnPIXDRIVWIcbTs/Z9vD2j7cW8PXuYu48ZyRxkWHdVJzyFw0SFVg+DI2vd7n5zQdbGZ4Www8n6eCz3kiDRAVOVTGUHWi3f2TZ1/vY5ajk/pknEWbTX8neSH9qKnAaO1pb3yIpr6nniY+/ZfKwZM4+qWsnzVLBo0dCqcBpnDW+9SBZ/O+dFFXWseRCHXzWm+kWiQqcQ3kQOwBiWx7m7nYbXv1qHzPHDGRcZmI3F6f8SYNEBc6hTW3u1ux0VHCkqp4zTtRdmt5Og0QFhrMOHNvaHBq/Zm8JAJOykrurKhUgGiQqMAq3g7u+zS2S1XuKSYkJJysluhsLU4GgQaICo3HW+NaDZO3eEiYMTdJO1j5Ag0QFxqE8CI1q9fScjvJa9hZVMTErqZsLU4GgQaIC43AepJ8EIS2f6Hvt3mIAJgzV/pG+QINE+V/D6Tnb2K1Zs6eEiNAQxmTonCN9gQaJ8r+y76C6pO2O1r0lZGcmEhHa8haL6l00SJT/tTM0vrrOxeYDpUzQ/pE+Q4NE+V/jrPEtn55zQ/4RnG7DxKEaJH2FBOvMmhMnTjRr1qwJymv3dfX19eTn51NTUxOcAioLwVUH8YNbfLi8pp7SaieDEyIJ0VNN9EiRkZFkZmYSFtZ0bhgRWWuMmdi8vU8H7YnI+cCTgA34ozHmsRba/ACYDxhggzHmRx0vX/lDfn4+cXFxZGVlBWeMxuEt1kRGyS3PdLa7sJIEp5sTBsZ1c2HKF8YYioqKyM/PZ9gw306V2u6ujYjYgGeAmcAo4GoRGdWszQjgfmCqMWY0cGdHi1f+U1NTQ0pKSnBCxO0CVy2EtTznqjGGqjonMRHaydpTiQgpKSkd2qL1pY/kFGCHMWaXMaYOWAZc2qzNjcAzxpgSAGNMgc8VqIAI2mhRp+eXL7TlYe+1Tjcut9Fz+fZwHf398SVIMoD9XvfzPcu8jQRGish/RORLz66Q6o/qq6zrVuZorax1AhAT3n1bJCtWrODzzz/vttfrj/z1rU0oMAL4HnA18IKIHDPBhIjcJCJrRGSNw+Hw00urHqW+2po13hbe4sNVdS5CQ0IID+2+Lwx7UpAYY3C73cEuw+98+WkeALxn5M30LPOWD7xtjKk3xuwGvsEKliaMMc8bYyYaYyampek5Xfuk+mqrf0SEV155hXHjxpGdnc21117LO++8w0VnT2fW+dM455xzOHz4MADz58/n2muv5dRTT2XEiBG88MILABw8eJDp06eTk5PDmDFjWLVqFQCxsbHMmzeP7OxspkyZ0rgeh8PBlVdeyaRJk5g0aRL/+c9/2LNnD4sXL+YPf/gDOTk5jeto7p133mHy5MmMHz+es88+u3GdFRUVXH/99YwdO5Zx48bxt7/9DYAPP/yQk08+mezsbM4666zG97Fo0aLGdY4ZM4Y9e/awZ88eTjjhBGbPns2YMWPYv38/P/vZz5g4cSKjR4/moYceanzO6tWrOe2008jOzuaUU06hvLyc6dOnk5ub29jm9NNPZ8OGDX75cfmNMabNC9bWxi5gGBAObABGN2tzPrDUczsVa1copa31TpgwwajA2LJlS3Be2O025rtcY47sN5s2bTIjRowwDofDGGNMUVGROewoNLn7ik1BWY154YUXzNy5c40xxjz00ENm3LhxpqqqyjgcDpOZmWkOHDhgFi1aZB599FFjjDFOp9OUlZUZY4wBzNtvv22MMeaee+4xv/71r40xxlx99dVm1apVxhhj9u7da0488cTG9S9cuLDN0ouLi43b7TbGmCa13XvvveaOO+5o0q6goMBkZmaaXbt2Nb63ll5n9OjRZvfu3Wb37t1GRMwXX3zR+FjDc5xOp5kxY4bZsGGDqa2tNcOGDTNff/21McaY0tJSU19fb15++eXGGrZv326662+npd8jYI1p4e+53R4vY4xTRG4FPsL6+vclY8xmEXnEs9K3PY+dKyJbABdwjzGmyJ+Bpzrn4Xc2s+W7Mr+uc9TgeB66uIXBZs5aMG4Ii+KTT/7OrFmzSE1NBSA5OZnPv17HXXffTVlxAc76+iZfLV566aVERUURFRXFGWecwddff82kSZP4yU9+Qn19PZdddhk5OTkAhIeHc9FFFwEwYcIE/vnPfwLw8ccfs2XLlsZ1lpWVUVFR4dN7ys/P56qrruLgwYPU1dU11vbxxx+zbNmyxnZJSUm88847TJ8+vbFNcnL7Bx4OI+MDKwAAGWNJREFUHTqUKVOmNN5fvnw5zz//PE6nk4MHD7JlyxZEhEGDBjFp0iQA4uOt45BmzZrFr3/9axYuXMhLL73EnDlzfHpP3cmnHVVjzPvGmJHGmOOMMQs8yx70hAiesJprjBlljBlrjFnW9hpVn+Sstq5DW/7q9+65d/Kj628kLy+P5557rsnXi82/JRARpk+fzsqVK8nIyGDOnDm88sorAISFhTW2t9lsOJ1WB67b7ebLL78kNzeX3NxcDhw4QGxsrE+l33bbbdx6660t1uar0NDQJv0f3uuIiYlpvL17924WLVrEv/71LzZu3MiFF17Y5utFR0dzzjnn8NZbb7F8+XKuueaaDtcWaPodXB/X4pZDoNRXAwJhkZx55plcfvnlzJ07l5SUFIqLizlSWsoQeyYhIixdurTJU9966y3uv/9+KisrWbFiBY899hh79+4lMzOTG2+8kdraWtatW8fs2bNbfflzzz2Xp59+mnvuuQeA3NxccnJyiIuLo6ys7a2y0tJSMjKsLyO9azvnnHN45plneOKJJwAoKSlhypQp3HLLLezevZthw4ZRXFxMcnIyWVlZvPvuuwCsW7eO3bt3t/haZWVlxMTEkJCQwOHDh/nggw/43ve+xwknnMDBgwdZvXo1kyZNory8nKioKEJDQ7nhhhu4+OKLmTZtGklJPe/QAj3WRvlPfTWERoCEMHr0aObNm8eMGTPIzs7mF7+Yy813/pLbb5jNhAkTGnd5GowbN44zzjiDKVOm8MADDzB48GBWrFhBdnY2/7+9e4+OujwXPf59Z3KZTO7I1QAGLBe5BQoFEXdLtR7BUnBRg/cK7tbTdVCx3V3dVOxerCpr6anb7nLqQnF7WSCnVUSFswvHXWvQroLWIG6JEKmEhADmAplcZ5K5PfuPmQwJmQkTJslMkuezVlZm3vnNb54kk2d+v/f3vs87Z84cXnvtNdatW9fty2/evJni4mJmzZrFtGnTeO655wD43ve+x1tvvdVtZ+vGjRspLCzsEttjjz2Gw+FgxowZFBQUUFRUxIgRI9i6dSsrV66koKCA22+/HYDvf//71NXVMX36dH73u98xefLksK/V/jNNnTqVu+66i0WLFgGBU7bXXnuNhx56iIKCAm666abQkcrcuXPJyspizZo1Ufwh+p/OtRmEjh07xjXXdL9od5+oKoHUDMjN7/JQc6uHsnMt5F+RTlZa5/kbGzduJCMjg5/97Gf9FOjAc/bsWRYvXkxpaSkWS/98/od7H0Waa6NHJKp3+LyBYs8Rhsa3uH0A2PtxINpgsW3bNhYsWMCmTZv6LYn0lPaRqN5xiY5Wp9uHLdlKUpi1fTdu3NiHgXW2adMmdu7c2amtsLCQDRs29FsMPfWDH/yg276hRKCJRPUOTzCRhDkikeBEveyLTmniYcOGDQmdNAaqxDxOUgOPxwWWZLB2TRatwYl66TpRb9DSRKJ6R/vQ+DCcwYl6di0dMGhpIlGxE3+gfEA3Ha1JVgspYfpH1OCgf1kVO08rIN0ekaSnWHVFvUFME4mKXTdXbDw+P26fXwsZDXKaSFTsPC7AEhjVepFQIaNu+keinQ+TCN5+++1OEwNVgCYSFTuPK1ARLcypi9Ptw2IMtuTB0dGaSImkfbJiItDjzcFu3/oLC1b1ltEzYWlwIQGRQCJJu1AQb/369YwbN461a9fS0uZl6789xchsO0VFRTgcDjweD0888QQrVlxc+je8p556ildffRWLxcLSpUt58skneeGFF9i6dStut5uvfe1rbN++HbvdzurVq7HZbBQXF9PY2MgzzzzDsmXL+Pzzz1mzZg1utxu/38+uXbtITk5m6dKlXH/99Rw4cIC8vDx2795NWloaJ06cYO3atdTW1mK323nhhReoq6tjz549vP/++zzxxBPs2rWLq6++uku8kWKrrq7mxz/+MWVlZQBs2bKF6667jm3btvH0009jjGHWrFls376d1atXs2zZMm677TYgcNTW3NzM/v37+eUvf0lubi6lpaUcP36cW2+9lcrKSlpbW1m3bh0PPPAAECi+9Oijj+Lz+Rg+fDh/+tOfmDJlCgcOHGDEiBH4/X4mT57MwYMHibnQWLgiJf3xpYWN+k6ngjR7/1nkpVt692vvP1/Yv6dN5MwnIs01oaZPPvlEvvnNb4rX55fPKutl0pSpcurUKWloaBARkdraWrn66qtDhYTS09Mj/ix79+6VhQsXSktLi4hcKAh07ty50DYbNmyQzZs3i4jIfffdJzfffLP4fD45fvy45OXlicvlkgcffFBeffVVERFpa2sTp9MpJ0+eFKvVKocPHxYRkcLCQtm+fbuIiNxwww1y/PhxERH58MMP5dvf/nZo/zt37uz29x8ptlWrVslvfvMbEQkUNKqvrw9bACrc67T/joqKisRut4eKKnV8jtPplOnTp8u5c+ciFl/auHFjKIZ33nlHVq5cGfHn6NXCRmqAW9plCaLeFaajdc6cOdTU1FBWforSL08xLDeX0aNH85Of/IQPPvgAi8XCmTNnqK6uZvTo0d3u/t1332XNmjXY7YGq9O1FhEpKSnjssceor6+nubmZm2++OfScVatWYbFYmDRpEhMnTqS0tJSFCxeyadMmTp8+zcqVK5k0KVAJdMKECaGCSXPnzqW8vJzm5mYOHDhAYWFhaJ9tbW1R/0oixfbee++FaqpYrVays7PZtm1blwJQlzJ//vxORaE2b97MW2+9BUBlZSV///vfqa2tDVt86f7772fFihU88sgjvPTSS702m1gTiYpNhKHxhYWFvP7GG5w8dYbb77idHTt2UFtby6FDh0hOTiY/Pz+mlQBXr17N22+/TUFBAa+88gr79+8PPRauSNJdd93FggUL+OMf/8gtt9zC888/z8SJE0lNvdBBbLVacblc+P1+cnJyOtVJ7a3YotWxSJLf78ftdoce61gkaf/+/bz77rscPHgQu93O4sWLu/29jhs3jlGjRvHee+/xt7/9jR07dvQ4tnC0s1XFxuMEaypYOnem3n777bz5xk7+vG8Pd6xaRUNDAyNHjiQ5OZmioiIqKiqi2v1NN93Eyy+/jNMZWOairq4OgKamJsaMGYPH4+nyz7Bz5078fj8nTpygrKyMKVOmUFZWxsSJE3n44YdZsWIFn332WcTXzMrKYsKECaHJfSISKracmZlJU1NTtzFHiu3GG29ky5YtAPh8PhoaGrjhhhvYuXMn58+f7/Tz5efnc+jQIQD27NmDx+MJ+1oNDQ3k5uZit9spLS3lww8/BODaa6/lgw8+CBVXat8vwA9/+EPuueceCgsLsVp7pxNcE4mKjac17Bo206ZNo6mxiTFX5jFmzBjuvvtuiouLmTlzJtu2bWPq1KlR7X7JkiUsX76cefPmMXv27FCV9scff5wFCxawaNGiLvsaP3488+fPZ+nSpTz33HPYbDZef/11ZsyYwezZsykpKbnkbNodO3bw4osvUlBQwPTp09m9ezcAd9xxB7/+9a+ZM2cOJ06cCPvcSLH99re/paioiJkzZzJ37lyOHj3apQDUT3/6UwB+9KMf8f7771NQUMDBgwc7HYVc/Pvxer1cc801rF+/PlQXNlLxJYDly5eHquP3mnAdJ/3xpZ2tfaffqsj7vIGO1savujzkbPPKf1U6pK6lrX9iCYqmM3So+/jjj+X666+/5Hba2ar6RzelA5zu/l9RT13ak08+yZYtW3qtb6SdJhJ1+boZGt/i9pFstZAc5US9I0eOcO+993ZqS01N5aOPPupRSK+88kqPto/F2rVr+etf/9qpbd26dQlbVxUCY3zWr1/f6/vVRKIuX2h5zq41SJxtXuw9mKg3c+bMy75KEi/PPvtsvENIGNrZOkhJfxT17rA8Z0dub2CinhYyGrh6+v7RRDII2Ww2zp8/37fJRCR4xSZy/4gWMhqYRITz589js3W9GheJfmQMQmPHjuX06dPU1tb23Yv4PNBUBXYPpHQeV1Hv9OB0e0lqtGkNkgHKZrMxduzYqLfXRDIIJScndxpC3SdKdsE798P//AuM6bz2ybL/8xcyU5P5/QNf79sYVMKI6tTGGLPEGPOFMeZLY0zELl9jzPeNMWKM6bKAjhpkqkrAkgQjpnRqbm7zcvRsI/PyE29ZSdV3LplIjDFW4FlgKTANuNMYMy3MdpnAOqBn1+vUwFR1BEZM7VLM6NNT9fgF5uVfevKZGjyiOSKZD3wpImUi4gb+AIQrJPE48BRw+TOx1MBRXQKjZnRpLq6owxiYMz4nzJPUYBVNIskDKjvcPx1sCzHGfB0YJyJ/7MXYVKJqOQdNXwUKHF3kUIWDKaMyybLFfzEs1X9ivvxrjLEAzwD/FMW2Dxhjio0xxX16RUH1rfaKa6M7H5H4/MLhU/XaPzIERZNIzgDjOtwfG2xrlwnMAPYbY8qBa4E94TpcRWSriMwTkXkxl3ZT8dOeSEZ1PiIprWqkuc3LvKu0f2SoiSaRfAxMMsZMMMakAHcAe9ofFJEGERkuIvkikg98CCwXkeI+iVjFX3UJZF4J6Vd0ai4udwDoEckQdMlEIiJe4EHgHeAY8LqIfG6M+ZUxZnlfB6gSUFVJ2P6R4goHo7Ns5OWEXyhLDV5RDUgTkb3A3ova/iXCtotjD0slLG8bnPsCpizp8tCh8jrm5ufqaNYhSOfaqJ6pLQW/t8ul37P1Ls42tDLvKj2tGYo0kaieCV2xmdWpubgi2D+iHa1DkiYS1TNVJZBsh2Gd5/IcKq/DnmLlmjGZcQpMxZMmEtUzVUdg1PQuVeM/LncwZ3wOSVFWRFODi/7VVfREoPpIl/6R5jYvpVWNzNXTmiFLE4mKXkMltDZ0ufR7+JQjMFFPO1qHLE0kKnpVJYHvFyWS4nIHFp2oN6RpIlHRqy4BDIzsXEXiUIWDKaOzyNSJekOWJhIVvarPYNhESM0INXl9fj455eAbOix+SNNEoqIXZmh8aVUTTrePudo/MqRpIlHRaW0Ex8kupQOKywOLU2tFtKFNE4mKTs3RwPeLSgcUVzgYk60T9YY6TSQqOqGh8RcSiYhQXO7Q0xqliURFqeoIpOVC1pWhpjP1LqoaW/mGntYMeZpIVHSqjgSORjqUCDgUnKinRyRKE4m6NJ830Edycf9IuYP0FCtTR+tEvaFOE4m6tLoT4G3tOqK1wsGc8bk6UU9pIlFRCFM1vrHVwxdVjXpaowBNJCoa1SVgSYbhF5bnPBxcUU87WhVoIlHRCC3PmRJqOlReh8XAbJ2op9BEoqIRZmh8cYWDa8ZkkZEaVf1wNchpIlHda66F5qpO/SNen59PK+u1/ogK0USiulfdvqrehURy7KvgRD3tH1FBmkhU98IMjf84OFFPSweodppIVPeqSiArD+wXjj4OVTjIy0ljTLZO1FMBmkhUZM46qDjQ6bRGRCiuqNPxI6oTTSQqvOYaeGUZtNTCwv8Vaj7tcFHd2KYLhatOokokxpglxpgvjDFfGmPWh3n8p8aYo8aYz4wxfzbGXNX7oap+03AaXloCjnK4+3WYuDj0kE7UU+FcMpEYY6zAs8BSYBpwpzFm2kWbHQbmicgs4A3gf/d2oKqfnD8BLy2FlnNw71udkggEOlozUpOYOjorLuGpxBTNEcl84EsRKRMRN/AHYEXHDUSkSEScwbsfAmN7N0zVL2pK4eVbwN0M9+2B8Qu6bHKoIrCintViwuxADVXRJJI8oLLD/dPBtkj+EdgXS1AqDs5+Ci8vDdxesw+unN1lkwaXhy+qm3ShcNVFr45vNsbcA8wDvhXh8QeABwDGjx/fmy+tYnHqI9hxG9hy4L7dgSUnwjh8yoEI2tGquojmiOQMMK7D/bHBtk6MMd8BNgDLRaQt3I5EZKuIzBOReSNGjLiceFVvK9sP22+FjJFw/76ISQQCpzVWi2H2OJ2opzqLJpF8DEwyxkwwxqQAdwB7Om5gjJkDPE8gidT0fpiqT3yxD3asgtwJgdOZ7O67torLHVwzJpN0nainLnLJRCIiXuBB4B3gGPC6iHxujPmVMWZ5cLNfAxnATmPMp8aYPRF2pxJFyS547R4YNR1W/0fgiKQbHp+fw5UO7R9RYUX10SIie4G9F7X9S4fb3+nluFRfOvwq7HkIxi+EO/8Atktfyj16tpFWj1/7R1RYOrJ1qPnoedi9FiZ+G+5+I6okAoH6I4AekaiwNJEMJX/5V9j3c5i6DO78PaTYo37qoYo68nLSGJ1t68MA1UClvWZDgQi893ggkcxcBbduAWv0f/r2FfUWXn1FHwapBjJNJIOd3w/v/AI+eg7mrobv/gYsPTsQraxzUdPUpguFq4g0kQxmfh/8v4cDnasLH4T/8USnlfKiVVwRKGSkpRVVJJpIBiufB958AD5/E761Hhavv6wkAoGO1szUJCaP0hX1VHiaSAYjTyvsXA3H98FNj8Oih2Pa3aFyB3OuytWJeioivWoz2Lhb4P+uCiSR7/5rzEmkwenheE2TntaobukRyWDS2hAY8n76b3DrczD7zph3+YlO1FNR0ESSgPx+oanVS73LjcPpod7ppt7pwRH8Xu8Mtrs8NDjdYAyjrc08WreBPPdJXs//FRVfzSbj/N9JT00iIzWJ9NQk7KnWwO2U9jYr6alJpCZZMBH6T4or6nSinrokTSS9SQSaqwMlCh3lSF0Z3vMn8Xh9uCyZtFgyaDLp1JOBw2fnnM9OjcdGtTuNM20p1Dgt1Ld6qXe68Uvkl8myJZGbnkJOWjLZ9hSyfef5edXPGemrYn3Kev58agotX5bj9vqjCjvJYkhPTSI9JZBYLiQfK5+dbmD6lVnYU/StoiLTd0eUPD4/9U4PDU1NOGtO4jlXhnGUk9RQTlpzJZmu0wxznyWlQwUFEUMNw/CJhWzTwnjj7OYVwGOSabVm4c7JwpuShT81B9KysdqHkZSeS2rWFaRlXoHFngs2G6TlgN8Lr/0CrHVwz5s8PeEfQvtze/043V6a27y0tPmC3wNfodtuX4e24O3gc2qaWrEYw21zteCd6t6QSCQenx+Xx0erx0erO3Db5fHhcvtwebw0urwXThda2nA3nSOl6RQZzkqy284wwn2WMVLNOFPDROqwmAuHC05JpZKRlFpGcz55FvW2PFrsY2nLvArJGUdWRga59mSy01LItVm4IrmVXOMkk2ZSPI3gqofWenA5SHbVk9xa36mNhpNQ1QBtDZF/QFs2/GA3jJ3XqTklyUJKUgo59pQIT1SqdyR8Itl35CvqXZ7gP30gGbTf7nrfT2vHx4K3fX4fmbjIxEmWcXb5PsacZ7yp4RummvGWGjJxdYqhKWU4TWl5uDKu43jWVZCbT/LwidhGfY3s4VcyOTWJKZc5RiNqfl+gM9XlCCaZYLJpbYAJ34Irru7b11eqGwmfSDbtPUaNozH0T59tWhie1MYVSS5GWlrJtbrItrjINk6yaCEDJxnSgt3aQlpqM7akFlJ9LRgidzr4ran4s8djGTYZy7AlkJsPwyYEvudcRWaKnbgPxbJYA6vd2XWYuko8CZ9I9qc8QpKtousD/uCXFzAWSM0KTIm3ZUNqNtjGBW63t9myg9tc3JaNJS0XSw/nnyilLkj4RJI0/x/B5w4UJk7tkABCSSMLUjJ6PBFNKdV7Ej6RsGhdvCNQSl2CfowrpWKmiUQpFTNNJEqpmGkiUUrFTBOJUipmmkiUUjEzIt1MM+3LFzamFggz0iys4cC5Pgynr2n88aXx956rRKTLwt1xSyQ9YYwpFpF5l94yMWn88aXx9z09tVFKxUwTiVIqZgMlkWyNdwAx0vjjS+PvYwOij0QpldgGyhGJUiqBJXQiMcYsMcZ8YYz50hizPt7x9IQxZpwxpsgYc9QY87kxZkBOYzbGWI0xh40x/xHvWHrKGJNjjHnDGFNqjDlmjFkY75h6whjzk+B7p8QY83tjjC3eMUWSsInEGGMFngWWAtOAO40x0+IbVY94gX8SkWnAtcDaARZ/u3XAsXgHcZl+C/x/EZkKFDCAfg5jTB7wMDBPRGYAVuCO+EYVWcImEmA+8KWIlImIG/gDsCLOMUVNRL4SkU+Ct5sIvInz4htVzxhjxgLfBf493rH0lDEmG/gm8CKAiLhFpD6+UfVYEpBmjEkC7MDZOMcTUSInkjygssP90wywf8R2xph8YA7wUXwj6bF/A35OoKjlQDMBqAVeDp6a/bsxJj3eQUVLRM4ATwOngK+ABhH5z/hGFVkiJ5JBwRiTAewCHhGRxnjHEy1jzDKgRkQOxTuWy5QEfB3YIiJzgBZgwPSzGWNyCRyBTwCuBNKNMffEN6rIEjmRnAHGdbg/Ntg2YBhjkgkkkR0i8ma84+mhRcByY0w5gdPKG4wxr8Y3pB45DZwWkfajwDcIJJaB4jvASRGpFREP8CZwXZxjiiiRE8nHwCRjzARjTAqBjqY9cY4paiawmO6LwDEReSbe8fSUiPxCRMaKSD6B3/17IpKwn4gXE5EqoNIYMyXYdCNwNI4h9dQp4FpjjD34XrqRBO4sTtjizyLiNcY8CLxDoMf6JRH5PM5h9cQi4F7giDHm02DboyKyN44xDTUPATuCH0RlwJo4xxM1EfnIGPMG8AmBK4CHSeARrjqyVSkVs0Q+tVFKDRCaSJRSMdNEopSKmSYSpVTMNJEopWKmiUQpFTNNJEqpmGkiUUrF7L8BR6ee/JmCCZMAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 288x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.engine.training.Model at 0x7fbb268ffa90>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "2706080d-2d50-4876-bd4d-c0f3c4ce87b5",
        "_uuid": "9afcde53f3cf3ba3eeeed1f083241874b4cd84e2",
        "id": "lMRMqKA9o8yS",
        "colab_type": "text"
      },
      "source": [
        "# Show the results on the hold-out\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "56a6fe58-fe97-45c8-95da-223297842f79",
        "_uuid": "25ac7feb2d111b82e755169288ffd47ebc4d196a",
        "id": "PL8it8clo8yT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 371
        },
        "outputId": "e65e69e0-03f2-49bf-efbc-ec13927ec499"
      },
      "source": [
        "\n",
        "\n",
        "test(model=eval_model, data=(x_test, y_test), args=args)\n",
        "#test(model=model, data=(x_test[:100], y_test[:100]))"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Model was constructed with shape (500, 28, 28, 1) for input Tensor(\"input_4:0\", shape=(500, 28, 28, 1), dtype=float32), but it was called on an input with incompatible shape (100, 28, 28, 1).\n",
            "------------------------------Begin: test------------------------------\n",
            "Test acc: 0.9821\n",
            "\n",
            "Reconstructed images are saved to ./result/real_and_recon.png\n",
            "------------------------------End: test------------------------------\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xiBpPdkmY500",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# pick some collabs stuff "
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}