CapsuleNet_on_MNIST_with_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 with retrain.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_with_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": "0fc3e6d1-4309-4890-f8dd-b0cdd8ece492",
        "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": 0,
      "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": "7492a525-2db5-4dba-d8b4-86f55a731787",
        "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": 0,
      "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",
        "\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": "c63c7d7b-af7d-44df-8fa1-bf54d3003023",
        "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.005, type=float,\n",
        "                        help=\"Initial learning rate\")\n",
        "parser.add_argument('--lr_decay', default=0.85, 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": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Namespace(batch_size=500, debug=False, digit=5, epochs=10, lam_recon=0.392, lr=0.005, lr_decay=0.85, 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": "0ef5d859-de7f-46ac-c2d6-27e3ef853670",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 544
        }
      },
      "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": 0,
      "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",
            "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": "8c4014f5-4c15-4218-a668-f9d378286f7a",
        "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": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8386 - capsnet_loss: 0.8094 - decoder_loss: 0.0744 - capsnet_accuracy: 0.0741\n",
            "Epoch 00001: val_capsnet_accuracy improved from -inf to 0.08110, saving model to ./result/weights-01.h5\n",
            "120/120 [==============================] - 217s 2s/step - loss: 0.8386 - capsnet_loss: 0.8094 - decoder_loss: 0.0744 - capsnet_accuracy: 0.0741 - val_loss: 0.8370 - val_capsnet_loss: 0.8094 - val_decoder_loss: 0.0704 - val_capsnet_accuracy: 0.0811 - lr: 0.0050\n",
            "Epoch 2/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.8341 - capsnet_loss: 0.8094 - decoder_loss: 0.0629 - capsnet_accuracy: 0.0847\n",
            "Epoch 00002: val_capsnet_accuracy improved from 0.08110 to 0.09220, saving model to ./result/weights-02.h5\n",
            "120/120 [==============================] - 218s 2s/step - loss: 0.8341 - capsnet_loss: 0.8094 - decoder_loss: 0.0629 - capsnet_accuracy: 0.0847 - val_loss: 0.8365 - val_capsnet_loss: 0.8094 - val_decoder_loss: 0.0689 - val_capsnet_accuracy: 0.0922 - lr: 0.0043\n",
            "Epoch 3/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 1.5372 - capsnet_loss: 1.5133 - decoder_loss: 0.0611 - capsnet_accuracy: 0.0992\n",
            "Epoch 00003: val_capsnet_accuracy improved from 0.09220 to 0.09800, saving model to ./result/weights-03.h5\n",
            "120/120 [==============================] - 218s 2s/step - loss: 1.5372 - capsnet_loss: 1.5133 - decoder_loss: 0.0611 - capsnet_accuracy: 0.0992 - val_loss: 2.4445 - val_capsnet_loss: 2.4206 - val_decoder_loss: 0.0609 - val_capsnet_accuracy: 0.0980 - lr: 0.0036\n",
            "Epoch 4/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 2.0259 - capsnet_loss: 2.0034 - decoder_loss: 0.0575 - capsnet_accuracy: 0.0987\n",
            "Epoch 00004: val_capsnet_accuracy did not improve from 0.09800\n",
            "120/120 [==============================] - 218s 2s/step - loss: 2.0259 - capsnet_loss: 2.0034 - decoder_loss: 0.0575 - capsnet_accuracy: 0.0987 - val_loss: 1.4378 - val_capsnet_loss: 1.4144 - val_decoder_loss: 0.0597 - val_capsnet_accuracy: 0.0980 - lr: 0.0031\n",
            "Epoch 5/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.7962 - capsnet_loss: 0.7744 - decoder_loss: 0.0556 - capsnet_accuracy: 0.0987\n",
            "Epoch 00005: val_capsnet_accuracy did not improve from 0.09800\n",
            "120/120 [==============================] - 217s 2s/step - loss: 0.7962 - capsnet_loss: 0.7744 - decoder_loss: 0.0556 - capsnet_accuracy: 0.0987 - val_loss: 0.5451 - val_capsnet_loss: 0.5232 - val_decoder_loss: 0.0557 - val_capsnet_accuracy: 0.0980 - lr: 0.0026\n",
            "Epoch 6/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.5396 - capsnet_loss: 0.5191 - decoder_loss: 0.0522 - capsnet_accuracy: 0.0987\n",
            "Epoch 00006: val_capsnet_accuracy did not improve from 0.09800\n",
            "120/120 [==============================] - 217s 2s/step - loss: 0.5396 - capsnet_loss: 0.5191 - decoder_loss: 0.0522 - capsnet_accuracy: 0.0987 - val_loss: 0.4722 - val_capsnet_loss: 0.4513 - val_decoder_loss: 0.0534 - val_capsnet_accuracy: 0.0980 - lr: 0.0022\n",
            "Epoch 7/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.2351 - capsnet_loss: 0.2157 - decoder_loss: 0.0493 - capsnet_accuracy: 0.6866\n",
            "Epoch 00007: val_capsnet_accuracy improved from 0.09800 to 0.95960, saving model to ./result/weights-07.h5\n",
            "120/120 [==============================] - 218s 2s/step - loss: 0.2351 - capsnet_loss: 0.2157 - decoder_loss: 0.0493 - capsnet_accuracy: 0.6866 - val_loss: 0.0882 - val_capsnet_loss: 0.0679 - val_decoder_loss: 0.0517 - val_capsnet_accuracy: 0.9596 - lr: 0.0019\n",
            "Epoch 8/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0998 - capsnet_loss: 0.0821 - decoder_loss: 0.0451 - capsnet_accuracy: 0.9399\n",
            "Epoch 00008: val_capsnet_accuracy improved from 0.95960 to 0.96920, saving model to ./result/weights-08.h5\n",
            "120/120 [==============================] - 219s 2s/step - loss: 0.0998 - capsnet_loss: 0.0821 - decoder_loss: 0.0451 - capsnet_accuracy: 0.9399 - val_loss: 0.0694 - val_capsnet_loss: 0.0503 - val_decoder_loss: 0.0486 - val_capsnet_accuracy: 0.9692 - lr: 0.0016\n",
            "Epoch 9/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0795 - capsnet_loss: 0.0631 - decoder_loss: 0.0419 - capsnet_accuracy: 0.9543\n",
            "Epoch 00009: val_capsnet_accuracy improved from 0.96920 to 0.97740, saving model to ./result/weights-09.h5\n",
            "120/120 [==============================] - 217s 2s/step - loss: 0.0795 - capsnet_loss: 0.0631 - decoder_loss: 0.0419 - capsnet_accuracy: 0.9543 - val_loss: 0.0577 - val_capsnet_loss: 0.0392 - val_decoder_loss: 0.0470 - val_capsnet_accuracy: 0.9774 - lr: 0.0014\n",
            "Epoch 10/10\n",
            "120/120 [==============================] - ETA: 0s - loss: 0.0685 - capsnet_loss: 0.0529 - decoder_loss: 0.0397 - capsnet_accuracy: 0.9632\n",
            "Epoch 00010: val_capsnet_accuracy did not improve from 0.97740\n",
            "120/120 [==============================] - 219s 2s/step - loss: 0.0685 - capsnet_loss: 0.0529 - decoder_loss: 0.0397 - capsnet_accuracy: 0.9632 - val_loss: 0.0571 - val_capsnet_loss: 0.0392 - val_decoder_loss: 0.0456 - val_capsnet_accuracy: 0.9770 - lr: 0.0012\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 0x7f52302b9470>"
            ]
          },
          "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",
        "outputId": "7c2269e0-218b-4e74-d882-f1feee4ef380",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 371
        }
      },
      "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": 0,
      "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.977\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": []
    }
  ]
}