Capsule_Network_static_routing.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fQdi03dYk89X",
        "outputId": "f20ff3cb-0616-4558-fbb5-e28fd7d1cf95"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7fd7367164b0>"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# import resources\n",
        "import numpy as np\n",
        "import torch\n",
        "import time\n",
        "\n",
        "# random seed (for reproducibility)\n",
        "seed = 1\n",
        "# set random seed for numpy\n",
        "np.random.seed(seed)\n",
        "# set random seed for pytorch\n",
        "torch.manual_seed(seed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "collapsed": true,
        "id": "9kqAx4Psk89b"
      },
      "outputs": [],
      "source": [
        "from torchvision import datasets\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# number of subprocesses to use for data loading\n",
        "num_workers = 0\n",
        "# how many samples per batch to load\n",
        "batch_size = 20\n",
        "\n",
        "# convert data to Tensors\n",
        "transform = transforms.ToTensor()\n",
        "\n",
        "# choose the training and test datasets\n",
        "train_data = datasets.MNIST(root='data', train=True,\n",
        "                            download=True, transform=transform)\n",
        "\n",
        "test_data = datasets.MNIST(root='data', train=False, \n",
        "                           download=True, transform=transform)\n",
        "\n",
        "# prepare data loaders\n",
        "train_loader = torch.utils.data.DataLoader(train_data, \n",
        "                                           batch_size=batch_size, \n",
        "                                           num_workers=num_workers)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(test_data, \n",
        "                                          batch_size=batch_size, \n",
        "                                          num_workers=num_workers)\n",
        "\n",
        "\n",
        "primary_caps_total_time = 0\n",
        "digit_caps_total_time = 0\n",
        "dynamic_routing_total_time = 0\n",
        "decoder_total_time = 0\n",
        "total_capsule_net_time = 0\n",
        "capsule_loss_total_time = 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "id": "GyvnrTM_k89c",
        "outputId": "5564a88d-118b-4f5a-87f0-6ac2a81d706c"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1800x288 with 20 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "    \n",
        "# obtain one batch of training images\n",
        "dataiter = iter(train_loader)\n",
        "images, labels = dataiter.next()\n",
        "images = images.numpy()\n",
        "\n",
        "# plot the images in the batch, along with the corresponding labels\n",
        "fig = plt.figure(figsize=(25, 4))\n",
        "for idx in np.arange(batch_size):\n",
        "    ax = fig.add_subplot(2, batch_size/2, idx+1, xticks=[], yticks=[])\n",
        "    ax.imshow(np.squeeze(images[idx]), cmap='gray')\n",
        "    # print out the correct label for each image\n",
        "    # .item() gets the value contained in a Tensor\n",
        "    ax.set_title(str(labels[idx].item()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "collapsed": true,
        "id": "FaUXPoBzk89d"
      },
      "outputs": [],
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "collapsed": true,
        "id": "0sSFuKzek89d"
      },
      "outputs": [],
      "source": [
        "class ConvLayer(nn.Module):\n",
        "    \n",
        "    def __init__(self, in_channels=1, out_channels=256):\n",
        "        '''Constructs the ConvLayer with a specified input and output size.\n",
        "           param in_channels: input depth of an image, default value = 1\n",
        "           param out_channels: output depth of the convolutional layer, default value = 256\n",
        "           '''\n",
        "        super(ConvLayer, self).__init__()\n",
        "\n",
        "        # defining a convolutional layer of the specified size\n",
        "        self.conv = nn.Conv2d(in_channels, out_channels, \n",
        "                              kernel_size=9, stride=1, padding=0)\n",
        "\n",
        "    def forward(self, x):\n",
        "        '''Defines the feedforward behavior.\n",
        "           param x: the input to the layer; an input image\n",
        "           return: a relu-activated, convolutional layer\n",
        "           '''\n",
        "        # applying a ReLu activation to the outputs of the conv layer\n",
        "        features = F.relu(self.conv(x)) # will have dimensions (batch_size, 20, 20, 256)\n",
        "        return features\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "collapsed": true,
        "id": "Bkf-fUMgk89e"
      },
      "outputs": [],
      "source": [
        "class PrimaryCaps(nn.Module):\n",
        "    \n",
        "    def __init__(self, num_capsules=8, in_channels=256, out_channels=32):\n",
        "        '''Constructs a list of convolutional layers to be used in \n",
        "           creating capsule output vectors.\n",
        "           param num_capsules: number of capsules to create\n",
        "           param in_channels: input depth of features, default value = 256\n",
        "           param out_channels: output depth of the convolutional layers, default value = 32\n",
        "           '''\n",
        "        super(PrimaryCaps, self).__init__()\n",
        "\n",
        "        # creating a list of convolutional layers for each capsule I want to create\n",
        "        # all capsules have a conv layer with the same parameters\n",
        "        self.capsules = nn.ModuleList([\n",
        "            nn.Conv2d(in_channels=in_channels, out_channels=out_channels, \n",
        "                      kernel_size=9, stride=2, padding=0)\n",
        "            for _ in range(num_capsules)])\n",
        "    \n",
        "    def forward(self, x):\n",
        "        global primary_caps_total_time\n",
        "        '''Defines the feedforward behavior.\n",
        "           param x: the input; features from a convolutional layer\n",
        "           return: a set of normalized, capsule output vectors\n",
        "           '''\n",
        "        s = time.time()\n",
        "        # get batch size of inputs\n",
        "        batch_size = x.size(0)\n",
        "        # reshape convolutional layer outputs to be (batch_size, vector_dim=1152, 1)\n",
        "        u = [capsule(x).view(batch_size, 32 * 6 * 6, 1) for capsule in self.capsules]\n",
        "        # stack up output vectors, u, one for each capsule\n",
        "        u = torch.cat(u, dim=-1)\n",
        "        # squashing the stack of vectors\n",
        "        u_squash = self.squash(u)\n",
        "        primary_caps_total_time += time.time() - s\n",
        "        # print(\"primary caps forward time\", time.time() - s)\n",
        "        return u_squash\n",
        "    \n",
        "    def squash(self, input_tensor):\n",
        "        '''Squashes an input Tensor so it has a magnitude between 0-1.\n",
        "           param input_tensor: a stack of capsule inputs, s_j\n",
        "           return: a stack of normalized, capsule output vectors, v_j\n",
        "           '''\n",
        "        squared_norm = (input_tensor ** 2).sum(dim=-1, keepdim=True)\n",
        "        scale = squared_norm / (1 + squared_norm) # normalization coeff\n",
        "        output_tensor = scale * input_tensor / torch.sqrt(squared_norm)    \n",
        "        return output_tensor\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "collapsed": true,
        "id": "b7hGMV-Wk89f"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn.functional as F\n",
        "\n",
        "def softmax(input_tensor, dim=1):\n",
        "    # transpose input\n",
        "    transposed_input = input_tensor.transpose(dim, len(input_tensor.size()) - 1)\n",
        "    # calculate softmax\n",
        "    softmaxed_output = F.softmax(transposed_input.contiguous().view(-1, transposed_input.size(-1)), dim=-1)\n",
        "    # un-transpose result\n",
        "    return softmaxed_output.view(*transposed_input.size()).transpose(dim, len(input_tensor.size()) - 1)\n",
        "\n",
        "# dynamic routing\n",
        "def dynamic_routing(u_hat, squash):\n",
        "    '''Performs dynamic routing between two capsule layers.\n",
        "       param b_ij: initial log probabilities that capsule i should be coupled to capsule j\n",
        "       param u_hat: input, weighted capsule vectors, W u\n",
        "       param squash: given, normalizing squash function\n",
        "       param routing_iterations: number of times to update coupling coefficients\n",
        "       return: v_j, output capsule vectors\n",
        "       '''  \n",
        "    global dynamic_routing_total_time\n",
        "    s = time.time()  \n",
        "    # update b_ij, c_ij for number of routing iterations\n",
        "    # for iteration in range(routing_iterations):\n",
        "        \n",
        "        # # dropout: drop the capsule from c_ij, b_ij, and u_hat if its c_ij is less than 0.1\n",
        "        # b_ij = b_ij.clone()\n",
        "        # b_ij[b_ij < 0.1] = 0\n",
        "\n",
        "\n",
        "    # softmax calculation of coupling coefficients, c_ij\n",
        "    # c_ij = helpers.softmax(b_ij, dim=2)\n",
        "\n",
        "    # calculating total capsule inputs, s_j = sum(c_ij*u_hat)\n",
        "    # s_j = (c_ij * u_hat).sum(dim=2, keepdim=True)\n",
        "    s_j = u_hat.sum(dim=2, keepdim=True)\n",
        "\n",
        "    # squashing to get a normalized vector output, v_j\n",
        "    v_j = squash(s_j)\n",
        "\n",
        "    # if not on the last iteration, calculate agreement and new b_ij\n",
        "    # agreement\n",
        "    a_ij = (u_hat * v_j).sum(dim=-1, keepdim=True)\n",
        "    \n",
        "    c_ij = softmax(a_ij, dim=2)\n",
        "\n",
        "    s_j = (c_ij * u_hat).sum(dim=2, keepdim=True)\n",
        "\n",
        "    v_j = squash(s_j)\n",
        "\n",
        "\n",
        "    dynamic_routing_total_time += time.time() - s\n",
        "    # print('dynamic routing time:', time.time() - s, 'seconds', \"| time per iteration:\", (time.time() - s)/routing_iterations)\n",
        "    \n",
        "    return v_j # return latest v_j\n",
        "    \n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m73oXK3Tk89g",
        "outputId": "c6cc3555-775e-40e3-a99a-7bf34283fdb9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training on GPU!\n"
          ]
        }
      ],
      "source": [
        "# it will also be relevant, in this model, to see if I can train on gpu\n",
        "TRAIN_ON_GPU = torch.cuda.is_available()\n",
        "\n",
        "if(TRAIN_ON_GPU):\n",
        "    print('Training on GPU!')\n",
        "else:\n",
        "    print('Only CPU available')\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "collapsed": true,
        "id": "z_f7b9u8k89g"
      },
      "outputs": [],
      "source": [
        "class DigitCaps(nn.Module):\n",
        "    \n",
        "    def __init__(self, num_capsules=10, previous_layer_nodes=32*6*6, \n",
        "                 in_channels=8, out_channels=16):\n",
        "        '''Constructs an initial weight matrix, W, and sets class variables.\n",
        "           param num_capsules: number of capsules to create\n",
        "           param previous_layer_nodes: dimension of input capsule vector, default value = 1152\n",
        "           param in_channels: number of capsules in previous layer, default value = 8\n",
        "           param out_channels: dimensions of output capsule vector, default value = 16\n",
        "           '''\n",
        "        super(DigitCaps, self).__init__()\n",
        "\n",
        "        # setting class variables\n",
        "        self.num_capsules = num_capsules\n",
        "        self.previous_layer_nodes = previous_layer_nodes # vector input (dim=1152)\n",
        "        self.in_channels = in_channels # previous layer's number of capsules\n",
        "\n",
        "        # starting out with a randomly initialized weight matrix, W\n",
        "        # these will be the weights connecting the PrimaryCaps and DigitCaps layers\n",
        "        self.W = nn.Parameter(torch.randn(num_capsules, previous_layer_nodes, \n",
        "                                          in_channels, out_channels))\n",
        "\n",
        "    def forward(self, u):\n",
        "        '''Defines the feedforward behavior.\n",
        "           param u: the input; vectors from the previous PrimaryCaps layer\n",
        "           return: a set of normalized, capsule output vectors\n",
        "           '''\n",
        "        global digit_caps_total_time\n",
        "\n",
        "        s = time.time()\n",
        "        \n",
        "        # adding batch_size dims and stacking all u vectors\n",
        "        u = u[None, :, :, None, :]\n",
        "        # 4D weight matrix\n",
        "        W = self.W[:, None, :, :, :]\n",
        "        \n",
        "        # calculating u_hat = W*u\n",
        "        u_hat = torch.matmul(u, W)\n",
        "\n",
        "        # update coupling coefficients and calculate v_j\n",
        "        v_j = dynamic_routing(u_hat, self.squash)\n",
        "        digit_caps_total_time += time.time() - s\n",
        "        # print('DigitCaps (dynamic routing included) forward time: ', time.time() - s)\n",
        "\n",
        "        return v_j # return final vector outputs\n",
        "    \n",
        "    \n",
        "    \n",
        "    def squash(self, input_tensor):\n",
        "        '''Squashes an input Tensor so it has a magnitude between 0-1.\n",
        "           param input_tensor: a stack of capsule inputs, s_j\n",
        "           return: a stack of normalized, capsule output vectors, v_j\n",
        "           '''\n",
        "        # same squash function as before\n",
        "        squared_norm = (input_tensor ** 2).sum(dim=-1, keepdim=True)\n",
        "        scale = squared_norm / (1 + squared_norm) # normalization coeff\n",
        "        output_tensor = scale * input_tensor / torch.sqrt(squared_norm)    \n",
        "        return output_tensor\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "collapsed": true,
        "id": "BCl1iIXkk89h"
      },
      "outputs": [],
      "source": [
        "class Decoder(nn.Module):\n",
        "    \n",
        "    def __init__(self, input_vector_length=16, input_capsules=10, hidden_dim=512):\n",
        "        '''Constructs an series of linear layers + activations.\n",
        "           param input_vector_length: dimension of input capsule vector, default value = 16\n",
        "           param input_capsules: number of capsules in previous layer, default value = 10\n",
        "           param hidden_dim: dimensions of hidden layers, default value = 512\n",
        "           '''\n",
        "        super(Decoder, self).__init__()\n",
        "        \n",
        "        # calculate input_dim\n",
        "        input_dim = input_vector_length * input_capsules\n",
        "        \n",
        "        # define linear layers + activations\n",
        "        self.linear_layers = nn.Sequential(\n",
        "            nn.Linear(input_dim, hidden_dim), # first hidden layer\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Linear(hidden_dim, hidden_dim*2), # second, twice as deep\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Linear(hidden_dim*2, 28*28), # can be reshaped into 28*28 image\n",
        "            nn.Sigmoid() # sigmoid activation to get output pixel values in a range from 0-1\n",
        "            )\n",
        "        \n",
        "    def forward(self, x):\n",
        "        '''Defines the feedforward behavior.\n",
        "           param x: the input; vectors from the previous DigitCaps layer\n",
        "           return: two things, reconstructed images and the class scores, y\n",
        "           '''\n",
        "        global decoder_total_time\n",
        "        s = time.time()\n",
        "        classes = (x ** 2).sum(dim=-1) ** 0.5\n",
        "        classes = F.softmax(classes, dim=-1)\n",
        "        \n",
        "        # find the capsule with the maximum vector length\n",
        "        # here, vector length indicates the probability of a class' existence\n",
        "        _, max_length_indices = classes.max(dim=1)\n",
        "        \n",
        "        # create a sparse class matrix\n",
        "        sparse_matrix = torch.eye(10) # 10 is the number of classes\n",
        "        if TRAIN_ON_GPU:\n",
        "            sparse_matrix = sparse_matrix.cuda()\n",
        "        # get the class scores from the \"correct\" capsule\n",
        "        y = sparse_matrix.index_select(dim=0, index=max_length_indices.data)\n",
        "        \n",
        "        # create reconstructed pixels\n",
        "        x = x * y[:, :, None]\n",
        "        # flatten image into a vector shape (batch_size, vector_dim)\n",
        "        flattened_x = x.contiguous().view(x.size(0), -1)\n",
        "        # create reconstructed image vectors\n",
        "        reconstructions = self.linear_layers(flattened_x)\n",
        "        decoder_total_time += time.time() - s\n",
        "        # print('Decoder forward time: {}'.format(time.time() - s), 'seconds')\n",
        "        \n",
        "        # return reconstructions and the class scores, y\n",
        "        return reconstructions, y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "collapsed": true,
        "id": "1S6MrHq2k89h"
      },
      "outputs": [],
      "source": [
        "class CapsuleNetwork(nn.Module):\n",
        "    \n",
        "    def __init__(self):\n",
        "        '''Constructs a complete Capsule Network.'''\n",
        "        super(CapsuleNetwork, self).__init__()\n",
        "        self.conv_layer = ConvLayer()\n",
        "        self.primary_capsules = PrimaryCaps()\n",
        "        self.digit_capsules = DigitCaps()\n",
        "        self.decoder = Decoder()\n",
        "                \n",
        "    def forward(self, images):\n",
        "        global total_capsule_net_time\n",
        "        '''Defines the feedforward behavior.\n",
        "           param images: the original MNIST image input data\n",
        "           return: output of DigitCaps layer, reconstructed images, class scores\n",
        "           '''\n",
        "        s = time.time()\n",
        "        primary_caps_output = self.primary_capsules(self.conv_layer(images))\n",
        "        caps_output = self.digit_capsules(primary_caps_output).squeeze().transpose(0,1)\n",
        "        reconstructions, y = self.decoder(caps_output)\n",
        "        total_capsule_net_time += time.time() - s\n",
        "        # print(\"Time to run entire Capsule Network:\", time.time() - s, \"seconds\")\n",
        "        return caps_output, reconstructions, y\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b2z9O4X1k89i",
        "outputId": "132aa94d-c55b-4e3e-8bfe-d69fa1a37ba9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "CapsuleNetwork(\n",
            "  (conv_layer): ConvLayer(\n",
            "    (conv): Conv2d(1, 256, kernel_size=(9, 9), stride=(1, 1))\n",
            "  )\n",
            "  (primary_capsules): PrimaryCaps(\n",
            "    (capsules): ModuleList(\n",
            "      (0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "      (1): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "      (2): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "      (3): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "      (4): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "      (5): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "      (6): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "      (7): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2))\n",
            "    )\n",
            "  )\n",
            "  (digit_capsules): DigitCaps()\n",
            "  (decoder): Decoder(\n",
            "    (linear_layers): Sequential(\n",
            "      (0): Linear(in_features=160, out_features=512, bias=True)\n",
            "      (1): ReLU(inplace=True)\n",
            "      (2): Linear(in_features=512, out_features=1024, bias=True)\n",
            "      (3): ReLU(inplace=True)\n",
            "      (4): Linear(in_features=1024, out_features=784, bias=True)\n",
            "      (5): Sigmoid()\n",
            "    )\n",
            "  )\n",
            ")\n"
          ]
        }
      ],
      "source": [
        "# instantiate and print net\n",
        "capsule_net = CapsuleNetwork()\n",
        "\n",
        "print(capsule_net)\n",
        "\n",
        "# move model to GPU, if available \n",
        "if TRAIN_ON_GPU:\n",
        "    capsule_net = capsule_net.cuda()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "collapsed": true,
        "id": "MRghx8Ark89i"
      },
      "outputs": [],
      "source": [
        "class CapsuleLoss(nn.Module):\n",
        "    \n",
        "    def __init__(self):\n",
        "        '''Constructs a CapsuleLoss module.'''\n",
        "        super(CapsuleLoss, self).__init__()\n",
        "        self.reconstruction_loss = nn.MSELoss(reduction='sum') # cumulative loss, equiv to size_average=False\n",
        "\n",
        "    def forward(self, x, labels, images, reconstructions):\n",
        "        global capsule_loss_total_time\n",
        "        s = time.time()\n",
        "        '''Defines how the loss compares inputs.\n",
        "           param x: digit capsule outputs\n",
        "           param labels: \n",
        "           param images: the original MNIST image input data\n",
        "           param reconstructions: reconstructed MNIST image data\n",
        "           return: weighted margin and reconstruction loss, averaged over a batch\n",
        "           '''\n",
        "        batch_size = x.size(0)\n",
        "\n",
        "        ##  calculate the margin loss   ##\n",
        "        \n",
        "        # get magnitude of digit capsule vectors, v_c\n",
        "        v_c = torch.sqrt((x**2).sum(dim=2, keepdim=True))\n",
        "\n",
        "        # calculate \"correct\" and incorrect loss\n",
        "        left = F.relu(0.9 - v_c).view(batch_size, -1)\n",
        "        right = F.relu(v_c - 0.1).view(batch_size, -1)\n",
        "        \n",
        "        # sum the losses, with a lambda = 0.5\n",
        "        margin_loss = labels * left + 0.5 * (1. - labels) * right\n",
        "        margin_loss = margin_loss.sum()\n",
        "\n",
        "        ##  calculate the reconstruction loss   ##\n",
        "        images = images.view(reconstructions.size()[0], -1)\n",
        "        reconstruction_loss = self.reconstruction_loss(reconstructions, images)\n",
        "\n",
        "        # return a weighted, summed loss, averaged over a batch size\n",
        "        ret = (margin_loss + 0.0005 * reconstruction_loss) / images.size(0)\n",
        "        capsule_loss_total_time += time.time() - s\n",
        "        # print(\"capsule loss iteration elapsed time:\", time.time() - s, \"seconds\")\n",
        "        return ret\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "collapsed": true,
        "id": "ywF4ki5Mk89j"
      },
      "outputs": [],
      "source": [
        "import torch.optim as optim\n",
        "\n",
        "# custom loss\n",
        "criterion = CapsuleLoss()\n",
        "\n",
        "# Adam optimizer with default params\n",
        "optimizer = optim.Adam(capsule_net.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "collapsed": true,
        "id": "rGspLYcNk89j"
      },
      "outputs": [],
      "source": [
        "def train(capsule_net, criterion, optimizer, \n",
        "          n_epochs, print_every=100):\n",
        "    '''Trains a capsule network and prints out training batch loss statistics.\n",
        "       Saves model parameters if *validation* loss has decreased.\n",
        "       param capsule_net: trained capsule network\n",
        "       param criterion: capsule loss function\n",
        "       param optimizer: optimizer for updating network weights\n",
        "       param n_epochs: number of epochs to train for\n",
        "       param print_every: batches to print and save training loss, default = 100\n",
        "       return: list of recorded training losses\n",
        "       '''\n",
        "\n",
        "    # track training loss over time\n",
        "    losses = []\n",
        "\n",
        "    # one epoch = one pass over all training data \n",
        "    for epoch in range(1, n_epochs+1):\n",
        "\n",
        "        # initialize training loss\n",
        "        train_loss = 0.0\n",
        "        \n",
        "        capsule_net.train() # set to train mode\n",
        "    \n",
        "        # get batches of training image data and targets\n",
        "        for batch_i, (images, target) in enumerate(train_loader):\n",
        "            # reshape and get target class\n",
        "            target = torch.eye(10).index_select(dim=0, index=target)\n",
        "\n",
        "            if TRAIN_ON_GPU:\n",
        "                images, target = images.cuda(), target.cuda()\n",
        "\n",
        "            # zero out gradients\n",
        "            optimizer.zero_grad()\n",
        "            # get model outputs\n",
        "            caps_output, reconstructions, y = capsule_net(images)\n",
        "            # calculate loss\n",
        "            loss = criterion(caps_output, target, images, reconstructions)\n",
        "            # perform backpropagation and optimization\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            train_loss += loss.item() # accumulated training loss\n",
        "            \n",
        "            # print and record training stats\n",
        "            if batch_i != 0 and batch_i % print_every == 0:\n",
        "                avg_train_loss = train_loss/print_every\n",
        "                losses.append(avg_train_loss)\n",
        "                print('Epoch: {} \\tTraining Loss: {:.8f}'.format(epoch, avg_train_loss))\n",
        "                train_loss = 0 # reset accumulated training loss\n",
        "        \n",
        "    return losses\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nsedhLIok89k",
        "outputId": "84b28887-d114-4b98-c2d5-7d6f689d1612"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 1 \tTraining Loss: 0.67663919\n",
            "Epoch: 1 \tTraining Loss: 0.13333731\n",
            "Epoch: 1 \tTraining Loss: 0.10524917\n",
            "Epoch: 1 \tTraining Loss: 0.09905915\n",
            "Epoch: 1 \tTraining Loss: 0.10191523\n",
            "Epoch: 1 \tTraining Loss: 0.08639419\n",
            "Epoch: 1 \tTraining Loss: 0.07672673\n",
            "Epoch: 1 \tTraining Loss: 0.07116133\n",
            "Epoch: 1 \tTraining Loss: 0.07040496\n",
            "Epoch: 1 \tTraining Loss: 0.06500148\n",
            "Epoch: 1 \tTraining Loss: 0.06430011\n",
            "Epoch: 1 \tTraining Loss: 0.06562293\n",
            "Epoch: 1 \tTraining Loss: 0.06297166\n",
            "Epoch: 1 \tTraining Loss: 0.06504481\n",
            "Epoch: 1 \tTraining Loss: 0.06460009\n",
            "Epoch: 1 \tTraining Loss: 0.06801058\n",
            "Epoch: 1 \tTraining Loss: 0.05863169\n",
            "Epoch: 1 \tTraining Loss: 0.05495624\n",
            "Epoch: 1 \tTraining Loss: 0.06164788\n",
            "Epoch: 1 \tTraining Loss: 0.05914574\n",
            "Epoch: 1 \tTraining Loss: 0.05902519\n",
            "Epoch: 1 \tTraining Loss: 0.05594128\n",
            "Epoch: 1 \tTraining Loss: 0.05359316\n",
            "Epoch: 1 \tTraining Loss: 0.06855385\n",
            "Epoch: 1 \tTraining Loss: 0.05963943\n",
            "Epoch: 1 \tTraining Loss: 0.05522475\n",
            "Epoch: 1 \tTraining Loss: 0.05714584\n",
            "Epoch: 1 \tTraining Loss: 0.05369336\n",
            "Epoch: 1 \tTraining Loss: 0.05182071\n",
            "primary_caps_total_time 4.495709419250488\n",
            "digit_caps_total_time 2.1548492908477783\n",
            "dynamic_routing_total_time 1.5968060493469238\n",
            "decoder_total_time 77.36426568031311\n",
            "total_capsule_net_time 85.10479307174683\n",
            "capsule_loss_total_time 1.6255717277526855\n"
          ]
        }
      ],
      "source": [
        "# training for 3 epochs\n",
        "n_epochs = 1\n",
        "losses = train(capsule_net, criterion, optimizer, n_epochs=n_epochs)\n",
        "print(\"primary_caps_total_time\", primary_caps_total_time)\n",
        "print(\"digit_caps_total_time\", digit_caps_total_time)\n",
        "print(\"dynamic_routing_total_time\", dynamic_routing_total_time)\n",
        "print(\"decoder_total_time\", decoder_total_time)\n",
        "print(\"total_capsule_net_time\", total_capsule_net_time)\n",
        "print(\"capsule_loss_total_time\", capsule_loss_total_time)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "6-oeBDcHk89k",
        "outputId": "7c7cf25e-08d0-4243-adb8-8095cfbbcb77"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(losses)\n",
        "plt.title(\"Training Loss\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "collapsed": true,
        "id": "WCCsB7cek89k"
      },
      "outputs": [],
      "source": [
        "def test(capsule_net, test_loader):\n",
        "    '''Prints out test statistics for a given capsule net.\n",
        "       param capsule_net: trained capsule network\n",
        "       param test_loader: test dataloader\n",
        "       return: returns last batch of test image data and corresponding reconstructions\n",
        "       '''\n",
        "    class_correct = list(0. for i in range(10))\n",
        "    class_total = list(0. for i in range(10))\n",
        "    \n",
        "    test_loss = 0 # loss tracking\n",
        "\n",
        "    capsule_net.eval() # eval mode\n",
        "\n",
        "    for batch_i, (images, target) in enumerate(test_loader):\n",
        "        target = torch.eye(10).index_select(dim=0, index=target)\n",
        "\n",
        "        batch_size = images.size(0)\n",
        "\n",
        "        if TRAIN_ON_GPU:\n",
        "            images, target = images.cuda(), target.cuda()\n",
        "\n",
        "        # forward pass: compute predicted outputs by passing inputs to the model\n",
        "        caps_output, reconstructions, y = capsule_net(images)\n",
        "        # calculate the loss\n",
        "        loss = criterion(caps_output, target, images, reconstructions)\n",
        "        # update average test loss \n",
        "        test_loss += loss.item()\n",
        "        # convert output probabilities to predicted class\n",
        "        _, pred = torch.max(y.data.cpu(), 1)\n",
        "        _, target_shape = torch.max(target.data.cpu(), 1)\n",
        "\n",
        "        # compare predictions to true label\n",
        "        correct = np.squeeze(pred.eq(target_shape.data.view_as(pred)))\n",
        "        # calculate test accuracy for each object class\n",
        "        for i in range(batch_size):\n",
        "            label = target_shape.data[i]\n",
        "            class_correct[label] += correct[i].item()\n",
        "            class_total[label] += 1\n",
        "\n",
        "    # avg test loss\n",
        "    avg_test_loss = test_loss/len(test_loader)\n",
        "    print('Test Loss: {:.8f}\\n'.format(avg_test_loss))\n",
        "\n",
        "    for i in range(10):\n",
        "        if class_total[i] > 0:\n",
        "            print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (\n",
        "                str(i), 100 * class_correct[i] / class_total[i],\n",
        "                np.sum(class_correct[i]), np.sum(class_total[i])))\n",
        "        else:\n",
        "            print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i]))\n",
        "\n",
        "    print('\\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (\n",
        "        100. * np.sum(class_correct) / np.sum(class_total),\n",
        "        np.sum(class_correct), np.sum(class_total)))\n",
        "    \n",
        "    # return last batch of capsule vectors, images, reconstructions\n",
        "    return caps_output, images, reconstructions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wrYweGZUk89l",
        "outputId": "05505541-3ad5-46b1-f19b-45c4a9a66e55"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Loss: 0.05295683\n",
            "\n",
            "Test Accuracy of     0: 99% (977/980)\n",
            "Test Accuracy of     1: 99% (1131/1135)\n",
            "Test Accuracy of     2: 97% (1007/1032)\n",
            "Test Accuracy of     3: 95% (968/1010)\n",
            "Test Accuracy of     4: 99% (974/982)\n",
            "Test Accuracy of     5: 98% (877/892)\n",
            "Test Accuracy of     6: 98% (940/958)\n",
            "Test Accuracy of     7: 97% (1005/1028)\n",
            "Test Accuracy of     8: 97% (953/974)\n",
            "Test Accuracy of     9: 95% (964/1009)\n",
            "\n",
            "Test Accuracy (Overall): 97% (9796/10000)\n"
          ]
        }
      ],
      "source": [
        "# call test function and get reconstructed images\n",
        "caps_output, images, reconstructions = test(capsule_net, test_loader)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "collapsed": true,
        "id": "dj1FUSHSk89l"
      },
      "outputs": [],
      "source": [
        "def display_images(images, reconstructions):\n",
        "    '''Plot one row of original MNIST images and another row (below) \n",
        "       of their reconstructions.'''\n",
        "    # convert to numpy images\n",
        "    images = images.data.cpu().numpy()\n",
        "    reconstructions = reconstructions.view(-1, 1, 28, 28)\n",
        "    reconstructions = reconstructions.data.cpu().numpy()\n",
        "    \n",
        "    # plot the first ten input images and then reconstructed images\n",
        "    fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(26,5))\n",
        "\n",
        "    # input images on top row, reconstructions on bottom\n",
        "    for images, row in zip([images, reconstructions], axes):\n",
        "        for img, ax in zip(images, row):\n",
        "            ax.imshow(np.squeeze(img), cmap='gray')\n",
        "            ax.get_xaxis().set_visible(False)\n",
        "            ax.get_yaxis().set_visible(False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "SfK6p2Bwk89m",
        "outputId": "1e5f6b7a-6eb0-43ae-877e-d2178a9ae445"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABbwAAAEhCAYAAAC0kWbAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdefxVVfX/8YUTo4IgqMiMCuKECApiOUdlZc75dSiz1HIoNa3MRrOvlWRlDqUND9NSMhtUtEzFERAckEEEFJBZkFEQFf38/ur3db338nPOvZz7Gc7n9fxvHfc+93Dvvnvvu/081mpVV1dnAAAAAAAAAAA0d1s09gMAAAAAAAAAAFAEDrwBAAAAAAAAAKXAgTcAAAAAAAAAoBQ48AYAAAAAAAAAlAIH3gAAAAAAAACAUuDAGwAAAAAAAABQCltV0rhVq1Z1tXoQNDkr6urqutbq5oylFqWmY8mM8dTCMDehKMxNKBJzE4rC3IQiMTehKMxNKBLjCYWpq6trFV3nL7zxQeY39gOgNBhLKBLjCUVhLKFIjCcUhbGEIjGeUBTGEorEeELNceANAAAAAAAAACgFDrwBAAAAAAAAAKXAgTcAAAAAAAAAoBQ48AYAAAAAAAAAlAIH3gAAAAAAAACAUuDAGwAAAAAAAABQChx4AwAAAAAAAABKYavGfgAAlenZs6eLR48enbQZPny4i0eOHJm0WbBgQbEPBgAAAAAAADQy/sIbAAAAAAAAAFAKHHgDAAAAAAAAAEqBA28AAAAAAAAAQCmQwxtoZjRn94knnpi0GT9+vIvJ190yDB061MWTJk0q5L533nmniz/zmc8Ucl8AAAAAANAwttgi/bvnc845x8U33HCDi1999dWkzyGHHOLiefPmbf7DFYy/8AYAAAAAAAAAlAIH3gAAAAAAAACAUuDAGwAAAAAAAABQChx4AwAAAAAAAABKgaKVQBN30UUXuTgqUqlOPvnkWj0OmogePXok12699VYX19XVFfJaRxxxRCH3AQAAAAAADaNLly4u/vGPf5y0OfPMM1383nvvuTg6e9BrFK0EAAAAAAAAAKBGOPAGAAAAAAAAAJQCB94AAAAAAAAAgFJotjm8+/Tpk1z7z3/+4+J+/fq5eO3atUmfK6+80sWjR4/e/IcDqtSzZ8/kmubwVhdffHFybcGCBYU9E5qmW265Jbk2cODAzH6rVq1y8S9+8YvM+w4YMKDCp0Nj2XrrrZNrQ4YMcfEVV1zh4o9//ONJny228P8/XPO4mZnNnz/fxbqe3n///UmfdevWuXj9+vVJGzRvrVu3Tq49+eSTLt5vv/2SNosWLXJxr169in0wNKhWrVq5OMr9+J3vfMfFZ511VsX3jWpVPPHEEy6+7LLLXDxhwoTM10HTFq11vXv3dvF3v/tdF5922mmZ9502bVpy7Qc/+IGL77rrLhcXVS8FiOg+fdCgQUmbo446qqEeB0AT17lz5+Taww8/7OK99tqr4vtOnDgxuTZ79uyK79PQ+AtvAAAAAAAAAEApcOANAAAAAAAAACgFDrwBAAAAAAAAAKXQJHN4R3lojzzySBdfcMEFSZu+ffu6WHOqaU5SM7OOHTu6+Pzzz3fxIYcckvT5yEc+klyrhTw5x3/zm980yLOgYYwYMSK5pnm9NT/3tddeW9NnQtNwySWXuPjwww+v6j6aE/7WW2/N7LN48eKqXgsNL1qzHnjggXr7RPlHNWd31EZzLN98882Zz/fcc8+5eMaMGUmbP/zhDy5+5JFHMu+LpiPKCT948GAXR+OJPLjN27HHHuvio48+2sVnnnlm5j3yjIE8bUaOHOnib37zmy4+5phjMu+BpqVt27Yuvvvuu5M2Wb/PoloUKsqPfMcdd7hY65rMmTMn875AtU444QQXR/smAC2X5uPW31FmZnvvvbeL8+ylNGf3cccdl7RZtmxZjidsXPyFNwAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKTaJo5S9/+UsXn3rqqUmbTp06bfbrtGnTJrn21a9+1cXt27d3catWrZI+DVVYqUOHDsm1G264wcUHHnigi88666yaPhOKpQUpr7nmmsw+FKlsGXr06OHic88918VbbZU9fa9cuTK5RrGbctFCxp/73Oca50FyGjJkiIv322+/pE23bt1cTNHKpm3HHXd08a9//etGehI0lJNOOim59tvf/tbF7dq12+zXWb16dXJN9/LR3l4NGzbMxVrgycxs2rRpFT4daqlfv34u/te//lXvf29Il112mYvPPvvsRnoSVGP48OEu/sc//pG0uf3221188cUX1/SZ/uuqq65Kru28884uZh/ftOjvsY997GNJm+OPP97F+pkuXbo06XPXXXe5+KWXXkrazJo1y8VaTH7fffcNnjibFn7WvfqUKVOSPjovonZ22mknF48bN87F22+/fVX3zSpSGY3T5oC/8AYAAAAAAAAAlAIH3gAAAAAAAACAUuDAGwAAAAAAAABQCo2Sw/vQQw918Re/+EUXb7PNNjV53S233DK5pjm7NS/W7Nmzkz55cnhrnuXly5e7WHM3m5ldeumlLj7yyCOTNppTXPO1ksO7edEc8tG4GD9+vIvJ4d0yaI7R/v37V3yPhQsXJtcmT55c9TOh8e25554uvvzyy13cUDUmaklzG2ouulWrVjXk4yCD7tk6d+7cSE+CWjnggANcfMsttyRtisjZfc8997j4iiuuyHydsWPHJm10ztA887feemvSR+sLoHY0563+DjQzu+iii1xcRM7uCRMmJNemTp2a+Syqbdu2Lo5+X7777rsVPh0ayje/+U0Xd+3aNWmjv69/8YtfuHj+/PmFP5dZXNcETcuuu+7qYq2lc/LJJxfyOqeffrqLo5oWa9ascbHWf+vSpUshz6KOOuqo5Bo5vBuO5onPk7Nb16S77747aXPhhRe6eNmyZVU8XdPDX3gDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKAUOvAEAAAAAAAAApdAoRSuLsHLlyuTac8895+Lbb7/dxdOnT8+876JFi1y8ZMmSKp4u20svvZRc0wJzeZ4XzcdJJ52UXLv44otdvGDBgsw2QF5aZAfN3z/+8Y/GfoTcbrzxxuSaFr/bf//9kzZasHWXXXZxMUUrmzYtrp3Xz3/+84KfBEXRfYgWfM9j48aNybWzzz7bxVq0cu3atZn3nTJlSnLt0EMPrbdPp06dkmtaLLdW+/+WRgtUmpl97Wtfc/FVV11VyGtNmjTJxTfffLOLdXyZmR199NEuzlO0UgvMt27dOmmzYcOGzPugYWjR91GjRmX2efHFF12s5wNFGThwoIuPOOKIpM17773n4ptuuqkmz4J8+vTp4+J99tmnQV43Wreiaw0hOodDbeh6Y5YWl8zjzTffdHFRxVWbA/7CGwAAAAAAAABQChx4AwAAAAAAAABKgQNvAAAAAAAAAEApNEoO73Hjxrn4+9//vouPOeaYpI/mdoxyYD///POb/3ANpEOHDsk1zWmXh+b9RtMxevRoF+fJxR2NgQkTJhT2TGhZTjnllOTa73//+0Z4EuSheUB//etfJ2369u3r4i228P/fWnM95hHlGr3vvvtcPHny5KTNvHnzXHzXXXdlvtZOO+3k4jx5MfXfiKatrq6usR8BBevatWvFfSZOnOjiE044IWmzePHiqp/pv6rJrRvlIO/YsaOLyeFdjGjsFJGzW/fYZmbXXnuti/N8hueff37Frz1r1iwXk6+7aRs2bJiLda8VrVma733Tpk3FP5iZ3XHHHS7eeuutkzYrVqxw8V//+teaPAvy+c9//uNirU2zbt26iu8Z7bGjul6VeuONN5Jrf/jDHzb7vkU8G/KJPq+svPEvvPBCcu34448v6pGaHX5FAgAAAAAAAABKgQNvAAAAAAAAAEApcOANAAAAAAAAACiFRsnhra6++up64zIaNGhQcu3MM8/M7Kf5WX/4wx8W9kzYPBdddJGL8+Ts1jZjxowp9JnQfI0fP97FmrMvTy6ukSNHJtfOPfdcF990001VPB1qQXPcnnbaaUkbzTWpa0KUS3T27NkuvvXWW1382GOPJX2effbZ+h+2IHnyPVeTPxhAcS644AIXn3zyyZl9fvKTn7h4/fr1hT7Tfx111FEV94nyfs+cObOIx4FYvXp1cu3222938dFHH5200Ty4v/3tb118yy23JH2ycnaPGjUqudanT596+6D5O/XUU12s+4633nor6XP//ffX5Fn09/+AAQMy+9x22201eRYUY/jw4RX30dp0V1xxRdKG2gAt09e//nUXH3zwwRXf4957702uvfLKK1U/U3PHX3gDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKAUOvAEAAAAAAAAApdAkilY2Zdtuu21ybbvttqv4PmvXrnWxFtDISwuy3HzzzVXdB5vnpJNOSq797Gc/q7dP9N+vvfbawp4J5bJmzRoXX3XVVS4+4ogjkj6dOnVycdu2bZM2o0ePdrEWizr77LOTPlmFoFCM008/fbPv8eCDDybXjjvuuM2+b1F69+5dcR99Xx566KGiHgdNSEMVSkXlZsyY4eLvfve7jfQk6bq2xRbZf7ujxX1ff/31Qp8JH+zNN99Mrp1xxhku3n///ZM2S5cudXFUaDSL/l7TQqpm6b4psnLlShf/6U9/qvhZ0Hii3/Lvt3HjxuTalClTNvt127dvn1z7wQ9+4OLWrVtn3mfWrFmb/Swojs5X//znPyu+x2GHHebiI488MmlTzX3R/PTq1cvF55xzjou32ir7uHby5Mkuvvrqqzf/wczs2GOPdfHAgQOTNloM88477yzktYvEX3gDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKIUWn8O7VatWLj7hhBNcfNFFFyV9DjzwwIpfZ8KECS4ePnx4Zp+6urrk2pVXXlnxa2Pz6ed1zTXXZPbRnN2XXHJJoc+EluX555938W233Za0Oe2001wc5abU/Keaw/vvf/970ueYY45xsebWROV233335FqedUFpHQDN9d7UHH/88Y39CCjYV7/6VRfrviryxhtvJNceffTRwp4J5RDl3v3jH//o4h122CHzPpr/+aijjtq8B0OhnnnmmULus9dee7n4lltuqfe/5/Wb3/zGxePGjavqPqi9r33ta8m1kSNHVnyfbbbZpt7/fuihhybXNL/tBRdckLTp379/vfedO3ducu3Pf/5zvX3QsDTnclQvKcu+++7r4ug33ZgxY1z85S9/OWnz9ttvV/zaaDxbbrllck3XqT59+mTeZ9OmTS7+1Kc+5eJoH/6jH/3IxdE+SPPT632is0kV1Xj50Ic+5OKGrqPCX3gDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKIUWlcO7Y8eOybVvf/vbLtac3VEOnDz5a1Q1uVkXL16cXLv55psrvg8q17NnTxdrHi3972Zm48ePd3E1Obuj+2p+VG1z4oknZj7LQQcdVPGzoGm78MILk2v6ud9+++0V33fYsGHJtU9/+tMuvummmyq+LzzNZ2Zm1qFDh4rvo/nUV61aVfUzNYRofKFc8uyRNCcuENG6FGZmn/zkJzP7vffeey6+/vrrC3smNF2aM7mo9ebhhx8u5D6ovY9+9KPJtShv7vtF5wMbN24s7Jkq8atf/Sq5tmbNmkZ4EnyQL3zhC4XfM9r/f/7zn3fxdtttl7TRNZKc3k3biBEjkmtHHHGEi3UPHc1FWqvgK1/5ioujM6itt9663teJrlVz5jlgwIDk2vbbb+9icngDAAAAAAAAAFAFDrwBAAAAAAAAAKXAgTcAAAAAAAAAoBQ48AYAAAAAAAAAlEKzLVrZp0+f5Nopp5zi4kceecTFN9xwQ9Jn8ODB9b7O1Vdfnfkse+21V3LtE5/4RGY/pQUyr7jiiorvgWJkFYpcsGBB0ufkk0+u+HVOOukkF19zzTVJm6iQZZaFCxdW3AfV6dKli4t//vOfJ23mzp3r4quuusrFb731ViHP8uijj7p45syZSZuBAwcW8lrYPIccckhyLSqSrDZs2ODi9evXF/ZMDeHQQw91sRaXi+i4BlBOxx57rIv/93//t6r7aIH3n/70p1U/E3Dbbbe5WH87Llu2rCEfByWyZMkSF//ud79rpCdBXmvXrq24z4svvuji3XbbzcVbbZV9JHfCCSck1/7617+6+M4776z42VA722yzjYsvv/zyiu+xdOnS5JrujbbddtuK7/vuu+8m1/S8onXr1i7OcyY1adKk5Nprr71W4dMVi7/wBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKzTaH92mnnZZc+/73v+/it99+28XvvPNO0mf06NEu/sEPfuDidevWZT7LGWeckVw7+uijM/upuro6Fx944IFJm1tvvbXi+6J+mkfbzOziiy928fjx410c5euO8nq/X5T3SHN2R7m3//KXv9T7bNHrXnLJJfU+C4rz5S9/2cWnnnpqZp9Nmza5WOedPNq1a5dcO+igg1xcTb7uVatWJdcefPDBiu+D+ul8/0HXlNaiuPHGGwt7poagObujf/O0adNc/Pe//72mz4TN84UvfKGxHwHNVKdOnVz87W9/28XV5KU0q25NRfN33XXXufi4445zcefOnau6b7du3Vz8pS99ycXf+973qrovinf//fcn13beeefNvu/UqVNdPGvWrKTN1772NRe3adMm8776e3LNmjVVPB0a0nnnnefia6+9NrNPVg7v008/Penzla98peJn0d9rK1euzLwHaueAAw5w8ahRoyq+R1S3MEtUV+LVV1918Q9/+MOkjY6fn/zkJy4+//zzM1974sSJybVq8t4Xib/wBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKHHgDAAAAAAAAAEqh2RStfPTRR10cFXRUTz31lIt/+tOfJm0eeOCBip9FC8HVqjjOF7/4xeSaFrvLU9AAnhaP1MKRkZ///OcujgpF6n1POOEEF5944olJnzyFLi666CIX/+xnP6v32T7o+VAb1XwH99xzz4r7dO/e3cXf+c53kjZnn312xffVOUWLIpqZvfzyyxXfF4jmvDyWLFni4qiQKhrPIYcc4uLtttvOxVqYNNKqVatCnwlNX/v27ZNrf/vb31y87777VnzfaN2LCjah/LTg8YgRI1w8ZMiQpM9NN93k4o4dO2a+ju7H0HSMHj0617XN1aVLl+SaFq3v27dv0kYLxz377LPFPhhqTgtBPv300xXfQz/3rbfeOmmT5/flwQcf7OJevXq5mKKVjevMM89slNfV4pNmaVHwpUuXJm30TEyLokYuu+wyF9988815HrFB8RfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKHHgDAAAAAAAAAEqhSebw/ta3vpVcO+CAA1wc5TqaOnWqiz/96U+7eN26dRU/S5Rr9x//+IeLNXdzHjNmzEiuDRo0yMVbbrll0ubzn/+8i6+//noXz5o1q+JnaWk0l1v0+Wme7DFjxmT2ufPOO12suQPHjx+f9NH83NF9//KXv7j4kksuSdqg8WgO0rPOOqvie7Rt2za5pnUK7rjjDhd369at4tcxS/Mha85uzfEF5NWvXz8XX3XVVZl9ovzcP/7xjwt7JhRP8+Bqzu66urrMe9x3332FPhOavijn7Yc//OHNvu8jjzySXNN84W+99ZaL33nnnc1+XTR9c+bMqTc2M+vUqZOLb7zxxsz7Hn/88S6+/PLLkzYrVqzI84hopk455ZTkWpSzW2ntpg0bNhT2TKjf/vvv7+JLL700aXPBBRe4ePny5TV9JqAWTjvttOSa7reiHN563qomT56cXNN6iGvXrs3ziA2Kv/AGAAAAAAAAAJQCB94AAAAAAAAAgFLgwBsAAAAAAAAAUApNIof3SSed5OIoh6zm7F65cmXSRvtpzu42bdokfQ4++GAXf+QjH3FxlAOna9euybUsZ555posffPDBpM3Xv/51F++3335JG33em266ycWHH354xc9WZjq2zMxOPPHEzH4LFy6s9z7XXHNN0icrl7vm9DYzW7BggYtPPvnkpI3mD0fT8tRTT7lYv+tmZlts4f/fouaRu/vuu5M+o0aNqvhZNm3a5OKXXnopaaO1DV5++eWKXweNZ+jQoY39CP+fzqWas1tzekeisT9u3LjNei40fbNnz27sR0CNde7c2cVa/6YoecaS5oyP8u+uX7++sGdCZfS3jVm6fui68Oqrrxby2tXk6NW831tt1SR+TqMBDR48OLON/sYzM/vjH/9Yi8dBDpprOKor8Y1vfMPFDZXDW+u4AUXr3bu3i3v16pXZZ/Xq1S4+55xzkjbTp0/fvAdrAPyFNwAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKTaLKhhZn1AKVkXvuuSfz2q677uriCy64IOlz/vnn1/s6rVq1Sq7V1dW5eMWKFUmbCy+80MX333+/i9euXZv0+epXv+ri1q1bJ20OOuggF7/yyitJG/yf8ePHJ9e0iEhUbPJnP/vZZr+2vs61116btImuoXn5/e9/7+If/vCHSZudd97ZxVqMKU9xvzwmTpzo4g996EOF3BfFi9aW6Jo69NBDXfy9733PxT/+8Y+TPm+++aaL27Zt6+KOHTsmfdq1a+fiqJj0GWecUd+jhl577TUX/+IXv6j4HmhcQ4YMaexHQDOgc9M+++zTOA9iZkcffbSLo8Jxn/vc51wc7dNRjB49erh47NixSZv27du7WH9r/e53v0v6PPnkky6+9957M58lT/FBpQXBdY1F+Wy33XYujgrfqqjg4cqVKwt7JlSmTZs2mW1GjBjh4nnz5lX8Ottss01yrVu3bi6+8cYbXfzRj3604tcxMxs9erSLX3jhharuA5iZPfHEEy5++OGHXfz888835OMUhr/wBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKjZLD+0tf+pKLL7744sw+mp/7l7/8ZdLmqKOOcrHmd+vevXveR/z/opyqf/jDH1z8q1/9Kmnz7LPPVvxa6q233kquPfLII5t935ZE82ibmY0cOdLFmv8qMnz4cBdHeb9PPvlkF48ZMybPI6Jk3n333ZrcV2sHzJkzJ2lz+umn1+S1Uby77747ufapT33KxR06dMi8j+bWPvzww5M2c+fOdXHfvn1drLUhzNK1T8ffB117vyh/5RFHHOHiGTNm1HsPND2HHHKIi7fYwv/txHvvvZf00VoHCxcuLP7B0Ki0Js65557bSE+S7Zhjjkmu6T7v3//+d0M9Tqlp/nSz9PeZ5uuO7LDDDi6+7LLLkjZvv/22i1etWpV53y5dumS2UZrndM2aNRXfA83L7bff7mKthRK56qqravU4qIKe35x33nlJm+9+97suXrp0aeZ9hw4d6uIoH/dhhx1W7z3y1IyL1iStgxPtv9B4Jk+e7GKtFdKQ3nnnHRf/5Cc/Sdr86Ec/cnFZ6lPwF94AAAAAAAAAgFLgwBsAAAAAAAAAUAoceAMAAAAAAAAASoEDbwAAAAAAAABAKTRK0cobbrjBxXkS7OdJ3F9N4RG1du1aF997771Jm3POOcfFmgQeTZsWsjzppJMa6UlQRlp40MzsW9/6louPP/74zPvMnj3bxVdeeaWLb7vttiqeDk3F3//+9+TapZde6uIbb7yx4vtGBSija7Xw29/+1sU//elPkzZRsVU0L7of0z1cVMz0lltuqekzoWGNGjUquabf9y233LLi+z711FMufvzxx5M2WvB32LBhSZvrrrvOxVFBMDSMqLjfZz7zGRdHBebvueceF+++++6Zr7XNNtu4eMcdd8zziBV7+umna3JfNB06f+26666ZfaZNm+bif/7zn4U+EzaPfj4RnWceeuihWj2Os2zZsuTa1Vdf7WJd18zM3n333Zo9Ezbfr3/9axe/8cYbSRsdc2eccYaLe/Tokfk6WhwzOifV8bR+/frM+5YFf+ENAAAAAAAAACgFDrwBAAAAAAAAAKXAgTcAAAAAAAAAoBQaJYd3NaK8uJWK8kq+/vrrLv7Yxz7m4meffXazXxdAy/H8888n10488cRGeBI0N3fccYeLo5yl5557rovbtWtX02f6ryeffDK5ds0117j4P//5j4vffPPNmj4TgMbxjW98I7mm+ZPVhg0bkmu//OUvXfyjH/3IxXlyTGruSjOzPfbYw8XnnXeei3Xvb2a2aNGizNdC5e66666q+u23334uPuWUU1x8+eWXJ3369etX1WtlufDCC138u9/9riavg6bj4IMPdvGAAQMy+0ycONHF5FduWsaMGePiQYMGJW30vKl3796Z99Xzpfnz5ydtdB7U/O4TJkxI+mzatCnztdG0aY2bP/7xj5l9vv3tb9fqcVos/sIbAAAAAAAAAFAKHHgDAAAAAAAAAEqBA28AAAAAAAAAQCk0Sg5vzbv2ne98x8WPPPJI0mfUqFEVv87y5ctdfOWVVyZtrr/++orvCwBA0datW+fiSy+9NLPN0Ucf7eL999+/4teNcuDqevnQQw8lbTZu3Fjxa6H509omPXr0cPGSJUuSPtE1NF8vvfRScu3DH/6wizV35bHHHpv00bz/Rfn617/u4vvvv9/FUU2CtWvX1uRZUB1dX37/+9+7OMqF2qdPHxfr78tTTz016aNj+cgjj0za6PwV1YRCyzJu3Ljk2o033tjwD4LcVq1a5eKvfOUrSZuLLrrIxR//+Mcz76u5th944IEqng5ArfAX3gAAAAAAAACAUuDAGwAAAAAAAABQChx4AwAAAAAAAABKgQNvAAAAAAAAAEAptKqk8EarVq2o0tFyPFNXVze0VjdnLLUoNR1LZoynFoa5CUVhbkKRmJtQFOYmFIm5CUVhbkKRGE8oTF1dXavoOn/hDQAAAAAAAAAoBQ68AQAAAAAAAAClwIE3AAAAAAAAAKAUOPAGAAAAAAAAAJQCB94AAAAAAAAAgFLgwBsAAAAAAAAAUAoceAMAAAAAAKs/bKYAACAASURBVAAASoEDbwAAAAAAAABAKXDgDQAAAAAAAAAoBQ68AQAAAAAAAAClwIE3AAAAAAAAAKAUOPAGAAAAAAAAAJTCVhW2X2Fm82vxIGhyetf4/oyllqPWY8mM8dSSMDehKMxNKBJzE4rC3IQiMTehKMxNKBLjCUX5wLHUqq6uriEfBAAAAAAAAACAmiClCQAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKHHgDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKAUOvAEAAAAAAAAApcCBNwAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKHHgDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKAUOvAEAAAAAAAAApcCBNwAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKHHgDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKIWtKmncqlWrulo9CJqcFXV1dV1rdXPGUotS07FkxnhqYZibUBTmJhSJuQlFYW5CkZibUBTmJhSJ8YTC1NXVtYqu8xfe+CDzG/sBUBqMJRSJ8YSiMJZQJMYTisJYQpEYTygKYwlFYjyh5jjwBgAAAAAAAACUAgfeAAAAAAAAAIBSqCiHN2KtWqXpYurqSBcEAAAAAAAAAA2Jv/AGAAAAAAAAAJQCB94AAAAAAAAAgFLgwBsAAAAAAAAAUAoceAMAAAAAAAAASqHZFq2MCkXqtS222KLeOM99t9xyy6SN3ufdd99N2rz33nsufuedd1wcFbWk0GW56FiKxmybNm1cvN122yVtOnTo4OJtttnGxW+//XbSZ9myZS5ev3590kbHKFqGaBy+XzQPaR/mKgAAAAAAGk/WGaiZWdu2bV3csWPHpM22227r4q228kfFmzZtSvosXrzYxW+88UbSprHPnPgLbwAAAAAAAABAKXDgDQAAAAAAAAAoBQ68AQAAAAAAAACl0CRzeEd5ZzQ3zdZbb5200Wua61jzJZuZtW/f3sWaQ1nzJ5uZderUqd7XMTPbuHGji5cuXeriJUuWJH1WrVrl4rfeeitpo/nCGzsnDj6Y5n+Pxl/v3r1dfNhhhyVtdIxq/uS1a9cmfebPn+/iF198MWnz6quvupix1Pxl5eeO2lTTJ8rhnTV+yPvdeLI+8zw1MaI2+plW8xlH44ax0nTkmR+K6BPJMw4YK40j+ow116PugfLs2zXWe5qlvxGivfKbb77pYq11EtXe0WuMraalqHUrSzU1lqjLhFrKM44Zb0DLkVVzsF27dkmfvn37uvjQQw9N2kT93m/dunXJNT1zmjFjRtJm3rx5Lo72YLXEX3gDAAAAAAAAAEqBA28AAAAAAAAAQClw4A0AAAAAAAAAKAUOvAEAAAAAAAAApdAkilZqARpNvG6WrwClFpjs2LGji7t165b06dGjR71x165dkz6dO3d2sRYVNEuLR6xZs8bFU6ZMSfqMHz/exZrg3SwtbEmhwaZDCwhosSUdN2Zmw4cPd/GQIUOSNlokVYtUTpw4Memzfv16F0eFVfV7x1hqWqopNJhVNCy6pnGe+7Zu3Tppo4UuXn/9dRfrmDRLi41RdCebfj76PY6+67pG7bTTTi7eZZddkj477LCDi6M1V19b56bXXnst6bNgwQIXr1y5MmmjY0ULzjFOqpOn8JV+plERcR1jbdu2dXE0VrRPVBB8++23d7E+rxb/NjNbsWKFi6N5Jk/BQvyfatcALfque54uXbokfbp37+7iffbZJ7NPnqKVCxcudLEW7p42bVrSZ/HixZn3ZexULppDsvYhZuk8ovNMVFwray6KnkU/040bNyZtdF7ZsGGDi6OxoteisaP7bsZX01VUAeesPVw0RvOMY90X6ZjdtGlTZh80bUUV6s0qeGiW7tl0PovGE+cIDUc/Q/289DecmdmBBx7o4sGDBydt9OxUi1ROmjQp6fPGG2+4OCpQXlQx+2rxF94AAAAAAAAAgFLgwBsAAAAAAAAAUAoceAMAAAAAAAAASqFRcnhn5Q6KcgNqvsco/6Pmq9l5551d3Lt376SPXtPcplH+QM1TGD2v5ozUZ4vuqznG77vvvqTNzJkzXbx69WoXkz+pYUS5iDRnkeYjPeCAA5I+o0aNcnGUS1dzlC5atMjFmtfdLF8uXXK3FSNPXip9r/PkXMvKCR/lydWcllEeLW2j81lUt6BPnz4uHjBgQNJGc81rnq8xY8YkfXScRrkzW9I4zcrtaJZ+ppqzNKoVoLUptFbAXnvtlfTp37+/i7fddtukTVatitmzZyd9tH7F1KlTkzYvv/yyi5cvX+7iKM9pSxoneVWTyzFr3jFL5x7NEa9rn1m+eaZfv34u1vH/6quvJn1eeeUVF8+fPz9pozkIdZ5p6Xlz83zmuueO9rC6nx44cKCL99xzz6SP5pTUtSbK06zPp/kjzdIc3i+99JKLtWaOmdlDDz3k4mj+Yuxk088nqiuhn2u0bul+WOeHXXfdNemjOeF17YtqLun41z23WbomzZo1y8Vz5sxJ+uh8FdUg0Fzguo7xm65y1eSKjfZaRdTRifbgWetnnrVx9913T9q8+eabLh47dqyL9fzALM7DjMYRjcE8+d11jOn40pzMZma9evVy8b777pu00bnzqaeecvH999+f9HnnnXdczPpYjKLOnI466igX65mnWVpXSfdSWp/LLP0tv2zZsqRNY+MvvAEAAAAAAAAApcCBNwAAAAAAAACgFDjwBgAAAAAAAACUQqPk8FaawzvKTav5AzVfrFmaY1TzYEW5ajRvnPaJchmuX7/exZpf1CzNs5Qnx6Xmo4vyHWpeHM2bQ763hhHl0dLxN3jwYBefccYZSZ/99tvPxVGOv6xclM8++2zSZ8mSJS7W3G5mjJU8qskFWE0u4Tx52TQH7o477pj00ZyXUf5TrRWgtQ40B6ZZmq81yuesc6WOLx230TXNT29W3hyD0djScRDlf9S1UOtDRLUqhg4d6uKRI0e6WPNDmqXrZVSrQv8Nmks3ypeq40LrXZileXJ1zY1y9pLDO1ueWgF55jzds2ke+Wje0Xklqleh+Zv1c9fcgmbxd0TpmGOsePqZRzmXNQ+o5vc0S2sBHHrooS6O8s7q/KVzYLR30eeN8oTq82rO0qiP7q91H2VGjtKIrv26VkT7Bf3c9btvlv4G0toTu+22W9JH9yo6F0W/L3U+i9YkfS2No1oUEydOdLHm6zZL17pq9pwtSbXvT1Z9FB0D0TUd51GfrBor0TU9z4hq5BxxxBEujvZjmldeRX10beR3Ye1k1a+Lxor+7ova6Jync+mgQYOSPjp/RedjOlfqs0Q1VebOneviqMYY+69sWWPFLN3j7L///i7+n//5n6SPnktFexz9XDX3f7VnTo29V+IvvAEAAAAAAAAApcCBNwAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBSaJSilVnJ2KMiRFpgIiqqown28xSl0Dbr1q1zcZRc//XXX3fxihUrkjb6WloYTmOztJBlVBRIi2pqQcOyFnhrbDpmo8I3/fv3d/FZZ53l4iOPPDLpo0VsoiIQjz/+uIsffvhhF69Zsybpo8UBokIkFI7Ipu9RnoI5edrovBMVedM5QgsPaoEKs3R+iMapFh7JKsxjlhbHiIpsanESLWIRFVvJU5ijrHNankKlWqDSLLvY1wEHHJD0Ofjgg12sxeOi19HibLo2mqVFkPT7Eq1zWpApKkC5evVqF2sxOS1miHwFKfP0y7Mu6PdUx0FUlFv3M7pemqXFl7RIZbTX0jZRYTgdy6x9ns5FUXGzPIXVRowY4WIthBXN5brnee2111yse1yz9DPWQsxm6VjSArp51tzod4a+V9V8f5qzaE7Jmg+i91r3IVGBYx1zWghr+fLlSZ+1a9e6OM/+Qfc80Xqo/0YdG1ERcR2X0X4s2gfg/1SzhlVTeDn6zHX+0nGi64pZ+lsr+sz1+6AFnKMig/osS5cuTdpMmTLFxbqP4ndgw4m+1/q56x7owAMPTPro/l5/i5mlY0PHcjT/6twUrXW639IxF53V6RiLvouMucpF84gWHv3sZz/r4ujMSX9vRWdOTzzxhIvHjRvnYp1XzNLPPSpQ2difOystAAAAAAAAAKAUOPAGAAAAAAAAAJQCB94AAAAAAAAAgFJolBzeKisnnlmaOyvKRfXWW2+5WPN8am5AM7O333673meL8otqDm99XbM0Z5LmkdPcdGZpDqUoZ4/mHSP/W8PQ9zn6/A4//HAXjxo1qt57mJlNnz7dxffee2/S5p577nGx5jHMo7FzJ7V0Oqdpjsvu3bsnfT7ykY+4+Pjjj3ex5us2y5dzfOPGjS7WuSnKeal9NF+3WTqWNYf3tttum/TRfHTap0zy5CvXdSOaZzTP7J577uniKLd7v379XKzjL8qNPHfuXBdHObx1Hda8udEY1fyCUa0Kfe3OnTu7OFrLo5xxyJY1Z0R7LX2vs/LbmqXjVvMPmqX5dzVX84IFC5I+msM72o9F/wb8H92bRLk5NS+7fifN0noi8+bNc3GUe//ll1928QsvvODiKE+zzpPRnDdkyBAX58nhreM2mqPZS6WqyWOu3+1oTp8wYYKLdQ8RjVOlYztaJzSf+K677pq00Rzduo5F+/usGhfR8zC+akPHqNaU2WOPPZI+xxxzjIs1d+2zzz6b9NGcuNHao8+iOZh79uyZ9NHvi+63zcxmz57tYl1Po5zjKIZ+ptHvncMOO8zF5513not1HJilc0j0m07HWJ45RO8TrbNPPvmki3U9j/6Nus7qGEQ+uveI9ls6nvTMIBor06ZNc/HYsWOTNvfdd5+Lo7o4WZriOsZpKQAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKjVK0Mkqk/n55kp3nKVq5bNkyF2vBiYgWbIuK7GgbLX5hZrbDDju4WAueaBFOs+z3JepH0cra0M9CC4j27ds36XPqqae6WIsiaTETM7Pbb7/dxVoswCwtUpmnMCGKUc17G/XR4kpazG/48OFJHx1PWuQtmpsWL17s4qhgiBYo1GJR0X31PlqcLLqvFrrQYr9maSHEMhfV0blai9GYpUVgdB0xM+vTp4+LBw8e7OJobtICKEuXLnXxiy++mPSZMWOGi6PCljquswpqmpl169bNxVHhGy3eowVbomJlUbHCli7PWqFt8uy/dA+UVbzULC0EF7XRorVahCsagzqHREV3q/k3tiT6+UXfJV0XZs6cmbSZM2eOi/WziT4/LZala030Wem8GBWc00KEWgA4+j2g/8aoqH1LL4Cap/CixtGeQtvk+X2ma2j0+0cLj+rvs2i90TU1+tx1vdbXjvYu+hs02jdRtLJ40Tqn40I/8zPOOCPpM2LECBc//vjjLn7qqaeSPjrWo9/6ugfSfVNU9FkLeWuxX7N0X6fzeEufu4qkY0x/7w8dOjTpc8UVV7i4f//+Lo7mHf19FhWP199WOg6iooOrVq1ycbQ2a5FKLRAeFRpmzFUnq6iujhUzs1NOOcXFOgb18zMz+/Of/+ziqGiljpeynDlxWgoAAAAAAAAAKAUOvAEAAAAAAAAApcCBNwAAAAAAAACgFBolh7fmg9EcP1EeI83rp3nPzMw2btzo4qw8k3leW3OfmqX5nKNn0fyU2kdjs/T5NXdz9FqaSydPjk5k089d8/6dcMIJSR/NI6ljacyYMUmfRx991MVvvPFG0qaIPO3RGNCxzzgpRjRnaD7Rvfbay8Wf/exnkz677767i3VsTJ8+Penz7LPPulhzrpmleSU1d1uUI07nUp2ron7aJ5rX9d9U5jGo40LzrZmZbb/99i7WPJNmZkOGDHGx5kaO1hbNkztt2jQXT5o0KemjOXqjPKyaa1I/zyhfqn4Xojaa01JzeEd1M6K5syUp6ruje4jovnpNx1yPHj2SPv369XNxtG/SnJCzZs1yseadNEvnlTLPIbWin0X0XZo6daqLoxzeWWMnyq+etQ+J8tl26NDBxTq2zNKaF+3bt3dxlN9S8+RG6xz54FM6fvR9i77rmic0zz5X20Rjo2PHji7W9SWqcbHPPvu4OMoJr3WYdK7SsWOW5lnOk8uc8bT5oj245v0/7rjjXPzpT3866aN74wULFtQbm6X74KgOS8+ePeuNo7MKna+0XkL02jrf5lnLkY/WkdF55Vvf+lbSR9cpPeN57rnnkj6PPPKIi6NaSDpOdZ8U5fDWsRG10boKWqcgWs+j33nIprn+dR2LzpwGDBjgYs2fHp05aR2C6Pe+zp/V5PDOc97a0HMPf+ENAAAAAAAAACgFDrwBAAAAAAAAAKXAgTcAAAAAAAAAoBQaJYe30hxmmofGLM31EuWE07wzefINKc1No3l1ojZRDlLNz9q1a1cXRzlIs/IwmaV5lvLk1iFHV/2i96x169Yu3nvvvV38iU98Iumj4+/FF1908UMPPZT00VyZUV5fzVuoeZCi74Jei/IpMS6y5fl+6TUdO2ZmvXv3dvHJJ5/sYs3LbJZ+7pqHeeHChUmfJUuWuFjHoFmad1DzSkZ5S7WNzq1m2fNrnrxfZRqT+u/VfKN5clcPGjQoabPnnnu6WPN+a949szRn9zPPPONizf1uluZ6jz5fna8071z0LLqGderUKWmj+XY1R7TmT0Rx8sx5utZpzZJo3Gpeb81va5aO06VLl7o4T10T8pRWLs/+Os8+PU9Nmaw+OraivbLWLTj44IOTNrrm6n46yuGtYzJaC6O9VEuXlas9es/0c45yeOuaqetAt27dkj6a11T3VgMHDkz6aE0VXVPN0ty5uj5GOe11jxZ9ZxhPm0/Hjub4NzMbNmyYi7/whS+4ONqPPf/88y7W/LfR/kbHdVTPYvDgwfW2mTFjRuazRPOXro+se8WIcsLrnuecc85xsX7GEd3vPPjgg0mbyZMnuzj63bdmzRoX6/wb/V7LU/uE8VMb0Vqna5uOn4997GNJHx2Xs2fPdvG4ceOSPnrmpL+1zNJ9T54zp+ZQL4C/8AYAAAAAAAAAlAIH3gAAAAAAAACAUuDAGwAAAAAAAABQChx4AwAAAAAAAABKoUkWrcwjT/G4PEnUswqnaNEUszS5fFTgpGfPni7WYmRR8SUt0LRo0aKkzdq1a12syeTzvC+NnTi+qYkKk2pBijPOOMPFvXr1SvpoMYB//etfLtaiN2bp2ImKY2ihGy1AoQUrzNJxUs13DPnoZ7bDDjskbY444ggXa5GtaAxq4QgtkBMVItluu+1cHM1NixcvdrGOjTwFKfMUAFYtbd7JKmbauXPnpI8WWtMClWbp+NJx8tJLLyV9tCjl+PHjXaxjwixeo5SuPzpGV65cmfTRNlGxKF2H9fsRzZNoOFo0tE+fPi7+8Ic/nPTRvZSuUWZmkyZNcvG6detcHM07Oq+0tHmmFmr1Hkbf26xivn379k366HoaFUnVMapFBidMmJD0yVOol/GVynpP8hSwigoR6/5Fi/vtt99+SR8dG/vss4+Lu3fvnvTRtVkLupmZzZ8/38W6ZurYMUvX0GgfzniqTPQbV8eOFrU1M7vwwgtdvOOOO7r4lVdeSfr87W9/c7F+5tGY1UKq0VqohVR1/E2ZMiXpo0UqtZC8GWOpVqLCyUceeaSLP/rRj7o4Kkar+2Hdq0dziI4xHSvRa+X5vca+qfFE80bXrl1dfPrpp7s4Kn6rZ07//ve/XRydOenvzujsQdc/jaMzJ70WFWhubPyFNwAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBSaBI5vFWUo0tz/0U5cDQXjd4nTz5u7RPlt+nYsaOLNe+qmdkee+zhYs1Ft3z58qTPa6+95uIVK1YkbTRfq+Y6jXIkkqvJ08+4Xbt2SZvhw4e7eMSIEZn31Rzs06dPd3GUs1fzyGkeJ7M0X3j79u1d/MILLyR97rnnHhdH+eCrycOMlM4rUX73gw46yMWaazvKl6w5sXTOi+YdnZt22mmnpE2/fv1cPHHiRBdPmzYt6RPlo0P9dC7W72302ey2224ujvKN6n0XLFjgYp13zNIc3gsXLnRxlA9S843qWmOW5nvXPtG40dxu0Tyk982zZlGrouHoWNY8pdE6pvm4o3VLc6Rq7sA8uYDRMPLs03Vt7NChQ9JH98Za/2bo0KFJn5EjR7pY9/FmZqtWrXLxY4895uIoTy45lxuOjp8oT66ukXvvvbeLNV+3mdmwYcNcrDUvot9Iuk5F65bOeTpuo1oU+m+K1ll9LcZX/aJ9iH4Wmk/ZzGzw4MEu1rUlyumvv+l0PxbtXXSMHnbYYUkbPR947rnnXPzyyy8nfTRfb4Q9UDF0jEV1mT75yU+6WH/TbdiwIemja1KnTp1cfOCBByZ9NK+33sPMbO7cuS7WvVV03sTYaDj6vdS1xCw9I9B1LKL75RkzZrhYa9GZpWdOGpulezDdt02dOjXpo2dOWvPCLK4P1pD4C28AAAAAAAAAQClw4A0AAAAAAAAAKAUOvAEAAAAAAAAApdAkcnhrnuwol5vmR8qTD1nzI0V99LU0z2SUW1fz4kQ5BnfffXcXa76klStXJn00r+ratWuTNpoDR/PRRTkHNX9QlHuxJeVz0vcsymGUlZ9Lx4lZmtdI8zRF42TAgAEu7tOnT9JGczVrPqUo75eO0euvvz5p8/rrr7u4JY2BauXJWxrlhF+9erWLdaxoPsGoj+bvjz4vzWUa5fDaZZddXKz56jQfnFmcNw7103Gh649+DmZmffv2dXE0lnTu0XyPUQ52zfOt+QWjXJQ6vqKxr2NH19Oo1oaO0Sivm+b51n8zOeXziT6zSkU5UzVPqa5tUR/d84wdOzZpozluqT/SdOhnGtXE0b2J7pu6deuW9Onfv7+LtY7BAQcckPTR3M5RvlTNyfvggw+6OMprSl2ThqNzUzRn6B5ax080H2jeZc1zGs2JrVu3drGOW7N0LdO9uv7mM0v3UlEeZv3NFv2Ga0myxkW0J9LfUR/60IeSNnrOoN//qF6X/rbSeSba32juXc3XHb2W7q91/2OW7iej59Wxw3pZHR2D0Xyg32Xdd+vvNbN0D6TjKaovoPmUNV+9WfpbQs+t9Lc+GpZ+V6P6TUcffbSLdS8VnQfqmNP1csiQIUmfPGdOek2fJcovrnnur7vuuqSN5qNv6PmJv/AGAAAAAAAAAJQCB94AAAAAAAAAgFLgwBsAAAAAAAAAUAoceAMAAAAAAAAASqHmRSujAiFa7KZjx44u1uTnZmb9+vVzsRZNMjMbOHCgi7XASVTsQos8aFGBqIiNFhHo0aNH0kaL0GlhsagwnBZbiYoeaAEPLXIQFT3Qf2NLKvgVjT8tmhYl7dfE/voeRkX8tDBEnuIAOkajIoP6fdHPLyoEpYWe7rnnnqSNjnUKnGTLUwRuxYoVybUnnnjCxTqvREUroyJO7xcVW9U5rmvXrkkbHYfdu3d3cVQUZdGiRfU+C1Ja0EjXNX3fzeLvv9LCH7Nnz3bxq6++mvTRoo9aKDL67utYj9YWLVKpxX2if48WVoleW+dX/X5Ehb2Yv1J5Co8qbaOfl1laFEyL2kR7DC0iOGPGjKSNzot8pg0jTwFB3YdExeV1HPTq1cvFu+66a9JH90ka637bLC3q9sILLyRtxowZ4+I5c+a4OCqWm4e+V4zR6uj7Fu2BdE89c+ZMF0eFvHSc5inQrOuUFlI1Mxs0aFC9fbTYqpnZ888/7+Lod4OOwzzFyVsSLfimxb/N0t/+UZuoYOj76ecb3VfHVrQ26mtvu+22mc+i4yIqSKmFVaNCvSiGzvFr1qxJ2tx333319on2qLo+6njS9TJqo+PALB1zWsQyGk/RfIvNF+2x9Xe5nmeapetH1tmkWfaZU+/evZM+ec6c9LerPkt0rqCFLKPX1kLBDV2gmb/wBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKjZLDW3N2a96iKD/3yJEjXaz5YszSPEZ5cu1prsm+ffu6OMrR1alTJxdH+Q6XLFniYs0bF+Xn1jxLUc5xzV2Yh/67W1L+0+iz0Vy6+++/f9JG81Pq+x59Dpo3S9/n6PN87bXXXKzjxizNAac5mDQvmFma9ytP7lak9H2LcqFpbuMoV+Bzzz3n4jx5GvW1NK9W9Dp58nPpnKf3jf6N+j5E46msc0i1NNeefhY777xz0kfniCjP3uLFi108f/58F2teN7N0vspTx0HHdTR/7bTTTi7WtTyqb6HzVZSbTv+NmuOymnUQMf0u69oR1Z7Q3KY6h+i6Zmb24IMPuljzyufBvFOMrJzd0Rqgn3G079Dv/+677+7iKDfyXnvt5eJozlBat+Cuu+5K2rzyyisujnI3K30f9N9sll0TJxqPeq1sYzZrPOX53kZzutar0LzFU6dOTfro56NxVItCf5Pq/GaWrueahzWqfaL7MV3XzNJ/U556FS2JrkdRblj93R79vtbfVpqXOZoftCaJ1n+KPnOdF6NaAdOnT3fxiy++mPksOs9E9y3bvNIQojMCvfbmm28mbfQ3nX5P8+Ry1rESfe66Huo5g1l2bvmselAoTvRea87rIUOGJG10bBRx5hTVWdE82tGZk45L/Z0X1SXQvVJTPHPiWwAAAAAAAAAAKAUOvAEAAAAAAAAApcCBNwAAAAAAAACgFDjwBgAAAAAAAACUQs2LVmoyfbO0aOCgQYNcfMghhyR9DjroIBdHxdhWr17tYi3eFRXi0eTret+oUFdU9CSrjSaP33HHHZM+WmgjT6EB/TdFfbTYRUsq+BW9H/re9+zZM2lTTeEbHStaHGDatGlJn1mzZtX7bGZmdlC6NQAAEoBJREFUe+65p4u1UEFUvHDhwoX1PosZBU4iWmhBCxXtuuuumfeICg1q8aU840mvaWGlaD7r3r27i7WwUvTa69evd7EWUTJjrFRD53z9/LQgklk6/qLCflrAUYs+RuNP5SlSp4VvtCCdmdngwYNdvO+++7pYi7WYpevPvHnzkjaLFi1ysf4bW9IatjmyismZpXs0HaeHHXZY0kfXKS22NGnSpKTP0qVL63226FpjFr5pSXOevs9RsUYt0LbHHnskbXQ+0L1K1EeLcumzRAVQn3zySRdHxQD1PlGRTaVrX1TcV8e6rqfR/KtFz5rz2Iq+k7pX0TbR/ibP7xvd2+p6WM38EI1t/e3VuXPnpI3u4XQOzFOkTtdUs3T+1fcqGoPNefxUSr9vUZG1p59+2sVr165N2uh7pucD0Rjt1KmTi7XAbp7Pc8GCBUmbO++808VTpkxxsf5+M0vPNyhaWR39nup5lFk6N0XFJFesWFHvfaN5Rvet+jrRedk+++zj4ug3qBZo1vksT8FmFCOaR7R4cVSYWz8jnfej32jVnDlpwW8tSGmW7tP0jCw6I9A5K9q3Nfb8xF94AwAAAAAAAABKgQNvAAAAAAAAAEApcOANAAAAAAAAACiFmufwjvIYaV6/IUOGuHjo0KFJH82/F+Uknjt3ros1/1uUw69NmzYu1hxLmp/PLM2lE7XRnH362v3790/66HsV5W7TPFGaFzPKbap9GjuPTkOK8gSuWbPGxfpZmaX50fQ9jHLEaU64OXPmuHjGjBlJH80RHeW81e+LPouOezOzxx57zMVRPiWk9L0dMWKEi6Mca/r9j3Kqa/49zZut48AszR+48847u7h3795JH51Lo/z0mh9Zc29pbjqzdC6qZg6JclyWeS7SsaL5HnXtMUvfj2hu0jle16NojGo+ce2jtSzM0nlH8/OapeNNc8ZHa5jmG3z55ZeTNpr3UufbKH9lS5cnJ3aePICaIzL63PU+uvZFObw1/260N8zK61vUfFHmeUflGRead1LXHrN0XGi+frO0Ho/m/dc1zCydB3XO0z2uWTqvRPtpfS1dpzXPqVm6LkdtdBzrehmtnzpnR/NicxF9R/W7rGtQ9F3XMRj9jsrKa5onv3WeugB6TesYmKXfCX2daN+XJw+rvp+NWbegKdD3VcfFq6++mvTR84Bo/dExqLn2o89G99iai1dri0TPO3bs2KTNc88952Kt5aS/Uc3Suag5zyGNSdeKPHXPov2mfk91PEW5nLUOxoABA1ys+bqja9FvRR0beibAfrnh1OrMKarnpPOP/rbSecUsXZujMyfNMa7/pug32+OPP+7iaN/W2Ptu/sIbAAAAAAAAAFAKHHgDAAAAAAAAAEqBA28AAAAAAAAAQCnUPId3lE9U82BprtAo17bmVIpyVSvNuRblJdScMpp/T3P6Rdc2bNiQtNEcPZofLM/zb7fddpnXNK+P5uM0S/MHl1mefH2a70rzxUZt9H3VMWsWj/X36969e3Ktc+fOLo5yLmvuOc3T9MgjjyR9HnjgARdrfjGzxs+n1NiisaG5qvbcc08XR7lCdc6I8ltpri0dX1GOy912283Fw4YNqzc2S/OWRnm0dPy88MILLo5yhRWVs7sl0X+/jq0oZ6m+z1E+OM0v2rdv38xn0fGma6HmbDMz22OPPeqNzcy6dOniYv03z5w5M+kzdepUF+t4NEu/U5rDW3O7tkR51jodP9EapXkl99prLxfrGmWWjt358+e7OMpnq88S5bDXvZV+ztF3BpXTsaJ5QXfYYYekj84zuj6Zme2+++4u7tOnj4vz1C1Qeg+zdN6J1izdY+u/WfPOm6Xr5apVq5I28+bNc7GO9WjOLtNaGOWm1f2x/obT+hVm6XsS5ZnVz1D3sVEf/a2oe6vod+Dee+/t4oMOOihpo/t3fe2oTo6uW9E+XOc0cjN7+v5E84X+3o7eZ/0Nrt/TqI6JzjM77riji6OzCp0fpkyZkrRZsmSJi3Xdi56fcVEM3cdqbQqzdB2I6mRl7UmjtW748OEu/sQnPuFirRllls6ds2fPTto8/fTTLtbfoIyd2qnmzCmqQ1DEmZPOaVEfndOiNrpm6vh/9NFHkz5aqyDPGWdD4y+8AQAAAAAAAAClwIE3AAAAAAAAAKAUOPAGAAAAAAAAAJQCB94AAAAAAAAAgFKoedHKKIG7Fo/Q4h9RQSpNzh4Vi9DCW1r4IbrvwoULXbxo0SIXR8UKtDhJVGBCn1cLP+l7YJYmrV+zZk3SRgtk6nuXpyhKmWlBk+jfru/h5MmTkzb777+/i3v16uViLV5ilib/16JOUQFULbYSFV965plnXPzYY4+5+P7770/6aEGmll6gMpLnPdHiDQMHDkzaaNG3qCCFFkHReTEqpJRVMDMqaqvFSqKxreNHi1ZGc0geWcU7WlrhFC3aofN5VOxY16ioYKCOQV1LoiJvOo61cHRULHennXZycdu2bZM2OqfpWNK5yywtuqNrrllaLE7XRuaz9PsVFZPTfUhU1FqLsWnhwei+ur7oPipa63QtzlPcr6jPmfHiZRUzjQoZaXGvAQMGJG10btICu9HnoOuCtol+Q2iBuWi86d5Y5+OoqJjOk9FvBu2nbaI+zXn86fsfFdjWwmq6J4qKoOr7GM0z+pnpOqBxdB9dQ3V+MzMbOnRoZht9Ft1rReuYjsuomK/+G/IUaWxJiiqYrvfR8RftgbTIoM55+vvNzGzChAkujooM6u88nata2l65Iek4GDJkSNJG56uosLruebTwczSetCilFoKO1qSXXnrJxXfccUfS5l//+peLteh7S59DGlJ05qTz/qRJk5I2gwcPdrGeZ+rvMbPqzpx0vdHiq2Zmzz33nIvznDktX77cxdEc1tjjkL/wBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKNc/hrXnPzMyWLVvm4gULFrhY8yWbpTmVovyPmgdLc21HuXU1v5bGmqvSLF+OW30+zXGnORPN0ueP8tNpHljNDbR69eqkjz5vS8oPFv1bNX/a4sWLkzb33Xefi3UcH3DAAUkfzeut+YqifPCa43b69OlJm6eeesrFOo6jPE2aR7Kxcyc1F/o+6diIcu936dLFxVHe5egzer8oP7LOeZob7PHHH0/6PProoy5++OGHkzbTpk1zseZLLir3Vksfc5obTdcSzetuluZpi/IA9uvXz8VabyBrrJml403zD5ql65HmLDRL56bnn3/exVHuQ/1Oae43s3Rda0l1KPLSXLXRnkI/Z82ta5bmAdTaAFHeWf1uz5s3z8XRZ6r5TqNcx1n5nGulzHNVlM9Wr+n3Pxonui+PckpG69j7Rb8HdJ5cuXKli6Pxp22iOU/3eboP1vnNLJ2To/y7mqtZnz/6N5Zp/oq+K3pN9y55akRE+yadD/LUZdKxq/Ob5kaNXjv67aVjYerUqS6O1kcdT9HvSepT1E/fj+j9yaofY5bmntff5FHedh0rOhfpGDBLc3gvWbIkaaPzlc5FjIHa0T1p9HtHf8tH62FWrZOoboFe07XjgQceSPr86U9/cvGTTz6ZtNGzrmheRMPIc+YU1XsYO3asi3WtGzZsWNJH19A8Z076G03PA8zSMaZnTtGerDnMYfyFNwAAAAAAAACgFDjwBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKNS9aqYWKzMwmT55ccZ/evXu7OCrQpAUAtDjBnDlzkj7z5893sSZjj4qXaEGAKEm9XtOCGdHzqyjpuxbE0efbsGFD0icqztNSRJ+NFgOIilZqsT8dS/fcc0/SRz9jHUsrVqxI+mgBVy0gaJZ+pi2p6GhD0+/cvffe62ItEGiWfr86duyYtNEiOlrUNip0pUWQpkyZ4mItUGmWFqDIUzxOC2rlKTYRFQWCl1XgqGvXrkkfHTvbbrttZhstuNWtW7ekj36mum5o0RuztKDu008/nbR58cUXXazFTaIiXVpYOVrvqxmTLY1+B6OCgR06dKg3NksLKWlh3mhN0iI8ureK5h3dn0XFv4soWpmnT0saT3mKDOr3LSqyqIUto8JFup/WvXK0B9Ki9RrrPc3SYoDRPl3XWP1+RP9GHbfROM4qmBk9S3Meb/rs0e8JncM11gKBZulvuj59+iRttFicrn1aYNfMrF27dsm194sKnOqY08JeZun6rUUsde0zS9fV6LUbq1Bvc6HvR/T7R+cZ/e6bpUUFdex06tQp6aPfZR0DUQHBmTNnujhaP3Xtq+Yzj/bgjJ1sumf997//nbTRPWpUgDLrN53ewyz9DffEE0+4+KGHHkr66PlEtL5wJtB4svZSZunv+4Y6c4p+f+mZk+5nzNJ1qizji7/wBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKNc/hrbm1zNKcMePGjXOx5g41S/NtaT4uszR3juaai3IfaZs8uUOryRGp+Z7y5MCNXkdz6ejz5smL2ZJE76G+Z9H7o7kmo1xIWa+VFaPpycp1fN111yV9TjjhBBf37NkzaaO5tlSU52/GjBn1xprH1CzN4RXl2yxiPmAsZ9N5RnPRjh07NumzZMmSemMzsz322MPFml8wyuWsOVVffvllF2vud7M0L3OUd05zlGqe5jxrbktenzaHvm/Rd133X9F+TPNxaz7b6DOcPn26i3WcRrlqdW9STQ5v8nNXLno/dBzonjzK1685Srt375600blHx9a8efOSPnPnznWx5j7NM4fk2SvnoWMy+r5k7R/LPv6i90T3Hfo5R7UotIZFlI9br+kYjPKl6t5d16hordNruj6apTVVNL+7jnWzdOxG713Zx0vRou+1/p6O3lNto/eJfuNpvmfdc+s6aJaOizw5l6upm8O4qY6+b3fddVfSRj/Dfv36JW3atGnjYp2LohzeOp50ntT9s1m+mnFoOvKcOUVzgub5juqdZL0WZ0714y+8AQAAAAAAAAClwIE3AAAAAAAAAKAUOPAGAAAAAAAAAJRCq0pyvLRq1apBEsLkyW8dtcnTT2lOuDz3LCKPZJ4cY3nyh9cwZ88zdXV1Q4u6mWqosYQmoaZjyax240m/k9F8sdNOO7l40KBBSZvtt9/exZrTa8OGDUkfzYur+QM1b6ZZmoM0ynFZgrxfpZiborVFc71HuU+7dOniYs1zutVWaWkOHRc63qL8o5qHOco7l5VfsNoaGA2o2c5NKpqbdCxss802SZv27dvX2yfKGak54fPkVNaxEs1NJciHXIq56QNe28XReNPaOtXUqtExEI2/FpLLvdnMTfo56zoW1ZXQWid9+vRJ2uyyyy4ubteunYujz3jNmjUuXrRokYuj2ieabzfaj+mcl2ev1cTy7ZZ2btK5KBpvek33TVEOeV0LtdZOlGdX90nRGMgzx2Vp5Pmt2cxN1dCx0rdv36RN586d671HtF/WuUdrZ2geZ7NS7InyKPV4QsOqq6sLN578hTcAAAAAAAAAoBQ48AYAAAAAAAAAlAIH3gAAAAAAAACAUuDAGwAAAAAAAABQCml1qyagIQvSZBWLqKYQpll1z1fSYgRAs6XfyagwkRaXjArZtGnTxsVaKC4qJqeFkzSOCpzo8zWDooEtVvQ5aCGs119/PWmj16pdo7IwTpqXaC+j40ljs7j4LaDyrIXRNZSfjo08887atWtdPGPGjKSNFiPUOFr7qinKXVQbNA5d+7TAqFl24e7ly5cnfXQ+0+LMeQrqsgdvfnT8zJw5M2mjBU31N17r1q2TPjrmdExWW6AZQDb+whsAAAAAAAAAUAoceAMAAAAAAAAASoEDbwAAAAAAAABAKTTJHN4NKSs/Up78SXnyyAEoJ827FuXW1lxt69atc/GWW26ZeV9yAyLCZw4AaE7y7GeyaiwBkWjc6LVNmza5uJp88GgZqqmPwrkQ0LTwF94AAAAAAAAAgFLgwBsAAAAAAAAAUAoceAMAAAAAAAAASoEDbwAAAAAAAABAKbT4opVFoBABgPpkFb+hOBMAAABQWxSkRC0xnoCmhb/wBgAAAAAAAACUAgfeAAAAAAAAAIBS4MAbAAAAAAAAAFAKlebwXmFm82vxIGhyetf4/oyllqPWY8mM8dSSMDehKMxNKBJzE4rC3IQiMTehKMxNKBLjCUX5wLHUisT6AAAAAAAAAIAyIKUJAAAAAAAAAKAUOPAGAAAAAAAAAJQCB94AAAAAAAAAgFLgwBsAAAAAAAAAUAoceAMAAAAAAAAASoEDbwAA/l87diADAAAAMMjf+h5fYQQAAAAsCG8AAAAAABaENwAAAAAAC8IbAAAAAICFAAAbjz+VGxy8AAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 1872x360 with 20 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# display original and reconstructed images, in rows\n",
        "display_images(images, reconstructions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "collapsed": true,
        "id": "tDqsUBJbk89m"
      },
      "outputs": [],
      "source": [
        "from math import atan, degrees\n",
        "\n",
        "shear_degrees = degrees(atan(0.2))\n",
        "\n",
        "# convert data to Tensor *and* perform random affine transformation\n",
        "transform = transforms.Compose(\n",
        "    [transforms.RandomAffine(degrees=100),\n",
        "     transforms.ToTensor()]\n",
        "    )\n",
        "\n",
        "# test dataset\n",
        "transformed_test_data = datasets.MNIST(root='data', train=False,\n",
        "                                       download=True, transform=transform)\n",
        "\n",
        "# prepare data loader\n",
        "transformed_test_loader = torch.utils.data.DataLoader(transformed_test_data, \n",
        "                                                      batch_size=batch_size,\n",
        "                                                      num_workers=num_workers)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "id": "ObjMvY8yk89m",
        "outputId": "ddfac793-e677-4527-ae3b-8c5e00b7d190"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1800x288 with 20 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# obtain one batch of test images\n",
        "dataiter = iter(transformed_test_loader)\n",
        "images, labels = dataiter.next()\n",
        "images = images.numpy()\n",
        "\n",
        "# plot the images in the batch, along with the corresponding labels\n",
        "fig = plt.figure(figsize=(25, 4))\n",
        "for idx in np.arange(batch_size):\n",
        "    ax = fig.add_subplot(2, batch_size/2, idx+1, xticks=[], yticks=[])\n",
        "    ax.imshow(np.squeeze(images[idx]), cmap='gray')\n",
        "    # print out the correct label for each image\n",
        "    # .item() gets the value contained in a Tensor\n",
        "    ax.set_title(str(labels[idx].item()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0OVVfQgfk89p",
        "outputId": "74ed20f7-82dc-4e54-bb4b-e38c04bef0b1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Loss: 0.59666622\n",
            "\n",
            "Test Accuracy of     0: 95% (931/980)\n",
            "Test Accuracy of     1: 51% (582/1135)\n",
            "Test Accuracy of     2: 46% (482/1032)\n",
            "Test Accuracy of     3: 41% (422/1010)\n",
            "Test Accuracy of     4: 51% (506/982)\n",
            "Test Accuracy of     5: 51% (458/892)\n",
            "Test Accuracy of     6: 46% (450/958)\n",
            "Test Accuracy of     7: 51% (526/1028)\n",
            "Test Accuracy of     8: 44% (436/974)\n",
            "Test Accuracy of     9: 51% (517/1009)\n",
            "\n",
            "Test Accuracy (Overall): 53% (5310/10000)\n"
          ]
        }
      ],
      "source": [
        "# call test function and get reconstructed images\n",
        "_, images, reconstructions = test(capsule_net, transformed_test_loader)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "e_y8z_Hhk89q",
        "outputId": "6c1f54d9-d3e0-4967-ba8e-984a4cf309bb"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1872x360 with 20 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# original input images\n",
        "display_images(images, reconstructions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "collapsed": true,
        "id": "uJETxOffk89q"
      },
      "outputs": [],
      "source": [
        "def vector_analysis(capsule_net, x, select_idx=1):\n",
        "    '''Generates perturbed iage reconstructions given some digit capsule outputs.\n",
        "       param capsule_net: trained capsule network\n",
        "       param x: a batch of digit capsule outputs\n",
        "       param select_idx: selects which image in a batch to analyze, default = 1 \n",
        "       return: list of perturbed, reconstructed images\n",
        "       '''\n",
        "    \n",
        "    classes = (x ** 2).sum(dim=-1) ** 0.5\n",
        "    classes = F.softmax(classes, dim=-1)\n",
        "\n",
        "    # find the capsule with the maximum vector length\n",
        "    # here, vector length indicates the probability of a class' existence\n",
        "    _, max_length_indices = classes.max(dim=1)\n",
        "\n",
        "    # create a sparse class matrix\n",
        "    sparse_matrix = torch.eye(10) # 10 is the number of classes\n",
        "    if TRAIN_ON_GPU:\n",
        "        sparse_matrix = sparse_matrix.cuda()\n",
        "    # get the class scores from the \"correct\" capsule\n",
        "    y = sparse_matrix.index_select(dim=0, index=max_length_indices.data)\n",
        "\n",
        "    # create reconstructed pixels\n",
        "    x = x * y[:, :, None]\n",
        "    \n",
        "    # flatten image into a vector shape (batch_size, vector_dim)\n",
        "    flattened_x = x.reshape(x.size(0), -1)\n",
        "    # select a single image from a batch to work with\n",
        "    flattened_x = flattened_x[select_idx]\n",
        "    \n",
        "    # track reconstructed images\n",
        "    reconstructed_ims = []\n",
        "    # values to change *one* vector dimension by\n",
        "    perturb_range = np.arange(-0.25, 0.30, 0.05)\n",
        "    \n",
        "    # iterate through 16 vector dims\n",
        "    for k in range(16):\n",
        "        # create a copy of flattened_x to modify\n",
        "        if TRAIN_ON_GPU:\n",
        "            transformed_x = torch.zeros(*flattened_x.size()).cuda()\n",
        "        else:\n",
        "            transformed_x = torch.zeros(*flattened_x.size())\n",
        "            \n",
        "        transformed_x[:] = flattened_x[:]\n",
        "        # iterate through each perturbation value\n",
        "        for j in range(len(perturb_range)):\n",
        "            # for each capsule output\n",
        "            for i in range(10):\n",
        "                transformed_x[k+(16*i)] = flattened_x[k+(16*i)]+perturb_range[j]\n",
        "\n",
        "            # create reconstructed images\n",
        "            reconstructions = capsule_net.decoder.linear_layers(transformed_x)\n",
        "            # reshape into 28x28 image, (batch_size, depth, x, y)\n",
        "            reconstructions = reconstructions.view(-1, 1, 28, 28)\n",
        "            reconstructed_ims.append(reconstructions)\n",
        "    \n",
        "    # return final list of reconstructed ims    \n",
        "    return reconstructed_ims\n",
        "        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "collapsed": true,
        "id": "QKo72txzk89r"
      },
      "outputs": [],
      "source": [
        "# call function and get perturbed reconstructions\n",
        "reconstructed_ims = vector_analysis(capsule_net, caps_output, select_idx=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "6MGCJDhtk89r",
        "outputId": "0e02ab89-8695-42da-d0fc-36c897cd1bcb"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 720x1440 with 176 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig = plt.figure(figsize=(10, 20)) # define figsize\n",
        "\n",
        "# display all ims\n",
        "for idx in range(len(reconstructed_ims)):\n",
        "    # convert to numpy images\n",
        "    image = reconstructed_ims[idx]\n",
        "    image = image.detach().cpu().numpy()\n",
        "    # display 16 rows of images\n",
        "    ax = fig.add_subplot(16, len(reconstructed_ims)/16, idx+1, xticks=[], yticks=[])\n",
        "    ax.imshow(image.squeeze(), cmap='gray')\n",
        "    "
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Capsule_Network_original.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}