CapsuleNet_on_MNIST_retrain.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 learning rate.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_on_MNIST_retrain.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": "394d9f82-1dc8-4dff-fdaf-9524a64d5dea",
        "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": 1,
      "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": "1c05aa49-3c2e-44ea-9560-c35c78348e37",
        "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": 2,
      "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": 2
        }
      ]
    },
    {
      "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",
        "from google.colab import drive\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",
        "\n",
        "    # model_save_name = 'mnistconv.h5'\n",
        "\n",
        "    # !ls 'drive/My Drive/saved_models'\n",
        "    # path = F\"drive/My Drive/saved_models/{model_save_name}\" \n",
        "    # base_model = tf.keras.models.load_model(path, custom_objects={'loss': margin_loss}, compile=False)\n",
        "    # # Check its architecture\n",
        "    # base_model.compile( loss = margin_loss, optimizer = tf.keras.optimizers.Adam())\n",
        "    # base_model.trainable = False\n",
        "    # # Let's take a look at the base model architecture\n",
        "    # base_model.summary()\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",
        "#model.add(layers.Conv2D(filters=256, kernel_size=9, strides=1, padding='valid', activation='relu', name='conv1',  input_shape = input_shape))\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",
        "\n",
        "#model.get_layer('layerName').set_weights(myNpArrayWeights)\n",
        "#  conv1 = convlayer(x)\n",
        "#     tf.keras.layers.Conv2D.set_weights\n",
        "# layer.set_weights([np.random.rand(784, 64), np.random.rand(64)])\n",
        "# If you need that these weights are not trainable, before compiling the keras model you set:\n",
        "\n",
        "\n",
        "\n",
        "#conv1.s  \n",
        "\n",
        "#intermediate_base_model = Model(inputs=base_model.input,\n",
        "#                                  outputs=base_model.get_layer(layer_name).output)\n",
        "\n",
        "\n",
        "    #.Input(shape=input_shape, batch_size=batch_size);\n",
        "    primarycaps = PrimaryCap(conv1, dim_capsule=8, n_channels=32, kernel_size=9, strides=2, padding='valid')\n",
        "\n",
        "    # layer_name = 'conv1'\n",
        "    # print(\"input_shape\",input_shape)\n",
        "    # print(\"nclass\",n_class)\n",
        "    # print(\"l2\", primarycaps.shape)\n",
        "    \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",
        "    # layer = train_model.get_layer('conv1')\n",
        "    # layer.trainable=False\n",
        "    # weights = base_model.get_layer(layer_name).get_weights()\n",
        "    # layer.set_weights(weights)\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": "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, 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": "6d53edaa-f08d-4458-f565-8d4ed6a666b5",
        "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": 7,
      "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",
        "outputId": "cf11ea09-69f7-436e-e0e3-20dffbe36b10",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        }
      },
      "source": [
        "\n",
        "# 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)\n",
        "\n",
        "mnist = tf.keras.datasets.mnist\n",
        "\n",
        "(xtrain, ytrain), (xtest, ytest) = mnist.load_data()\n",
        "print('Xtrain shape: ',xtrain.shape)\n",
        "print('Xtest shape: ',np.shape(xtest ))\n",
        "print('ytrain shape: ',xtrain.shape)\n",
        "print('ytest shape: ',np.shape(ytest ))\n",
        "\n",
        "x_train = xtrain.reshape(-1, 28, 28, 1).astype('float32') / 255.\n",
        "x_test = xtest.reshape(-1, 28, 28, 1).astype('float32') / 255.\n",
        "y_train = to_categorical(ytrain.astype('float32'))\n",
        "y_test = to_categorical(ytest.astype('float32'))\n",
        "print('X_train shape: ',x_train.shape)\n",
        "print('X_test shape: ',np.shape(x_test ))\n",
        "print('y_train shape: ',y_train.shape)\n",
        "print('y_test shape: ',np.shape(y_test ))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 0s 0us/step\n",
            "Xtrain shape:  (60000, 28, 28)\n",
            "Xtest shape:  (10000, 28, 28)\n",
            "ytrain shape:  (60000, 28, 28)\n",
            "ytest shape:  (10000,)\n",
            "X_train shape:  (60000, 28, 28, 1)\n",
            "X_test shape:  (10000, 28, 28, 1)\n",
            "y_train shape:  (60000, 10)\n",
            "y_test shape:  (10000, 10)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xusqj3xnjS_L",
        "colab_type": "code",
        "outputId": "c73eeced-1802-4296-bcf1-5682ff4791bc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        }
      },
      "source": [
        "train_filter = np.where(ytrain != 0 ) \n",
        "test_filter = np.where(ytest != 0) \n",
        "\n",
        "y_train_without0 = ytrain[train_filter]\n",
        "y_test_without0 =ytest[test_filter]\n",
        "\n",
        "x_train_without0 = xtrain[train_filter].reshape(-1, 28, 28, 1).astype('float32') / 255.\n",
        "x_test_without0 = xtest[test_filter].reshape(-1, 28, 28, 1).astype('float32') / 255.\n",
        "y_train_without0 = to_categorical(y_train_without0.astype('float32'))\n",
        "y_test_without0 = to_categorical(y_test_without0.astype('float32'))\n",
        "\n",
        "print('X_train_without shape: ',x_train_without0.shape)\n",
        "print('X_test_without shape: ',np.shape(x_test_without0 ))\n",
        "print('y_train_without shape: ',y_train_without0.shape)\n",
        "print('y_test_without shape: ',np.shape(y_test_without0 ))\n",
        "\n",
        "print(y_train_without0[:5])"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train_without shape:  (54077, 28, 28, 1)\n",
            "X_test_without shape:  (9020, 28, 28, 1)\n",
            "y_train_without shape:  (54077, 10)\n",
            "y_test_without shape:  (9020, 10)\n",
            "[[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n",
            " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
            " [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l-i3c_UESE2P",
        "colab_type": "code",
        "outputId": "155a471a-68f7-438e-ce58-c43b70a61995",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 544
        }
      },
      "source": [
        " # load data\n",
        "\n",
        "print(x_train.shape)\n",
        "print(x_train.shape[1:])\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": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(60000, 28, 28, 1)\n",
            "(28, 28, 1)\n",
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_1 (InputLayer)            [(500, 28, 28, 1)]   0                                            \n",
            "__________________________________________________________________________________________________\n",
            "conv1 (Conv2D)                  (500, 20, 20, 256)   20992       input_1[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_2 (InputLayer)            [(None, 10)]         0                                            \n",
            "__________________________________________________________________________________________________\n",
            "mask (Mask)                     (500, 160)           0           digitcaps[0][0]                  \n",
            "                                                                 input_2[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "capsnet (Length)                (500, 10)            0           digitcaps[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "decoder (Sequential)            multiple             1411344     mask[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": "f0b3a717-7da2-4505-a0f9-939a2707f06c",
        "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": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8484 - capsnet_loss: 0.8094 - decoder_loss: 0.0994 - capsnet_accuracy: 0.0932\n",
            "Epoch 00001: val_capsnet_accuracy improved from -inf to 0.00000, saving model to ./result/weights-01.h5\n",
            "120/120 [==============================] - 185s 2s/step - loss: 0.8484 - capsnet_loss: 0.8094 - decoder_loss: 0.0994 - capsnet_accuracy: 0.0932 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 0.0010\n",
            "Epoch 2/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8358 - capsnet_loss: 0.8094 - decoder_loss: 0.0674 - capsnet_accuracy: 0.1053\n",
            "Epoch 00002: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 188s 2s/step - loss: 0.8358 - capsnet_loss: 0.8094 - decoder_loss: 0.0674 - capsnet_accuracy: 0.1053 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 9.0000e-04\n",
            "Epoch 3/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8358 - capsnet_loss: 0.8094 - decoder_loss: 0.0673 - capsnet_accuracy: 0.1243\n",
            "Epoch 00003: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 190s 2s/step - loss: 0.8358 - capsnet_loss: 0.8094 - decoder_loss: 0.0673 - capsnet_accuracy: 0.1243 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 8.1000e-04\n",
            "Epoch 4/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8358 - capsnet_loss: 0.8094 - decoder_loss: 0.0673 - capsnet_accuracy: 0.1255\n",
            "Epoch 00004: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 184s 2s/step - loss: 0.8358 - capsnet_loss: 0.8094 - decoder_loss: 0.0673 - capsnet_accuracy: 0.1255 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 7.2900e-04\n",
            "Epoch 5/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8583 - capsnet_loss: 0.8319 - decoder_loss: 0.0673 - capsnet_accuracy: 0.1093\n",
            "Epoch 00005: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 183s 2s/step - loss: 0.8583 - capsnet_loss: 0.8319 - decoder_loss: 0.0673 - capsnet_accuracy: 0.1093 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 6.5610e-04\n",
            "Epoch 6/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.3371 - capsnet_loss: 0.3147 - decoder_loss: 0.0573 - capsnet_accuracy: 0.6395\n",
            "Epoch 00006: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 183s 2s/step - loss: 0.3371 - capsnet_loss: 0.3147 - decoder_loss: 0.0573 - capsnet_accuracy: 0.6395 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 5.9049e-04\n",
            "Epoch 7/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.1022 - capsnet_loss: 0.0819 - decoder_loss: 0.0517 - capsnet_accuracy: 0.9463\n",
            "Epoch 00007: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 185s 2s/step - loss: 0.1022 - capsnet_loss: 0.0819 - decoder_loss: 0.0517 - capsnet_accuracy: 0.9463 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 5.3144e-04\n",
            "Epoch 8/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0753 - capsnet_loss: 0.0557 - decoder_loss: 0.0500 - capsnet_accuracy: 0.9635\n",
            "Epoch 00008: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 185s 2s/step - loss: 0.0753 - capsnet_loss: 0.0557 - decoder_loss: 0.0500 - capsnet_accuracy: 0.9635 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 4.7830e-04\n",
            "Epoch 9/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0642 - capsnet_loss: 0.0456 - decoder_loss: 0.0475 - capsnet_accuracy: 0.9698\n",
            "Epoch 00009: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 182s 2s/step - loss: 0.0642 - capsnet_loss: 0.0456 - decoder_loss: 0.0475 - capsnet_accuracy: 0.9698 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 4.3047e-04\n",
            "Epoch 10/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0576 - capsnet_loss: 0.0397 - decoder_loss: 0.0456 - capsnet_accuracy: 0.9733\n",
            "Epoch 00010: val_capsnet_accuracy did not improve from 0.00000\n",
            "120/120 [==============================] - 180s 2s/step - loss: 0.0576 - capsnet_loss: 0.0397 - decoder_loss: 0.0456 - capsnet_accuracy: 0.9733 - val_loss: 0.0000e+00 - val_capsnet_loss: 0.0000e+00 - val_decoder_loss: 0.0000e+00 - val_capsnet_accuracy: 0.0000e+00 - lr: 3.8742e-04\n",
            "Trained model saved to './result/trained_model.h5'\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\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 0x7fc040514da0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "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": "649a658c-3083-4253-af9a-9ad0a331b9f5"
      },
      "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": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Model was constructed with shape (500, 28, 28, 1) for input Tensor(\"input_1: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.9782\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": []
    }
  ]
}