MOCA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "colab": {
      "name": "MOCA.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.8"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kQC1XFs4Q5xR"
      },
      "source": [
        "# Continuous Meta-Learning without Tasks\n",
        "Notebook  by: Swapnil Ahlawat\n",
        "\n",
        "Paper link: https://arxiv.org/pdf/1912.08866.pdf\n",
        "\n",
        "The paper tries to develop a generic wrapping algorithm that can enable any meta learning algorithm to perform well on unsegmented time-series data. It presents meta-learning via online changepoint analysis (MOCA), an approach that combines meta learning with differentiable Bayesian changepoint detection schemes to softly detect task switches and make predictions according to that.\n",
        "\n",
        "For the prediction at every time step, MOCA maintains a belief (probability), b[r=t], over all possible run-lengths (Here run lengths mean number of past data points belonging to current task). It also maintains separate versions of the base meta learning algorithm’s posterior parameters for all possible run-lengths, n[t][r=x]. Then it uses the belief probability along with their probabilistic prediction for the label, p(yhat | x, n[t][r=x]), to calculate the final prediction probability, p(yhat | x[1:t], y[1:t-1]). The belief is updated after observing every datapoint. This way of maintaining belief acts as a **soft version of estimating the task switch points** in the unsegmented time-series.\n",
        "\n",
        "Putting all the MOCA steps mathematically:\n",
        "1. Predict p(yhat | x[1:t], y[1:t−1]): Summation of b[r]*p(yhat | x[t], n[t-1][r] over all run lengths\n",
        "2. Observe label for current time step and calculate loss.\n",
        "3. Update posterior parameters: Calculate n[t][r] for all run-lengths\n",
        "4. Compute b[r | x[t], y[t]]: proportional to b[r]*p(y[t] | x[t], n[t-1][r])\n",
        "5. Update belief: If r=0, b[r]= Hazard rate, else b[r]= (1- Hazard rate)*b[r-1 | x[t], y[t]]\n",
        "\n",
        "*Hazard rate is probability that the current data point is the task switch point (Hyperparameter)*\n",
        "\n",
        "During training, the losses are cumulated over the complete time series and then gradient update step is performed after that. There is no gradient update step in testing.\n",
        "\n",
        "In the paper, there is also another step where you partial update belief based on only X, but this step relies on maintaining a generative model of the input variable, which is atypical for most regression models and is not\n",
        "done for discriminative classification models. Hence, I have skipped that step in this notebook.\n",
        "\n",
        "In this noteboook, I have done two experiments:\n",
        "1. **Classification using CNP with MOCA**: I have implemented MOCA on top of CNP and compared its results with baseline, oracle and an ablated model.\n",
        "2. **Time Series Forecasting using LSTM meta-learner with MOCA:** I have performed time-series forecasting using MOCA and LSTM meta-learner. Its result has been compared to a baseline model. A different way of calculating base meta-learning algorithm’s conditional posterior predictive, p(y[t] | x[t], n[t][r=x]),  in regression scenario has also been tried.\n",
        "\n",
        "**Ablation performed:**\n",
        "\n",
        "To see the role of belief probability in MOCA, I have compared the performance of general MOCA with that of a version of MOCA in which belief probability over all run-lengths is equal (uniform belief probability). This ablation is performed in experiment 1.\n",
        "\n",
        "**Extensions performed:**\n",
        "1. The paper demonstrated the utility of this approach only on regression and classification task. I have tried to use MOCA for a time-series forecasting task in experiment 2.\n",
        "2. An easier way of calculating meta-learning algorithm’s conditional posterior predictive, p(y[t] | x[t], n[t][r=x]), in regression scenario has been implemented in experiment 2.\n",
        "\n",
        "\n",
        "**To reproduce results:**\n",
        "All the weights and datasets used are saved and given with this notebook. To reproduce the result, you can directly move on to result/test accuracy section of each model and get the results (without training the model). \n",
        "\n",
        "Running the complete notebook will overwrite these weights and datasets, so kindly keep a backup."
      ],
      "id": "kQC1XFs4Q5xR"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GJH1S-a2TLgK"
      },
      "source": [
        "### Install packages\n",
        "If you are running this on local environment and learn2learn installation fails, run the following command, restart the kernel and run the cell again:\n",
        "\n",
        ">sudo apt install libjpeg8-dev zlib1g-dev"
      ],
      "id": "GJH1S-a2TLgK"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qxYK1EN0WIMO"
      },
      "source": [
        "! pip3 install torch torchvision torchaudio && pip install matplotlib && pip install scikit-learn && pip install learn2learn"
      ],
      "id": "qxYK1EN0WIMO",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "17e500b5"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import Dataset\n",
        "from matplotlib import pyplot as plt\n",
        "import learn2learn as l2l\n",
        "import sklearn.datasets as skds\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "id": "17e500b5",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "99f029fb"
      },
      "source": [
        "import random\n",
        "import numpy as np\n",
        "import matplotlib\n",
        "import os\n",
        "from scipy import randn, rand\n",
        "import io\n",
        "import base64\n",
        "from IPython.display import HTML, clear_output"
      ],
      "id": "99f029fb",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OT7K0U7FYmNx"
      },
      "source": [
        "dataset_folder='datasets/'\n",
        "weight_folder= 'weights/'\n",
        "result_folder= 'results/'\n",
        "\n",
        "if not os.path.exists(dataset_folder):\n",
        "    os.mkdir(dataset_folder)\n",
        "\n",
        "if not os.path.exists(weight_folder):\n",
        "    os.mkdir(weight_folder)\n",
        "\n",
        "if not os.path.exists(result_folder):\n",
        "    os.mkdir(result_folder)"
      ],
      "id": "OT7K0U7FYmNx",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jzfIoutDTroF"
      },
      "source": [
        "# Experiment 1: Classification using CNP with MOCA\n",
        "CNP- https://arxiv.org/pdf/1807.01613.pdf\n",
        "\n",
        "Implementation and performance comparison of CNP with MOCA on a 2-way classification task.\n",
        "\n",
        "## Intuition behind using CNP\n",
        "MOCA is required to maintain different versions of posterior parameters for various run-lengths which serves as distribution representation for these run-lengths. In the paper, for the classification task, they have assumed the data to follow Categorical-Gaussian generative model and used Dirichlet prior over the class probabilities and a Gaussian prior over the mean for each class and use its variables as posterior parameters.\n",
        "\n",
        "Instead of following this complex probabilistic approach for classification, I have used CNP to learn these posterior parameters and perform classification. For each run-length, the adapt step in CNP encodes all the data points of that run-length into a vector that act as a posterior parameter in MOCA(representation of distribution for this run-length). As the encoding weights would also be updated in every training step, CNP would keep on learning a better way to encode the distribution. \n",
        "\n",
        "The model was able to achieve 83% test accuracy within 2000 epochs."
      ],
      "id": "jzfIoutDTroF"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4698813c"
      },
      "source": [
        "## Unsegmented Time-series Euclidean Dataset Generation\n",
        "The code for generating euclidean dataset has been taken from Meta Learning course notebooks. It has been modified to get unsegmented time-series dataset.\n",
        "\n",
        "A 20-way 20-dimensional euclidean dataset has been used for generating dataset."
      ],
      "id": "4698813c"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FEJAqDO-ZMQW"
      },
      "source": [
        "class MyDS(Dataset):\n",
        "    def __init__(self, X,y):\n",
        "        self.samples = torch.Tensor(X)\n",
        "        self.labels = torch.LongTensor(y)\n",
        "        \n",
        "    def __len__(self):\n",
        "        return len(self.samples)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        return (self.samples[idx],self.labels[idx])"
      ],
      "id": "FEJAqDO-ZMQW",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pvu41QXYZNLT"
      },
      "source": [
        "def euclideanDataset(n_samples=1000,n_classes=2,class_sep=2.0,n_features=5,batch_size=1):\n",
        "    X,y = skds.make_classification(n_samples=n_samples,n_classes=n_classes,\n",
        "                                   class_sep=class_sep,n_features=n_features, \n",
        "                                 n_informative=n_features,n_redundant=0,\n",
        "                                 n_repeated=0,n_clusters_per_class=1)\n",
        "    X_train,X_test,y_train,y_test = train_test_split(X,y)\n",
        "    ds = MyDS(X_train,y_train)\n",
        "    ds_hold = MyDS(X_test,y_test)\n",
        "    dsloader = torch.utils.data.DataLoader(dataset=ds,batch_size=batch_size,shuffle=True)\n",
        "    return ds,ds_hold,dsloader"
      ],
      "id": "pvu41QXYZNLT",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "417cad98"
      },
      "source": [
        "#20-dimensional Euclidean dataset with 20 class labels\n",
        "meta_train_ds, meta_test_ds, _ = euclideanDataset(n_samples=20000,n_features=20,n_classes=20,batch_size=32)"
      ],
      "id": "417cad98",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ImdG2rujZS4A"
      },
      "source": [
        "class KShotLoader():\n",
        "    def __init__(self,myds,num_tasks=1000,shots=2,ways=2,classes=None):\n",
        "        self.shots = shots\n",
        "        self.ways = ways\n",
        "        self.myMds = l2l.data.MetaDataset(myds)\n",
        "        if classes == None:\n",
        "            n_classes = len(set(myds.labels))\n",
        "            classes = [i for i in range(n_classes)]\n",
        "        self.my_tasks = l2l.data.TaskDataset(self.myMds, task_transforms=[\n",
        "                                l2l.data.transforms.FilterLabels(self.myMds,classes),\n",
        "                                l2l.data.transforms.NWays(self.myMds,ways),\n",
        "                                l2l.data.transforms.KShots(self.myMds, shots),\n",
        "                                l2l.data.transforms.LoadData(self.myMds),\n",
        "                                l2l.data.transforms.RemapLabels(self.myMds),\n",
        "                                l2l.data.transforms.ConsecutiveLabels(self.myMds)\n",
        "                                ],num_tasks=num_tasks)\n",
        "    def get_task(self):\n",
        "        data,labels = self.my_tasks.sample()\n",
        "        return data, labels"
      ],
      "id": "ImdG2rujZS4A",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b28aa56d"
      },
      "source": [
        "ways= 2 #Number of ways"
      ],
      "id": "b28aa56d",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i4DEOBENVakd"
      },
      "source": [
        "For getting training dataset, 1000 tasks with random number of shots between 2 to 10 are concatenated to generate unsegmented time-series training data."
      ],
      "id": "i4DEOBENVakd"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dbfb3b12"
      },
      "source": [
        "numTasks=1000\n",
        "X_train=torch.empty(0)\n",
        "y_train= torch.empty(0, dtype=torch.long)\n",
        "oracle_tasks_train=[] #To get dataset with task switches known (for oracle model)\n",
        "for i in range(numTasks):\n",
        "    #Selecting Number of shots for this task\n",
        "    shots= random.randint(2, 10)\n",
        "    meta_train_kloader=KShotLoader(meta_train_ds,shots=shots,ways=ways,num_tasks=1000)\n",
        "    X, y=meta_train_kloader.get_task()\n",
        "    #Randomising Order of data points\n",
        "    rp = torch.randperm(y.shape[0])\n",
        "    X=X[rp]\n",
        "    y=y[rp]\n",
        "    #Concatenating the task to the unsegmented time series\n",
        "    X_train= torch.cat([X_train, X], dim=0)\n",
        "    y_train= torch.cat([y_train, y], dim=0)\n",
        "    oracle_tasks_train.append((X, y))"
      ],
      "id": "dbfb3b12",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3OBT7OJVXzHH"
      },
      "source": [
        "Same method is used to get test dataset, but with only 100 tasks"
      ],
      "id": "3OBT7OJVXzHH"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0cf6319f"
      },
      "source": [
        "numTasks=100\n",
        "X_test=torch.empty(0)\n",
        "y_test= torch.empty(0, dtype=torch.long)\n",
        "oracle_tasks_test=[] #To get dataset with task switches known (for oracle model)\n",
        "for i in range(numTasks):\n",
        "    #Selecting Number of shots for this task\n",
        "    shots= random.randint(2, 10)\n",
        "    meta_test_kloader=KShotLoader(meta_test_ds,shots=shots,ways=ways,num_tasks=1000)\n",
        "    X,y=meta_test_kloader.get_task()\n",
        "    #Randomising Order of data points\n",
        "    rp = torch.randperm(y.shape[0])\n",
        "    X=X[rp]\n",
        "    y=y[rp]\n",
        "    #Concatenating the task to the unsegmented time series\n",
        "    X_test= torch.cat([X_test, X], dim=0)\n",
        "    y_test= torch.cat([y_test, y], dim=0)\n",
        "    oracle_tasks_test.append((X, y))"
      ],
      "id": "0cf6319f",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GLxW4mI0YIFh"
      },
      "source": [
        "Saving Dataset"
      ],
      "id": "GLxW4mI0YIFh"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b2001415"
      },
      "source": [
        "if not os.path.exists(dataset_folder):\n",
        "    os.mkdir(dataset_folder)\n",
        "torch.save((X_train, y_train), dataset_folder+'euclidean_train.pt')\n",
        "torch.save((X_test, y_test), dataset_folder+'euclidean_test.pt')\n",
        "torch.save(oracle_tasks_train, dataset_folder+'euclidean_train_oracle.pt')\n",
        "torch.save(oracle_tasks_test, dataset_folder+'euclidean_test_oracle.pt')"
      ],
      "id": "b2001415",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fcd91020"
      },
      "source": [
        "## Models"
      ],
      "id": "fcd91020"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6vURfa6-ZySK"
      },
      "source": [
        "# Load Dataset\n",
        "X_train, y_train= torch.load(dataset_folder + 'euclidean_train.pt')\n",
        "X_test, y_test= torch.load(dataset_folder +'euclidean_test.pt')"
      ],
      "id": "6vURfa6-ZySK",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fNvZjB94ilhj"
      },
      "source": [
        "# Load Oracle data\n",
        "data_train= torch.load(dataset_folder+'euclidean_train_oracle.pt')\n",
        "data_test= torch.load(dataset_folder+'euclidean_train_oracle.pt')"
      ],
      "id": "fNvZjB94ilhj",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ofRXNuepZEDF"
      },
      "source": [
        "MLP class (Taken from Meta Learning course notebooks)"
      ],
      "id": "ofRXNuepZEDF"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q_zwRt4haud0"
      },
      "source": [
        "class MLP(nn.Module):\n",
        "    def __init__(self,dims=[5,3,2],task='classification'):\n",
        "        super(MLP,self).__init__()\n",
        "        self.dims=dims\n",
        "        self.n = len(self.dims)-1\n",
        "        self.task=task\n",
        "        self.layers=nn.ModuleList()\n",
        "        for i in range(self.n-1):\n",
        "            self.layers.append(nn.Linear(dims[i],dims[i+1]))\n",
        "            self.layers.append(nn.ReLU())\n",
        "        if task=='classification': \n",
        "            self.layers.append(nn.Linear(dims[i+1],dims[i+2]))\n",
        "            self.layers.append(nn.LogSoftmax(dim=1))\n",
        "        elif task=='regression': \n",
        "            self.layers.append(nn.Linear(dims[i+1],dims[i+2]))\n",
        "            self.layers.append(nn.Linear(dims[i+2],1))\n",
        "        else: self.layers.append(nn.Linear(dims[i+1],dims[i+2]))\n",
        "\n",
        "    def forward(self,x):\n",
        "        for l in self.layers:\n",
        "            x = l(x)\n",
        "        return(x)"
      ],
      "id": "Q_zwRt4haud0",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3pUNAD5CZi5G"
      },
      "source": [
        "CNP class (Taken from Meta Learning course notebooks and modified slightly)"
      ],
      "id": "3pUNAD5CZi5G"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "64f2b975"
      },
      "source": [
        "class CNP(nn.Module):\n",
        "    def __init__(self,n_features=1,dims=[32,32],n_classes=2, optimizerReq=False, lr=1e-3):\n",
        "        super(CNP,self).__init__()\n",
        "        self.n_features = n_features\n",
        "        self.n_classes = n_classes\n",
        "        self.dimL1 = [n_features]+dims\n",
        "        self.dimL2=[n_features+n_classes*dims[-1]]+dims+[n_classes]\n",
        "        self.mlp1 = MLP(dims=self.dimL1,task='embedding')\n",
        "        self.mlp2 = MLP(dims=self.dimL2)\n",
        "        if optimizerReq:\n",
        "            self.optimizer=torch.optim.Adam(self.parameters(),lr=lr)\n",
        "    \n",
        "    def getEncodingSize(self):\n",
        "        return self.dimL1[-1]*self.n_classes\n",
        "    \n",
        "    def adapt(self,X,y):\n",
        "        R = self.mlp1(X)\n",
        "        m = torch.eye(self.n_classes)[y].transpose(0,1)/self.n_classes\n",
        "        r = (m@R).flatten().unsqueeze(0)\n",
        "        return r\n",
        "        \n",
        "    def forward(self,X,r):\n",
        "        rr = r.repeat(X.shape[0],1)\n",
        "        p = self.mlp2(torch.cat((X,rr),dim=1))\n",
        "        return p"
      ],
      "id": "64f2b975",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KxPVqgmdZmij"
      },
      "source": [
        "### MOCA Class\n",
        "This class has been implemented completely from scratch. It is wrapper class which requires a base model (CNP in this case).\n",
        "\n",
        "Terminologies:\n",
        "1. Hazard rate (hazard_rate): Probability that the current data point is the task switch point (Hyperparameter)\n",
        "2. Run-length: Number of past data points belonging to current tasks.\n",
        "2. Belief (logb): Probability distribution over all possible run-lengths. In essence, high belief for a particular run-length means that this is the most likely the run-length for current datapoint. (Softer version of task switches)\n",
        "\n",
        "All the operations in this class are performed in log for improved numerical performance."
      ],
      "id": "KxPVqgmdZmij"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1fb3f1ed"
      },
      "source": [
        "class MOCA(nn.Module):\n",
        "    def __init__(self, baseModel, hazard_rate, lossfn, lr=1e-4):\n",
        "        super(MOCA,self).__init__()\n",
        "        self.hazard_rate= hazard_rate\n",
        "        self.baseModel= baseModel #Base meta-learning algorithm\n",
        "        self.encodingSize= baseModel.getEncodingSize()\n",
        "        self.lossfn= lossfn\n",
        "        self.optimizer=torch.optim.Adam(self.parameters(),lr=lr)\n",
        "    \n",
        "    def forward(self, X, y):\n",
        "        #Length of time-series data\n",
        "        T= X.shape[0]\n",
        "        #Initialising belief (b(r=0)=1)\n",
        "        logb= torch.tensor([0])\n",
        "        loss=0\n",
        "        acc=0\n",
        "        for t in range(T):\n",
        "            yhat=[]\n",
        "            #Calulcating p(yhat | x, history) for all run lengths\n",
        "            for hist in range(t+1):\n",
        "                if hist==0:\n",
        "                    encoding= torch.randn((1,self.encodingSize))\n",
        "                else:\n",
        "                    #Using CNP adaptation step to caclulate posterior parameters (history)\n",
        "                    encoding= self.baseModel.adapt(X[t-hist:t], y[t-hist:t])\n",
        "                #Storing log( b(r=len(history)) * p(yhat | x, history))\n",
        "                yhat.append(self.baseModel(X[None,t], encoding) + logb[hist])\n",
        "            yhat= torch.stack(yhat)\n",
        "            #Summing over b(r=len(history)) * p(yhat | x, history) to get prediction probability p(yhat | x[1:t], y[1:t-1]) (Marginalisation)\n",
        "            ypred= torch.logsumexp(yhat, dim=0)\n",
        "            _, predicted = torch.max(ypred, 1)\n",
        "            if(predicted==y[None, t]):\n",
        "                acc+=1\n",
        "            #Calculating loss\n",
        "            loss+= self.lossfn(ypred, y[None, t])\n",
        "            #Updating belief after observing the label\n",
        "            #b(r=0)= hazard rate and b(r=t)= (1-hazard rate)*b(r=t-1) * p(yhat | x, history)\n",
        "            logbhist= torch.log(torch.tensor(1-self.hazard_rate))+torch.log_softmax(yhat[:, 0, y[t]], dim=0)\n",
        "            logb0= torch.log(torch.tensor([self.hazard_rate]))\n",
        "            logb= torch.cat((logb0, logbhist))\n",
        "        return loss, (acc/T)*100"
      ],
      "id": "1fb3f1ed",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UZEeBwhykNGc"
      },
      "source": [
        "#### Training\n",
        "\n",
        "As the whole data series is very long and impractical to train on, we'll sample \n",
        "short random series from the whole series in every epoch and train on that.\n",
        "\n",
        "\n",
        "Training parameters:\n",
        "* Time-series length: 100-300 data points\n",
        "* Epochs: 2000\n",
        "* Learning rate: 1e-3 for first 1000 epochs and 1e-4 for next 1000 epochs\n",
        "* Optimizer: Adam\n",
        "\n",
        "The series lengths are kept considerably long (between 100-300 data points) to achieve good performance on low hazard rates, as short batch lengths artificially increase the hazard rate as a result of the assumption that each batch begins with a new task."
      ],
      "id": "UZEeBwhykNGc"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d75dfe62"
      },
      "source": [
        "epochs=2000\n",
        "ways=2\n",
        "lr=1e-3\n",
        "hazard_rates= [0.01, 0.05, 0.1, 0.25, 0.5] #Model's performance testing for different hazard rates\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "\n",
        "for hazard_rate in hazard_rates:\n",
        "    #Initialise model\n",
        "    net = CNP(n_features=20,n_classes=ways,dims=[32,64,32])\n",
        "    model= MOCA(net, hazard_rate, lossfn, lr)\n",
        "\n",
        "    for i in range(epochs):\n",
        "        #Random starting point in series\n",
        "        start= random.randint(0, X_train.shape[0]-100)\n",
        "        #Random Length of series\n",
        "        T= random.randint(100, min(300, X_train.shape[0]-start))\n",
        "        #Getting the shorter time-series data\n",
        "        X= X_train[start:start+T]\n",
        "        y= y_train[start:start+T]\n",
        "        loss, accuracy= model(X, y)\n",
        "        print(\"Hazard rate: \", hazard_rate, \"Epoch: \", i, \"Data points:\", T, \"Accuracy:\", accuracy)\n",
        "        #Update step\n",
        "        model.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        model.optimizer.step()\n",
        "\n",
        "        #Change learning rate on epoch 1000\n",
        "        if (i+1)==1000:\n",
        "            for g in model.optimizer.param_groups:\n",
        "                g['lr'] = 1e-4\n",
        "    torch.save(model.state_dict(), weight_folder+'weights_MOCA_'+str(int(hazard_rate*100))+'.pt')"
      ],
      "id": "d75dfe62",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I10C8ArIjg69"
      },
      "source": [
        "#### Test accuracies\n",
        "During testing, time-series length can be as small as 50 data points. This has been done to also incorporate the performance of MOCA on shorter time-series."
      ],
      "id": "I10C8ArIjg69"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a42c8213"
      },
      "source": [
        "ways=2\n",
        "lr=1e-3\n",
        "hazard_rates= [0.01, 0.05, 0.1, 0.25, 0.5]\n",
        "accuracies=[]\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "T= [50, 100, 150, 200, 250, 300] # To get the performance on all run-lengths\n",
        "for hazard_rate in hazard_rates:\n",
        "    #Load model\n",
        "    net = CNP(n_features=20,n_classes=ways,dims=[32,64,32])\n",
        "    model= MOCA(net, hazard_rate, lossfn, lr)\n",
        "    model.load_state_dict(torch.load(weight_folder + 'weights_MOCA_'+str(int(hazard_rate*100))+'.pt'))\n",
        "    with torch.no_grad():\n",
        "        accuracy=0\n",
        "        start=0\n",
        "        while start < y_test.shape[0]:\n",
        "            for length in T:\n",
        "                end= min(start+length, y_test.shape[0])\n",
        "                if start==end:\n",
        "                    break\n",
        "                X= X_test[start:end]\n",
        "                y= y_test[start:end]\n",
        "                loss, acc= model(X, y)\n",
        "                accuracy+= acc*(end-start)\n",
        "                start=end\n",
        "        accuracies.append(accuracy/y_test.shape[0])\n",
        "        print(\"Hazard rate: \", hazard_rate, \" Test accuracy: \", accuracy/y_test.shape[0])"
      ],
      "id": "a42c8213",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PR-qbZT-mDF-"
      },
      "source": [
        "### Ablation Performed: MOCA with Uniform Belief\n",
        "\n",
        "To look at the importance of belief in MOCA, I've implemented another MOCA class, but in this version, the belief remains uniform for all run lengths (1/number of run-lengths)."
      ],
      "id": "PR-qbZT-mDF-"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpdvv3jSBILI"
      },
      "source": [
        "class MOCAUniformB(nn.Module):\n",
        "    def __init__(self, baseModel, lossfn, lr=1e-4):\n",
        "        super(MOCAUniformB,self).__init__()\n",
        "        self.baseModel= baseModel\n",
        "        self.encodingSize= baseModel.getEncodingSize()\n",
        "        self.lossfn= lossfn\n",
        "        self.optimizer=torch.optim.Adam(self.parameters(),lr=lr)\n",
        "    \n",
        "    def forward(self, X, y):\n",
        "        #Length of time-series data\n",
        "        T= X.shape[0]\n",
        "        loss=0\n",
        "        acc=0\n",
        "        for t in range(T):\n",
        "            yhat=[]\n",
        "            #Calulcating p(yhat | x, history) for all run lengths\n",
        "            for hist in range(t+1):\n",
        "                if hist==0:\n",
        "                    encoding= torch.randn((1,self.encodingSize))\n",
        "                else:\n",
        "                    encoding= self.baseModel.adapt(X[t-hist:t], y[t-hist:t])\n",
        "                #Same as before, but here, b(r)= 1/time for all run lengths\n",
        "                yhat.append(self.baseModel(X[None,t], encoding) + torch.log(torch.tensor(1/(t+1))))\n",
        "            yhat= torch.stack(yhat)\n",
        "            #Marginalisation step\n",
        "            ypred= torch.logsumexp(yhat, dim=0)\n",
        "            _, predicted = torch.max(ypred, 1)\n",
        "            if(predicted==y[None, t]):\n",
        "                acc+=1\n",
        "            loss+= self.lossfn(ypred, y[None, t])\n",
        "        return loss, (acc/T)*100"
      ],
      "id": "cpdvv3jSBILI",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wayjrgW5Q2ZZ"
      },
      "source": [
        "#### Training\n",
        "Training parameters: Same as MOCA"
      ],
      "id": "wayjrgW5Q2ZZ"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vJdQDJW1mh-V"
      },
      "source": [
        "epochs=2000\n",
        "ways=2\n",
        "lr=1e-3\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "net2 = CNP(n_features=20,n_classes=ways,dims=[32,64,32])\n",
        "model2= MOCAUniformB(net2, lossfn, lr)\n",
        "\n",
        "for i in range(epochs):\n",
        "    #Random starting point in series\n",
        "    start= random.randint(0, X_train.shape[0]-100)\n",
        "    #Random Length of series\n",
        "    T= random.randint(100, min(300, X_train.shape[0]-start))\n",
        "    #Getting the shorter time-series data\n",
        "    X= X_train[start:start+T]\n",
        "    y= y_train[start:start+T]\n",
        "    loss, accuracy= model2(X, y)\n",
        "    print(\"Epoch: \", i, \"Data points:\", T, \"Accuracy:\", accuracy)\n",
        "    model2.optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    model2.optimizer.step()\n",
        "    #Change learning rate on epoch 1000\n",
        "    if (i+1)==1000:\n",
        "        for g in model2.optimizer.param_groups:\n",
        "            g['lr'] = 1e-4\n",
        "torch.save(model2.state_dict(), weight_folder + 'weights_MOCA_Uniform_B.pt')"
      ],
      "id": "vJdQDJW1mh-V",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cxoXZlzSnPcI"
      },
      "source": [
        "#### Test accuracy"
      ],
      "id": "cxoXZlzSnPcI"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ruNtGF-Nmvog"
      },
      "source": [
        "ways=2\n",
        "lr=1e-3\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "net2 = CNP(n_features=20,n_classes=ways,dims=[32,64,32])\n",
        "model2= MOCAUniformB(net2, lossfn, lr)\n",
        "#Load saved model\n",
        "model2.load_state_dict(torch.load(weight_folder + 'weights_MOCA_Uniform_B.pt'))\n",
        "T= [50, 100, 150, 200, 250, 300]\n",
        "\n",
        "with torch.no_grad():\n",
        "    accuracy=0\n",
        "    start=0\n",
        "    while start < y_test.shape[0]:\n",
        "        for length in T:\n",
        "            end= min(start+length, y_test.shape[0])\n",
        "            if start==end:\n",
        "                break\n",
        "            X= X_test[start:end]\n",
        "            y= y_test[start:end]\n",
        "            loss, acc= model2(X, y)\n",
        "            accuracy+= acc*(end-start)\n",
        "            start=end\n",
        "    accuracy_UniformB = accuracy/y_test.shape[0]\n",
        "    print(\"Test accuracy: \", accuracy_UniformB)"
      ],
      "id": "ruNtGF-Nmvog",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wfcW7Tyiltoh"
      },
      "source": [
        "### Baseline model: Train on Everything\n",
        "This implementation consists of ignoring task variation and treating the whole training timeseries as one task. Only CNP is used and it is adapted on all past data points."
      ],
      "id": "wfcW7Tyiltoh"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNBajpWRHF5U"
      },
      "source": [
        "#Prediction function (Directly runs on CNP)\n",
        "#Simple run over the time series where prediction is done by adapting over all the past data points\n",
        "def predict(net, X, y, lossfn):\n",
        "    T= X.shape[0]\n",
        "    accuracy=0\n",
        "    loss=0\n",
        "    for t in range(T):\n",
        "        if t==0:\n",
        "            encoding= torch.randn((1,net.getEncodingSize()))\n",
        "        else:\n",
        "            encoding= net.adapt(X[:t], y[:t])\n",
        "        yhat= net(X[None, t], encoding)\n",
        "        _, predicted = torch.max(yhat, 1)\n",
        "        if predicted==y[None, t]:\n",
        "            accuracy+=1\n",
        "        loss+= lossfn(yhat, y[None, t])\n",
        "    return loss, (accuracy/T)*100"
      ],
      "id": "lNBajpWRHF5U",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K-Si_6HalxnR"
      },
      "source": [
        "Training Parameters:\n",
        "Same as MOCA except learning rate is 1e-3 for whole 2000 epochs"
      ],
      "id": "K-Si_6HalxnR"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M75cyj59nsiQ"
      },
      "source": [
        "ways=2\n",
        "lr=1e-3\n",
        "epochs=2000\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "model3 = CNP(n_features=20,n_classes=ways,dims=[32,64,32], optimizerReq= True, lr=lr)\n",
        "for i in range(epochs):\n",
        "    start= random.randint(0, X_train.shape[0]-100)\n",
        "    T= random.randint(100, min(300, X_train.shape[0]-start))\n",
        "    X= X_train[start:start+T]\n",
        "    y= y_train[start:start+T]\n",
        "    loss, accuracy= predict(model3, X, y, lossfn)\n",
        "    print(\"Epoch: \", i, \"Data points:\", T, \"Accuracy:\", accuracy)\n",
        "    model3.optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    model3.optimizer.step()\n",
        "torch.save(model3.state_dict(), weight_folder + 'weights_trainOnEverything.pt')"
      ],
      "id": "M75cyj59nsiQ",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xdpxqmXpc8d"
      },
      "source": [
        "#### Test accuracy"
      ],
      "id": "4xdpxqmXpc8d"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Z72h2LStiXk"
      },
      "source": [
        "ways=2\n",
        "lr=1e-3\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "model3 = CNP(n_features=20,n_classes=ways,dims=[32,64,32], optimizerReq= True, lr=lr)\n",
        "model3.load_state_dict(torch.load(weight_folder+'weights_trainOnEverything.pt'))\n",
        "T= [50, 100, 150, 200, 250, 300]\n",
        "\n",
        "with torch.no_grad():\n",
        "    accuracy=0\n",
        "    start=0\n",
        "    while start < y_test.shape[0]:\n",
        "        for length in T:\n",
        "            end= min(start+length, y_test.shape[0])\n",
        "            if start==end:\n",
        "                break\n",
        "            X= X_test[start:end]\n",
        "            y= y_test[start:end]\n",
        "            _, acc= predict(model3, X, y, lossfn)\n",
        "            accuracy+= acc*(end-start)\n",
        "            start=end\n",
        "    accuracy_toe= accuracy/y_test.shape[0]\n",
        "    print(\"Test Accuracy:\", accuracy_toe)"
      ],
      "id": "8Z72h2LStiXk",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S7VXrvgFl2Cd"
      },
      "source": [
        "### Oracle Model: CNP with Task Switches known\n",
        "To get the maximum achievable accuracy, we train an Oracle model. Here, the task switches of the dataset are known beforehand and CNP is adapted on past data points of only that task."
      ],
      "id": "S7VXrvgFl2Cd"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NlX-Y7w3S5lE"
      },
      "source": [
        "Training Parameters: Same as MOCA but learning rate is 1e-3 for whole 2000 epochs"
      ],
      "id": "NlX-Y7w3S5lE"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FzQp1Ku5gEqs"
      },
      "source": [
        "ways=2\n",
        "epochs=2000\n",
        "lr=1e-3\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "model4 = CNP(n_features=20,n_classes=ways,dims=[32,64,32], optimizerReq= True, lr=lr)\n",
        "for i in range(epochs):\n",
        "    numTasks= random.randint(8, 25)\n",
        "    start= random.randint(0, len(data_train)-numTasks-1)\n",
        "    loss=0\n",
        "    accuracy=0\n",
        "    for task in range(start, start+numTasks):\n",
        "        X, y= data_train[task]\n",
        "        ls, acc= predict(model4, X, y, lossfn)\n",
        "        loss+=ls\n",
        "        accuracy+=acc\n",
        "    print(\"Epoch: \", i, \"Accuracy:\", accuracy/numTasks)\n",
        "    model4.optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    model4.optimizer.step()\n",
        "torch.save(model4.state_dict(), weight_folder+ 'weights_oracle.pt')"
      ],
      "id": "FzQp1Ku5gEqs",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IygMhduPqgKr"
      },
      "source": [
        "#### Test Accuracy"
      ],
      "id": "IygMhduPqgKr"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2VIquhEjwAOd"
      },
      "source": [
        "ways=2\n",
        "lr=1e-3\n",
        "lossfn = torch.nn.NLLLoss()\n",
        "model4 = CNP(n_features=20,n_classes=ways,dims=[32,64,32], optimizerReq= True, lr=lr)\n",
        "model4.load_state_dict(torch.load(weight_folder + 'weights_oracle.pt'))\n",
        "with torch.no_grad():\n",
        "    accuracy=0\n",
        "    totalDataPoints=0\n",
        "    for task in range(len(data_test)):\n",
        "        X, y= data_test[task]\n",
        "        _, acc= predict(model4, X, y, lossfn)\n",
        "        accuracy+= (acc*y.shape[0])\n",
        "        totalDataPoints+=y.shape[0]\n",
        "    accuracy_oracle= accuracy/totalDataPoints\n",
        "    print(\"Test Accuracy:\", accuracy_oracle)"
      ],
      "id": "2VIquhEjwAOd",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_VCrDQ1Ll_NQ"
      },
      "source": [
        "## Experiment Results, Discussion and Conclusion"
      ],
      "id": "_VCrDQ1Ll_NQ"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8bPg66WVOqfu"
      },
      "source": [
        "**Test Accuracies:**\n",
        "\n",
        "MOCA Models: \n",
        "1. Hazard rate:  0.01 ------ 79.56%\n",
        "2. Hazard rate:  0.05 ------ 80.17%\n",
        "3. Hazard rate:  0.10 ------ 82.43%\n",
        "4. Hazard rate:  0.25 ------ 83.04%\n",
        "5. Hazard rate:  0.50 ------ 79.57%\n",
        "\n",
        "MOCA with Uniform belief ---- 67.65%\n",
        "\n",
        "Train on everything ----------- 55.56%\n",
        "\n",
        "Oracle Model --------------------- 93.71%"
      ],
      "id": "8bPg66WVOqfu"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NLX2yrbnyHUC"
      },
      "source": [
        "plt.figure(figsize=(16, 8))\n",
        "plt.plot(hazard_rates, [accuracy_oracle for i in hazard_rates], label='Oracle Model (CNP with Task Switches known)')\n",
        "plt.plot(hazard_rates, accuracies, label='MOCA', marker='o')\n",
        "plt.plot(hazard_rates, [accuracy_UniformB for i in hazard_rates], label='MOCA with Uniform Belief')\n",
        "plt.plot(hazard_rates, [accuracy_toe for i in hazard_rates], label='Baseline Model (Train on Everything)')\n",
        "plt.legend()\n",
        "plt.xlabel('Hazard rate')\n",
        "plt.ylabel('Accuracy (%)')\n",
        "plt.title('Accuraciey of various models')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "id": "NLX2yrbnyHUC",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pr-3QUG1UO9v"
      },
      "source": [
        "**Comparison of models:**\n",
        "![comparison.png](data:image/png;base64,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)\n"
      ],
      "id": "pr-3QUG1UO9v"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "25jJ3OxaNSrT"
      },
      "source": [
        "**Discussion and Conclusions:**\n",
        "1. MOCA model with hazard rate 0.25 performs the best. The increased hazard rate is the result of the assumption that each batch begins with a new task.\n",
        "2. The ablated model, MOCA with Uniform Belief, performs significantly better than the baseline Train on everything model. (12% improvement)\n",
        "3. The accuracy of the ablated model, MOCA with Uniform Belief, is very less compared to the complete MOCA model. Hence, the belief probability plays a very significant role in MOCA. (15.5% improvement)\n",
        "4. MOCA's accuracy is approximately 10% less than Oracle model's accuracy. The reason behind this is a very high task switch rate in the dataset (Task switches after every 12 data points on an average). MOCA is an approximation of our Oracle model and it'll generally waste at least 1 data point in getting to know that the task has switched. MOCA's performance will keep on getting closer to Oracle model's performance with the reduction of task switch rate."
      ],
      "id": "25jJ3OxaNSrT"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7bMa9v5OrjRM"
      },
      "source": [
        "# Experiment 2 (Extension of Paper): Time Series Forecasting using LSTM Meta-learner with MOCA\n",
        "\n",
        "LSTM meta-learner: https://link.springer.com/chapter/10.1007/3-540-44668-0_13\n",
        "\n",
        "Implementation of MOCA on top of LSTM meta-learner and comparing its performance on 2 bouncing balls dataset as a forecasting task.\n",
        "\n",
        "**Extensions performed and their reason/intuition:**\n",
        "1. The paper only discussed the performance of MOCA on regression and classification tasks. In this experiment, we'll be looking at MOCA's performance on a time-series forecasting task. From the previous experiment, we know that MOCA can detect task switches, but the motivation behind this experiment is that it can predict task switches.\n",
        "2. MOCA requires base meta learning algorithm's conditional posterior predictive, p(y | x, n[t][r=x]) to update its belief probabilities. But this is not directly available in regression tasks. The paper uses a separate output from the decoder and do calculations on that to get this. Instead of doing that, I have attempted a much simpler way to calculate it by just using mean squared error."
      ],
      "id": "7bMa9v5OrjRM"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LR_1z_uk1T2M"
      },
      "source": [
        "## Bouncing Balls Generator\n",
        "Because of the collisions against the wall/other balls, the bouncing balls dataset naturally has task switches. But the difference here is that, unlike our previous dataset where there were no relation between 2 tasks, these task switches can be predicted if the model learns to forecast the ball's trajectory and what action to take on collision.\n",
        "\n",
        "Generator code taken from bb.py file uploaded on Meta Learning course page and modified to get ball coordinates instead of whole matrix.\n",
        "This is done to get smaller dimensional dataset."
      ],
      "id": "LR_1z_uk1T2M"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vujMQj_DU_vN"
      },
      "source": [
        "#Taken from bb.py on Course website\n",
        "def bounce_n(T=150, n=2, r=None, m=None, radius=0.5, size=10, gravity=0.05):\n",
        "    if r==None: r=np.array([radius]*n)\n",
        "    if m==None: m=np.array([1]*n)\n",
        "    # r is to be rather small.\n",
        "    X=np.zeros((T, n, 2), dtype='float')\n",
        "    v = np.random.randn(n,2)\n",
        "    v = v / norm(v)*.5\n",
        "    good_config=False\n",
        "    while not good_config:\n",
        "        x = 2+np.random.rand(n,2)*8\n",
        "        good_config=True\n",
        "        for i in range(n):\n",
        "            for z in range(2):\n",
        "                if x[i][z]-r[i]<0:      good_config=False\n",
        "                if x[i][z]+r[i]>size:     good_config=False\n",
        "        # that's the main part.\n",
        "        for i in range(n):\n",
        "            for j in range(i):\n",
        "                if norm(x[i]-x[j])<r[i]+r[j]:\n",
        "                    good_config=False\n",
        "                    \n",
        "    eps = .5\n",
        "    for t in range(T): # for how long do we show small simulation\n",
        "        for i in range(n):\n",
        "            X[t,i]=x[i]\n",
        "        for mu in range(int(1/eps)):\n",
        "            #Gravity\n",
        "            for i in range(n):\n",
        "                v[i][1]+=gravity\n",
        "            for i in range(n):\n",
        "                x[i]+=eps*v[i]\n",
        "            for i in range(n):\n",
        "                for z in range(2):\n",
        "                    if x[i][z]-r[i]<0:  v[i][z]= abs(v[i][z]) # want positive\n",
        "                    if x[i][z]+r[i]>size: v[i][z]=-abs(v[i][z]) # want negative\n",
        "            for i in range(n):\n",
        "                for j in range(i):\n",
        "                    if norm(x[i]-x[j])<r[i]+r[j]:\n",
        "                        # the bouncing off part:\n",
        "                        w    = x[i]-x[j]\n",
        "                        w    = w / norm(w)\n",
        "                        v_i  = np.dot(w.transpose(),v[i])\n",
        "                        v_j  = np.dot(w.transpose(),v[j])\n",
        "                        new_v_i, new_v_j = new_speeds(m[i], m[j], v_i, v_j)\n",
        "                        v[i]+= w*(new_v_i - v_i)\n",
        "                        v[j]+= w*(new_v_j - v_j)\n",
        "    return X"
      ],
      "id": "vujMQj_DU_vN",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TNYnfWi_r1J4"
      },
      "source": [
        "#Helper functions\n",
        "def ar(x,y,z): return z/2+np.arange(x,y,z,dtype='float')\n",
        "def norm(x): return np.sqrt((x**2).sum())\n",
        "def new_speeds(m1, m2, v1, v2):\n",
        "    new_v2 = (2*m1*v1 + v2*(m2-m1))/(m1+m2)\n",
        "    new_v1 = new_v2 + (v2 - v1)\n",
        "    return new_v1, new_v2"
      ],
      "id": "TNYnfWi_r1J4",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mjJnU0ndBQQZ"
      },
      "source": [
        "#Convert coordinate to matrix\n",
        "def matricize(X,res,r=None, radius=0.5, size=10):\n",
        "    T, n= np.shape(X)[0:2]\n",
        "    if r==None: r=np.array([radius]*n)\n",
        "    A=np.zeros((T,res,res), dtype='float')\n",
        "    [I, J]=np.meshgrid(ar(0,1,1./res)*size, ar(0,1,1./res)*size)\n",
        "    for t in range(T):\n",
        "        for i in range(n):\n",
        "            A[t]+= np.exp(-(  ((I-X[t,i,0])**2+(J-X[t,i,1])**2)/(r[i]**2))**4)\n",
        "        A[t][A[t]>1]=1\n",
        "    return A"
      ],
      "id": "mjJnU0ndBQQZ",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L9hwbl1Jmx3R"
      },
      "source": [
        "#Convert matrix to image\n",
        "def show_sample(V, T):\n",
        "    T   = len(V)\n",
        "    res = int(np.sqrt(np.shape(V)[1]))\n",
        "    for t in range(T):\n",
        "        plt.imshow(V[t].reshape(res,res),cmap=matplotlib.cm.Greys_r) \n",
        "        # Save it\n",
        "        fname = logdir+'/'+str(t)+'.png'\n",
        "        plt.savefig(fname)      \n",
        "        "
      ],
      "id": "L9hwbl1Jmx3R",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uSIZWComtMLK"
      },
      "source": [
        "Generating Dataset"
      ],
      "id": "uSIZWComtMLK"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l0UUAnbyrGP4"
      },
      "source": [
        "SIZE=10\n",
        "n=2 #Number of balls\n",
        "res=50\n",
        "T=100 #Simulation length\n",
        "N=250 #Number of simulations"
      ],
      "id": "l0UUAnbyrGP4",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VTyrPmk2q0dr"
      },
      "source": [
        "X_train=[]\n",
        "for i in range(N):\n",
        "    #Generate simulations with random ball radius and gravity\n",
        "    RADIUS= random.uniform(0.1, 1)\n",
        "    GRAVITY= random.uniform(0.01, 0.1)\n",
        "    if i==0:\n",
        "        visual_Radius_train= RADIUS\n",
        "    X_train.append(bounce_n(T, n, radius=RADIUS, size=SIZE, gravity=GRAVITY))"
      ],
      "id": "VTyrPmk2q0dr",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3fB3zx_JivD8"
      },
      "source": [
        "N_test=32\n",
        "T_test=100\n",
        "X_test=[]\n",
        "for i in range(N_test):\n",
        "    #Generate simulations with random ball radius and gravity\n",
        "    RADIUS= random.uniform(0.1, 1)\n",
        "    GRAVITY= random.uniform(0.01, 0.1)\n",
        "    if i==0:\n",
        "        visual_Radius= RADIUS\n",
        "    X_test.append(bounce_n(T_test, n, radius=RADIUS, size=SIZE, gravity=GRAVITY))"
      ],
      "id": "3fB3zx_JivD8",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w-PYF53htdCM"
      },
      "source": [
        "### Visualing a sample"
      ],
      "id": "w-PYF53htdCM"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lzD44rR9rJgP"
      },
      "source": [
        "V = matricize(X_train[0], res, radius=visual_Radius_train, size=SIZE)\n",
        "dat_train= V.reshape(T, res**2)\n",
        "logdir='train_sample'\n",
        "if not os.path.exists(logdir):\n",
        "    os.mkdir(logdir)\n",
        "\n",
        "show_sample(dat_train, T)\n",
        "os.system(\"ffmpeg -start_number 0 -i train_sample/%d.png -c:v libx264 -pix_fmt yuv420p -r 30 results/train_sample.mp4\")"
      ],
      "id": "lzD44rR9rJgP",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lYPJJ4LMxA8J"
      },
      "source": [
        "Run the cell below again if not able to play video"
      ],
      "id": "lYPJJ4LMxA8J"
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 501
        },
        "id": "3llWYzH6wYP0",
        "outputId": "89b1a99e-201c-461e-e311-f66c43895990"
      },
      "source": [
        "video = io.open(result_folder + 'train_sample.mp4', 'r+b').read()\n",
        "encoded = base64.b64encode(video)\n",
        "HTML(data='''<video alt=\"test\" width=\"640\" height=\"480\" controls>\n",
        "<source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" /> </video>'''.format(encoded.decode('ascii')))"
      ],
      "id": "3llWYzH6wYP0",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<video alt=\"test\" width=\"640\" height=\"480\" controls>\n",
              "<source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" /> </video>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 235
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nxNULnVblm5a"
      },
      "source": [
        "\n",
        "\n",
        "---\n"
      ],
      "id": "nxNULnVblm5a"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r3Xg1Vxh6utR"
      },
      "source": [
        "The data currently has shape (Batch, Sequence_Length, Number of Balls, Coordinates). \n",
        "\n",
        "To feed it into our model, we have to convert it into (Batch, Sequence_Length, Number of Balls * Coordinates) "
      ],
      "id": "r3Xg1Vxh6utR"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FcpiHhIevK6r"
      },
      "source": [
        "X_train= np.array(X_train)\n",
        "X_train= X_train.reshape((*X_train.shape[:-2], -1))"
      ],
      "id": "FcpiHhIevK6r",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zXJbJZM5i9pJ"
      },
      "source": [
        "X_test= np.array(X_test)\n",
        "X_test= X_test.reshape((*X_test.shape[:-2], -1))"
      ],
      "id": "zXJbJZM5i9pJ",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aWNsb0h161o9"
      },
      "source": [
        "Generating Labels"
      ],
      "id": "aWNsb0h161o9"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "whdb0Sg9QTSW"
      },
      "source": [
        "y_train= np.zeros(X_train.shape)\n",
        "for i in range(X_train.shape[0]):\n",
        "    for j in range(X_train.shape[1]-1):\n",
        "        y_train[i][j]= X_train[i][j+1]- X_train[i][j]"
      ],
      "id": "whdb0Sg9QTSW",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fli-8BmijEMY"
      },
      "source": [
        "y_test= np.zeros(X_test.shape)\n",
        "for i in range(X_test.shape[0]):\n",
        "    for j in range(X_test.shape[1]-1):\n",
        "        y_test[i][j]= X_test[i][j+1]- X_test[i][j]"
      ],
      "id": "fli-8BmijEMY",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3viV3Mql64p-"
      },
      "source": [
        "The coordinates are scaled down to 0-1 range, as that range is more amenable for training with standard network initialization.\n"
      ],
      "id": "3viV3Mql64p-"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_V5PlEO2cZa_"
      },
      "source": [
        "X_train/=SIZE"
      ],
      "id": "_V5PlEO2cZa_",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g0ZadQx8jL4T"
      },
      "source": [
        "X_test/=SIZE"
      ],
      "id": "g0ZadQx8jL4T",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wNQQhwcL68HZ"
      },
      "source": [
        "Conversion to tensors and saving the dataset"
      ],
      "id": "wNQQhwcL68HZ"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aBQAn_hDWLh0"
      },
      "source": [
        "X_train= torch.from_numpy(X_train)\n",
        "y_train= torch.from_numpy(y_train)"
      ],
      "id": "aBQAn_hDWLh0",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nJw62jWajPdK"
      },
      "source": [
        "X_test= torch.from_numpy(X_test)\n",
        "y_test= torch.from_numpy(y_test)"
      ],
      "id": "nJw62jWajPdK",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q0e_8aObciyG"
      },
      "source": [
        "if not os.path.exists(dataset_folder):\n",
        "    os.mkdir(dataset_folder)\n",
        "torch.save((X_train, y_train), dataset_folder+'bouncingBalls_train.pt')"
      ],
      "id": "Q0e_8aObciyG",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BkZ1OiCnjTxC"
      },
      "source": [
        "if not os.path.exists(dataset_folder):\n",
        "    os.mkdir(dataset_folder)\n",
        "torch.save((X_test, y_test), dataset_folder+'bouncingBalls_test.pt')"
      ],
      "id": "BkZ1OiCnjTxC",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YAhv0b3OegIl"
      },
      "source": [
        "## Models"
      ],
      "id": "YAhv0b3OegIl"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UF-ix_FW7LXB"
      },
      "source": [
        "LSTM Meta Learner Class\n",
        "\n",
        "In this class, the LSTM input is the concatenation of the current encoded input z[t] = φ(x[t], w) (encoded using MLP) and the label from the past timestep y[t−1]. In this way, through the LSTM update process, the hidden state can process a sequence of input/label pairs and encode statistics of the posterior distribution in the hidden state.\n",
        "\n",
        "The LSTM output and the encoded input are then concatenated and feeded into a decoding network (MLP) which outputs the label y[t]. By including z[t] as input to the decoder, we lessen the information that needs to be stored in the hidden state."
      ],
      "id": "UF-ix_FW7LXB"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b3a008fc"
      },
      "source": [
        "class LSTMmeta(nn.Module):\n",
        "    def __init__(self,input_features=1, encoding_dims=[32,32], lstm_hidden_dims=64, lstm_n_layers=1, decoding_dims=[32,32], optimizerReq=False, lr=1e-4):\n",
        "        super(LSTMmeta,self).__init__()\n",
        "        #Encoder\n",
        "        dimEncoder = [input_features]+encoding_dims\n",
        "        self.encoder = MLP(dims=dimEncoder,task='embedding')\n",
        "        \n",
        "        #LSTM\n",
        "        self.output_features= input_features\n",
        "        self.lstm_n_layers= lstm_n_layers\n",
        "        self.lstm_hidden_dims= lstm_hidden_dims\n",
        "        lstm_input_dims= encoding_dims[-1] + self.output_features\n",
        "        self.lstm = nn.LSTM(lstm_input_dims, lstm_hidden_dims, lstm_n_layers, batch_first=True)\n",
        "        \n",
        "        #Decoder\n",
        "        dimDecoder= [lstm_hidden_dims+encoding_dims[-1]]+ decoding_dims + [self.output_features]\n",
        "        self.decoder = MLP(dims=dimDecoder,task='embedding')\n",
        "        \n",
        "        #Optimiser initialisation for baseline model\n",
        "        if optimizerReq:\n",
        "            self.optimizer=torch.optim.Adam(self.parameters(),lr=lr)\n",
        "\n",
        "    def forward(self, X, y):\n",
        "        #Encoding X[t]\n",
        "        encoding= self.encoder(X)\n",
        "        yzero= torch.zeros((X.shape[0], 1, self.output_features)) #All zeros for previous label of X[0] (required for concatenation for LSTM input)\n",
        "        y= torch.cat((yzero, y), dim=1)\n",
        "        input= torch.cat((encoding, y), dim=-1)\n",
        "\n",
        "        #LSTM\n",
        "        hidden_state = torch.randn((self.lstm_n_layers, X.shape[0], self.lstm_hidden_dims)).double()\n",
        "        cell_state = torch.randn((self.lstm_n_layers, X.shape[0], self.lstm_hidden_dims)).double()\n",
        "        hidden = (hidden_state, cell_state)\n",
        "        out, hidden = self.lstm(input, hidden)\n",
        "\n",
        "        #Decoding\n",
        "        out = torch.cat((out[:, -1], encoding[:, -1]), dim=-1)\n",
        "        yhat= self.decoder(out)\n",
        "        return yhat      "
      ],
      "id": "b3a008fc",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SQfU_XO99CcI"
      },
      "source": [
        "### MOCA Class\n",
        "\n",
        "The class has been implemented specifically for using MOCA in regression setting. \n",
        "\n",
        "For using MOCA with LSTM learner, yhat is calculated for all run-lengths by feeding them one by one to LSTM meta-learner but with different number of past data points. The final regression prediction yhat is the weighted average of yhat from all run lengths, weighted by the belief of that run-length.\n",
        "\n",
        "\n",
        "**Calculating p(y[t] | x[t], n[t][r=x]) in regression setting:**\n",
        "\n",
        "For easier and more intuitional calculation, p(y[t] | x[t], n[t][r=x]) is calculated by first getting the MSE loss individually on predictions from all run-lengths and then taking the inverse of it. As the predicted coordinates for a particular run-length digress from the label, MSE loss increases and its inverses decreases, leading to drop in belief probability for that run-length."
      ],
      "id": "SQfU_XO99CcI"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v3DJl3GbO-cj"
      },
      "source": [
        "class MOCA(nn.Module):\n",
        "    def __init__(self, baseModel, hazard_rate, lossfn, lr=1e-4, SIZE=10):\n",
        "        super().__init__()\n",
        "        self.hazard_rate= hazard_rate\n",
        "        self.baseModel= baseModel #Base meta-learning algorithm\n",
        "        self.lossfn= lossfn\n",
        "        self.SIZE=SIZE #Used to scale down label when forecasting\n",
        "        self.optimizer=torch.optim.Adam(self.parameters(),lr=lr)\n",
        "    \n",
        "    def forward(self, X, y, T, forecast=False):\n",
        "        # Initialising belief (b(r=0)=1)\n",
        "        b= torch.ones((X.shape[0], 1))\n",
        "        loss=0\n",
        "        for t in range(T):\n",
        "            yhat=[]\n",
        "            weighted_yhat=[]\n",
        "            #Repeating b to match number of input features (4 times for 2 bouncing balls case)\n",
        "            bb = b[:, :, None].repeat(1, 1, X.shape[2])\n",
        "            for hist in range(t+1):\n",
        "                #Prediction from LSTM meta learner\n",
        "                yhat0= self.baseModel(X[:, t-hist:t+1], y[:, t-hist:t])\n",
        "                yhat.append(yhat0)\n",
        "                #Storing b(r=len(history)) * p(yhat | x, history)\n",
        "                weighted_yhat.append(yhat0*bb[:, hist])\n",
        "            weighted_yhat= torch.stack(weighted_yhat)\n",
        "            yhat= torch.stack(yhat)\n",
        "            \n",
        "            #Summing over b(r=len(history)) * p(yhat | x, history) to get prediction probability p(yhat | x[1:t], y[1:t-1]) (Marginalisation)\n",
        "            ypred= torch.sum(weighted_yhat, dim=0)\n",
        "            \n",
        "            #Calculating loss (only when not forecasting)\n",
        "            if not forecast:\n",
        "                loss+= self.lossfn(ypred, y[:, t])\n",
        "            \n",
        "            # If forecasting and feeded data points are over, concatenate model's prediction to X and y\n",
        "            if forecast and y.shape[1]<=t:\n",
        "                y= torch.cat((y, ypred[:, None]), dim=1)\n",
        "                X_next= X[:, t]+ (ypred/self.SIZE)\n",
        "                X= torch.cat((X, X_next[:, None]), dim=1)\n",
        "\n",
        "            #Updating belief\n",
        "            pyhat= []\n",
        "            for hist in range(t+1):\n",
        "                # Storing b(r=t-1) * p(yhat | x, history) [p(yhat | x, history) calculated as inverse of loss]\n",
        "                pyhat.append(b[:,hist]/torch.sum((y[:, t]-yhat[hist])**2, dim= 1))\n",
        "            pyhat= torch.stack(pyhat)\n",
        "            pyhat= torch.transpose(pyhat, 0, 1)\n",
        "            #Normalisation step\n",
        "            pyhatsum= torch.sum(pyhat, dim=1)\n",
        "            for batch in range(X.shape[0]):\n",
        "                pyhat[batch]= pyhat[batch].clone()/pyhatsum[batch].clone()\n",
        "          \n",
        "            #b(r=0)= hazard rate and b(r=t)= (1-hazard rate)*b(r=t-1) * p(yhat | x, history)\n",
        "            b0= torch.ones((X.shape[0],1))*self.hazard_rate\n",
        "            pyhat= pyhat*(1-self.hazard_rate)\n",
        "            b= torch.cat((b0, pyhat), dim=1)\n",
        "        \n",
        "        if forecast: #If forward step for forecasting return predictions\n",
        "            return X\n",
        "        else:\n",
        "            return loss #If forward step for training/testing, return loss"
      ],
      "id": "v3DJl3GbO-cj",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SAJ2KnnsLENN"
      },
      "source": [
        "#Loading stored dataset\n",
        "X_train, y_train= torch.load(dataset_folder+'bouncingBalls_train.pt')"
      ],
      "id": "SAJ2KnnsLENN",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cv61_ViHOjej"
      },
      "source": [
        "#### Training\n",
        "\n",
        "Training parameters:\n",
        "\n",
        "* Epochs: 750 (Model was overfitting post 750 epochs)\n",
        "* Batch size: 8\n",
        "* Learning rate: 1e-3 for first 500 epochs and 1e-4 for next 250 epochs\n",
        "* Optimizer: Adam\n",
        "* Encoding MLP dimensions: [4, 8, 16, 8]\n",
        "* LSTM dimensions: 64-dimensional single layer\n",
        "* Decoding MLP dimensions: [72 (64+8), 128, 4]\n",
        "* Hazard rate: 0.01 "
      ],
      "id": "cv61_ViHOjej"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FucRluj3hrsp"
      },
      "source": [
        "#Initialising model\n",
        "SIZE=10\n",
        "lossfn= torch.nn.MSELoss()\n",
        "net= LSTMmeta(4, [8, 16, 8], 64, 1, [128])\n",
        "model= MOCA(net, 0.01, lossfn, 1e-3, SIZE).double()\n",
        "epochs=750"
      ],
      "id": "FucRluj3hrsp",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vBWCD_B-R2C8"
      },
      "source": [
        "batch_size=8\n",
        "for ep in range(epochs):\n",
        "    #Selecting random batch of size 8 from all simulations\n",
        "    rp = torch.randperm(X_train.shape[0])\n",
        "    loss= model(X_train[rp[0:batch_size]], y_train[rp[0:batch_size]], X_train.shape[1]-1)\n",
        "    print(\"Epoch \", ep, \"Loss: \", loss.item())\n",
        "    model.optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    model.optimizer.step()\n",
        "    #Reduce learning rate on epoch 500\n",
        "    if (i+1)==500:\n",
        "        for g in model.optimizer.param_groups:\n",
        "            g['lr'] = 1e-4\n",
        "torch.save(model.state_dict(), weight_folder + 'weights_MOCA_lstm.pt')"
      ],
      "id": "vBWCD_B-R2C8",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZZEDHkNmNaUV"
      },
      "source": [
        "### Baseline Model: Condition on Everything\n",
        "This implementation only uses LSTM meta-learner which runs on all available past data, as the LSTM can theoretically learn to only consider relevant data."
      ],
      "id": "ZZEDHkNmNaUV"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Agt26AG_JBK0"
      },
      "source": [
        "#Function for calculating loss of LSTM meta-learner's prediction on complete simulation\n",
        "def predict(net, X, y, T, lossfn):\n",
        "    loss=0\n",
        "    for t in range(T):\n",
        "        yhat= net(X[:, :t+1], y[:,:t])\n",
        "        loss+= lossfn(yhat, y[:, t])\n",
        "    return loss"
      ],
      "id": "Agt26AG_JBK0",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HK1Dd7axOboe"
      },
      "source": [
        "#### Training\n",
        "Training parameters same as that of MOCA except epochs and learning rate.\n",
        "* Epochs: 1000\n",
        "* Learning rate: 1e-3 for first 500 epochs and 1e-4 for next 500 epochs"
      ],
      "id": "HK1Dd7axOboe"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oiI3qZCXIVTn"
      },
      "source": [
        "lossfn= torch.nn.MSELoss()\n",
        "model2= LSTMmeta(4, [8, 16, 8], 64, 1, [128], True, 1e-3).double()\n",
        "epochs=1000\n",
        "batch_size=8\n",
        "\n",
        "for ep in range(epochs):\n",
        "    rp = torch.randperm(X_train.shape[0])    \n",
        "    loss= predict(model2, X_train[rp[0:batch_size]], y_train[rp[0:batch_size]], X_train.shape[1]-1, lossfn)\n",
        "    print(\"Epoch \", ep, \"Loss: \", loss.item())\n",
        "    model2.optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    model2.optimizer.step()\n",
        "    if (ep+1)==500:\n",
        "        for g in model2.optimizer.param_groups:\n",
        "            g['lr'] = 1e-4\n",
        "torch.save(model2.state_dict(), weight_folder+'weights_lstm.pt')"
      ],
      "id": "oiI3qZCXIVTn",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ls2K7ftiO-sr"
      },
      "source": [
        "## Time-series Forecasting & Comparison"
      ],
      "id": "Ls2K7ftiO-sr"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UesNCIp5Unis"
      },
      "source": [
        "### Loading test dataset and Feeding the first 10 frames into the model and forecasting"
      ],
      "id": "UesNCIp5Unis"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HRGE58iEcbsV"
      },
      "source": [
        "X_pred, y_pred= torch.load(dataset_folder+'bouncingBalls_test.pt')\n",
        "visual_Radius= 0.59 #Radius in 1st Simulation (for visualisation)"
      ],
      "id": "HRGE58iEcbsV",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pjuPGiU8ZUSV"
      },
      "source": [
        "T=100 # Final Simulation Length after forecasting\n",
        "n=2 # No. of balls"
      ],
      "id": "pjuPGiU8ZUSV",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gmGmCFyAWlrv"
      },
      "source": [
        "Forecasting using MOCA + LSTM Meta-learner"
      ],
      "id": "gmGmCFyAWlrv"
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UL0zlm5rbpb0",
        "outputId": "2694512c-7e15-494f-e0c3-d8546bb21673"
      },
      "source": [
        "# Load model\n",
        "SIZE=10\n",
        "lossfn= torch.nn.MSELoss()\n",
        "net= LSTMmeta(4, [8, 16, 8], 64, 1, [128])\n",
        "model= MOCA(net, 0.01, lossfn, 1e-3, SIZE).double()\n",
        "model.load_state_dict(torch.load(weight_folder+'weights_MOCA_lstm.pt'))"
      ],
      "id": "UL0zlm5rbpb0",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 202
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "asiymtyk0KDO"
      },
      "source": [
        "#Forecasting\n",
        "with torch.no_grad():\n",
        "    X_pred1= model(X_pred[:, 0:10], y_pred[:, 0:9], T-1, True)"
      ],
      "id": "asiymtyk0KDO",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X8oqtPD1ZolM"
      },
      "source": [
        "Forecasting using Condition on everything baseline model"
      ],
      "id": "X8oqtPD1ZolM"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UEHAaQK2Zwq-"
      },
      "source": [
        "SIZE=10\n",
        "lossfn= torch.nn.MSELoss()\n",
        "model2= LSTMmeta(4, [8, 16, 8], 64, 1, [128], True, 1e-3).double()\n",
        "model2.load_state_dict(torch.load(weight_folder +'weights_lstm.pt'))"
      ],
      "id": "UEHAaQK2Zwq-",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g6Io4RLxMiYH"
      },
      "source": [
        "with torch.no_grad():\n",
        "    X_pred2=X_pred[:, 0:10]\n",
        "    y_pred2=y_pred[:, 0:9]\n",
        "    for t in range(T-10):\n",
        "        y_next= model2(X_pred2, y_pred2)\n",
        "        y_pred2= torch.cat((y_pred2, y_next[:, None]), dim=1)\n",
        "        X_next= X_pred2[:, -1]+ y_next/SIZE\n",
        "        X_pred2= torch.cat((X_pred2, X_next[:, None]), dim=1)"
      ],
      "id": "g6Io4RLxMiYH",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OT71HE1cZpgx"
      },
      "source": [
        "### Loss Comparison\n",
        "We have the forecast from both the models and now we can calculate their MSE from the actual simulation."
      ],
      "id": "OT71HE1cZpgx"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dp_VAPslaAlp"
      },
      "source": [
        "lossfn= torch.nn.MSELoss()\n",
        "with torch.no_grad():\n",
        "    loss_MOCA= lossfn(X_pred1[:, 10:], X_pred[:, 10:])\n",
        "    loss_LSTM= lossfn(X_pred2[:, 10:], X_pred[:, 10:])\n",
        "\n",
        "print(\"MOCA with LSTM Learner Loss: \", loss_MOCA.item())\n",
        "print(\"Baseline Model Loss: \", loss_LSTM.item())"
      ],
      "id": "Dp_VAPslaAlp",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9-jVSW-HF0NI"
      },
      "source": [
        "**Results:** (May vary a bit on every run)\n",
        "1. MSE loss on testing on MOCA + LSTM meta-learner: 0.067\n",
        "2. MSE loss on testing on baseline model: 0.082"
      ],
      "id": "9-jVSW-HF0NI"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SHnSzHxUcUdh"
      },
      "source": [
        "### Visualing Forecast"
      ],
      "id": "SHnSzHxUcUdh"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MdjDtPOU3Cz-"
      },
      "source": [
        "X_pred1= X_pred1[0].reshape((T, n, 2)).numpy()\n",
        "X_pred2= X_pred2[0].reshape((T, n, 2)).numpy()"
      ],
      "id": "MdjDtPOU3Cz-",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cZ_qYIXtdDrT"
      },
      "source": [
        "Convert coordinates to matrix"
      ],
      "id": "cZ_qYIXtdDrT"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yXv4Pz6Z0yQU"
      },
      "source": [
        "res=50\n",
        "V_pred1 = matricize(X_pred1, res, radius=visual_Radius/SIZE, size=1)\n",
        "dat_pred1= V_pred1.reshape(T, res**2)\n",
        "\n",
        "V_pred2 = matricize(X_pred2, res, radius=visual_Radius/SIZE, size=1)\n",
        "dat_pred2= V_pred2.reshape(T, res**2)"
      ],
      "id": "yXv4Pz6Z0yQU",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kN64ZLACdFzB"
      },
      "source": [
        "Conver matrices to frames and then to video"
      ],
      "id": "kN64ZLACdFzB"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PckV9uxp1SUA"
      },
      "source": [
        "logdir='forecast_MOCA'\n",
        "if not os.path.exists(logdir):\n",
        "    os.mkdir(logdir)\n",
        "\n",
        "show_sample(dat_pred1, T)\n",
        "os.system(\"ffmpeg -start_number 0 -i forecast_MOCA/%d.png -c:v libx264 -pix_fmt yuv420p -r 30 results/MOCA_sample.mp4\")"
      ],
      "id": "PckV9uxp1SUA",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VXFJ8BfRdbAf"
      },
      "source": [
        "logdir='forecast_LSTM'\n",
        "if not os.path.exists(logdir):\n",
        "    os.mkdir(logdir)\n",
        "\n",
        "show_sample(dat_pred2, T)\n",
        "os.system(\"ffmpeg -start_number 0 -i forecast_LSTM/%d.png -c:v libx264 -pix_fmt yuv420p -r 30 results/LSTM_sample.mp4\")"
      ],
      "id": "VXFJ8BfRdbAf",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xS2fdR5Zdupn"
      },
      "source": [
        "MOCA forecast video\n",
        "\n",
        "Run the cell below again if not able to play video"
      ],
      "id": "xS2fdR5Zdupn"
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 501
        },
        "id": "9fPv8uz21d-i",
        "outputId": "6a9e51c8-396f-4426-8c0a-0eb732091dcd"
      },
      "source": [
        "video = io.open(result_folder+ 'MOCA_sample.mp4', 'r+b').read()\n",
        "encoded = base64.b64encode(video)\n",
        "HTML(data='''<video alt=\"test\" width=\"640\" height=\"480\" controls>\n",
        "<source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" /> </video>'''.format(encoded.decode('ascii')))"
      ],
      "id": "9fPv8uz21d-i",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<video alt=\"test\" width=\"640\" height=\"480\" controls>\n",
              "<source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAATI9tZGF0AAACrgYF//+q3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1MiByMjg1NCBlOWE1OTAzIC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAxNyAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTMgbG9va2FoZWFkX3RocmVhZHM9MSBzbGljZWRfdGhyZWFkcz0wIG5yPTAgZGVjaW1hdGU9MSBpbnRlcmxhY2VkPTAgYmx1cmF5X2NvbXBhdD0wIGNvbnN0cmFpbmVkX2ludHJhPTAgYmZyYW1lcz0zIGJfcHlyYW1pZD0yIGJfYWRhcHQ9MSBiX2JpYXM9MCBkaXJlY3Q9MSB3ZWlnaHRiPTEgb3Blbl9nb3A9MCB3ZWlnaHRwPTIga2V5aW50PTI1MCBrZXlpbnRfbWluPTI1IHNjZW5lY3V0PTQwIGludHJhX3JlZnJlc2g9MCByY19sb29rYWhlYWQ9NDAgcmM9Y3JmIG1idHJlZT0xIGNyZj0yMy4wIHFjb21wPTAuNjAgcXBtaW49MCBxcG1heD02OSBxcHN0ZXA9NCBpcF9yYXRpbz0xLjQwIGFxPTE6MS4wMACAAAAGQWWIhAA3//728P4FNjuY0JcRzeidMx+/Fbi6NDe9zgAAAwAAN9zmRP7KkwbmwAAC4ScJMtg7L3zAM6rIArvTEcfHVQB3dXAnB6Ym1tJ8cx6nzEmxQpEnHrKm5BuWVcow5FJlGiorG5k8gn2G+6XhJDFWopYUD2etDy9vBxyZ1jq7LQKwCGBT7yPRWniJAQEkkVt+nFAPdZHPzjIrD78IWzLWcli9PcmIIAEQFuum6jXVXCbJl4+wsVW9Ls15+gbQ5hmdVRQWKM85SItvL/OOdR7TEruVIMnPBGNGRgai6qNTH76IuflvfT+FBP6S9wNk7VOvzc3fphafkCWWnNQxOXPEIKQJ4eW/Sc4uZnXK4OH4SXqMDAFHIubJDMuFAd/ytgAnP21JwbuuJx7/3Z2uKLICynrA6bYEt3aL//zc94iEXQzl/i/JzhKDjKfgIqYI0hhMeMBV6gixQp13Zdx8MwAhnAgyH7CQcROVwop4ec22Mq1hLCmK2R27wCds4mM8qFcZ2vYo9zlz5vWiq5lgeSp7rkXLKtBqCLP34vJovY377RZ/ovgrCyYClYW1jkCdxkpjkYrNwbi4blUws3pKWC7jIvZfE/uUpdrH1nOQqynl/cG66xyOkteHIJzwYcxkYZr5kT863/siT8rw/wX7a+CfKPoEZWWG6FsdHH4h66oY/XcgszWxJA1dnJ2lD7lXFLSZu0fCCq+VNbeccZIBCogP0tYsQqdqX6E5Rc0MqJoKdpS4RoKilKnL0j2Xx5COvYfzY8GonnEOcK7uzhh5mvx0ARRgS1oCE/4TCom08d4V5BYQfCmiBrjo9WVE9XMPJYLunVKKFWe9mqMo1R2KQ/zqgIz9VDk+vW/+5kIP9np9/TmQCYhApiwSbBDyN4a9jNwBJTgMR1ZHaqtVJBWbtb3uBKqT4CiwV0Fn0zhDpUPtmkOxDCus4zX5BOT8fTKG0t6tS+EW5cJwTuoYtGgydzjWLE3KOfAiXGcp/ok9XKrwTJlJlCZGmxjoVPwqnZm4ZbdIYrONc5TDFRdylgbvJGeSIHJctrxAYJhZxCJohEHNzM2fGN1Ku5ZDYlltq36Rm5/C0S4jAVc7bnndOd1YbEkPBLseOvnIlRTrdfsx7oWXY4osizJgzQvetE7cgwEO54rXedGL9/lMJtDj1AEURtHDVWMGaq8lMGKUck5zBMXHKJA52xd27oSTCqqT2q7k7GZMiWx4dWGYWtZBxMV+jRew8QPKAcWUe0Bg+L1qm+snadfcpK08rM4oIerEvQFPSahdYlkFCT1E50N21UaJe/lIR3ZA2aujys9y7zqFzYciMykYM2SA35VyV/7RwBuGndpxOhdSSfdD0RR9MYlfPvngheyeY4/xrpI79YU4C2N/6GH6LcFLd2BF+A/ckAB4GTVyS0D9dtPKICD+tAxeIL1OH4IpulVZr2XVoMi+fxFi+szflVGqIDalu8EYBooSRVsz7inp5QA2iJ/Aq4EADF+4xcMuxyqpNN7au9UqbHldHnLMUeikPOq7L/G9V5/BugnCu0e/6DrImogoiFp5dDBgBl4w2Xois3tW3D5i3Ip/tpH9VTn3+ua/CSfsvLfzSIziVvy+3bhHLOFhGlECkuYo4J6e0YX2akTounyn7O4RxCdaZKfclizlgw4g7VqqW1aF0mhWIE3xihLXjs5EbFb/JyhYrylIFJViKvO2TDbWnAx8uKjMCW8drFLZGv4wLWb1tmUoNnOm/V4vNsQxYaSiEooVBHgw4HBTGzs/MSCYwediUp2v9L0xSv/tbuXzvpyqMnW4AscLNKJ2BPwgcjLbGyFn3oSNgoP2Mgbj1a+srvP6Gdu229DFRT1SR6k1hk3XMgBNMElQ5x9YFnGys4foU3+1WJq+pcr2HgQcRAFcHf2yLop7RkacUCmLbdPgDok05mzaQ8vyB/kKrrwc1KoI9XHTXnKISSa4qLKINqilTGJ/S7h6XevIM1B210O2lmLsN8xm3+/0K+gz4UceUPvVRWAAcW9BSc8CQYmWGAMFU3S5GligOe3x6ZigmkFWXQYBXELeWL+BUssPR2Q5Hni9OiCw4caBeyob8fhpw1fXB1z7zNvHkUA33sTMmhAELMCdCxsCXdWX6NJQA+1xgBJRAAAB+EGaImxDf/6nhAGuvfJAEJUmVPXG7b81/aZf7jqVYLZpMRbo7gRc3RwGu0N97ET/nRerZj6Bki2P6DB/vHtqf9jb8M37ND7UnTkAotdtQfKaXIUc1pjgE//SeL+CNmbClrjo2AkCqZz++fx1oMNDBvhoGeNG4CMyZhvZy9XMzr3Dp/H0l4Fc1L0ldExSAH89Rx4ESHLXBTyfVAMWqMp5dHlNVl+eiUHd6ndb21MzLq9rObRWsA2hOpzdGIfTHXujZfgrS0SIjlcU0nP16sk9AER4SkHD/szwHjAGmbwu8znSqsCHT9b/4yCmDGnnvj0tAbumbZegfwhFXDDshE5Ws2LX6U5XekjV3pjqFbVLQu5EvW28UbsydNv114rcfj3oeO7V3UVLu65E2AjiM5jspGPNZ+ZIJruJB6uE0DWYgPfAhhgDgxeTFrlcNXUDXf3HfPnPCSE5uDDA5q2n619vG086XkdimaaH17rc+PdjT/DjDS8bL3uXd146XutsblEXfoKqYibwWR+beZFpDqQSWFO5begQV1vo3UkxIdnEp2SoWwHYnDVwFWLLWkP9bPGLZJs2GGd9s4GdccAVVcg0GCdkRVZiEs/NNeaNxnIGuJ1/d78u4+/F1gXB9eRIvDYyvPcZdqaz1Eo4RThPVop0z9Rxo6er6n85IAAAAPwBnkF5Cf8Dm53w4VIxGDSrpQEXpmEwlH5uNqoCVSw2Q9ckGcaZxHT9Y/+AFvGd+Cp307u9whrj3U+lOByqzWUxEWLVEZjJZvd3vuCsmlX6x+g5RsTfVeqfpPl0q/8uIN4rqLVssrfxpEIQvy0qZfhjFEUJHOtnMROm/M1kbxJpKe8KCSdgvFLKVv64gjKacgXPj3h3eYVSGSYuRLnHwEbn0jE0PRFueWwvzsV6bBnEc7lqsGNsfRl/lWleiHIK+SnZwmmYHUF0lajgC1zK9zYTLUZD5lpi/1TVDLeNDKItX0QbraPLKefEQq7nkqzjOMaHXIVtHk1q3jtEEREAAAErQZpEPCGTKYQ3//6nhBItKL8Jd8aADVx+SPgpkOtiXi1COEjSStqed3/hixMbMhJ5Bfru2qyJfjVXm7elnK/b9nbpj+zuAIIr/Z0FpYO9iPCGUVF/5jpcX8Ff56gJGsej7vC6Ibej1zWCuqXaonRoSdkAA1SvX4yMTqchHpf0MzC9P7FysB4zlf3EGBjqHETwrXHwcsq1AqUblowvXca4Er7772hv78Xhj+ufesDbZlmBPnSKTnPFzFHce1COin8PTKd3YDX6bDGJuZEqy7BLJWrIpiFDuaFqJ3tO8mvllZDOOzzUpmuS8l6hpFY8wk7icGL0lYFmr4zVM8BBL3zoYUpCYvwFWhtg/gHDrW9Zk1y1rDB32WcgCMCGDIo8vpmc3F437VGkzmjLAwcAAAA9AZ5jakJ/A6+EWy7Ex67oP8UjQXQ2NB/G2xEup4uZ6ez/4wmjemHPs/5HQW1eybF9DFngO1MnSmJSezJAUQAAAXVBmmdJ4Q8mUwIb//6nhAGh8hCAEEHL3pjujaa33cRP+dF64vnbVCzP/K1gwiXUxjWdmKSlpTzz46zidedp8LGLrV9FzLvulIcYYYocoFDDNARd++ZUDyTPgba6djJgPcjGXh1W0d5mnvGNaeN7Ys/OAGRayXJeLKMDnflKlJXIk6UgrBhuiKl4cwBcG9KWB/XapjnwTtJ9eWM4I+mpp4lzcWM6VaOjcvNnsJoikFdGpJKyO8n4AVmcmsW18Nj8qM0SUpnDKst3ehJuikEVHnBXkUJQOcag2DI9D8ESBqm38X7Anl2JJW13I7mLkGdKKbdWjImjLwWVFxOq+u53mp5Q5RQbdtPjqRhKbjToPifQY3UXnIgrqxlJ1UAagY23DViPoZaJwmYIJXKqt+/cSi1uh1vJwOaVOSJLeC2cVnPHvCYm3DxTaKyQXnlnusqL70P1xYULODz8TF/HbKKlgHh76mp955UX+WFAztfc1mGBs4mIfMmBAAAA8kGehUURPCv/ATu3FKyN5yWUUIAaqu2bwleZg+TLJ5dTMHeacm+ixKRQPbTEAsyGk2dqfBCG07JrB2WdyKmTwD18aoaiNeEt8G86TrtGL9GcVM4P/PXWrE3OuW7OVCx4uXu72VwYdAN66EBYMJkY6tiww1Vet+1HovzB7ByDe+gDa/FHxrnuc6JrCzUZ3dKaRzfCj2fUikGS6Y0XT9MKFcBZ+oET17EZAHhELqPBtMFPFJmVhW7NaSH0E7xpVF8Wt1OtBG/YmKmXEfcbZTih1u0fG1E/agAKInl2NJ9m2TEIO69L9P+PjtozUYRY9mJrOQO7AAAAswGepmpCfwGaeAmcuV7IncQq5jYuWQw4JsKlWKk1c5uW4eG3QDLA9PqxZ2ZugA16ThB3IfavHrfFC6gjEoM40PO94vYPzAsUBHtIQE1cBQW76qTQ6/6AA8YZRgwKUeIerm2oJBgQc1ClvFIiGqe1N1jGgPorO5UmHBl2uuBqhoyqQRgLBJwheSLy6xbLxC4OWzltPQmtTDF/QTRNWCJG27I7yFriWtpffzILU2oE/QnGG4whAAABTEGaq0moQWiZTAhn//6eEAY4Xr3LgE25+CZ1f1WyOubstv7Whi7cI1CccllkjGhtMXf1h+L4O2AzNwPMP2+Dq7yWKx5HB31+TqDZz0zg3bTB0kNVnjSghPfAc+XpamwpifqUL6jT6bFAFO1vkn23lbrnx0JTl76DJJrdT2LCu8tViN2vMij3uzhSpeR9t9P+eumWObXL4ca7xyLPiLrp76b/N43tJ1LkscvZXJ1Nk/xnd+IFqLUwESbBn0YSEG665JXTBbbCZIHQPB3lrjoj2H7Et3OSOJni4AOyEMd7AWCySXlA4KtqYuro5NGQsE60AIlFbtslb/gsxGMCZMuGJdj9SqwXIK4dnLr9ioU1KnsEccBDY5cbdGHQSqqrJYs8txCmE7n5fLUoRKgqyioRsxx6awfbkEB2qctxX0nrSYur6Sc8ubg+aQRAsmdUAAABMEGeyUURLCv/AT9onI+nRXrj9XCmXTkD4PoturWcH5y5ogC95YLmW7bC63GHpvereSWHuiSadGBUT6Uzqp8h9snKGLo1eP+gQ/z22228prREPucgGMiDXLpDJ9dV5rEvlpary2Hs2Q+h45HhmXPqygJirxGxYleNnG5e7bgnpEFlZzRiZs1zxiprsfCOnEuJ76whRzX29BboJ9JbM1AmTLoz/L/IOyV/pC33NlUnziT5sKSxdI7QsG1aFC0mBe1gXqGOead1tWmp8k8iqdc3cCLkY3ZO9n+b+ze+fOFJQKJJkCktYshitBWavWUYROeEJLz03eqORJ8Dc7zZs6XnIF3xun7yaFqyJh4ExoXuXRrixw1LO+C+d4VbsmRid+QwgyVA69tJ3QnEcKPd5IRfw0AAAADEAZ7odEJ/AZnye8Z+zqBKzyAVKqlh7b9YytK0299AAhHj2KTxmOTaTh7juuGpnmyU3dfmTKk1YfEGbI+TBJM3lOO1NKD2Rb6dH6ZK0RQcRVMD5pY83ZFpk38mElt4z9F0einN7LdpG9hpsrgTjmeL2qKr+DVUdgE8ipOeGBnkZR3jvJlzn7jqO6lmYPq8/7bBvvqmZtCJZjALq0X9BkvEQyzuFt5ecj+3XJdGh2rPSRxGe4omFvNvXzv13Omsm9YGmY26wQAAACIBnupqQn8AAX54CZ3QtHY/M21ZSHOUtPCGn1A8i2xftbmRAAABLEGa7UmoQWyZTBRMM//+nhAABYa19uU6+ADYwzRWI2p8dyfrqBbNIikXCxfYi/a7FXjOUyYwDa+etNLiAj3SMMLM7eRjiOJetcnM4JATxSLX6Tfw5YAbcB5t7D5ec1MYnY4BHHAZaBVC3Y0DusSch7HxSvV1MW7AsrWbdJYr/Nk4sXgO1vlVOxTuwq+dFwzT3+R8qkqcXqQuYoTvCgJCVrXkRkAzt//WQdBGlo7WrO2sMmEdNwkYxC6KQXwUFV9y8KTdxLP5DWCUXe8YxpVr3nrBtw3K2JkflDjPj7EC/H+MH5FaXaNzcCNp8MUzbj8Qh5SK3nYTNs3CjZdDl4nhLZYQGZBgUsa4C2vYc1CaaTVGdSI18OcjKWsXPta/5L5uYFp+oBrzvKo4aM04YAAAAPgBnwxqQn8AAulwOLtDtVgACV6spPc7ndpiskwiPFE2Z7TtTafpZCH7S4mF0FV2qvuqKYkZA3xHHUyuGYID9Wy8RSVZ8UpIxLtxn3gNHVReMWbMMR47H2QyTSxzxaDgHijFnW9kLvrl6ku08YzrQNNanu3wqiTPoXTTneYaSsIiy8AM728K6/wTHrBYYN7HjlobQCbzSX70r8+utgRL/inZx/KGFig06A5YAxLlhCRbxM3ungaGo+F0ARiqLDjePMRXaeixVQhMUJBqa2RDX7eRXtgnRrPSV807dPFHg3tO6atgKq5HmgBwrpRo5Tq4+fNea/ipXCDaUQAAAQlBmw5J4QpSZTAhv/6nhAAC1bckChYJi6D3sO+H/81Peui3c/Gn3qmj/ZXBq5ntcKVdNLWIRhdPjbhV1XrO4AkGNfV6C0oc4WzfdiqjBRIwugQLOF6VfmVPN3X+7T5ix6zh9m2S9hghrrCOc9NWCeDbZsRLiv0+0LcnQ8lu7ohxD8I6kiKSygDVgmP7MWkHom0QOzr0JfM+kD39KZjpYIFkJ7Yz34OQYFGfq1QQx2p1k8M2rkFddsRdQIGGEGoq3b94hKxnjrfJPJHQs7enVtSVcYHRfTxLXt+lK6yYPuFISZWAWoJNBIkyA0MmWlYLyEghnOfcaqvsMXgqTr91/NutTGmK+YgqflW3AAABNEGbMknhDomUwIb//qeEAALZzLtHN7ijd5SoGkgAotyA+7BTd/VELWuiJsMNr6EzYYeq5BaT38OqV+CXrp0EWmx/278ZFurcJF16iVfNv3frKyxkhwBAO+5ArBB+oNnoecdbkWcrgBkyY0b3WvRlL5KZVoLkSM1qTZ6VakcGIOL4x5sJofpmemzTm0L7zjpILEeW6tM83wbnMYep82u9Cblh4laCgH7WmH3c7iaAJeEsstrtcfyNlh24Yt0bzN/uBvSmyWr1n374blsTvl9nFtIQDNGUIKGfJW8ucSv7Yg0gbCFK90KDVlfcRTZE3u5G0mUpFhXtISZDTL9aMXQ4uTA+4o9n/2lfmxlNUBlJVosaPMfSHT//qaCddy2yHUii+18sB/1pG9rjPZEim5KgOMTw/TKhAAAAykGfUEURPCv/AAKzm1heqAJ/iuy5wRZyMI8viHMg5dsQIhpD7kq6XNFZnQDxrGv/QiasvPhNv3DevU3m2Ki87H8Xqc/w6+EgNYeYFDxCalekquABw591enTy4zNgrR38UcL5kZTSS1nYa7qYyb3M+F0+kRSgZiNctJXIDzP38O286uzKIMcUwLv1yP8zyngSIx+CcrAcg6y3UQN4WVdKqp0BLqq4WfrvhBYIsH/EyrUuB4QWlB8q6FEbUO+h3tWuKubYu0JlK6j6RrwAAAAoAZ9vdEJ/AAL75PgPc14+mXsK0sc2GTMbq2IasWW6itOd3q3eExU7sAAAAIMBn3FqQn8AAv17N5HwCkp7yzyQmHsBlL5AbjilsesfSx06VdPvHC6xxvKU6vBtczMAIzc+Ywppg+LWE4CUOznbUkurwv7K98NYO0Lvzr9OCiYxXK6DGDWUOxqwvHsx0iDhUz/puKUoehUZINFcN0JH4hSYu2MhsZbzOv0akf1IfsS5HQAAANFBm3RJqEFomUwU8N/+p4QAAWz6O/xXbVFLoYP7sYZUh9xIAne7gR1V7pd5GQw4fNHq4Eqrq71ZsMAZ/oDBNXKLy8AIQ1V8ORLpL2UY3tud7+lHBapSGzYfYBT+QNiYENn/WCeO7jpsGnzGyPxcqiuNgdvSI54lw2AsUm1KgxP/NAwjP89vscfNYr9VF1S5ZgM62A4gkmZrQZCfMKwu79w9oMfxVquXeGbD04wOFaevrn+zeaw34YrSvILZ+YmQ7x7t4iI+fI6mgSzoue0HxJxj2gAAAL4Bn5NqQn8AAuErRsuiDyoLaIATss7QPWf5afuc7RhS9IuEttppWJRNpqCU4jl0Xk5yIeumiZeb7yoZjt/yyAVi8zUZPRbq/fEghRsSp3K+SbqUmKxm8XqLTApG8eo38ATafW8utsikcmocWoKvATWxtRV58JrLQyAcLwsM//6LUIxlPb+I1T+tY2ZuJZycdVMtToE6eyVLO5EWc+NWVVxUXTdn/afckof/armgAsFcr76UZykrGCx3A8516PeVAAABAUGbl0nhClJlMCG//qeEAAC2e8Jbv4vXoPIq/YpJLLl9qx+oAbkCRcbTo5u2+8VwxRBH5cdZ9WaA36vMOlsRoNFpq/UcFUpkzQeeWwfq+LN4U0UBiHTRBRYApTP77SmAei0n/BjwIX7D8z3BvvA3nyCqI+ZnjKrI64gvJeIAMpDTlixmEIf/5rsSQsyVG700Vtl74huxqjvnNySLQMSz+xPuO4fPV4YEY7wSyHT04ovVqeN1i0FUKWiei3FMnqlyVdcEhD08fS2sjYYhALVHuAa1iYzHfK7WRzVWw9MJchBjP8wad+DIhucAskSa+PfGIET07Jgb9d6rjQqsz96WyCNVAAAA30GftUU0TCv/AAKzmyE+TK4R9dx0kfvy9aXiACdg4VVb1FesQJxiElCZhBqngc+GwZBFziPuHo1RWCuabSjw+PoSBfEMr0jrl9IO3xB4TiBglvpfiCvLK4q8G+BO5Urt0ySNnMmojQPdK6VAYZsAaSF9+BNdRpJP3njhmXkTiO/OCJMMcDC6jNbhgYryUl+0ksfp7FANzOrerF7SWTT9o9Aig7OY+gan9HhSgfECW86nxyRNEpspbHe0foH3F5+h7Ug241VG0kk/wawgzfBAgIoxKcfB158SWzCBnAhHMYgAAAAoAZ/WakJ/AAFQtxoQew/0j0VlpOHph7B0DRjbBCTXnwN4EWv2I8iogQAAAUxBm9tJqEFomUwIb//+p4QAALVC6pSOCtuQAmr3gBCsVcF/kwSxrjj51WTwCKO2GBjG8YR9CCZfE5sLsErGWLEHq5PY5M3YjIlh4w3D6CyZK9R4vrA8JU/9Bd1h7JD0NeJLH7s+GzwnLNQXQhBGfce0JVrLtSD4x37tnIhcxRWgmr37NndlM7D4gHLRG4vka7M0spvEQddih0qlofuZDIW8UMQ1PVpibQnfHTz1BiLf8cB9WY/eWMqZ+imUsDqXDiKdIGvIE/hBpoIXolER8sbku4eEYMw/P0GFaMvX75AHunBfNeYgNO8dyzSWDvUOsUEa3KU0mWUUrak1flHkB+rpkzLHzqPI1SzJ7XM8fmN8kh8mcG4yh6q8oxn1WXGvx8A7dR4qO4tYtGmwf2OlC0x3rxMKaYx2I+1qz+h0nnrQprSlKmFGcK/O+7yL4wAAANBBn/lFESwr/wACs8miUJGbJu7BGhj5Ye11YA5OTEAzwBcQrKByIGJyXn5Fa8QGAdzu0Y5jsoAkwA+tCv6R/SVMv5wO4ZwPQsLwnhM75KXb/BQoFSooOEENDTU4Szl1Xw61+rDkVPKB+4HUmqZS8aVOFfYDRVPD5oW1lzL7NvW8fgXhvtrb9vyidVdSRqBVwSlO1SIfuTrJM7+ywD6/mogkz8dT2QLTpw/xvcFT3K6L9tZG7pcK82tTmFvrgqsGwQ6WznJGhbz2ErFq9xwm4kGqAAAAuAGeGHRCfwABUEY5mxqXiezqd2SUADYzs5tEqsGnk+Qm4PbYf//HE1nnHpzcCLmc8WsUmdTp2bcI4OqFYMqefIaV1i6U0FV7Y4E6zVo4cASqaO+HEJu2489hqLsbki3e9mXb7gA+QheMxD3pYrw5w+bgUvw9miyyigYNXxEtr0igduaqfVhbDu2TlCE9B+MacIKFM6vkmUoCM7nPXeeEc9EccKEHS/2yC56gc8O9kq9pkAoxOAYBFHEAAACqAZ4aakJ/AAC/PATO4BHePQCglgAdWmQu+QFikumgSc+Rg8WYjxQWZnig6XALHJCvqswSqUBhGEmu7hjWJDEEzuAnGwHUtHqQjFWRHn2WWKNQR5/y2GomuPttDpWvl1fQu0tbfjLO58OLtlTjUdvWHlDmrq66ixUOUUrVTsXpfoB0Z1dpN78hs5lTseKmCThb+JCYo2Fh58NmkYKr8zgJqTBOs606WqlcyMgAAAE4QZofSahBbJlMCG///qeEAAFq25IAHG9A92jp+z55P7mNF9zNr9tPsLnigX8Gb5WHwm+HydFJiQ20DgaLCnHlIDg6EFSBeq+F3/YmADBXG96bsA/x+Ip+n7iPq3F77i+Si38lbf5p1BZjexmqHYghwOzpuODbaiG+dfk9t+FkGXezl8mU3p6MV3O1Y4IukS/y6YUdHEwVXOy9tNGE6KfLOgfne0Zq8DTkqW3RnZv+/pCK02wp5TAyQzbciG6n2c8if/xOm2E1Lm91MU/EPXQhm+rG1uAyr6YlwSWE3bXDP/HHtgK+oL8PpXUbCfKxR9AcrxSOU08RL/LkUj2fEwpRhLPywBXnBivP9sCkGf0mM+jReDNGPm11Mke2KTigX8Sl3aN3hGyUHk9FHnZIZcajBs2BHQ6EA1iBAAAA+0GePUUVLCv/AAKzydoCYna2ztzIcjCGI2cwH3AslIAN1zoATHRdr5yz3sXQYyvCOBlqbWg1i9n7QUncr4qmPt8MGkaimIORB3QBlhtGLLGrrc/6GVuenPXrozbw+90e8YD0K3kWFARnmWsSq0Hi6nSEk5C1hp0D3NHzqZR2nNW2uPasucCOtbR1Udf9cm6EHg81rlCEmDbKNz3I+iinG2o+DqpKnuUcEmNQuwfiKKiBitPhjxCyG/Qd22Lwa3UCpv3JwyXY+AWc/7kEo3ytPl5jo3aBrFwYDwq3gFTsr217k1PCCEWgm14gERKAz6KqtOg+NYJldQ3rXW/nAAAAIQGeXHRCfwAC6IzTUeALcN5s1NLFkbhkZ1XWa3rdc9eifwAAAMEBnl5qQn8AAulwOGE2Q+uMQcVYAE1aAhDGBvOPX4XsuqwGlv55JNdV4ZioXneJPlLDgz9QLJYPRVBW/iozNr9xln3mUXbaxiiy4cC665Y5d+jnGmwrRJpkq2HLOBCHENIMXXoKfiQSerD1Kb6cYn2Xs//Mn/KzUos7IscOyxoX2S4vraoBJRqMr7wk5UaKRZu3h4z2T8bq428iT3jhtYJhIHOHqgBsiRq3QUS8ivxqajXHwBJeDFTB0o5juWgmKG9AAAABJ0GaQUmoQWyZTBRMN//+p4QAAWz6OcsJJFpsiQAhTZLTlxtXBw2WTPBcydAyuA+HXcZX/v3spvggHP7Rmgxnf+QQZMCMYH6e7+3ZTxVdfgX5pCyEpuiCWnYt3/jPAQWlorBBseIRvaq4xxTZfdS+wb08HI/fCGgS/TWULmHogaCf78hcxXeWF5UnfeiTyxY/0jsrGtFl/IjzPnHp3aArie6HX0sIljacfFFuxavXCpABUkaeZkX3Iy/NX7SIIZT3cjt5yeIMBzrGcwOgXk1PLOF953p46BIpirZUaDDRmV+dYvWWh4dAp9K6+SHtEszCgX6MKwquaOaQZRY/R/Hyg/PN2aW+TEZvb6Tor+zFkyYY8ac65hBBUD4kWtr53F3ezi5XPakJu4EAAADEAZ5gakJ/AAF1hngBClwEQilmSsdhBJLtlORuGxvFTtUlgVc1zKnpP6KEh+tvF4z3Tb/NTU1XNyf37Y//13HSDVPotV8+eg6BsxY+qrWxIG2mqMRF18JTgi5mvQyuNv1eAUcFvY+NFOQJa+jil2BdWbSHfvM7JGzUkIlrvJepy1VrT2qnV+Dn20abx5m+dYQyjAUW8kqopK+SR2jHB/wV7JPJt/4jcU0qTxZP37pBdJieDX7WCS42Yi01b8iaA47w/BvbwAAAAOpBmmVJ4QpSZTAhv/6nhAABY/o791587bdrXOltloKb+HeroAcCT1F1EcZIoQ/+Hjulr5lq0neuSxP83hK5NyWerEQFBtmHSW1onxYGRTsu2sMCSmPVbAha6YxoKobgGaOmDcirET+BCTCN2r8MrrzmX1HhPS9OljaOiOqr63s5/SNETIdlvuP80AYFTMfCSCXSQ1iy78Ir6E/qfVf9qUoitcNtVJ/LQGv+RMYyCKRyw/hHcbLQ7q5fkrXTUgO2tVfvBpTbgA8CcKsBtGvgOyYZcHvaqUf47NbrYloyREuNZfmZMjtma1Ibu0EAAAC/QZ6DRTRMK/8AArObUoMTYXo0sTr0AATvLlBNhmpnWV5MNYXalfrNu4pnTnFWr8cgA0yiG1XIbDqVnc6ez2pbWUMWRcrCJS87kWook3ZhMjlPKeqdLEWp4mEHnhKJcMN95oZKmAj5h5JikoFx9bu8Bk/acaQkFoJIUy/QTDC5kjLnbrOCFKrwiKqmBMPSE1f1EMM6HeHCimxc2BOoXFx4K2C8sRMSmfeQ3bTTeFHj3aw2G/SvAuXIHDch4OijHJQAAAAjAZ6idEJ/AALojIOluy6c/4ymjcWLsRjKwHVgquShXWGClJcAAACXAZ6kakJ/AALpcDR+emG3vSuLPnAC3hUSu9N8KbVjyKS88gb/CfW/gszGZ8p8zWgKIcWxjj5kRneiZAcH1jywx4XsI+DS5xpnABQOi/N6UNSEnPs1TfrN4B7irEINGzLzbNm1FN0hSAYAlHeWNkxyEeWaE2xOvVSb8UZZDvFeNCiJaD9irCmcBtw9NQ9yMJ+RtIWSOHfmfwAAAQJBmqlJqEFomUwIb//+p4QAAFiU1L3OqQAt1b/gFk0Fz0NkUVxK+sgVmpVNxu+eJwyfl5fqDV3URUa3HeUdYptejh2vGBIAB99Is/fmwP2Dw1B1XEZ8NMuwOiks5DMKDEYhC0ZB5YVYbCrFWxb7N+VHR74PN4GA0U8fjxwxaBj1Dd9x362WmBX9byrKe9q63uOFxPZkJ0yMgCFXFFMCj5oAnbbISUFPD4lVbGQaW2K5+cM0jE9RaTADINLG4IrxJ593KHDFCkB3tjcWhNKkdfYHjFLf1ncHMjD64qFPYS1vqAOv6TGmfEL9OfQTCqICR/93Qr/FBBvDe8f75L5qjluzO7MAAADgQZ7HRREsK/8AArPJ3XcC64SPrY7bTiGJaslMQcqta4nJqaAHCNdrcrFTOekFCgyKfY3jADnHin1QrBVUOmbmZHMAuXBlfyP8cWP607NngjhNr/0LprLyUhu5AGAglCdcp1wThTb4/ZXPCKDiZtNTnvyKwfYQmuF92Qkhs6+2EkIZR2+L0On/Xr3Eg2IsPWXVKSmsURjpcoZYDXYWGFAf1OQ7vKh/+lf35t1/L7Zq2wzVwndgJDQWLH48HFMzaaj9MdiC0EnZiMTalrMWidtez67J8gHEp3cXwieCWQQzCz8AAACAAZ7mdEJ/AALojLMLNKgRwAX67iSAbflvOKhaAcSzebruQMeVHrARBwBKD7Z7Rj2K/NqhUQjG9X0yqQIi4k5dAbNKhhg8w42iQSCO1Dm4gQ+ic20MBSN6YeapdAI1tLiy8ptdexP807IS8b8HAfjVHrC9ogSv5LzWix49REv+5eAAAAAgAZ7oakJ/AALpcB3nRkHH5ofcEp6RDeqZvHiFEAVdEvgAAAEWQZrtSahBbJlMCG///qeEAACw4ghIKm7alNAAD+KzLaP3EkcZ2N59xtILZVoCZS6aSsSrGiK6R+N22bRlJnI/zgB0ISe09Khv56/xmNSWaPMvJpHvWBSfQhwTzV90AUiVoZsJIEv5QwqjsQ/PG5nBABzxEaO/tabdFV0Su4Ipk4aey7hkySSHbCNaLHxPEmfq8Y/4vCpbIbIgJ1HvVEsRLHXjz5T+KnDow4ms/y8KoH58Kg2dG7/YQNM1lEvq3CQEhiWdffX7is7vGhTrobkCWqtLl9kRTMTtytvPatbw7V7CxLG4HW1I04OQS024zfZNsmkYjxz3MhkkabcWvgi7UK8S9HvtkugiexMwfqZBNCd1b+bTLuEAAADlQZ8LRRUsK/8AArPJ3XcC64SPr8anFAKQFuop263ywlG5n8XUtxYyPS+9c5+fPHZ7H9qr2Kz+9hWz9KiFz3rp1WB8yu4gfPofbFMdiFuIZzr2033hbqxjCbSKxvHfpzApRFbQKLf2t+px4VYts7L3UWpVvps3t+KhHOKqeBSfhn2nDoOI19I0aefmSDNS/CQLJk4stf1I+WuLIJVbkEX9vNKBigOjdrsxaiIPGXdSpy0Z1/z4+JwWFT1yXD57bmdmHCtaSVMwx/kjlhgp64lqkPiGEHeiLr2qr3leqAOwHxGGmqIb+AAAALgBnyp0Qn8AAuiMswtgp5jVA+Ikv7AC28bwFhuesFFd0Z+BrRyPUWDpsGeTF8aaLqO6uxF9jwfklrfiUFvb8yph+ysozY+DOgznk+DSh+po62EqtdR7/iw7Xbk0mBxOGmD39uu2hES8HH8lY90S1NwEkSDnays5YdzXRoAqEEgNly29YpptvM1AfhvC5colNyvIWNP1mrDa+h/nfX1NWB4USAwyLW6Ann33r57wG16At1HMrIbUeQkKAAAAkgGfLGpCfwAC6XAd52uTBACw+WBKoWhxZ2o8Nt/g/R289pWeCM6H29gZrqJv+Op3Inb6P58db0LepfDJYZ+zqX7vUzKd89/Dnc4FONIMZf25Ps411EjDBDrX5fK7ldBa/UXQfVdt/t4sHXeacSInoN/QVK+LAqNngH8GvqXyGXFt9TGOeJma6sH6wKFQYMDpLmNhAAABKUGbMUmoQWyZTAhv//6nhAABbPo8LivWlToauM5Ifv5T8OqhQL7ABfLYjolQibyT/3BNCNv4+LdGVIa92AKjDYJHlUxslO1xyAdKmcdo3XeGgBh9mdHZ3CKLr+MNHa3HeL649dA8sVCvedWKGF2AwO2n9NpZcTrTqOesovhmvi0HSdbfwb1b+DhGgpQlQwTKfM1kjsdRuIePeS1EvDDpDfasjMNE7le/03BqPcJ9iETXd9Fyuayys3dM6WckoCrQKOFZBzrqjIXWcNYCh0cvqS7CldRZyOfAmvQtsHUG2lrw1KBrCPIVvmnnJRLOE8vl708SUkNcumeWSO9NFl4NudsPLa/crzpGtqKBrWpAsw6Gxgg6B+KLFSGgP4JQNKamy1q6wz+p5ZhwuQAAAJZBn09FFSwr/wACs8nddwOFqPLcGCPuD5y2Y1+85mQBe5/dADiZBTDR89q5Xa15VyfzpE/s/aUvlejdZk+iRuAHJdAzSUPVUUIa6xTTX+JZ0UL+9YH3q6phEXC8lcE/yAUK/Dq8caxQ3jVGVbXKhfkg5OKjW117YxlnT7adwnrTHBZCoQyUrQ0lDcpUVZ6xpra9wPH4MkEAAAAiAZ9udEJ/AALojNLawMenDF5C0WjgFo1MgIKvB6Y4kz6k4AAAAKwBn3BqQn8AAulwHednCi8eUZVDOLKgBaNimYzBqgnWp0Fq5OIfFB/lgfOc2AFbYbNaP5B8XZVpwiI0isZy4OWiuYmmuxQkjVgQjrstCIPtwSdKNm7mG8LGFGVjor98EtlaKsb35iRYkkt2QtOXBOHcr65vV++Hpr4NJWKannZkEBKwYmfcrp0jsc0fTGZsJLvT3T2FF/rlR/nW47GOq1BzQh7P6ERU/cs1kNwsAAAA1kGbdUmoQWyZTAhv//6nhAAAWz3hW7d0hbrB+cgBcn/b+pWgXzt6tmcQbKBJ+zuEP+7v0M/J3Arrq4Z2DIc3CpyHCOhwcaXJJ3GNVHWfSDyYyQUQrPl3nOIPjBpn6ljA2YUAvfm9AK4ImOTnn9k/bKGM6cygIkEfovPmGGhlNUZtOcGtt28D9h2CX7SDENMRoNRgVfoCAl9zCoZcT2kwIzf2x/MVNh/XnzEZzJmjY0CpHHLbx0mXJd/3p22nHw2tq/eadNYueUfQoXZd/yV3etL6Eb8GYBEAAABkQZ+TRRUsK/8AArPJ3XcC64SPrY7baBIn/Ie99pD/KemoAWuAO+DA7oJ4cWBisR0xdrgLBJdbWDr4kyRUxUGjUquJcFCzPW+TDRLC2bCAh8vcIxbNeCXogtMwI3zPD9ZJ7d8SgAAAAH4Bn7J0Qn8AAuiMsws03y0bJ1hy45zgDOOkTurACYzgjd0AB+d38ASQig88JZUZ0dlF2lrhfk9XPANKkjxDX5n9CNLWiqw/RN1H+/sezEshndCY0rmGLAmTZTaqPUHaGzNxtaWCJPVAJSCG6QXrbF2PG5rUsIC+yE/eoXyoLdAAAAAoAZ+0akJ/AALpcB3nRhnH5nS4DWYKVLQAXOo24yvm1yGeqT7gep1JgQAAARhBm7dJqEFsmUwUTDf//qeEAABbN/fCMYwAKTPwT/GRZGMejLdHiWlexHkjAr+qma+hBVstHvlhRAsHKKGyUX81nhGUzRy97tzEPhntgfzTQmMsPIQKZCZoa0CRqkKZGGSHya83DoddC5zxf3v22xHvlJT5k4WbHCDEcKBRMnjK0gaLfMcVbAMaTWBelD8+9WwoiqFSKbCqEL8tNx4CtVNSRxKydOETM95SxwM1Y7C1nryI1cXBo3q0ei0P+g84eGyAExgC6PPeDdwWB6gdkb/WRf9ngVn25TAuex38+peYKHwLRAN8R2cQ+4JQC5ztRkRe83kD8F6VQVr1Fl81hzgAWhyw8zDPDWH92+krl9jfau9q19tGm/YGAAAAXAGf1mpCfwAAX54NdWdIQePccZVAkgA05dMiBwXFTCw+hrdOLROtoLMvk3Gz6zj5AitUurgvEcWEd6bDQimjAA6x3lb8OAxEOSuooyvh23yjOqdBQEmTu+VQdiUhAAAA30Gb20nhClJlMCG//qeEAABbOZdo5vKHpWt2SveprKYAC66G2sAb1YUjqvv83RfKd2/YvcJDz7hwvAUNuqgbXgXg7Sa4IrrSUIEo73FFqLNN5Hau232TtSSGspIAKzgHZGNVRyxHMzzGZDkz2QjoGt9jf0J05e98Mltc7AyhY3KeSi5824RGSe+GgTv8Ls8OqJ8WvkK3NsrlnNbCt9fh3RG20hR6s+rngm5uPM0hESB366Nk2mWm/BduRpU/Uzug2kSnIBNGl1xBDBMTqg4/22ZUFgXnIg/GRs6/LQ/9GgEAAADeQZ/5RTRMK/8AArObUoMVZYa1Db+zECjkxjUj4QARwnq+Eif12QiHYhv5859q5SKjox/YcrcQr3MvvB8QFvohI+tde1G9szLrQ/ub+U0LidvHgWb+f8FB1Mrsexo7hvJFRMLwypcFV95PwtAE5Yzu/YNNFsTcpBZ7nk4UTwq4r6j+uCCm1P48Z+xiqzLG/35DI5b6m6ohapG1Riw13zsUs6YVn8kDo8o6WI335CVBH21+mZA53x07hviXIIq/6afk0JDcZ2meWEakEHXXrQ3oFUplCyqwv/OdDolSge3wAAAAbwGeGHRCfwAC6IyzCzTjANQBWlG6znOlAf6vMtM22Lyge1enUgudtPKNaEq4gFcRoJ6xJZeK+2tVK4DDq6LgKwAcBhVdtcpmDiwBiOYtxiypuQJwwUGqdgpjT1V0qb3GZvTQB3pqQh/uZnQT6L1UgQAAACABnhpqQn8AAulwHedGP3ErMZlDTaaCg1Eb83iBuOBwOwAAANpBmh9JqEFomUwIb//+p4QAAFa94UOrs7d0PkgEI6lOaLWxQxDvBBanno/Xl2BqwWKhlVKAxGGIc0D/XDUduK5Ldsp+HUbZ/8vLT0piVAXIDPZhnK2m08tDr/HVNB1hRaWAU8tFu9p8E+37yMzK5ANa2g6Ga56CymIT/da3gNtN+9iYtY2HY1/DNnMSIECDM4bt+LPWR1aHuHvRwRvxryfk+Bhu/eGaDM1Fg4Z8Pbk3it3/eFJdoRcQGhLKY9HipTeXs4F+JWFZMK9psl6HwgAtzjn5xyeYfbdxkQAAALFBnj1FESwr/wACs8nddwLrhI+tjtmOxUd/gDCgMM32/zT4gBNIZN4RnXaH6+8TYW5gXAcjTzO4lfnvU1uwb/XMl7t4VQ5a+N0AE8/s6VshwIIyVZ8dUu52GhZwb8jXryEnSns0oVt+fMaNn8cYpWZDAv0Ol/OTEVJ+Dc9xGIuU2LFMZofnhpPKh2PDO96BRKEhHhmyusw8N/Ozf2rL/+ZXzIUnJon9omgpJduLl1O+K3EAAACPAZ5cdEJ/AALojLMLNLctQLsDJju6xuGqAEhEcpsZWl/A7u0MtfWsZRUZRDMexz0WCWQPoMns4ZXUtuakKHb7p3u/0n+qE2Y4WJ3P1NmkUdMe0abo/A2QpPkSCVcDjYoUe2fOy8p716ojZxrp86BolMHDmLTv39gI6FU88889RQtqHqZNtl0jTrjz1ngQc9wAAAB1AZ5eakJ/AALpcB3nRhnqb/vCB4GkzgBMutg4qJEkk7sJNMdp7FQr17rDlkCgDG7AF0+jJ+KAzav6QMw7O8yKKTqX0w9/4wb21iuAANspKyCU38hMWHubNEfzvMH8fNPSD5klAzIsqb1GpG6KIFg5bLIr3m0gAAAAxkGaQ0moQWyZTAhv//6nhAAALFLMMHlx5ACDwZ6Oa6YkV8eIVFmbzVwmuuIGRuarzG2oWOWUdZEse7W2yE+lIsPqbw+ZMzKyoBiwdGKmlecHY8/xNUyaj1ny/rd6ag3yBQ9DMXwv+0maRrrgn9+jL0uOWOrxWVfERBvVFBFKB7WImp5HhumiZunyG4xX4P1aUApcrktszuTbwTR0GVz2EULGnuwQme91bAIZ2i/hgHfRY6OO0pKbBkbmtSqSVLJGPq52V844QQAAAH5BnmFFFSwr/wACs8nddwLrhI+tjtnNmbtbACOtfzQ9Xa0WXa54toUcYuI0guVrvXjJLZkHFoJucw014VVGqUEvlSqhIYIGSri0OmPRC8TzNKnR9MirNSW1lS/hlFUs6KPgQDyH8GHW9PGuyUDRjig8z5tNstUKerLynpjkCoAAAAAdAZ6AdEJ/AALojLMLNLdARP38WeLqqts3VkorXCEAAABaAZ6CakJ/AALpcB3nRhnqcMjPQ4OgAXow3tRM0958v6buH6H3VbPRDZ1EwyEQko1vrpOfdsFT/vVh/obos0l1j+G7MJgRMMS+/fuqqtcd96DTafAOhGARH+ZgAAAArkGah0moQWyZTAhn//6eEAAAsfMufiORO+S2AAugry0cVx4gVItzyyUmiCk7VcZyS+9x75qSENQdF/GqljMMB8BPRkbhw6Mot/qNHMSi8fuAIDS8GX/k2j6kTG037lyOOYJRMqqzitaLrPCLSA7zEYQjYwWy6JJ9t+ayEtSjByVxom13O8L3v5fYzzEctJyBJF1mAr5AevlorEgviS0K7jCQNHqJVI79oBRjQ0bpNwAAAIJBnqVFFSwr/wACs8nddwLrhI+tjtnNmURjmTxzKAF0+Sfwn/P8oP5r/THMLnQjfbDqU6rmxlWaKquFEpYbWRDHOduHrxi9Yo8AFbOs8Uyg7EJK/Dsik1rHFLqS3cGDE/EfrPfoqTtztBmplQj4wLRnDlJ3Bl4uj9xR4p5ojlIqnzuvAAAAfAGexHRCfwAC6IyzCzS3QEERhYgAbG2xNsL65ISLj7XXH7LlJMVOaAiXQ/AyT1BMqUwHEC0a3a9CiKP4sLvQ761GTOBLUvPCLVCmAorUy+ws5+W5uJy43fTiPlP8Z4xskxxF5Qx9W7X/egUuPxPiXFlnzSDMQhsj+46SghMAAAAjAZ7GakJ/AALpcB3nRhnnDBN4JMzgT3twCG/r5SRKsxqdwFEAAAClQZrISahBbJlMCGf//p4QAACtb7+DwomAI9nFfOrssYahqTDMeXvqTH069/PvMsmoN/BXBGku9eVyrZpP/h9ZeFL0lk/TWLcnLzYo+OnRLMoffpvNrawrO0/BbBq5yYCNh6+1hhXuBo2jvpfJUw7OfgiGwfKAtSzvinmtVyXofPOXphF09X1m+geVkFCo0rBCgLD3dWPInM7R17ng9vFemEavy49jAAAAjUGa6UnhClJlMCGf/p4QAACx8y6A7I4AFfq+2RHQbq76NjxGNOGl+7fpFV7N1yq49E0ijJAt4gTHD3Q0dqcUTo6bgqtNWrm2pn0jHA+bnQRCrhiCWgin37ubGjYR6ysJXRU7zzsez5CAUbxZUhhcw7BnlQbVX+vnWDd8p/PvuEB1QEb53PpBd/i0Eo3ZgAAAAKJBmwpJ4Q6JlMCG//6nhAAALWE5Rms1i+RgBLZng42a40qcTXbhPCellfcmLD15yiutXg6LLp0zPxqOIkwrHW9T8c696Cf+fXfLXICdw0fRlh1tKpP7jOkm4UEfsfQTtXI/HoygRdjjiKvJBYseQ9g9/xxuvmB+ilZxNI5EAIcm88Zl/tOuJAkK7lHlH9dQ7y/wLR4DMDzWGMIOThRBZ0fo1ssAAACEQZssSeEPJlMFETw3//6nhAAALVbKZ05Dgkz80NAXV+4KMEmToGJHBazyIVuYYMDYfz9U1LNNQBZgWD+QSth9mC7FNPzAaIDpOl0TX6gPLHX+co30+/Gw0x7wuC5/Sshb/fjm1FZdfytz5Uj5AZI9CFC2WJOM0qU5mxSmA1Mhkyn7GPhgAAAAGgGfS2pCfwAAL8JkgbQq8f/XCax8wxifAc8gAAAAwEGbUEnhDyZTAhv//qeEAAAtnvCW7+LdeTCWXsSgv/PG0AJQ30b9D7CKeNAGRH4t6hW6uoMmn9yUDOsd/ZNzEjAbx4yNP9+gm+wrBmiKV5xMGjW4LwRE7A5aLo3QFSS+IMhP4049b9qIw6sY1jh95i3VGjAJhki9rt4i0o2RYV7SgizYDQoAanPCFF7khoI9YT8A84gauuoYHQo/QhOY2QxHfL3fk0MMFA3cU809OKG8wHRAYVkqmzgUYN5ItI8+yQAAAH5Bn25FETwr/wAAJEqgmPwTgBsgEKfqRn3m79W7zPG/DFTz3Z3qIbum7w4pgj+s9TPrQCOznTr9JHiCxU8yjc1MMLTF+eKe5y/iNVDkdeG0eJLYYPjhEzE+gYFhXy5bz0lPY8V/P5GIPWnn+tGau1PQYW5fMz6s1XAtSB+tckEAAAA1AZ+NdEJ/AAAura8ANyol81U0r7IZjxIJxwiA/6qRJ11wNxG+i/MxOd+HdE7nEZJwxwfhpI0AAABJAZ+PakJ/AAAuErL0wO/AAByjQte1/7jco3XCPkU+AwRF/TDREk0Ph7BriEXrTKTWJ5RQQ6563J+tGBK3pW7KUE5EqOhYvxg7wAAAAMVBm5RJqEFomUwIZ//+nhAAAFhtQjUAFzbJenMnx0CKPTI+TegbsH7Xzlv+vMZIsS7haE2MjInXGwQB548BWXKd2NPpQnduf86/bnDmzGeJui6F+gfKUVfna4bkC9l1LgVtWPbJBkg/XpGyzejUTz49Ok4D6VeVUfSpR/Weh+9AqdvvFz7Ye+1OLcEWPhBiXf/XUuTSHjatcO4OSgQTi/CvhTnO8+kIECNqHGhClSZg4Y8rvEA72qTkY55HcuZd/0eqTwGnWgAAAEhBn7JFESwr/wAAI0qklmpDBAACxIi6O6J09V+HvMdUOAs702SPDWVh5VQFVzq0c6rRKlFyJAdK8BBAqYyRJfrmAQp2Z3N1ECEAAAAgAZ/RdEJ/AAAX3ye8jk0Zi/fgAB1vuYRYYOpXtgbASKwAAAAXAZ/TakJ/AAAMwOv37Uel7D9Hl44vKtwAAABkQZvVSahBbJlMCG///qeEAAAWxDE1gBNULgt/VblGWx1RyQsK5Vr0jpBUGR95EyetrJedrqMsvRvYIlxv9qNTEGCzjQkBZ+ok2y5hXvCv3zoIk2gJ7XZncjUvBPOVrjNJ//TbLQAAAL5Bm/lJ4QpSZTAhv/6nhAAAFrY+CIAQgU5lyLIr964ihwrPSJSCtzDiEUki/JLZTtAk8IN/WY64Kgkqj/LFCBXJ4/ASNoK2TBX6W9g39lK+UAsgai4v1jn3j3Im83ZV7L/Y4H79U75qn3Yp/WVM/Q1p5JoTaTSscpH+dmAQcZ8HqjnNYjv3CvcIT9quwzrcjPHNjkH/yiMZjf5t05tPBPw96zQJMh8/BfqLo9rLRvg6Yctd23XpP4TXJIzH2vWAAAAAekGeF0U0TCv/AAAjvrGWUQAe0do9lSlA+ku7Haj4DUbMB5TddW+mW6FofrcWi2+sbvOPrOIrUyLzAjp8AGxnz51M2fqLkX+Tc3INTlCWSxXY0QVLvZ1usZaL/mFYm1WEC7XOivqterfl6apnOK2LgF5rvQpLjawdkZm9AAAALQGeNnRCfwAAFshngBM7jifNOvF8q2UVzpBJrJRB3IkL9kzFfZ8C6WSY9+McwQAAAB8BnjhqQn8AABfn2dQAXeM1PUic3UoeFgPy4IfjwAmcAAAAsEGaPEmoQWiZTAhv//6nhAAAFrO8PUQAmgTVdYNcYG8KKx8K2oK94ZOiypbgN+7z0MmCIvTFuB2gxg05MbdQ9cKCLAROalXwdhRnCye59+Rk6JH0rxGi9sltNL5gRkN7QCnXI0A2eTqpYS8ggeDpMKr/cZUCmsl9a39Q+1OmaFlCRCUmD+biayjNYZe21wb66rOXRRMwGpQWzXVCogf4uhWW0hoWEUCIJhnD0cP1HC8rAAAAOUGeWkURLCv/AAAjwZmND4ABzFVgGVG0g4DDhxuXFWBGEvA66OqA+tvkF1JDp37OEQK+2uWyoj1heAAAABYBnntqQn8AABa8wODn2SFN/eihWi6dAAAAaUGafkmoQWyZTBRMN//+p4QAABc6eCkqBdCecsAzJJ5wLY11wp/lM2WJU2av0L0bKgUEPdLqcPRT29iZ756KKDhc7fh7KwGoVjN2tAHRHqN13+GmW+CJN9lONuHxBVe83lreGyebIkRHMQAAABwBnp1qQn8AABiBMgwsKEN3AEaa1D9rR5RW8kvwAAAApEGagknhClJlMCGf/p4QAABatg/ITjq1ScmPe1Z6wcvhV28IFMSRyfMSdGT9scSwE22Wl0G6d5QVTbI5wQ8wizr4OkM8Vc3n+Ge3f5g8FW0XjA+7kE6AKN0KKTcrh5acDF1wVdjvc3hkEn3blLddfEqogpo93triB6SOKvBbfzmTHUmAddSKBBB7EmKRMD+Dq0sPC+jzsZtKrU9nqJ2sdnC7Xw1gAAAATkGeoEU0TCv/AAAR1S7A5ACaTWKretg/VDZ9b1rZfVX0fLW01UdBNfRfT1hIGgh5820uB3qBb6On3LdOZrahIVCjbIU9BA7ZReQBKx+uQQAAABYBnt90Qn8AABa4sIdJkGijGansQXSgAAAAHgGewWpCfwAAFrZsu/rFLlDFIAN1rlDfG7ow53LPKQAAAIRBmsRJqEFomUwU8M/+nhAAAFq2D8gr0IS7XT71ZHanAas6wOQcArCZnRrobTcLODXWxA+DcUjsO/DAaAtJtrLHj3laCMVZ9VC5FVXmgOFgTT/sRGsZ9szkrGvKOM1XbPH0A8512VoObQH9EIkQd86aHakRIKaWWaP1mhIkfzNOJ7OiMFQAAAAiAZ7jakJ/AAAYgTIN2xVcfHo8XIAHbMPxFgF7OPoelkJCnQAAAHJBmuZJ4QpSZTBSw3/+p4QAABc+vtICh3AsuHiwpjyRxWpgAK4B4XOuxlzwgH3RsC4mJG502+1GD2sLSjce6ka8FRP5++2UbXKmE49EDRgZq3QUK9UT70ecimXSVYBwqelNPsyRAV4n5XDjrYhtif71toEAAAAYAZ8FakJ/AAAMwOwNfn2dcRdPHvW5jptpAAAAdEGbCUnhDomUwIZ//p4QAABatg/IChEuJZFRwCkBaaLYm7J5ayn6bWuAMgA5SJ7X4Oot9k/3PioHwboyR6jwIdeId4nIzmjevZvesPrm5svnSvZQJLcsM2co7dsZLk3xZuBnRlcVpUdPMadOBKQW7OSRj6GxAAAAI0GfJ0UVPCv/AAAJ1bmrdpgAdCQxRk0Mp/GNApDCvzFvIp+AAAAAEwGfSGpCfwAADMDr9UhQXrBNsMAAAABoQZtMSahBaJlMCGf//p4QAABYwyKbgEAFq2e7q41+7KWI8TxBfn8BarIZ4Z4uqfCjHh0U3Y7tDJYyOy81YHLdrXzqNYRoBiLnouuVEf0e3rvondPUFIjSzLdR56NsB/2s4RWqRRdSrsEAAAAcQZ9qRREsK/8AABJdbZAcfdHhG5WbIWIkjYjEgAAAABYBn4tqQn8AABdZf0Bil9ykrBAqV8mAAAAAWUGbjUmoQWyZTAhn//6eEAAAWrGL0AqK3uGmzRotjpKsIpEHqAlJvQIAXaT1sH+r39iwnQi66Fc5oX1Jks/LwhJvLEjXuc+U9opsYNTvQv8M//tu4Myet6dhAAAATUGbrknhClJlMCG//qeEAAAWqL2eBbgBM8m6OHBDWkQs/qe8Z9qKJCpzzbz7Be1mL2PWisM4oAh/ryZGtMqWnff9d5RQKQYcRH9/088lAAAAX0Gb0knhDomUwIZ//p4QAABatvEvMs3OwALnmJn9C1+J6Vz+1cITYvYv2WlMw8dw5//uv4X8rmq45xXZunhN7tqzBBnW7QrtjAz3bD6mkZuS/H4I8d7h/R1aHifLyDOFAAAAJkGf8EURPCv/AAARpVJMe0FACRHp2f4MNdP+HLaxgZTPAr/RQ0ZJAAAAEwGeD3RCfwAAF0RmlsnRl9TeEEAAAAASAZ4RakJ/AAAXS4Gj88ZAyPZBAAAAVkGaFUmoQWiZTAhf//6MsAAAW4LOH84ChQmUWXlQpPLBPSmOERDXKy0En0g0zu2Blw9NZ62vhE2bUzxALzkYSXry/g6GMSqyg46l/zUD5lJ1sY1fxxjgAAAAFkGeM0URLCv/AAAR4Mz6gGMzPJ1jn4AAAAANAZ5UakJ/AAAFiuBOwQAAAC5BmldJqEFsmUwUTCf//fEAAAMDTiiRaR7lABxJPdvEmQTBAi+cPGK/NNzc+e+gAAAAEgGedmpCfwAAF+eNjbtaGPdNvQAACHttb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAPoAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAHpXRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAPoAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAABsAAAASAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAAD6AAAAQAAAEAAAAABx1tZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAADwAAADwAFXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAAAbIbWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAAGiHN0YmwAAACoc3RzZAAAAAAAAAABAAAAmGF2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAABsAEgAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY//8AAAAyYXZjQwFkABX/4QAZZ2QAFazZQbCWwEQAAAMABAAAAwDwPFi2WAEABmjr48siwAAAABBwYXNwAAAAAQAAAAEAAAAYc3R0cwAAAAAAAAABAAAAeAAAAgAAAAAUc3RzcwAAAAAAAAABAAAAAQAAA4hjdHRzAAAAAAAAAG8AAAABAAAEAAAAAAEAAAYAAAAAAQAAAgAAAAABAAAGAAAAAAEAAAIAAAAAAQAACAAAAAACAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAABgAAAAABAAACAAAAAAEAAAQAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAGAAAAAAEAAAIAAAAAAQAACAAAAAACAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAGAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAYAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAMAAAQAAAAAAQAABgAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAEAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACAAAAAACAAACAAAAAAEAAAYAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAYAAAAAAQAAAgAAAAABAAAGAAAAAAEAAAIAAAAAAQAACAAAAAACAAACAAAAAAEAAAgAAAAAAgAAAgAAAAACAAAEAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACAAAAAACAAACAAAAAAEAAAYAAAAAAQAAAgAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAHgAAAABAAAB9HN0c3oAAAAAAAAAAAAAAHgAAAj3AAAB/AAAAQAAAAEvAAAAQQAAAXkAAAD2AAAAtwAAAVAAAAE0AAAAyAAAACYAAAEwAAAA/AAAAQ0AAAE4AAAAzgAAACwAAACHAAAA1QAAAMIAAAEFAAAA4wAAACwAAAFQAAAA1AAAALwAAACuAAABPAAAAP8AAAAlAAAAxQAAASsAAADIAAAA7gAAAMMAAAAnAAAAmwAAAQYAAADkAAAAhAAAACQAAAEaAAAA6QAAALwAAACWAAABLQAAAJoAAAAmAAAAsAAAANoAAABoAAAAggAAACwAAAEcAAAAYAAAAOMAAADiAAAAcwAAACQAAADeAAAAtQAAAJMAAAB5AAAAygAAAIIAAAAhAAAAXgAAALIAAACGAAAAgAAAACcAAACpAAAAkQAAAKYAAACIAAAAHgAAAMQAAACCAAAAOQAAAE0AAADJAAAATAAAACQAAAAbAAAAaAAAAMIAAAB+AAAAMQAAACMAAAC0AAAAPQAAABoAAABtAAAAIAAAAKgAAABSAAAAGgAAACIAAACIAAAAJgAAAHYAAAAcAAAAeAAAACcAAAAXAAAAbAAAACAAAAAaAAAAXQAAAFEAAABjAAAAKgAAABcAAAAWAAAAWgAAABoAAAARAAAAMgAAABYAAAAUc3RjbwAAAAAAAAABAAAAMAAAAGJ1ZHRhAAAAWm1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAALWlsc3QAAAAlqXRvbwAAAB1kYXRhAAAAAQAAAABMYXZmNTcuODMuMTAw\" type=\"video/mp4\" /> </video>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 211
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7HKRcwbKdyYL"
      },
      "source": [
        "Baseline forecast video"
      ],
      "id": "7HKRcwbKdyYL"
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 501
        },
        "id": "fbQTvTQadqSE",
        "outputId": "9203e347-1f8f-4c9a-8a2e-de6f5bd74814"
      },
      "source": [
        "video = io.open(result_folder +'LSTM_sample.mp4', 'r+b').read()\n",
        "encoded = base64.b64encode(video)\n",
        "HTML(data='''<video alt=\"test\" width=\"640\" height=\"480\" controls>\n",
        "<source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" /> </video>'''.format(encoded.decode('ascii')))"
      ],
      "id": "fbQTvTQadqSE",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<video alt=\"test\" width=\"640\" height=\"480\" controls>\n",
              "<source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" /> </video>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 212
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RppGFQPvFuB8"
      },
      "source": [
        "## Discussion and Conclusion\n",
        "\n",
        "1. MSE loss for MOCA with LSTM meta-learner is significantly less than baseline model on the time-series forecasting task. Even though it is only 0.015, the label y values stays in the approximate range of [-1.5, 1.5] and 0.015 loss difference means an average deviation of 0.122, which is significant. Hence, MOCA positively helps in predicting task switches and making right predictions.\n",
        "2. The simple conditional posterior probability calculation using MSE loss reduced the complexity of the model while not negatively impacting the performance.\n",
        "3. On visually comparing the forecasting of MOCA and the baseline model, we can see that even though both the able have not been able to accurately predict trajectories and collisions, MOCA is able to capture the effect of gravity and bouncing off the ground better than the baseline model. The prediction of MOCA seems more naturally plausible than that of the baseline model."
      ],
      "id": "RppGFQPvFuB8"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MtEmhSKX-GEk"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n"
      ],
      "id": "MtEmhSKX-GEk"
    }
  ]
}