03_mppn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Models\" data-toc-modified-id=\"Models-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Models</a></span></li><li><span><a href=\"#Training\" data-toc-modified-id=\"Training-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Training</a></span></li><li><span><a href=\"#PPM\" data-toc-modified-id=\"PPM-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>PPM</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp mppn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MPPN\n",
    "===\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook includes the implementation of the `MPPN` as described in the paper. It includes the pytorch models, a training procedure containing pre-processing and data loader generation, the implementation of the `PPModel` based on MPPN's pytorch models for each process prediction task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%load_ext memory_profiler\n",
    "%load_ext line_profiler\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from mppn.imports import *\n",
    "from mppn.preprocessing import *\n",
    "from mppn.pipeline import *\n",
    "from mppn.baselines import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "_RUN_TRAINING=True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "class BaseMPPN(nn.Module):\n",
    "\n",
    "    def __init__(self, num_perspectives, feature_size=64, output_dim=128):\n",
    "        super(BaseMPPN, self).__init__()\n",
    "        self.feature_size = feature_size\n",
    "        self.output_dim = output_dim\n",
    "        self.mode = 99\n",
    "        self.stop_training = False\n",
    "\n",
    "        if self.mode == 1:\n",
    "            self.num_perspectives = 1\n",
    "        else:\n",
    "            self.num_perspectives = num_perspectives\n",
    "\n",
    "        self.CNN = nn.Sequential(\n",
    "            nn.Conv2d(3, 32, kernel_size=4, stride=4, padding=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(32, 64, kernel_size=4, padding=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=4, stride=2),\n",
    "            nn.Conv2d(64, 64, kernel_size=4, padding=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "            nn.Conv2d(in_channels=64, out_channels=self.feature_size, kernel_size=3, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "        )\n",
    "\n",
    "        self.MLP = nn.Sequential(\n",
    "            nn.Dropout(p=0.1),\n",
    "            nn.Linear(self.num_perspectives * self.feature_size, self.num_perspectives * self.feature_size),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(p=0.1),\n",
    "            nn.Linear(self.num_perspectives * self.feature_size, self.num_perspectives * int(self.feature_size)),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(self.num_perspectives * int(self.feature_size), self.output_dim),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.transpose(0, 1)\n",
    "\n",
    "        view_pool = []\n",
    "\n",
    "        for v in x:\n",
    "            \"\"\"size of v: [batch_size, 3, img_height, img_width]\"\"\"\n",
    "            \"\"\"Get features from GAFs using CNN\"\"\"\n",
    "            v = self.CNN(v)\n",
    "            \"\"\"size of v: [batch_size, feature_size, ?, ?], last two should be 1, 1\"\"\"\n",
    "            \"\"\"Reduce dimensions from 4 to 2 (first is batchsize)\"\"\"\n",
    "            v = v.view(v.size(0), self.feature_size)\n",
    "\n",
    "\n",
    "            view_pool.append(v)\n",
    "\n",
    "\n",
    "        pooled_view = view_pool[0]\n",
    "        \"\"\"Max-pooling of all views\"\"\"\n",
    "        if self.mode == 1:\n",
    "            for i in range(1, len(view_pool)):\n",
    "                pooled_view = torch.max(pooled_view, view_pool[i])\n",
    "\n",
    "        else:\n",
    "            \"\"\"Concatenate features from all perspectives\"\"\"\n",
    "            pooled_view = torch.cat(view_pool, dim=1)\n",
    "\n",
    "        \"\"\"Get representation from MLP\"\"\"\n",
    "        representation = self.MLP(pooled_view)\n",
    "\n",
    "        return representation\n",
    "\n",
    "    def count_parameters(self):\n",
    "\n",
    "        param_CNN = sum(p.numel() for p in self.MLP.parameters() if p.requires_grad)\n",
    "        param_MLP = sum(p.numel() for p in self.MLP.parameters() if p.requires_grad)\n",
    "\n",
    "        params = param_CNN + param_MLP\n",
    "\n",
    "        return params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "class MPPNClassifier(BaseMPPN):\n",
    "    \"\"\"\n",
    "    Extends Base MPPN with one classification layer.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, num_perspectives, num_classes, feature_size=64, output_dim=128,with_softmax=True):\n",
    "        super().__init__(num_perspectives, feature_size=feature_size, output_dim=output_dim)\n",
    "        self.with_softmax=num_classes!=1\n",
    "        self.classification = nn.Sequential(\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(p=0.1),\n",
    "            nn.Linear(output_dim, num_classes)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        representation = BaseMPPN.forward(self, x)\n",
    "        classifier_output = self.classification(representation)\n",
    "        if self.with_softmax:\n",
    "            classifier_output=F.log_softmax(classifier_output,dim=1)\n",
    "        return classifier_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "class MPPNMultitask(BaseMPPN):\n",
    "    \"\"\"\n",
    "    Extends the MPPNClassifier with multiple heads to predict multiple outputs at once.\n",
    "    \"\"\"\n",
    "    def __init__(self, num_perspectives, output_attr, feature_size=64, representation_dim=128):\n",
    "        super().__init__(num_perspectives, feature_size=feature_size, output_dim=representation_dim)\n",
    "        del self.MLP\n",
    "\n",
    "        self.output_attr = output_attr\n",
    "        self.representation_dim = representation_dim\n",
    "\n",
    "        \"\"\"Get the output dimension of the CNN\"\"\"\n",
    "        self.CNN_out_dim = self.CNN[-3].out_channels\n",
    "\n",
    "        self.MLP = nn.Sequential(\n",
    "            nn.Dropout(p=0.1),\n",
    "            nn.Linear(self.num_perspectives * self.feature_size, self.num_perspectives * int(self.feature_size/2)),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(p=0.1),\n",
    "            nn.Linear(self.num_perspectives * int(self.feature_size/2), self.representation_dim),\n",
    "        )\n",
    "\n",
    "        \"\"\"Dynamically create heads for each attribute to predict\"\"\"\n",
    "        self.output_attr = self.output_attr\n",
    "        self.heads = nn.ModuleList()\n",
    "        for attr_name, output_dim in self.output_attr.items():\n",
    "            #print(\"Head\", attr_name)\n",
    "            self.heads.append(self.create_head(output_dim))\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        x = x.transpose(0, 1)\n",
    "\n",
    "        view_pool = []\n",
    "\n",
    "        for v in x:\n",
    "            \"\"\"size of v: [batch_size, 3, img_height, img_width]\"\"\"\n",
    "            \"\"\"Get features from GAFs using CNN\"\"\"\n",
    "            v = self.CNN(v)\n",
    "            \"\"\"size of v: [batch_size, feature_size, ?, ?], last two should be 1, 1\"\"\"\n",
    "            \"\"\"Reduce dimensions from 4 to 2 (first is batchsize)\"\"\"\n",
    "            v = v.view(v.size(0), self.feature_size)\n",
    "\n",
    "            view_pool.append(v)\n",
    "\n",
    "        pooled_view = view_pool[0]\n",
    "        \"\"\"Max-pooling of all views\"\"\"\n",
    "        if self.mode == 1:\n",
    "            for i in range(1, len(view_pool)):\n",
    "                pooled_view = torch.max(pooled_view, view_pool[i])\n",
    "\n",
    "        else:\n",
    "            \"\"\"Concatenate features from all perspectives\"\"\"\n",
    "            pooled_view = torch.cat(view_pool, dim=1)\n",
    "\n",
    "        shared = self.MLP(pooled_view)\n",
    "\n",
    "        outputs = []\n",
    "\n",
    "        \"\"\"Predict each attribute\"\"\"\n",
    "        for head in self.heads:\n",
    "            if head[-1].out_features > 1:\n",
    "                outputs.append(F.log_softmax(head(shared), dim=1))\n",
    "            else:\n",
    "                outputs.append(head(shared))\n",
    "\n",
    "        return outputs\n",
    "\n",
    "\n",
    "    def create_head(self, num_classes):\n",
    "        \"\"\"Create a head, i.e. a subnetwork to predict a certain attribute in multi-task fashion\"\"\"\n",
    "        head = nn.Sequential(\n",
    "            nn.Dropout(p=0.1),\n",
    "            nn.Linear(self.representation_dim, self.representation_dim),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(self.representation_dim, num_classes)\n",
    "        )\n",
    "\n",
    "        return head\n",
    "\n",
    "    def count_parameters(self):\n",
    "\n",
    "        param_CNN = sum(p.numel() for p in self.MLP.parameters() if p.requires_grad)\n",
    "        param_MLP = sum(p.numel() for p in self.MLP.parameters() if p.requires_grad)\n",
    "        param_heads = sum(p.numel() for head in self.heads for p in head.parameters() if p.requires_grad)\n",
    "\n",
    "        params = param_CNN + param_MLP + param_heads\n",
    "\n",
    "        return params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "def load_checkpoint(path, filename):\n",
    "    \"\"\"\n",
    "    Load checkpoint from disk\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    path\n",
    "    filename\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "\n",
    "    \"\"\"\n",
    "    loadpath = os.path.join(path, filename + '_checkpoint.pth.tar')\n",
    "\n",
    "    assert os.path.isfile(loadpath), 'Error: no checkpoint file found!'\n",
    "\n",
    "    checkpoint = torch.load(loadpath)\n",
    "\n",
    "    return checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "import torch.utils.model_zoo as model_zoo\n",
    "model_urls = {\n",
    "    'alexnet': 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth',\n",
    "}\n",
    "\n",
    "def mppn_pretraining_model(pretrained=False, **kwargs):\n",
    "    \"\"\"Returns a model either pretrained as alexnet or on GAF images.\"\"\"\n",
    "    model = MPPNClassifier(**kwargs)\n",
    "\n",
    "    pretrained_model = \"alexnet\"\n",
    "\n",
    "    if pretrained:\n",
    "        if pretrained_model == \"alexnet\":\n",
    "            print(\"Loading Alexnet to train MPPNs CNN from scratch\")\n",
    "            pretrained_dict = model_zoo.load_url(model_urls['alexnet'])\n",
    "            model_dict = model.state_dict()\n",
    "            # 1. filter out unnecessary keys\n",
    "            pretrained_dict = {k: v for k, v in pretrained_dict.items() if\n",
    "                               k in model_dict and v.shape == model_dict[k].shape}\n",
    "            # 2. overwrite entries in the existing state dict\n",
    "            model_dict.update(pretrained_dict)\n",
    "            # 3. load the new state dict\n",
    "            model.load_state_dict(model_dict)\n",
    "\n",
    "        elif pretrained_model == \"MPPN_GAF\":\n",
    "            print(\"Load pretrained MPPN trained with GAFs on variant classification\")\n",
    "            checkpoint = load_checkpoint(os.path.join(root_dir(), \"data\", \"ML\", \"checkpoint\"),\n",
    "                                         filename=\"MPPN_gaf_pretrained\")\n",
    "            best_model = checkpoint[\"model\"]\n",
    "            best_model.load_state_dict(checkpoint['state_dict'])\n",
    "\n",
    "            model.CNN = best_model.CNN\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "def mppn_representation_learning_model(pretrained, num_perspectives, output_attr, feature_size=64, representation_dim=128):\n",
    "    \"\"\"Returns a model for representation learning (multitask). CNN is pretrained on GAF images\"\"\"\n",
    "    model = MPPNMultitask(num_perspectives, output_attr, feature_size, representation_dim)\n",
    "\n",
    "    if pretrained:\n",
    "        print(\"Load pretrained MPPN trained with GAFs on variant classification\")\n",
    "        #checkpoint = load previously trained model on GAF images\n",
    "        best_model = checkpoint[\"model\"]\n",
    "        best_model.load_state_dict(checkpoint['state_dict'])\n",
    "\n",
    "        model.CNN = best_model.CNN\n",
    "    else:\n",
    "        alexnet_mppn = mppn_pretraining_model(pretrained=True, num_perspectives=num_perspectives, num_classes=1)\n",
    "        model.CNN = alexnet_mppn.CNN\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "def mppn_fine_tuning_model(representation_model, num_perspectives, num_classes):\n",
    "    \"\"\"\n",
    "    Fine-tune a MPPN model that has been trained as representation model on a specific task\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    dataset: Specifies the dataset, for which the model was trained before.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "    model = MPPNClassifier(num_perspectives, num_classes=num_classes)\n",
    "\n",
    "    model.CNN = representation_model.CNN\n",
    "    model.MLP = representation_model.MLP\n",
    "\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "from pyts.image import GramianAngularField\n",
    "from PIL import Image\n",
    "\n",
    "def _gaf_loop(e,transformer):\n",
    "        inp,y=e\n",
    "        inp[inp>1]=1\n",
    "        inp[inp<0]=0\n",
    "        inp=inp*2-1\n",
    "        x=torch.stack(\n",
    "            tuple(_gaf_attr(inp[:,i],transformer) for i in range(inp.shape[1]))\n",
    "        ).transpose(0,1)\n",
    "        x=x[:,:,None].expand(-1,-1,3,-1,-1)\n",
    "        return x,y\n",
    "\n",
    "def _gaf_attr(x,transformer):\n",
    "    try:\n",
    "\n",
    "        x = transformer.transform(x)\n",
    "    except ValueError as e:\n",
    "        print(x)\n",
    "        raise e\n",
    "    x=tensor(x).cuda()\n",
    "    x = x * 255\n",
    "    return x\n",
    "\n",
    "\n",
    "\n",
    "class gaf_transform(ItemTransform):\n",
    "    ''' GAF transormation: converts a bash into a gramian angular field and reshapes it to RGB'''\n",
    "    def __init__(self,gs=64):\n",
    "        self.transformer=GramianAngularField(image_size=gs,sample_range=None, method=\"s\", overlapping=True)\n",
    "\n",
    "    def encodes(self,e): return _gaf_loop(e,self.transformer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "v=torch.rand((2556,10,100)),10\n",
    "gt=gaf_transform()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 5.55 s, sys: 1.22 s, total: 6.78 s\n",
      "Wall time: 3.71 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "x,y=gt(v)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def mppn_get_output_attributes(o):\n",
    "    '''Utility function that puts vocab size of each output attribute in a dict. \n",
    "    For regression tasks, it adds vocab size 1'''\n",
    "    output_attributes = {i:len(o.procs.categorify[i]) for i in o.ycat_names }\n",
    "    for i in o.ycont_names: output_attributes[i]=1\n",
    "    return output_attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next few cells show how to create a dataloader for MPPN and apply them to the representation learning and the finetuning step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Alexnet to train MPPNs CNN from scratch\n"
     ]
    }
   ],
   "source": [
    "# Create mppn repreentation learning and create the dataloader\n",
    "path=EventLogs.Mobis\n",
    "log=import_log(path)\n",
    "_t=attr_dict[get_ds_name(path)]\n",
    "cat_names,cont_names,date_names=[_t[i] for i in list(_t)]\n",
    "o=PPObj(log,[Categorify,Datetify,FillMissing,MinMax],\n",
    "        cat_names=cat_names,cont_names=cont_names,date_names=date_names,\n",
    "        splits=split_traces(log),y_names=['activity','resource','timestamp_Relative_elapsed_minmax'])\n",
    "output_attributes=mppn_get_output_attributes(o)\n",
    "m = mppn_representation_learning_model(False, len(o.cont_names), output_attributes)\n",
    "dls=o.get_dls(after_batch=gaf_transform,bs=64)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get one batch\n",
    "xb,yb=dls.one_batch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get loss and metrics\n",
    "loss=partial(multi_loss_sum,o)\n",
    "metrics=get_metrics(o)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorBase(10.9851, grad_fn=<AliasBackward>)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test forward pass\n",
    "xb=xb.cpu()\n",
    "p=m(xb)\n",
    "loss(p,yb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>acc_activity</th>\n",
       "      <th>acc_resource</th>\n",
       "      <th>mae_days</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2.806212</td>\n",
       "      <td>2.718509</td>\n",
       "      <td>0.939918</td>\n",
       "      <td>0.402286</td>\n",
       "      <td>6.824545</td>\n",
       "      <td>00:57</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 2.7185089588165283.\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.940420389175415.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Train representation learning model\n",
    "if _RUN_TRAINING:\n",
    "    train_validate(dls,m,loss=loss,metrics=metrics,epoch=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Fine-tuning model\n",
    "col='activity'\n",
    "m2 = mppn_fine_tuning_model(m, len(output_attributes), output_attributes[col])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change input and output features for the dataloader\n",
    "o.ycat_names=L(col)\n",
    "o.ycont_names=L()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get new dataloader for next-activity prediction\n",
    "dls=o.get_dls(after_batch=gaf_transform,bs=60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get new loss and metrics for for next-activity prediction\n",
    "loss=partial(multi_loss_sum,o)\n",
    "metrics=get_metrics(o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorBase(0., device='cuda:0')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test forward pass\n",
    "\n",
    "xb,yb=dls.one_batch()\n",
    "yb.shape\n",
    "\n",
    "p=m2.cuda()(xb.cuda())\n",
    "\n",
    "accuracy(p.cuda(),yb.cuda())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>acc_activity</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.201164</td>\n",
       "      <td>0.185873</td>\n",
       "      <td>0.936980</td>\n",
       "      <td>00:58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.164601</td>\n",
       "      <td>0.175458</td>\n",
       "      <td>0.930531</td>\n",
       "      <td>00:53</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.193403</td>\n",
       "      <td>0.174247</td>\n",
       "      <td>0.940000</td>\n",
       "      <td>00:54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.187607</td>\n",
       "      <td>0.199790</td>\n",
       "      <td>0.936327</td>\n",
       "      <td>00:54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.203035</td>\n",
       "      <td>0.222902</td>\n",
       "      <td>0.927510</td>\n",
       "      <td>00:54</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.18587279319763184.\n",
      "Better model found at epoch 1 with valid_loss value: 0.17545795440673828.\n",
      "Better model found at epoch 2 with valid_loss value: 0.17424732446670532.\n",
      "No improvement since epoch 1: early stopping\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.939941942691803.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Train model\n",
    "if _RUN_TRAINING:\n",
    "    train_validate(dls,m2,loss=loss,metrics=metrics,epoch=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creates the PPM for the MPPM. In the setup der general representation learning model is trained. Afterwards, in each prediction task, a seperate head is created, which is than fine-tuned for the specific task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "class PPM_MPPN(PPModel):\n",
    "\n",
    "\n",
    "    def _attr_from_dict(self,ds_name):\n",
    "        if not self.attr_dict: raise AttributeError('attr_dict is required!')\n",
    "\n",
    "        return (listify(self.attr_dict[self.ds_name]['cat attr']),\n",
    "                listify(self.attr_dict[self.ds_name]['num attr']),\n",
    "                listify(self.attr_dict[self.ds_name]['date attr']))\n",
    "\n",
    "\n",
    "    def setup(self):\n",
    "        def act_acc(p,y): return accuracy(p[0],y[0])\n",
    "        def act_res(p,y): return accuracy(p[1],y[1])\n",
    "        cat_names,cont_names,date_names=self._attr_from_dict(self.ds_name)\n",
    "        self.o=PPObj(self.log,[Categorify,Datetify,FillMissing,MinMax],\n",
    "                     cat_names=cat_names,date_names=date_names,cont_names=cont_names,\n",
    "                     y_names=['activity','resource','timestamp_Relative_elapsed'],\n",
    "                     splits=self.splits)\n",
    "        self.o.cont_names=['timestamp_Relative_elapsed']\n",
    "        norm=Normalize()\n",
    "        self.o.procs.add(norm,self.o)\n",
    "        self.mean=norm.means['timestamp_Relative_elapsed']\n",
    "        self.std=norm.stds['timestamp_Relative_elapsed']\n",
    "        self.o.cont_names=L(['activity_minmax','resource_minmax','timestamp_Relative_elapsed_minmax'])\n",
    "        self.output_attributes=mppn_get_output_attributes(self.o)\n",
    "        self.pretrain = mppn_representation_learning_model(False, len(self.o.cont_names), self.output_attributes)\n",
    "        dls=self.o.get_dls(after_batch=gaf_transform,bs=self.bs)\n",
    "        loss=partial(multi_loss_sum,self.o)\n",
    "        time_metric=lambda p,y: maeDurDaysNormalize(listify(p)[-1],listify(y)[-1],mean=self.mean,std=self.std)\n",
    "        self._train_validate(dls,self.pretrain,loss=loss,metrics=[act_acc,act_res,time_metric])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    def next_step_prediction(self,col='activity',outcome=False):\n",
    "        pretrain=copy.deepcopy(self.pretrain)\n",
    "        m = mppn_fine_tuning_model(pretrain, len(self.output_attributes), self.output_attributes[col])\n",
    "        self.o.ycat_names,self.o.ycont_names=L(col),L()\n",
    "        dls=self.o.get_dls(after_batch=gaf_transform,bs=self.bs,outcome=outcome)\n",
    "        loss=partial(multi_loss_sum,self.o)\n",
    "        metrics=get_metrics(self.o)\n",
    "        return self._train_validate(dls,m,loss=loss,metrics=metrics)\n",
    "\n",
    "    def next_resource_prediction(self):return self.next_step_prediction(outcome=False,col='resource')\n",
    "\n",
    "    def last_resource_prediction(self): return self.next_step_prediction(outcome=True,col='resource')\n",
    "    def outcome_prediction(self): return self.next_step_prediction(outcome=True)\n",
    "\n",
    "    def duration_to_next_event_prediction(self,outcome=False,col='timestamp_Relative_elapsed'):\n",
    "        pretrain=copy.deepcopy(self.pretrain)\n",
    "        time=partial(maeDurDaysNormalize,mean=self.mean,std=self.std)\n",
    "        m = mppn_fine_tuning_model(pretrain, len(self.output_attributes), self.output_attributes[col])\n",
    "        self.o.ycat_names,self.o.ycont_names=L(),L(col)\n",
    "        dls=self.o.get_dls(after_batch=gaf_transform,bs=self.bs,outcome=outcome)\n",
    "        xb,yb=dls.one_batch()\n",
    "        return self._train_validate(dls,m,loss=mae,metrics=time)\n",
    "\n",
    "\n",
    "    def duration_to_end_prediction(self):return self.duration_to_next_event_prediction(outcome=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Alexnet to train MPPNs CNN from scratch\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>act_acc</th>\n",
       "      <th>act_res</th>\n",
       "      <th><lambda></th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>5.849926</td>\n",
       "      <td>5.189992</td>\n",
       "      <td>0.681125</td>\n",
       "      <td>0.071973</td>\n",
       "      <td>5.108842</td>\n",
       "      <td>00:04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 5.189992427825928.\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.7095046639442444.\n",
      "CPU times: user 4min 6s, sys: 9.35 s, total: 4min 15s\n",
      "Wall time: 44.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "if  _RUN_TRAINING:\n",
    "    path=EventLogs.BPIC_12_O\n",
    "    log=import_log(path)\n",
    "    ppm=PPM_MPPN(log,get_ds_name(path),split_traces(log),print_output=True,epoch=1,bs=512,attr_dict=attr_dict)\n",
    "    ppm.setup()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>acc_activity</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.003388</td>\n",
       "      <td>0.649134</td>\n",
       "      <td>0.712583</td>\n",
       "      <td>00:04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.6491336226463318.\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.7364696860313416.\n"
     ]
    }
   ],
   "source": [
    "if _RUN_TRAINING: ppm.next_step_prediction()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>maeDurDaysNormalize</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.488340</td>\n",
       "      <td>0.379671</td>\n",
       "      <td>3.703171</td>\n",
       "      <td>00:04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.37967097759246826.\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 3.591909646987915.\n"
     ]
    }
   ],
   "source": [
    "if _RUN_TRAINING: ppm.duration_to_next_event_prediction()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>maeDurDaysNormalize</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.952126</td>\n",
       "      <td>0.987435</td>\n",
       "      <td>9.631075</td>\n",
       "      <td>00:04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.9874348044395447.\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 8.892857551574707.\n"
     ]
    }
   ],
   "source": [
    "if _RUN_TRAINING: ppm.duration_to_end_prediction()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mppn_current",
   "language": "python",
   "name": "mppn_current"
  },
  "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.7.11"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}