add bouncingball experiment and ablation studies

author: fredeee 2024-03-23 13:27:00 +0100
committer: fredeee 2024-03-23 13:27:00 +0100
commit: 6bcf6b8306ce4903734fb31824799a50281cea69 (patch)
tree: 0545ff1b8beb051993c2d75fd81306db1a22274d
parent: ad0b64a7f0140406151d18b19ab2ed5d19b6c511 (diff)
41 files changed, 5859 insertions, 471 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..15495d3
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+*.DS_Store
+*.pyc
+\ No newline at end of file
diff --git a/cfg/bouncingballs/bb-level1-run1.json b/cfg/bouncingballs/bb-level1-run1.json
new file mode 100644
index 0000000..1e6f21b
--- /dev/null
+++ b/cfg/bouncingballs/bb-level1-run1.json
@@ -0,0 +1,87 @@
+{
+   "model_path": "bb_baseline",
+   "datatype": "bouncingballs",
+   "dataset": "BOUNCINGBALLS_OCCLUSION",
+   "scenario": "occlusion",
+   "num_updates": 0,
+   "max_epochs": 1000,
+   "max_updates": 400000,
+   "learning_rate": {
+    "lr": 0.0004,
+    "deacrease_lr_every": 100000,
+    "deacrease_lr_factor": 0.75
+   },
+   "blackout": {
+    "blackout_start_timestep": 10,
+    "blackout_rate": 0.1,
+    "blackout_rate_max": 0.45,
+    "blackout_increase_every": 10000,
+    "blackout_increase_rate": 0.01
+   },
+   "phases": {
+    "start_inner_loop": 40000,
+    "shufleslots_end": 3000000,
+    "entity_pretraining_phase2_end": 30000,
+    "entity_pretraining_phase1_end": 15000,
+    "background_pretraining_end": 0
+   },
+   "defaults": {
+    "num_workers": 2,
+    "prefetch_factor": 2,
+    "statistics_offset": 10,
+    "load_optimizers": false,
+    "teacher_forcing": 5,
+    "skip_frames": 1,
+    "error_dropout": 0.1,
+    "seed": 67
+   },
+   "bptt": {
+    "bptt_start_timestep": 0,
+    "bptt_steps": 1,
+    "bptt_steps_max": 3,
+    "increase_bptt_steps_every": 100000
+   },
+   "model": {
+    "level": 2,
+    "batch_size": 128,
+    "num_objects": 3,
+    "img_channels": 3,
+    "input_size": [
+     64,
+     64
+    ],
+    "latent_size": [
+     4,
+     4
+    ],
+    "gestalt_size": 12,
+    "bottleneck": "binar",
+    "position_regularizer": 0.01,
+    "time_regularizer": 0.25,
+    "encoder_regularizer": 0.333333,
+    "latent_regularizer": 0.0,
+    "inner_loop_enabled": false,
+    "latent_loss_enabled": false,
+    "encoder": {
+     "channels": 24,
+     "level1_channels": 12,
+     "num_layers": 2,
+     "reg_lambda": 1e-10
+    },
+    "predictor": {
+     "heads": 2,
+     "layers": 3,
+     "channels_multiplier": 2,
+     "reg_lambda": 1e-10,
+     "transformer_type": "shared"
+    },
+    "decoder": {
+     "channels": 24,
+     "level1_channels": 12,
+     "num_layers": 2
+    },
+    "update_module": {
+     "reg_lambda": 1e-05
+    }
+   }
+  }
+\ No newline at end of file
diff --git a/cfg/bouncingballs/bb-level1-run2.json b/cfg/bouncingballs/bb-level1-run2.json
new file mode 100644
index 0000000..a257408
--- /dev/null
+++ b/cfg/bouncingballs/bb-level1-run2.json
@@ -0,0 +1,87 @@
+{
+   "model_path": "bb_baseline",
+   "datatype": "bouncingballs",
+   "dataset": "BOUNCINGBALLS_OCCLUSION",
+   "scenario": "occlusion",
+   "num_updates": 400000,
+   "max_epochs": 1000,
+   "max_updates": 800000,
+   "learning_rate": {
+    "lr": 0.0001,
+    "deacrease_lr_every": 100000,
+    "deacrease_lr_factor": 0.75
+   },
+   "blackout": {
+    "blackout_start_timestep": 10,
+    "blackout_rate": 0.45,
+    "blackout_rate_max": 0.45,
+    "blackout_increase_every": 10000,
+    "blackout_increase_rate": 0.01
+   },
+   "phases": {
+    "start_inner_loop": 40000,
+    "shufleslots_end": 3000000,
+    "entity_pretraining_phase2_end": 30000,
+    "entity_pretraining_phase1_end": 15000,
+    "background_pretraining_end": 0
+   },
+   "defaults": {
+    "num_workers": 2,
+    "prefetch_factor": 2,
+    "statistics_offset": 10,
+    "load_optimizers": false,
+    "teacher_forcing": 5,
+    "skip_frames": 1,
+    "error_dropout": 0.1,
+    "seed": 67
+   },
+   "bptt": {
+    "bptt_start_timestep": 0,
+    "bptt_steps": 3,
+    "bptt_steps_max": 3,
+    "increase_bptt_steps_every": 100000
+   },
+   "model": {
+    "level": 2,
+    "batch_size": 128,
+    "num_objects": 3,
+    "img_channels": 3,
+    "input_size": [
+     64,
+     64
+    ],
+    "latent_size": [
+     4,
+     4
+    ],
+    "gestalt_size": 12,
+    "bottleneck": "binar",
+    "position_regularizer": 0.01,
+    "time_regularizer": 0.25,
+    "encoder_regularizer": 0.333333,
+    "latent_regularizer": 0.0,
+    "inner_loop_enabled": false,
+    "latent_loss_enabled": false,
+    "encoder": {
+     "channels": 24,
+     "level1_channels": 12,
+     "num_layers": 2,
+     "reg_lambda": 1e-10
+    },
+    "predictor": {
+     "heads": 2,
+     "layers": 3,
+     "channels_multiplier": 2,
+     "reg_lambda": 1e-10,
+     "transformer_type": "shared"
+    },
+    "decoder": {
+     "channels": 24,
+     "level1_channels": 12,
+     "num_layers": 2
+    },
+    "update_module": {
+     "reg_lambda": 1e-05
+    }
+   }
+  }
+\ No newline at end of file
diff --git a/cfg/bouncingballs/bb-level1-run3.json b/cfg/bouncingballs/bb-level1-run3.json
new file mode 100644
index 0000000..cb4be46
--- /dev/null
+++ b/cfg/bouncingballs/bb-level1-run3.json
@@ -0,0 +1,87 @@
+{
+   "model_path": "bb_baseline",
+   "datatype": "bouncingballs",
+   "dataset": "BOUNCINGBALLS_OCCLUSION",
+   "scenario": "occlusion",
+   "num_updates": 800000,
+   "max_epochs": 1000,
+   "max_updates": 1200000,
+   "learning_rate": {
+    "lr": 5e-05,
+    "deacrease_lr_every": 100000,
+    "deacrease_lr_factor": 0.75
+   },
+   "blackout": {
+    "blackout_start_timestep": 10,
+    "blackout_rate": 0.45,
+    "blackout_rate_max": 0.45,
+    "blackout_increase_every": 10000,
+    "blackout_increase_rate": 0.01
+   },
+   "phases": {
+    "start_inner_loop": 40000,
+    "shufleslots_end": 3000000,
+    "entity_pretraining_phase2_end": 30000,
+    "entity_pretraining_phase1_end": 15000,
+    "background_pretraining_end": 0
+   },
+   "defaults": {
+    "num_workers": 2,
+    "prefetch_factor": 2,
+    "statistics_offset": 10,
+    "load_optimizers": false,
+    "teacher_forcing": 5,
+    "skip_frames": 1,
+    "error_dropout": 0.1,
+    "seed": 5
+   },
+   "bptt": {
+    "bptt_start_timestep": 0,
+    "bptt_steps": 3,
+    "bptt_steps_max": 3,
+    "increase_bptt_steps_every": 100000
+   },
+   "model": {
+    "level": 2,
+    "batch_size": 128,
+    "num_objects": 3,
+    "img_channels": 3,
+    "input_size": [
+     64,
+     64
+    ],
+    "latent_size": [
+     4,
+     4
+    ],
+    "gestalt_size": 12,
+    "bottleneck": "binar",
+    "position_regularizer": 0.01,
+    "time_regularizer": 0.25,
+    "encoder_regularizer": 0.333333,
+    "latent_regularizer": 0.0,
+    "inner_loop_enabled": false,
+    "latent_loss_enabled": false,
+    "encoder": {
+     "channels": 24,
+     "level1_channels": 12,
+     "num_layers": 2,
+     "reg_lambda": 1e-10
+    },
+    "predictor": {
+     "heads": 2,
+     "layers": 3,
+     "channels_multiplier": 2,
+     "reg_lambda": 1e-10,
+     "transformer_type": "shared"
+    },
+    "decoder": {
+     "channels": 24,
+     "level1_channels": 12,
+     "num_layers": 2
+    },
+    "update_module": {
+     "reg_lambda": 1e-05
+    }
+   }
+  }
+\ No newline at end of file
diff --git a/data/datasets/BOUNCINGBALLS/dataset.py b/data/datasets/BOUNCINGBALLS/dataset.py
new file mode 100644
index 0000000..3460d02
--- /dev/null
+++ b/data/datasets/BOUNCINGBALLS/dataset.py
@@ -0,0 +1,195 @@
+from pickletools import int4
+from torch.utils import data
+from typing import Tuple, Union, List
+import numpy as np
+import json
+import math
+import cv2
+import h5py
+import os
+import pickle
+import sys
+import yaml
+import warnings
+from PIL import Image
+from einops import reduce, rearrange, repeat
+import torch as th
+
+
+class BouncingBallDataset(data.Dataset):
+
+    def __init__(self, root_path: str, dataset_name: str, type: str, size: Tuple[int, int], type_name: str = None, full_size: Tuple[int, int] = None, create_dataset: bool = False):
+
+        assert type in ["train", "test", "val"]
+        assert type_name in ["interaction", "occlusion", "twolayer", "twolayerdense", "twolayer_ood", "threelayer_ood", "twolayer_ood_3balls"]
+
+        data_path  = f'data/data/video/{dataset_name}'
+        data_path  = os.path.join(root_path, data_path)
+        self.file  = os.path.join(data_path, f'balls_{type_name}-{type}-{size[0]}x{size[1]}-v1.hdf5')
+        self.train = (type == "train")
+        self.samples    = []
+
+        if os.path.exists(self.file):
+            self.hdf5_file = h5py.File(self.file, "r")
+        
+        # load dataset
+        self.length     = self.hdf5_file['sequence_indices'].shape[0]
+        self.background = np.zeros((3, size[0], size[1]), dtype=np.uint8)
+
+        # set number of objects
+        if (type_name == "twolayer") or (type_name == "threelayer_ood" and type != "test"):
+            self.num_objects = 6
+        elif (type_name == "twolayer_ood" and type == "test") or (type_name == "twolayer_ood_3balls" and type == "test"):
+            self.num_objects = 4
+        elif type_name == "twolayer_ood":
+            self.num_objects = 2
+        elif type_name == "twolayer_ood_3balls":
+            self.num_objects = 3
+        elif (type_name == "threelayer_ood" and type == "test"):
+            self.num_objects = 9
+        else:
+            self.num_objects = 3
+
+        if len(self) == 0:
+            raise FileNotFoundError(f'Found no dataset at {data_path}')
+        
+        # loop trough own dataset by calling __getitem__
+        if False:
+            for i in range(len(self)):
+                self[i]
+
+    def add_one_timestep(self, x):
+        return np.concatenate((x, np.zeros_like(x[:1])), axis=0)
+        
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, index: int):
+
+        index_start, length = self.hdf5_file['sequence_indices'][index]
+        rgb_images   = self.hdf5_file["rgb_images"][index_start:index_start+length]
+
+        if rgb_images[0].dtype == np.uint8:
+            images = []
+            for i in range(len(rgb_images)):
+                img = cv2.imdecode(rgb_images[i], 1)
+                images.append(img.transpose(2, 0, 1).astype(np.float32) / 255.0)
+
+            rgb_images   = np.stack(images)
+
+        rgb_images   = th.from_numpy(rgb_images)
+
+        if self.train:
+            return (
+                rgb_images,
+                self.background
+            )
+
+        # EVALUATION
+        num_objects = self.num_objects
+        instance_positions = self.hdf5_file['instance_positions'][index_start*num_objects:(index_start+length)*num_objects]
+        instance_positions = rearrange(instance_positions, '(t o) c -> t o c', o=num_objects)
+        instance_positions = instance_positions[:, :, ::-1] # IMPORTANT: flip x and y axis
+
+        instance_pres = self.hdf5_file['instance_incamera'][index_start*num_objects:(index_start+length)*num_objects]
+        instance_pres = rearrange(instance_pres, '(t o) c -> t o c', o=num_objects).squeeze(-1)
+
+        instance_bounding_boxes = self.hdf5_file['instance_mask_bboxes'][index_start*num_objects:(index_start+length)*num_objects]
+        instance_bounding_boxes = rearrange(instance_bounding_boxes, '(t o) c -> t o c', o=num_objects)
+        instance_bounding_boxes = instance_bounding_boxes[:, :, [1, 0, 3, 2]]
+
+        foreground_mask   = self.hdf5_file['foreground_mask'][index_start:(index_start+length)]
+        foreground_mask   = rearrange(foreground_mask, 't 1 h w -> t h w')/255
+
+        instance_masks = self.hdf5_file['instance_masks'][index_start*num_objects:(index_start+length)*num_objects]
+        instance_masks = rearrange(instance_masks, '(t o) 1 h w -> t o 1 h w', o=num_objects).squeeze()/255
+
+        # CUSTOM
+        # use instance masks to to create hidden masks
+        hidden_mask = reduce(instance_masks, 't o h w -> t 1 h w', 'sum').squeeze()
+        hidden_mask = (hidden_mask > 1).astype(np.uint8)
+
+        # segmentation_masks: index gives which object is visible at that pixel
+        segmentation_mask = np.argmax(instance_masks[:, ::-1], axis=1) + 1
+        segmentation_mask = foreground_mask * segmentation_mask
+
+        # segmentation mask but only for hidden objects
+        segementation_mask_hidden = np.argmax(instance_masks[:, :3], axis=1) + 1 # TODO only works for 6 objects
+        segementation_mask_hidden = hidden_mask * segementation_mask_hidden
+                
+        # add one dummy timestep at the end
+        instance_positions = self.add_one_timestep(instance_positions)
+        rgb_images = self.add_one_timestep(rgb_images)
+        foreground_mask = self.add_one_timestep(foreground_mask)
+        hidden_mask = self.add_one_timestep(hidden_mask)
+        instance_pres = self.add_one_timestep(instance_pres)
+        instance_bounding_boxes = self.add_one_timestep(instance_bounding_boxes)
+        instance_masks = self.add_one_timestep(instance_masks)
+        segmentation_mask = self.add_one_timestep(segmentation_mask)
+        segementation_mask_hidden = self.add_one_timestep(segementation_mask_hidden)
+
+        if False:
+            video       = np.array(rgb_images)
+            locations   =  np.array(instance_positions)
+            fg_masks    = np.array(foreground_mask)
+            bb          = np.array(instance_bounding_boxes)
+            h_masks     = np.array(hidden_mask)
+
+            # loop through video frames and show them using cv2
+            for t in range(video.shape[0]):
+                frame = rearrange(video[t], 'c h w -> h w c') * 255
+
+                for loc in locations[t]:
+                    x, y = loc
+                    #cv2.circle(frame, (int(x), int(y)), 2, (255, 0, 0), -1) # did not work properly
+                    x_max = int(min(int(x + 2), frame.shape[1]))
+                    x_min = int(max(int(x - 2), 0))
+                    y_max = int(min(int(y + 2), frame.shape[0]))
+                    y_min = int(max(int(y - 2), 0))
+                    frame[x_min:x_max, y_min:y_max] = [255, 0, 0]
+
+                # draw the bounding boxes into the frame
+                for i, b in enumerate(bb[t]):
+                    x_min, y_min, x_max, y_max = b
+                    
+                    x_min = int(max(x_min, 0))
+                    y_min = int(max(y_min, 0))
+                    x_max = int(min(x_max, frame.shape[0]-1))
+                    y_max = int(min(y_max, frame.shape[0]-1))
+
+                    # dont't use c2 rectangeel function here but draw it manually
+                    for pixel in range(x_min, x_max):
+                        frame[pixel, y_min, 0] = 255
+                        frame[pixel, y_max, 0] = 255
+                    for pixel in range(y_min, y_max):
+                        frame[x_min, pixel, 0] = 255
+                        frame[x_max, pixel, 0] = 255
+                
+                fg_mask = repeat(fg_masks[t], 'h w -> h w 3') * 255
+                h_mask = repeat(h_masks[t], 'h w -> h w 3') * 255
+                s_mask = repeat(segmentation_mask[t], 'h w -> h w 3') * (255/6)
+                s_mask_hidden = repeat(segementation_mask_hidden[t], 'h w -> h w 3') * (255/3)
+                frame = np.concatenate((frame, fg_mask, s_mask, h_mask, s_mask_hidden), axis=1)
+
+                # add instance masks to visualisation
+                for i, mask in enumerate(instance_masks[t]):
+                    mask = repeat(mask, 'h w -> h w 3') * 255
+                    # add border to the right side
+                    mask[:, -1, 0] = 255
+                    frame = np.concatenate((frame, mask), axis=1)
+
+                frame = frame.astype(np.uint8)
+                cv2.imshow('frame', frame)
+                cv2.waitKey(0)
+
+        return (
+            rgb_images,
+            self.background,
+            instance_positions,
+            segmentation_mask,
+            instance_pres,
+            segementation_mask_hidden
+        )
+    
+
+#a = BouncingBallDataset("./", 'BOUNCINGBALLS', "train", (64,64))
+\ No newline at end of file
diff --git a/evaluation/adept/evaluation_gswm.ipynb b/evaluation/adept/evaluation_gswm.ipynb
new file mode 100644
index 0000000..31abb91
--- /dev/null
+++ b/evaluation/adept/evaluation_gswm.ipynb
@@ -0,0 +1,428 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import scipy.stats as stats\n",
+    "import os\n",
+    "\n",
+    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+    "pd.options.mode.chained_assignment = None \n",
+    "plt.style.use('ggplot')\n",
+    "sns.color_palette(\"Paired\");\n",
+    "sns.set_theme();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: '../../out/pretrained/adept/gswm/results/'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[2], line 5\u001b[0m\n\u001b[1;32m      2\u001b[0m root_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m../../out/pretrained/adept/gswm/results/\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;66;03m# list all folders in root path that don't stat with a dot\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m nets \u001b[38;5;241m=\u001b[39m [f \u001b[38;5;28;01mfor\u001b[39;00m f \u001b[38;5;129;01min\u001b[39;00m \u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlistdir\u001b[49m\u001b[43m(\u001b[49m\u001b[43mroot_path\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m f\u001b[38;5;241m.\u001b[39mstartswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m'\u001b[39m)]\n\u001b[1;32m      7\u001b[0m \u001b[38;5;66;03m# read pickle file\u001b[39;00m\n\u001b[1;32m      8\u001b[0m sf \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame()\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../../out/pretrained/adept/gswm/results/'"
+     ]
+    }
+   ],
+   "source": [
+    "# setting path to results folder\n",
+    "root_path = '../../out/pretrained/adept/gswm/results/'\n",
+    "\n",
+    "# list all folders in root path that don't stat with a dot\n",
+    "nets = [f for f in os.listdir(root_path) if not f.startswith('.')]\n",
+    "\n",
+    "# read pickle file\n",
+    "sf = pd.DataFrame()\n",
+    "af = pd.DataFrame()\n",
+    "\n",
+    "# load statistics files from nets\n",
+    "for net in nets:\n",
+    "    #path = os.path.join(root_path, net, 'control', 'statistics',)\n",
+    "    path = os.path.join(root_path, 'statistics',)\n",
+    "    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:\n",
+    "        sf_temp = pd.read_csv(f, index_col=0)\n",
+    "    sf_temp['net'] = net\n",
+    "    sf = pd.concat([sf,sf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:\n",
+    "        af_temp = pd.read_csv(f, index_col=0)\n",
+    "    af_temp['net'] = net\n",
+    "    af = pd.concat([af,af_temp])\n",
+    "\n",
+    "# cast variables\n",
+    "sf['visible'] = sf['visible'].astype(bool)\n",
+    "sf['bound'] = sf['bound'].astype(bool)\n",
+    "sf['occluder'] = sf['occluder'].astype(bool)\n",
+    "sf['inimage'] = sf['inimage'].astype(bool)\n",
+    "sf['alpha_pos'] = 1-sf['alpha_pos']\n",
+    "sf['alpha_ges'] = 1-sf['alpha_ges']\n",
+    "\n",
+    "# scale to percentage\n",
+    "sf['TE'] = sf['TE'] * 100\n",
+    "\n",
+    "# add surprise as dummy code\n",
+    "sf['control'] = [('control' in set)  for set in sf['set']]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Tracking Error (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tracking Error when visible: M: 30.3 , STD: 14.1, Count: 507\n",
+      "Tracking Error when occluded: M: 25.8 , STD: 16.1, Count: 15\n",
+      "Tracking Error Overall: M: 30.2 , STD: 14.1, Count: 522\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "\n",
+    "def get_stats(col):\n",
+    "    return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'\n",
+    "\n",
+    "# When Visible\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Tracking Error when visible:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Occluded\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Tracking Error when occluded:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Overall\n",
+    "temp = sf[grouping]\n",
+    "print(f'Tracking Error Overall:' + get_stats(temp['TE']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Succesfull Trackings (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>set</th>\n",
+       "      <th>evalmode</th>\n",
+       "      <th>tracked_pos</th>\n",
+       "      <th>tracked_neg</th>\n",
+       "      <th>tracked_pos_pro</th>\n",
+       "      <th>tracked_neg_pro</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>control</td>\n",
+       "      <td>control</td>\n",
+       "      <td>1</td>\n",
+       "      <td>19</td>\n",
+       "      <td>0.05</td>\n",
+       "      <td>0.95</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       set evalmode  tracked_pos  tracked_neg  tracked_pos_pro  \\\n",
+       "0  control  control            1           19             0.05   \n",
+       "\n",
+       "   tracked_neg_pro  \n",
+       "0             0.95  "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target\n",
+    "# determine last visible frame numeric\n",
+    "grouping_factors = ['net','set','evalmode','scene','slot']\n",
+    "ff = sf[sf.visible].groupby(grouping_factors).max()\n",
+    "ff.rename(columns = {'frame':'last_visible'}, inplace = True)\n",
+    "ff = ff[['last_visible']]\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf = sf.merge(ff, on=grouping_factors, how='left')\n",
+    "sf['last_visible'] = (sf['last_visible'] == sf['frame'])\n",
+    "\n",
+    "# same for first bound frame\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()\n",
+    "ff.rename(columns = {'frame':'first_visible'}, inplace = True)\n",
+    "ff = ff[['first_visible']]\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf = sf.merge(ff, on=grouping_factors, how='left')\n",
+    "\n",
+    "# extract the trials where the target was last visible and threshold the TE\n",
+    "ff = sf[sf['last_visible']] \n",
+    "ff['tracked_pos'] = (ff['TE'] < 10)\n",
+    "ff['tracked_neg'] = (ff['TE'] >= 10)\n",
+    "\n",
+    "# fill NaN with 0\n",
+    "sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')\n",
+    "sf['tracked_pos'].fillna(False, inplace=True)\n",
+    "sf['tracked_neg'].fillna(False, inplace=True)\n",
+    "\n",
+    "# Aggreagte over all scenes\n",
+    "temp = sf[(sf['frame']== 15) & ~sf.occluder & sf.control & (sf.first_visible < 20)]\n",
+    "temp = temp.groupby(['set', 'evalmode']).sum()\n",
+    "temp = temp[['tracked_pos', 'tracked_neg']]\n",
+    "temp = temp.reset_index()\n",
+    "\n",
+    "temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "\n",
+    "temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mostly Tracked stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "temp = af[af.index == 'OVERALL']\n",
+    "temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']\n",
+    "temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']\n",
+    "temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']\n",
+    "g = temp[['mostly_tracked', 'partially_tracked', 'mostly_lost','set']].set_index(['set']).groupby(['set']).mean().plot(kind='bar', stacked=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MOTA "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>idf1</th>\n",
+       "      <th>idp</th>\n",
+       "      <th>idr</th>\n",
+       "      <th>recall</th>\n",
+       "      <th>precision</th>\n",
+       "      <th>num_unique_objects</th>\n",
+       "      <th>mostly_tracked</th>\n",
+       "      <th>partially_tracked</th>\n",
+       "      <th>mostly_lost</th>\n",
+       "      <th>num_false_positives</th>\n",
+       "      <th>num_misses</th>\n",
+       "      <th>num_switches</th>\n",
+       "      <th>num_fragmentations</th>\n",
+       "      <th>mota</th>\n",
+       "      <th>motp</th>\n",
+       "      <th>num_transfer</th>\n",
+       "      <th>num_ascend</th>\n",
+       "      <th>num_migrate</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>set</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>control</th>\n",
+       "      <td>0.54837</td>\n",
+       "      <td>0.487418</td>\n",
+       "      <td>0.626745</td>\n",
+       "      <td>0.70247</td>\n",
+       "      <td>0.546309</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>4345.0</td>\n",
+       "      <td>2216.0</td>\n",
+       "      <td>240.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>0.086869</td>\n",
+       "      <td>0.07704</td>\n",
+       "      <td>119.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>19.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            idf1       idp       idr   recall  precision  num_unique_objects  \\\n",
+       "set                                                                            \n",
+       "control  0.54837  0.487418  0.626745  0.70247   0.546309                86.0   \n",
+       "\n",
+       "         mostly_tracked  partially_tracked  mostly_lost  num_false_positives  \\\n",
+       "set                                                                            \n",
+       "control            35.0               44.0          7.0               4345.0   \n",
+       "\n",
+       "         num_misses  num_switches  num_fragmentations      mota     motp  \\\n",
+       "set                                                                        \n",
+       "control      2216.0         240.0                73.0  0.086869  0.07704   \n",
+       "\n",
+       "         num_transfer  num_ascend  num_migrate  \n",
+       "set                                             \n",
+       "control         119.0        55.0         19.0  "
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "af[af.index == 'OVERALL'].groupby(['set']).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "loci23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/evaluation/adept/evaluation_loci_looped.ipynb b/evaluation/adept/evaluation_loci_looped.ipynb
index 1de5e2b..8b39ac1 100644
--- a/evaluation/adept/evaluation_loci_looped.ipynb
+++ b/evaluation/adept/evaluation_loci_looped.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -30,7 +30,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -89,7 +89,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -125,7 +125,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -179,7 +179,7 @@
        "0         0.033333  "
       ]
      },
-     "execution_count": 50,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -495,9 +495,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 360x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "def get_plot_complete():\n",
     "\n",
@@ -534,9 +547,9 @@
     "        vslot = vanish_slot\n",
     "        if error == 'TE':\n",
     "            vslot = vanish_slot[(vanish_slot['TE'] > 0) | (vanish_slot['frame'] < 10)]\n",
-    "        sns.lineplot(x=\"frame\", y=error, data=control_slot, ax=axs[row][col], label=control_label)\n",
+    "        sns.lineplot(x=\"frame\", y=error, data=control_slot, ax=ax, label=control_label)\n",
     "        sns.lineplot(x=\"frame\", y=error, data=vslot, ax=axs[row][col], label=vanish_label)\n",
-    "        axs[row][col].set_xlabel('')\n",
+    "        ax[col].set_xlabel('')\n",
     "        axs[row][col].set_ylabel(ylabel)\n",
     "        axs[row][col].legend()\n",
     "\n",
@@ -682,7 +695,7 @@
     "                    (sf['first_visible'] < 20)]\n",
     "    control_slot['visible'] = (control_slot['visible'] & control_slot['bound'])\n",
     "    control_slot['slot_error'] = control_slot['slot_error'] * 10000000\n",
-    "    control_label = 'Reappearing'\n",
+    "    control_label = 'Reappearing objects'\n",
     "\n",
     "    # line plot of mean slot error as a function of frames per jumping mode\n",
     "    vanish_slot = sf[(sf['vanishing'] == True) &\n",
@@ -693,62 +706,62 @@
     "                    (sf['first_visible'] < 20)]\n",
     "    vanish_slot['visible'] = (vanish_slot['visible'] & vanish_slot['bound'])\n",
     "    vanish_slot['slot_error'] = vanish_slot['slot_error'] * 10000000\n",
-    "    vanish_label = 'Vanishing'\n",
+    "    vanish_label = 'Vanishing objects'\n",
     "\n",
     "    a = control_slot.groupby(['frame']).mean()['visible']\n",
     "    b = vanish_slot.groupby(['frame']).mean()['visible']\n",
     "    #b[28:] = 0\n",
     "\n",
     "    # combined plot of slot error and tracking error\n",
-    "    fig, axs = plt.subplots(ncols=2, nrows=2, figsize=(10, 4), gridspec_kw={'height_ratios': [3, 1]})\n",
+    "    fig, axs = plt.subplots(ncols=1, nrows=5, figsize=(5, 10), gridspec_kw={'height_ratios': [3, 1, 0.5, 3, 1]})\n",
     "    alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']\n",
     "\n",
     "    for i, (error,ylabel) in enumerate(zip(['alpha_pos', 'alpha_ges'],['Position Updates', 'Gestalt Updates'])):\n",
     "\n",
     "        # set row and column\n",
-    "        row = int(i/2) \n",
-    "        col = i % 2\n",
+    "        ax = axs[3*i]\n",
     "\n",
     "        # line plot of slot error as a function of frames\n",
     "        vslot = vanish_slot\n",
     "        if error == 'TE':\n",
     "            vslot = vanish_slot[(vanish_slot['TE'] > 0) | (vanish_slot['frame'] < 10)]\n",
-    "        sns.lineplot(x=\"frame\", y=error, data=control_slot, ax=axs[row][col], label=control_label)\n",
-    "        sns.lineplot(x=\"frame\", y=error, data=vslot, ax=axs[row][col], label=vanish_label)\n",
-    "        axs[row][col].set_xlabel('')\n",
-    "        axs[row][col].set_ylabel(ylabel, fontsize=12)\n",
-    "        axs[row][col].legend()\n",
+    "        sns.lineplot(x=\"frame\", y=error, data=control_slot, ax=ax, label=control_label)\n",
+    "        sns.lineplot(x=\"frame\", y=error, data=vslot, ax=ax, label=vanish_label)\n",
+    "        ax.set_xlabel('')\n",
+    "        ax.set_ylabel(ylabel, fontsize=12)\n",
+    "        ax.legend()\n",
     "\n",
     "        # set y lim from 0 to 0.6\n",
-    "        axs[row][col].set_ylim(0, 0.6)\n",
+    "        ax.set_ylim(0, 0.6)\n",
     "\n",
-    "        axs[row][col].set_yticks([0, 0.3, 0.6])\n",
-    "        axs[row][col].set_yticklabels(['0%', '30%', '60%'])\n",
+    "        ax.set_yticks([0, 0.3, 0.6])\n",
+    "        ax.set_yticklabels(['0%', '30%', '60%'])\n",
     "\n",
     "        # add a,b,c ... labels to the top left conrner of each plot\n",
-    "        axs[row][col].text(-0.2, 1, alphabet[i], transform=axs[row][col].transAxes, size=15, weight='bold')\n",
+    "        ax.text(-0.2, 1, alphabet[i], transform=ax.transAxes, size=15, weight='bold')\n",
     "\n",
     "        # remove x axis ticks from top plot but keep grid lines in x axis\n",
-    "        if row == 0:\n",
-    "            axs[row][col].set_xticklabels([])\n",
-    "            axs[row][col].set_xlabel('')\n",
+    "        ax.set_xticklabels([])\n",
+    "        ax.set_xlabel('')\n",
     "\n",
-    "    for col in [0,1]:\n",
+    "    for row in [1,4]:\n",
+    "\n",
+    "        ax = axs[row]\n",
     "\n",
     "        # add occulusion plot\n",
-    "        axs[1][col].plot(range(len(a)),a.to_list(), label=control_label)\n",
-    "        axs[1][col].plot(range(len(a)),b.to_list(), label=vanish_label)\n",
-    "        axs[1][col].set_xlabel('Frame', fontsize=12)\n",
-    "        axs[1][col].set_ylabel('Visiblity', fontsize=12)\n",
+    "        ax.plot(range(len(a)),a.to_list(), label=control_label)\n",
+    "        ax.plot(range(len(a)),b.to_list(), label=vanish_label)\n",
+    "        ax.set_xlabel('Frame', fontsize=12)\n",
+    "        ax.set_ylabel('Visiblity', fontsize=12)\n",
     "\n",
     "        # set y axis ticks as 0% to 100%\n",
-    "        axs[1][col].set_yticks([0, 1])\n",
+    "        ax.set_yticks([0, 1])\n",
     "        #axs[3][col].set_yticks([])\n",
-    "        axs[1][col].set_yticklabels(['0%', '100%'])\n",
+    "        ax.set_yticklabels(['0%', '100%'])\n",
     "\n",
     "        # add same text as above but center the text\n",
-    "        axs[1][col].text(28, 0.5, 'Object\\nvanishes', fontsize=9, color='grey', rotation=90, ha='center', va='center')\n",
-    "        axs[1][col].text(60, 0.5, 'Occluder\\nrotates', fontsize=9, color='grey', rotation=90, ha='center', va='center')\n",
+    "        ax.text(29, 0.5, 'Reappear', fontsize=9, color='grey', rotation=90, ha='center', va='center')\n",
+    "        ax.text(60, 0.5, 'Occluder\\nrotates', fontsize=9, color='grey', rotation=90, ha='center', va='center')\n",
     "\n",
     "        # Update Gates\n",
     "        #axs[2][col].set_yticks([0, 0.2,0.4])\n",
@@ -758,6 +771,12 @@
     "\n",
     "    plt.tight_layout()\n",
     "\n",
+    "    # reduce space between row 0 and 1, and row 2 and 3\n",
+    "    plt.subplots_adjust(hspace=0.1)\n",
+    "    \n",
+    "    # delete row 2\n",
+    "    axs[2].remove()\n",
+    "\n",
     "    pass"
    ]
   },
@@ -805,29 +824,537 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 720x288 with 4 Axes>"
+       "<Figure size 360x720 with 4 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
    "source": [
     "get_plot_gates()\n",
-    "plt.savefig('plots/loci_looped_gates.pdf')"
+    "plt.savefig('plots/loci_looped_gates2.pdf')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Text(0, 0, 'Expected moment of reappearance'), Text(1, 0, 'Occluder rotates')]"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "control_slot = sf[(sf['vanishing'] == False) &\n",
+    "                (sf['occluder'] == False) &\n",
+    "                sf['set'].isin(['createdown_control']) &\n",
+    "                (sf['tracked_pos']) &\n",
+    "                (sf['first_visible'] < 20)]\n",
+    "control_slot['visible'] = (control_slot['visible'] & control_slot['bound'])\n",
+    "\n",
+    "# line plot of mean slot error as a function of frames per jumping mode\n",
+    "vanish_slot = sf[(sf['vanishing'] == True) &\n",
+    "                (sf['occluder'] == False) &\n",
+    "                sf['set'].isin(['createdown_surprise']) &\n",
+    "                (sf['tracked_pos']) & \n",
+    "                (sf['first_visible'] < 20)]\n",
+    "vanish_slot['visible'] = (vanish_slot['visible'] & vanish_slot['bound'])\n",
+    "\n",
+    "# concat the two dataframes\n",
+    "temp = pd.concat([control_slot, vanish_slot])\n",
+    "temp1 = temp[(temp['frame'] > 30) & (temp['frame'] < 50)]\n",
+    "temp2 = temp[(temp['frame'] > 50)]\n",
+    "\n",
+    "temp1 = pd.Series.to_frame(temp1.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "temp1['name'] = 30\n",
+    "\n",
+    "temp2 = pd.Series.to_frame(temp2.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "temp2['slot_error'] = temp2['slot_error'] \n",
+    "temp2['name'] = 50\n",
+    "\n",
+    "# concatenate the two dataframes\n",
+    "temp = pd.concat([temp1, temp2]).reset_index()\n",
+    "\n",
+    "# make box plot of the slot_error in one figure grouped by set and then by name\n",
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "sns.boxplot(x='name', y='slot_error', hue='set', data=temp, ax=ax)\n",
+    "ax.set_xlabel('')\n",
+    "ax.set_ylabel('Surprise')\n",
+    "ax.legend(title='Frame', loc='upper right')\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "# set legend labels to ['Reappearing', 'Vanishing']\n",
+    "handles, labels = ax.get_legend_handles_labels()\n",
+    "ax.legend(handles, ['Reappearing', 'Vanishing'], title='', loc='upper right')\n",
+    "\n",
+    "# set x-axis labes to [Reappearing, Occluder Rotates]\n",
+    "ax.set_xticklabels(['Expected moment of reappearance', 'Occluder rotates'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 146,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_plot_voe():\n",
+    "\n",
+    "    ########################################\n",
+    "    # line plot of mean slot error as a function of frames per jumping mode\n",
+    "    control_slot = sf[(sf['vanishing'] == False) &\n",
+    "                    (sf['occluder'] == False) &\n",
+    "                    sf['set'].isin(['createdown_control']) &\n",
+    "                    #(sf['net'] == net) &\n",
+    "                    (sf['tracked_pos']) &\n",
+    "                    (sf['first_visible'] < 20)]\n",
+    "    control_slot['visible'] = (control_slot['visible'] & control_slot['bound'])\n",
+    "    control_slot['slot_error'] = control_slot['slot_error'] * 10000000\n",
+    "    control_label = 'Reappearing'\n",
+    "\n",
+    "    # line plot of mean slot error as a function of frames per jumping mode\n",
+    "    vanish_slot = sf[(sf['vanishing'] == True) &\n",
+    "                    (sf['occluder'] == False) &\n",
+    "                    sf['set'].isin(['createdown_surprise']) &\n",
+    "                    #(sf['net'] == net) & \n",
+    "                    (sf['tracked_pos']) & \n",
+    "                    (sf['first_visible'] < 20)]\n",
+    "    vanish_slot['visible'] = (vanish_slot['visible'] & vanish_slot['bound'])\n",
+    "    vanish_slot['slot_error'] = vanish_slot['slot_error'] * 10000000\n",
+    "    vanish_label = 'Vanishing'\n",
+    "\n",
+    "    a = control_slot.groupby(['frame']).mean()['visible']\n",
+    "    b = vanish_slot.groupby(['frame']).mean()['visible']\n",
+    "    #b[28:] = 0\n",
+    "\n",
+    "    # get 3 plots underneath each other the ratio of the plots is 3:1:3\n",
+    "    fig, axs = plt.subplots(ncols=1, nrows=4, figsize=(5, 9), gridspec_kw={'height_ratios': [3, 0.5, 2, 1]})\n",
+    "    alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']\n",
+    "\n",
+    "    error = 'slot_error'\n",
+    "    ylabel = 'Slot Error'\n",
+    "    ax = axs[2]\n",
+    "\n",
+    "    # line plot of slot error as a function of frames\n",
+    "    vslot = vanish_slot\n",
+    "    if error == 'TE':\n",
+    "        vslot = vanish_slot[(vanish_slot['TE'] > 0) | (vanish_slot['frame'] < 10)]\n",
+    "    sns.lineplot(x=\"frame\", y=error, data=control_slot, ax=ax, label=control_label)\n",
+    "    sns.lineplot(x=\"frame\", y=error, data=vslot, ax=ax, label=vanish_label)\n",
+    "    ax.set_xlabel('')\n",
+    "    ax.set_ylabel(ylabel, fontsize=12)\n",
+    "    ax.legend()\n",
+    "\n",
+    "    # add a,b,c ... labels to the top left conrner of each plot\n",
+    "    ax.text(-0.15, 1, alphabet[1], transform=ax.transAxes, size=15, weight='bold')\n",
+    "    # add arrow to plot axs[0][0] at position (x,y) = (10, 0.5)\n",
+    "    ax.annotate('', xy=(33, 0.45), xytext=(25, 0.6), arrowprops={'arrowstyle': '->', 'color': 'black'})\n",
+    "    ax.text(21, 0.62, 'Expectation', fontsize=9, color='black', ha='center', va='center')\n",
+    "\n",
+    "    ax.annotate('', xy=(63, 0.31), xytext=(56, 0.45), arrowprops={'arrowstyle': '->', 'color': 'black'})\n",
+    "    ax.text(52, 0.47, 'Expectation', fontsize=9, color='black', ha='center', va='center')\n",
+    "\n",
+    "    # remove x axis ticks from top plot but keep grid lines in x axis\n",
+    "    ax.set_xticklabels([])\n",
+    "    ax.set_xlabel('')\n",
+    "\n",
+    "    # remove legend\n",
+    "    ax.legend().remove()\n",
+    "\n",
+    "    ########################################\n",
+    "    ax = axs[3]\n",
+    "\n",
+    "    # add occulusion plot\n",
+    "    ax.plot(range(len(a)),a.to_list(), label=control_label)\n",
+    "    ax.plot(range(len(a)),b.to_list(), label=vanish_label)\n",
+    "    ax.set_xlabel('Frame', fontsize=12)\n",
+    "    ax.set_ylabel('Visiblity', fontsize=12)\n",
+    "\n",
+    "    # move ylbale a bit more to the right\n",
+    "    ax.yaxis.set_label_coords(-0.09, 0.5)\n",
+    "\n",
+    "    # set y axis ticks as 0% to 100%\n",
+    "    ax.set_yticks([0, 1])\n",
+    "    ax.set_yticklabels(['0%', '100%'])\n",
+    "\n",
+    "    # add same text as above but center the text\n",
+    "    ax.text(28, 0.5, 'Object\\nvanishes', fontsize=9, color='grey', rotation=90, ha='center', va='center')\n",
+    "    ax.text(60, 0.5, 'Occluder\\nrotates', fontsize=9, color='grey', rotation=90, ha='center', va='center')\n",
+    "\n",
+    "\n",
+    "    ########################################\n",
+    "    axs[1].axis('off')\n",
+    "\n",
+    "    ax = axs[0]\n",
+    "    ax.text(-0.15, 1, alphabet[0], transform=ax.transAxes, size=15, weight='bold')\n",
+    "\n",
+    "    # concat the two dataframes\n",
+    "    temp = pd.concat([control_slot, vanish_slot])\n",
+    "    temp1 = temp[(temp['frame'] > 30) & (temp['frame'] < 50)]\n",
+    "    temp2 = temp[(temp['frame'] > 50)]\n",
+    "\n",
+    "    temp1 = pd.Series.to_frame(temp1.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "    temp1['name'] = 30\n",
+    "\n",
+    "    temp2 = pd.Series.to_frame(temp2.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "    temp2['name'] = 50\n",
+    "\n",
+    "    # concatenate the two dataframes\n",
+    "    temp = pd.concat([temp1, temp2]).reset_index()\n",
+    "\n",
+    "    # make box plot of the slot_error in one figure grouped by set and then by name\n",
+    "    sns.boxplot(x='name', y='slot_error', hue='set', data=temp, ax=ax)\n",
+    "    ax.set_xlabel('')\n",
+    "    ax.set_ylabel('Surprise')\n",
+    "\n",
+    "    # remove legend\n",
+    "    plt.tight_layout()\n",
+    "\n",
+    "    # set x-axis labes to [Reappearing, Occluder Rotates]\n",
+    "    ax.set_xticklabels(['Expected moment\\nof reappearance', 'Occluder rotates'])\n",
+    "\n",
+    "    # set legend labels to ['Reappearing', 'Vanishing']\n",
+    "    handles, labels = ax.get_legend_handles_labels()\n",
+    "    ax.legend(handles, ['Reappearing', 'Vanishing'], title='', loc='upper center', bbox_to_anchor=(0.5, 1.105), ncol=2)\n",
+    "\n",
+    "    # reduce the space between the second and the third plot\n",
+    "    plt.subplots_adjust(hspace=0.05)\n",
+    "    \n",
+    "\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 148,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 360x648 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "get_plot_voe()\n",
+    "plt.savefig('plots/loci_looped_voe2.pdf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ttest_indResult(statistic=1.691198428694689, pvalue=0.09495066166428383)\n",
+      "Ttest_indResult(statistic=3.6836011726202966, pvalue=0.00043158165864250897)\n"
+     ]
+    }
+   ],
+   "source": [
+    "control_slot = sf[(sf['vanishing'] == False) &\n",
+    "                (sf['occluder'] == False) &\n",
+    "                sf['set'].isin(['createdown_control']) &\n",
+    "                (sf['tracked_pos']) &\n",
+    "                (sf['first_visible'] < 20)]\n",
+    "control_slot['visible'] = (control_slot['visible'] & control_slot['bound'])\n",
+    "control_slot['slot_error'] = control_slot['slot_error'] * 10000000\n",
+    "\n",
+    "# line plot of mean slot error as a function of frames per jumping mode\n",
+    "vanish_slot = sf[(sf['vanishing'] == True) &\n",
+    "                (sf['occluder'] == False) &\n",
+    "                sf['set'].isin(['createdown_surprise']) &\n",
+    "                (sf['tracked_pos']) & \n",
+    "                (sf['first_visible'] < 20)]\n",
+    "vanish_slot['visible'] = (vanish_slot['visible'] & vanish_slot['bound'])\n",
+    "vanish_slot['slot_error'] = vanish_slot['slot_error'] * 10000000\n",
+    "\n",
+    "\n",
+    "temp = pd.concat([control_slot, vanish_slot])\n",
+    "temp1 = temp[(temp['frame'] > 30) & (temp['frame'] < 50)]\n",
+    "temp2 = temp[(temp['frame'] > 50)]\n",
+    "\n",
+    "temp1 = pd.Series.to_frame(temp1.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "temp2 = pd.Series.to_frame(temp2.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "\n",
+    "# \n",
+    "temp1 = temp1.groupby(['set', 'scene', 'slot']).max()['slot_error']\n",
+    "temp2 = temp2.groupby(['set', 'scene', 'slot']).max()['slot_error']\n",
+    "\n",
+    "# t-test between reappearing and vanishing\n",
+    "print(stats.ttest_ind(temp1['createdown_surprise'], temp1['createdown_control']))\n",
+    "print(stats.ttest_ind(temp2['createdown_surprise'], temp2['createdown_control']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 141,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.047"
+      ]
+     },
+     "execution_count": 141,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "0.094/2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# vertical aligned\n",
+    "def get_plot_voe():\n",
+    "\n",
+    "    # increase font site of all plots\n",
+    "    sns.set(font_scale=1.2)\n",
+    "\n",
+    "\n",
+    "    ########################################\n",
+    "    # line plot of mean slot error as a function of frames per jumping mode\n",
+    "    control_slot = sf[(sf['vanishing'] == False) &\n",
+    "                    (sf['occluder'] == False) &\n",
+    "                    sf['set'].isin(['createdown_control']) &\n",
+    "                    #(sf['net'] == net) &\n",
+    "                    (sf['tracked_pos']) &\n",
+    "                    (sf['first_visible'] < 20)]\n",
+    "    control_slot['visible'] = (control_slot['visible'] & control_slot['bound'])\n",
+    "    control_slot['slot_error'] = control_slot['slot_error'] * 10000000\n",
+    "    control_label = 'Reappearing'\n",
+    "\n",
+    "    # line plot of mean slot error as a function of frames per jumping mode\n",
+    "    vanish_slot = sf[(sf['vanishing'] == True) &\n",
+    "                    (sf['occluder'] == False) &\n",
+    "                    sf['set'].isin(['createdown_surprise']) &\n",
+    "                    #(sf['net'] == net) & \n",
+    "                    (sf['tracked_pos']) & \n",
+    "                    (sf['first_visible'] < 20)]\n",
+    "    vanish_slot['visible'] = (vanish_slot['visible'] & vanish_slot['bound'])\n",
+    "    vanish_slot['slot_error'] = vanish_slot['slot_error'] * 10000000\n",
+    "    vanish_label = 'Vanishing'\n",
+    "\n",
+    "    a = control_slot.groupby(['frame']).mean()['visible']\n",
+    "    b = vanish_slot.groupby(['frame']).mean()['visible']\n",
+    "    #b[28:] = 0\n",
+    "\n",
+    "    # get 4 plots in 2 rows and 2 columns where the the first column has a ratio of 3:0.5 and the second column has a ratio of 2:1\n",
+    "    #fig, axs = plt.subplots(ncols=2, nrows=2, figsize=(9, 5), gridspec_kw={'height_ratios': [3, 0.5, 2, 1]})\n",
+    "    fig = plt.figure(constrained_layout=True, figsize=(9, 5))\n",
+    "    gs = fig.add_gridspec(4, 8)\n",
+    "\n",
+    "    alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']\n",
+    "\n",
+    "    error = 'slot_error'\n",
+    "    ylabel = 'Slot Error'\n",
+    "    ax = fig.add_subplot(gs[:3, 3:])\n",
+    "\n",
+    "    # line plot of slot error as a function of frames\n",
+    "    vslot = vanish_slot\n",
+    "    if error == 'TE':\n",
+    "        vslot = vanish_slot[(vanish_slot['TE'] > 0) | (vanish_slot['frame'] < 10)]\n",
+    "    sns.lineplot(x=\"frame\", y=error, data=control_slot, ax=ax, label=control_label)\n",
+    "    sns.lineplot(x=\"frame\", y=error, data=vslot, ax=ax, label=vanish_label)\n",
+    "    ax.set_xlabel('')\n",
+    "    ax.set_ylabel(ylabel)\n",
+    "    ax.legend()\n",
+    "\n",
+    "    # add a,b,c ... labels to the top left conrner of each plot\n",
+    "    ax.text(-0.15, 1, alphabet[1], transform=ax.transAxes, size=15, weight='bold')\n",
+    "    # add arrow to plot axs[0][0] at position (x,y) = (10, 0.5)\n",
+    "    ax.annotate('', xy=(33, 0.45), xytext=(25, 0.6), arrowprops={'arrowstyle': '->', 'color': 'black'})\n",
+    "    ax.text(21, 0.62, 'Expectation', fontsize=11, color='black', ha='center', va='center')\n",
+    "\n",
+    "    ax.annotate('', xy=(63, 0.31), xytext=(56, 0.45), arrowprops={'arrowstyle': '->', 'color': 'black'})\n",
+    "    ax.text(52, 0.47, 'Expectation', fontsize=11, color='black', ha='center', va='center')\n",
+    "\n",
+    "    # remove x axis ticks from top plot but keep grid lines in x axis\n",
+    "    ax.set_xticklabels([])\n",
+    "    ax.set_xlabel('')\n",
+    "\n",
+    "    # set legend labels to ['Reappearing', 'Vanishing']\n",
+    "    handles, labels = ax.get_legend_handles_labels()\n",
+    "    ax.legend(handles, ['Reappearing objects', 'Vanishing objects'], title='', loc='upper center', bbox_to_anchor=(0.5, 1.18), ncol=2)\n",
+    "\n",
+    "    # remove legend\n",
+    "    #ax.legend().remove()\n",
+    "\n",
+    "\n",
+    "    ########################################\n",
+    "    ax = fig.add_subplot(gs[3:, 3:])\n",
+    "\n",
+    "    # add occulusion plot\n",
+    "    ax.plot(range(len(a)),a.to_list(), label=control_label)\n",
+    "    ax.plot(range(len(a)),b.to_list(), label=vanish_label)\n",
+    "    ax.set_xlabel('Frame')\n",
+    "    ax.set_ylabel('Visiblity', fontsize=12)\n",
+    "\n",
+    "    # move ylbale a bit more to the right\n",
+    "    ax.yaxis.set_label_coords(-0.09, 0.5)\n",
+    "\n",
+    "    # set y axis ticks as 0% to 100%\n",
+    "    ax.set_yticks([0, 1])\n",
+    "    ax.set_yticklabels(['0%', '100%'])\n",
+    "\n",
+    "    # add same text as above but center the text\n",
+    "    ax.text(29, 0.5, 'Reappear', fontsize=11, color='grey', rotation=90, ha='center', va='center')\n",
+    "    ax.text(60, 0.5, 'Occluder\\nrotates', fontsize=11, color='grey', rotation=90, ha='center', va='center')\n",
+    "\n",
+    "\n",
+    "    ########################################\n",
+    "    #axs[0][1].axis('off')\n",
+    "\n",
+    "    ax = fig.add_subplot(gs[:, :3])\n",
+    "    ax.text(-0.15, 1, alphabet[0], transform=ax.transAxes, size=17, weight='bold')\n",
+    "\n",
+    "    # concat the two dataframes\n",
+    "    temp = pd.concat([control_slot, vanish_slot])\n",
+    "    temp1 = temp[(temp['frame'] > 30) & (temp['frame'] < 50)]\n",
+    "    temp2 = temp[(temp['frame'] > 50)]\n",
+    "\n",
+    "    temp1 = pd.Series.to_frame(temp1.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "    temp1['name'] = 30\n",
+    "\n",
+    "    temp2 = pd.Series.to_frame(temp2.groupby(['set', 'scene', 'slot']).max()['slot_error'])\n",
+    "    temp2['name'] = 50\n",
+    "\n",
+    "    # concatenate the two dataframes\n",
+    "    temp = pd.concat([temp1, temp2]).reset_index()\n",
+    "\n",
+    "    # make box plot of the slot_error in one figure grouped by set and then by name\n",
+    "    sns.boxplot(x='name', y='slot_error', hue='set', data=temp, ax=ax)\n",
+    "    ax.set_xlabel('')\n",
+    "    ax.set_ylabel('Surprise')\n",
+    "\n",
+    "    # remove legend\n",
+    "    plt.tight_layout()\n",
+    "\n",
+    "    # set x-axis labes to [Reappearing, Occluder Rotates]\n",
+    "    ax.set_xticklabels(['Moment of \\nexpected \\nreappearance', 'Occluder \\nrotates'])\n",
+    "\n",
+    "    ax.legend().remove()   \n",
+    "\n",
+    "    # reduce the space between the second and the third plot\n",
+    "    plt.subplots_adjust(hspace=0.05)\n",
+    "        \n",
+    "\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-108-43cbf80ac39b>:124: UserWarning: This figure was using constrained_layout, but that is incompatible with subplots_adjust and/or tight_layout; disabling constrained_layout.\n",
+      "  plt.tight_layout()\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 648x360 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "get_plot_voe()\n",
+    "plt.savefig('plots/loci_looped_voe3.pdf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/evaluation/adept/evaluation_loci_looped_visibility.ipynb b/evaluation/adept/evaluation_loci_looped_visibility.ipynb
new file mode 100644
index 0000000..cbb2b7c
--- /dev/null
+++ b/evaluation/adept/evaluation_loci_looped_visibility.ipynb
@@ -0,0 +1,475 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import scipy.stats as stats\n",
+    "import os\n",
+    "\n",
+    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+    "pd.options.mode.chained_assignment = None \n",
+    "plt.style.use('ggplot')\n",
+    "sns.color_palette(\"Paired\");\n",
+    "sns.set_theme();"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setting path to results folder\n",
+    "root_path = '../../out/pretrained/adept/loci_looped/results_visibility'\n",
+    "\n",
+    "# list all folders in root path that don't stat with a dot\n",
+    "nets = [f for f in os.listdir(root_path) if not f.startswith('.')]\n",
+    "\n",
+    "# read pickle file\n",
+    "tf = pd.DataFrame()\n",
+    "sf = pd.DataFrame()\n",
+    "af = pd.DataFrame()\n",
+    "\n",
+    "# load statistics files from nets\n",
+    "for net in nets:\n",
+    "    path = os.path.join(root_path, net, 'surprise', 'statistics',)\n",
+    "    with open(os.path.join(path, 'trialframe.csv'), 'rb') as f:\n",
+    "        tf_temp = pd.read_csv(f, index_col=0)\n",
+    "    tf_temp['net'] = net\n",
+    "    tf = pd.concat([tf,tf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:\n",
+    "        sf_temp = pd.read_csv(f, index_col=0)\n",
+    "    sf_temp['net'] = net\n",
+    "    sf = pd.concat([sf,sf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:\n",
+    "        af_temp = pd.read_csv(f, index_col=0)\n",
+    "    af_temp['net'] = net\n",
+    "    af = pd.concat([af,af_temp])\n",
+    "\n",
+    "# cast variables\n",
+    "sf['visible'] = sf['visible'].astype(bool)\n",
+    "sf['bound'] = sf['bound'].astype(bool)\n",
+    "sf['occluder'] = sf['occluder'].astype(bool)\n",
+    "sf['inimage'] = sf['inimage'].astype(bool)\n",
+    "sf['vanishing'] = sf['vanishing'].astype(bool)\n",
+    "sf['alpha_pos'] = 1-sf['alpha_pos']\n",
+    "sf['alpha_ges'] = 1-sf['alpha_ges']\n",
+    "\n",
+    "# scale to percentage\n",
+    "sf['TE'] = sf['TE'] * 100\n",
+    "\n",
+    "# add surprise as dummy code\n",
+    "tf['control'] = [('control' in set) for set in tf['set']]\n",
+    "sf['control'] = [('control' in set)  for set in sf['set']]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Tracking Error (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tracking Error when visible: M: 7.65 , STD: 10.6, Count: 8266\n",
+      "Tracking Error when occluded: M: 6.72 , STD: 6.25, Count: 2236\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "\n",
+    "def get_stats(col):\n",
+    "    return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'\n",
+    "\n",
+    "# When Visible\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Tracking Error when visible:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Occluded\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Tracking Error when occluded:' + get_stats(temp['TE']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Succesfull Trackings (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>set</th>\n",
+       "      <th>evalmode</th>\n",
+       "      <th>tracked_pos</th>\n",
+       "      <th>tracked_neg</th>\n",
+       "      <th>tracked_pos_pro</th>\n",
+       "      <th>tracked_neg_pro</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>control</td>\n",
+       "      <td>open</td>\n",
+       "      <td>89</td>\n",
+       "      <td>115</td>\n",
+       "      <td>0.436275</td>\n",
+       "      <td>0.563725</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       set evalmode  tracked_pos  tracked_neg  tracked_pos_pro  \\\n",
+       "0  control     open           89          115         0.436275   \n",
+       "\n",
+       "   tracked_neg_pro  \n",
+       "0         0.563725  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target\n",
+    "# determine last visible frame numeric\n",
+    "grouping_factors = ['net','set','evalmode','scene','slot']\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).max()\n",
+    "ff.rename(columns = {'frame':'last_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['last_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# same for first bound frame\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()\n",
+    "ff.rename(columns = {'frame':'first_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['first_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf['last_visible'] = (sf['last_visible'] == sf['frame'])\n",
+    "\n",
+    "# extract the trials where the target was last visible and threshold the TE\n",
+    "ff = sf[sf['last_visible']] \n",
+    "ff['tracked_pos'] = (ff['TE'] < 10)\n",
+    "ff['tracked_neg'] = (ff['TE'] >= 10)\n",
+    "\n",
+    "# fill NaN with 0\n",
+    "sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')\n",
+    "sf['tracked_pos'].fillna(False, inplace=True)\n",
+    "sf['tracked_neg'].fillna(False, inplace=True)\n",
+    "\n",
+    "# Aggreagte over all scenes\n",
+    "temp = sf[(sf['frame']== 1) & ~sf.occluder & sf.control & (sf.first_visible < 20)]\n",
+    "temp = temp.groupby(['set', 'evalmode']).sum()\n",
+    "temp = temp[['tracked_pos', 'tracked_neg']]\n",
+    "temp = temp.reset_index()\n",
+    "\n",
+    "temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "\n",
+    "temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mostly Tracked stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "temp = af[af.index == 'OVERALL']\n",
+    "temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']\n",
+    "temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']\n",
+    "temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']\n",
+    "g = temp[['mostly_tracked', 'partially_tracked', 'mostly_lost','set']].set_index(['set']).groupby(['set']).mean().plot(kind='bar', stacked=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MOTA "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>idf1</th>\n",
+       "      <th>idp</th>\n",
+       "      <th>idr</th>\n",
+       "      <th>recall</th>\n",
+       "      <th>precision</th>\n",
+       "      <th>num_unique_objects</th>\n",
+       "      <th>mostly_tracked</th>\n",
+       "      <th>partially_tracked</th>\n",
+       "      <th>mostly_lost</th>\n",
+       "      <th>num_false_positives</th>\n",
+       "      <th>num_misses</th>\n",
+       "      <th>num_switches</th>\n",
+       "      <th>num_fragmentations</th>\n",
+       "      <th>mota</th>\n",
+       "      <th>motp</th>\n",
+       "      <th>num_transfer</th>\n",
+       "      <th>num_ascend</th>\n",
+       "      <th>num_migrate</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>set</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>control</th>\n",
+       "      <td>0.797811</td>\n",
+       "      <td>0.712093</td>\n",
+       "      <td>0.907404</td>\n",
+       "      <td>0.964629</td>\n",
+       "      <td>0.756651</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>80.333333</td>\n",
+       "      <td>5.666667</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1544.333333</td>\n",
+       "      <td>175.333333</td>\n",
+       "      <td>48.333333</td>\n",
+       "      <td>23.666667</td>\n",
+       "      <td>0.643333</td>\n",
+       "      <td>0.043260</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>43.000000</td>\n",
+       "      <td>0.666667</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>surprise</th>\n",
+       "      <td>0.775593</td>\n",
+       "      <td>0.672416</td>\n",
+       "      <td>0.917448</td>\n",
+       "      <td>0.966854</td>\n",
+       "      <td>0.708470</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>30.666667</td>\n",
+       "      <td>2.333333</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>642.666667</td>\n",
+       "      <td>53.000000</td>\n",
+       "      <td>18.666667</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>0.553262</td>\n",
+       "      <td>0.043718</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>13.333333</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              idf1       idp       idr    recall  precision  \\\n",
+       "set                                                           \n",
+       "control   0.797811  0.712093  0.907404  0.964629   0.756651   \n",
+       "surprise  0.775593  0.672416  0.917448  0.966854   0.708470   \n",
+       "\n",
+       "          num_unique_objects  mostly_tracked  partially_tracked  mostly_lost  \\\n",
+       "set                                                                            \n",
+       "control                 86.0       80.333333           5.666667          0.0   \n",
+       "surprise                33.0       30.666667           2.333333          0.0   \n",
+       "\n",
+       "          num_false_positives  num_misses  num_switches  num_fragmentations  \\\n",
+       "set                                                                           \n",
+       "control           1544.333333  175.333333     48.333333           23.666667   \n",
+       "surprise           642.666667   53.000000     18.666667            5.000000   \n",
+       "\n",
+       "              mota      motp  num_transfer  num_ascend  num_migrate  \n",
+       "set                                                                  \n",
+       "control   0.643333  0.043260           3.0   43.000000     0.666667  \n",
+       "surprise  0.553262  0.043718           4.0   13.333333     0.000000  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "af[af.index == 'OVERALL'].groupby(['set']).mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gate Openings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percept gate openings when visible: M: 1.01 , STD: 0.928, Count: 8266\n",
+      "Percept gate openings when occluded: M: 0.0118 , STD: 0.133, Count: 2236\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Percept gate openings when visible:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Percept gate openings when occluded:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "loci23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/evaluation/adept/plots/loci_looped_complete.pdf b/evaluation/adept/plots/loci_looped_complete.pdf
new file mode 100644
index 0000000..306c3cf
--- /dev/null
+++ b/evaluation/adept/plots/loci_looped_complete.pdf
diff --git a/evaluation/adept/plots/loci_looped_gates.pdf b/evaluation/adept/plots/loci_looped_gates.pdf
new file mode 100644
index 0000000..13d2630
--- /dev/null
+++ b/evaluation/adept/plots/loci_looped_gates.pdf
diff --git a/evaluation/adept/plots/loci_looped_gates2.pdf b/evaluation/adept/plots/loci_looped_gates2.pdf
new file mode 100644
index 0000000..d4513e3
--- /dev/null
+++ b/evaluation/adept/plots/loci_looped_gates2.pdf
diff --git a/evaluation/adept/plots/loci_looped_surprise.pdf b/evaluation/adept/plots/loci_looped_surprise.pdf
new file mode 100644
index 0000000..8faea0b
--- /dev/null
+++ b/evaluation/adept/plots/loci_looped_surprise.pdf
diff --git a/evaluation/adept/plots/loci_looped_voe.pdf b/evaluation/adept/plots/loci_looped_voe.pdf
new file mode 100644
index 0000000..9ae7116
--- /dev/null
+++ b/evaluation/adept/plots/loci_looped_voe.pdf
diff --git a/evaluation/adept/plots/loci_looped_voe2.pdf b/evaluation/adept/plots/loci_looped_voe2.pdf
new file mode 100644
index 0000000..c3190da
--- /dev/null
+++ b/evaluation/adept/plots/loci_looped_voe2.pdf
diff --git a/evaluation/adept/plots/loci_looped_voe3.pdf b/evaluation/adept/plots/loci_looped_voe3.pdf
new file mode 100644
index 0000000..52bbff8
--- /dev/null
+++ b/evaluation/adept/plots/loci_looped_voe3.pdf
diff --git a/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb b/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb
new file mode 100644
index 0000000..8fde028
--- /dev/null
+++ b/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb
@@ -0,0 +1,479 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import scipy.stats as stats\n",
+    "import os\n",
+    "\n",
+    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+    "pd.options.mode.chained_assignment = None \n",
+    "plt.style.use('ggplot')\n",
+    "sns.color_palette(\"Paired\");\n",
+    "sns.set_theme();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: '../../../out/pretrained/adept_ablations/lambda/results/adept_level1_ablation_lambda.run311/trialframe.csv'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[1;32m/Users/fredericbecker/Documents/Master/Masterarbeit/code/local/loci_public/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb Cell 3\u001b[0m line \u001b[0;36m1\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/fredericbecker/Documents/Master/Masterarbeit/code/local/loci_public/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb#W2sZmlsZQ%3D%3D?line=12'>13</a>\u001b[0m \u001b[39mfor\u001b[39;00m net \u001b[39min\u001b[39;00m nets:\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/fredericbecker/Documents/Master/Masterarbeit/code/local/loci_public/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb#W2sZmlsZQ%3D%3D?line=13'>14</a>\u001b[0m     path \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39mjoin(root_path, \u001b[39m'\u001b[39m\u001b[39mresults\u001b[39m\u001b[39m'\u001b[39m, net)\n\u001b[0;32m---> <a href='vscode-notebook-cell:/Users/fredericbecker/Documents/Master/Masterarbeit/code/local/loci_public/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb#W2sZmlsZQ%3D%3D?line=14'>15</a>\u001b[0m     \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39;49m(os\u001b[39m.\u001b[39;49mpath\u001b[39m.\u001b[39;49mjoin(path, \u001b[39m'\u001b[39;49m\u001b[39mtrialframe.csv\u001b[39;49m\u001b[39m'\u001b[39;49m), \u001b[39m'\u001b[39;49m\u001b[39mrb\u001b[39;49m\u001b[39m'\u001b[39;49m) \u001b[39mas\u001b[39;00m f:\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/fredericbecker/Documents/Master/Masterarbeit/code/local/loci_public/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb#W2sZmlsZQ%3D%3D?line=15'>16</a>\u001b[0m         tf_temp \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39mread_csv(f, index_col\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/fredericbecker/Documents/Master/Masterarbeit/code/local/loci_public/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl1.ipynb#W2sZmlsZQ%3D%3D?line=16'>17</a>\u001b[0m     tf_temp[\u001b[39m'\u001b[39m\u001b[39mnet\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m net\n",
+      "File \u001b[0;32m~/miniconda3/envs/loci23/lib/python3.9/site-packages/IPython/core/interactiveshell.py:282\u001b[0m, in \u001b[0;36m_modified_open\u001b[0;34m(file, *args, **kwargs)\u001b[0m\n\u001b[1;32m    275\u001b[0m \u001b[39mif\u001b[39;00m file \u001b[39min\u001b[39;00m {\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m, \u001b[39m2\u001b[39m}:\n\u001b[1;32m    276\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m    277\u001b[0m         \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mIPython won\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt let you open fd=\u001b[39m\u001b[39m{\u001b[39;00mfile\u001b[39m}\u001b[39;00m\u001b[39m by default \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    278\u001b[0m         \u001b[39m\"\u001b[39m\u001b[39mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    279\u001b[0m         \u001b[39m\"\u001b[39m\u001b[39myou can use builtins\u001b[39m\u001b[39m'\u001b[39m\u001b[39m open.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    280\u001b[0m     )\n\u001b[0;32m--> 282\u001b[0m \u001b[39mreturn\u001b[39;00m io_open(file, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../../../out/pretrained/adept_ablations/lambda/results/adept_level1_ablation_lambda.run311/trialframe.csv'"
+     ]
+    }
+   ],
+   "source": [
+    "# setting path to results folder\n",
+    "root_path = '../../../out/pretrained/adept_ablations/lambda'\n",
+    "\n",
+    "# list all folders in root path that don't stat with a dot\n",
+    "nets = ['adept_level1_ablation_lambda.run311']\n",
+    "\n",
+    "# read pickle file\n",
+    "tf = pd.DataFrame()\n",
+    "sf = pd.DataFrame()\n",
+    "af = pd.DataFrame()\n",
+    "\n",
+    "# load statistics files from nets\n",
+    "for net in nets:\n",
+    "    path = os.path.join(root_path, net, 'results')\n",
+    "    with open(os.path.join(path, 'trialframe.csv'), 'rb') as f:\n",
+    "        tf_temp = pd.read_csv(f, index_col=0)\n",
+    "    tf_temp['net'] = net\n",
+    "    tf = pd.concat([tf,tf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:\n",
+    "        sf_temp = pd.read_csv(f, index_col=0)\n",
+    "    sf_temp['net'] = net\n",
+    "    sf = pd.concat([sf,sf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:\n",
+    "        af_temp = pd.read_csv(f, index_col=0)\n",
+    "    af_temp['net'] = net\n",
+    "    af = pd.concat([af,af_temp])\n",
+    "\n",
+    "# cast variables\n",
+    "sf['visible'] = sf['visible'].astype(bool)\n",
+    "sf['bound'] = sf['bound'].astype(bool)\n",
+    "sf['occluder'] = sf['occluder'].astype(bool)\n",
+    "sf['inimage'] = sf['inimage'].astype(bool)\n",
+    "sf['vanishing'] = sf['vanishing'].astype(bool)\n",
+    "sf['alpha_pos'] = 1-sf['alpha_pos']\n",
+    "sf['alpha_ges'] = 1-sf['alpha_ges']\n",
+    "\n",
+    "# scale to percentage\n",
+    "sf['TE'] = sf['TE'] * 100\n",
+    "\n",
+    "# add surprise as dummy code\n",
+    "tf['control'] = [('control' in set) for set in tf['set']]\n",
+    "sf['control'] = [('control' in set)  for set in sf['set']]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Tracking Error (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tracking Error when visible: M: 11.6 , STD: 13.5, Count: 2281\n",
+      "Tracking Error when occluded: M: 7.1 , STD: 4.02, Count: 564\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "\n",
+    "def get_stats(col):\n",
+    "    return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'\n",
+    "\n",
+    "# When Visible\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Tracking Error when visible:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Occluded\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Tracking Error when occluded:' + get_stats(temp['TE']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Succesfull Trackings (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>set</th>\n",
+       "      <th>evalmode</th>\n",
+       "      <th>tracked_pos</th>\n",
+       "      <th>tracked_neg</th>\n",
+       "      <th>tracked_pos_pro</th>\n",
+       "      <th>tracked_neg_pro</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>control</td>\n",
+       "      <td>open</td>\n",
+       "      <td>0</td>\n",
+       "      <td>54</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       set evalmode  tracked_pos  tracked_neg  tracked_pos_pro  \\\n",
+       "0  control     open            0           54              0.0   \n",
+       "\n",
+       "   tracked_neg_pro  \n",
+       "0              1.0  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target\n",
+    "# determine last visible frame numeric\n",
+    "grouping_factors = ['net','set','evalmode','scene','slot']\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).max()\n",
+    "ff.rename(columns = {'frame':'last_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['last_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# same for first bound frame\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()\n",
+    "ff.rename(columns = {'frame':'first_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['first_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf['last_visible'] = (sf['last_visible'] == sf['frame'])\n",
+    "\n",
+    "# extract the trials where the target was last visible and threshold the TE\n",
+    "ff = sf[sf['last_visible']] \n",
+    "ff['tracked_pos'] = (ff['TE'] < 10)\n",
+    "ff['tracked_neg'] = (ff['TE'] >= 10)\n",
+    "\n",
+    "# fill NaN with 0\n",
+    "sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')\n",
+    "sf['tracked_pos'].fillna(False, inplace=True)\n",
+    "sf['tracked_neg'].fillna(False, inplace=True)\n",
+    "\n",
+    "# Aggreagte over all scenes\n",
+    "temp = sf[(sf['frame']== 1) & ~sf.occluder & sf.control & (sf.first_visible < 20)]\n",
+    "temp = temp.groupby(['set', 'evalmode']).sum()\n",
+    "temp = temp[['tracked_pos', 'tracked_neg']]\n",
+    "temp = temp.reset_index()\n",
+    "\n",
+    "temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "\n",
+    "temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mostly Tracked stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAEmCAYAAAB20LuSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAir0lEQVR4nO3dd3hUVf7H8fek0UsIoSoiCkdABUGKBVFkXeuqix10V0SKCy7KqvijN8FdUVAUFURBARfBLljoFqSJICoHBBsQIYagJBAgmfn9MQk7xEAmMOFmTj6v5+Ex994zd74mkw+Hc8891xcIBBAREXfEeF2AiIhEloJdRMQxCnYREcco2EVEHKNgFxFxTJzH718GaAWkADke1yIiEi1igdrASmB//oNeB3sr4GOPaxARiVbtgE/y7/Q62FMA0tMz8fs1nz4SkpIqkpaW4XUZIn+gz2bkxMT4SEysALkZmp/XwZ4D4PcHFOwRpO+llFT6bEZcgUPYungqIuIYBbuIiGO8HooRkeOUk5NNenoq2dkHvC7lqHbujMHv93tdRlSJi0sgMTGZ2NiiRbWCXSTKpaenUrZseSpUqIXP5/O6nCOKi4shO1vBHq5AIEBm5u+kp6dSvXrtIr02rGA3xlQGPgOuttb+kO9Yc2AyUBlYCvS01mYXqQoROWbZ2QdKfKhL0fl8PipUqExGxu4iv7bQMXZjTBuC8yQbHaHJK0Bva20jwAfcXeQqROS4KNTddKw/13Aunt4N/APYnv+AMeYUoJy19vPcXS8BNx5TJSIiEhGFDsVYa7sBGGMKOlyHwyfIpwAnFbWIpKSKRX3JCXcg5yAJsfFelxGW5ORKXpdQqGj6fpZ0O3b6iIs7vI9WrnwZypaJ/CW0rP3Z7Nv7hzvYw5a/znB8/fV6Fi1aQO/e/+Tdd9/miy9WM3jwsCKdIyNjDyNGDOXRR8cW2jYQCBy1p9yr191069aDli3PLVINAJMmPQvA3Xf3DPs1MTExRf6dPt6ffAwQeseBDyjy1ZG0tIwSf+NCcnIlbvpvL6/LcMasmyeSmrrH6zKc4MPH5l0/Hbbv3MTGXNPvrYi/1ztjr2X91k0RP+/RLF+/kh9/+YnNu35iZ2Yaew5k/OH/tzCpO3bw9bfrw3rdadXqHfUibyAQICfHf0wXgvNyriiv9fv9f/hdiYnxHbVDfLzBvpXgQjR5alHAkI2IlB7frPuKt16dTVx8HDt/2UHLtq0pU7Ysq5ctJ0CAB4cNZvPGTbz28nQC/gA1atXkrj73UCWxKtMnv8j6NWvx+Xy0PK8Nl197NXNemUnWvizefPU1EpOqAbD+y7XMfnkmQ8eOAWDJRwvYbDfRtXfBPeFpz04mfVc6T4wYTZfuXXl00HAqVa5MQkIC/xz4EJPGTWDXr2mkp+3i/Lbn8+CDAwGYOPEpli5dTFxcLH/5y1+56aZbD50zPX0X997bk+7d76Fdu4t5+eWXWLToI3Jy/LRp05Zeve7F5/MxY8Y03n77DapUqUqlSpVo3LhpMf8EjvMGJWvtj0CWMeaC3F23A/OOuyoRiWrf2Y107d2TkePH8uE7c6lcpQojnxxLvfr1mT/3faZMmMj9gx5mzDPjadSkMS9NfJ7UHTtZu+oLRj89jiGPjWHbTz8Tn5BApy630qJtK6675X+X75o2O5vd6ensSAmOBH+yYDEXdexwxHru6NmNxGqJ3DfoYQBStm7jngf68vAjw/hyxSpOaXAqwx5/lMcnP8OaNauxdgOLFi3gq6/WMm3aqzz//FTmzn2HtLRfAcjMzOCBB/rStWt32rW7mM8//wxrv2XSpGm8+OJ0UlNT+fDDeWzY8A3vvfc2U6ZMZ9y4Z0hN3VmM3/X/OaYeuzFmLjDYWrsK6AxMyp0S+QXwZATrE5EodHL9eiQlJwNQqXIlmjY/G4DqNZJZs3wlpzVqSHLNmgB0uOIy3p41h2rVk0hISGBov/6c0/pcbu16BwkJCQWe3+fz0e7SS/hk4RLa/+lSftu9m9PPONLEvT+qXLXKofc//+KL2Gw3Mu/Nt9n+81Z+++039u3by5dfrqZDhz+RkJBAQkICL70049Dr//Of0VSrlkT79sG/TFatWsE336znrrtuB2D//ixq1qxFWloabdteQPny5QG45JKO5OQU/wrlYQe7tbZ+yNdXhny9Fmgd2bJEJJrFxR0eLbGx/xscCAQOv54WHLPOITY2luFP/Jtvv/qaL1etZuj9/Rn46MgjvsdFHTvw78HDSUhIoN2llxSpvtC/MD54+11WfLKMDldcxpnNm5G6dQeBQIC4uDhCr6GmpGynatVEADp3voNlyz7ljTdm06nTTfj9Odx0063ccksXAPbs2UNsbCxvvfU6oZchY2NjT0iwa60YETmhTjON+G7DRlJ37ABg4bwPadLsLH7YvIURDw3kjLOa0rnbndStdxIp27YRGxuLP+ePFxuTa9agWlIS89+bx4UdLj7qe8bExpJTwDkA1q9ZS4crLuOCS9pz8MBBNm2y+P1+mjVrweLFC8nOziYrK4t+/focGkpp2NDQr19/XnxxEqmpO2nRohUffDCXvXv3kp2dzcMP92Px4gWce24rPv30YzIyMti/fz9Lly46vm9emLSkgIicUFWqVuGue3vxxIgxZGdnU71GMnf37U1itWo0bGx4qNe9lClThkZNzqDZuS3ZmfILr09/lVdfnEbtk+oedq7z2l/Iik+XHbqoeuT3rEr1GtUZ2X8gPe7rc9ixy6+9hheffpa3Z82hfIUKnHVWM1JStnPNNdexYcM3dO3aGb8/wI033kq9eqccet3JJ9fjr3+9kccf/zejRz/Gd99tpHv3v+P359CmzflcccXV+Hw+brzxVrp1u4NKlSpRs2bRlgY4Vr78/yw6weoD32u6Y+mj6Y6Rs3Pnz+wre/i868Z1G1ChbJmIv1dm1n6+3bYl4uc9Fjk5OUx8bBxtLjyfVhecF7HzFjbd8UT75ZcfqVXrlMP2hUx3PBX4If9r1GMXcVBJCd/iEggE6N2lK2ee04yW57UBYMP6r5n67KQC2z84bHChvXqXKNhFJOr4fD4mzpx62L4zzmzK6AnjvCmohNHFUxERxyjYRUQco2AXEXGMgl1ExDEKdhERx2hWjIiDzq57Cglly0f8vAey9rJu248RP2+evZmZPPf4k9w36GHS03YxafwEHhw++Ijt57wyE4BOXW6l85XXMX3um0V+z9mvzOTM5mdzxpnHt+ri3LnvsGbNagYMGFrk16akbKdPnx7Mnv3OcdWQR8Eu4qCEsuXZMqpTxM/bYMCciJ8zVGZGBj9sDs7BT0yqdtRQj5QNX62nydlnFvv7nEgKdhGJqG/WfcWbM2cRGxdH6i87aNCoIXf37c0bM/7L+i/Xkbkng8SkRPr0f4AqiVXpecsdnNrwdHan76JqYrXD1k0f+dBAxr80iZ9/+JGpz05i/74sftv9G3+5qRMdr7r8D+/t9/u5r2sP+o8cSu2T6pKVlcUD3f/B2MkTC1wp8uMFi9iyaTOTxz9N34H9mfbsJGpUq8GWLZsZPnw069Z9yfvvzyUrax/x8fEMHTqKevXqs3LlciZMGEcg4KdWrdoMGXL4YmXjx49l1640Bg8ewcaNG3jyycfZvz+LKlWq8sAD/0edOnXZuHEDY8aMAOD008NfmTIcGmMXkYjb+K3l9h7d+M/zT3Pw4EHef/Mdtv+8laFjxzB28jMkJSfzyaLFAOz5/XeuufF6Rk8YR9fePQ5bNz3P4g8+4rpbbmTE+McYOGYEM6e8VOD7xsTE0K5jBz5dtASAlZ8u45zWrY64/G+7Sy+hQcPT6PbPf1Dv1PoAnH56Q2bOfJ06deqydOkSJkx4jpdfnsX557djzpxZHDhwgOHDBzFw4FCmTfsvDRqczrx57x465wsvPEdq6k4GDRqO3+9nzJiRDBkyiilTpnPLLV149NFRAIwcOYRevfowZcp06tSpW1B5x0w9dhGJuDPObEKd3AW7LuxwMQvnfcjf77mbxR98xPat29i0wVKjdq1D7U83R++xdu52J2tXr+Gt/87m5x9+JGtf1hHbtv9TB0b/3xBuuP02Pp6/kJv+dnuRam/a9CwAKlSoyNChI5k//0N+/vknli//jIYNDVu2fEdycjINGwafA92zZ28gOMb++eefsXt3OpMmTSMuLo4tW75j+/at9O9//6HzZ2Zmsnv3bn799VdatWoLwBVXXM2770buUYYKdhGJuNjY2ENfB/x+fD4YM2AYV1z/F9pceD4xMTEQsgBhQpmjL1j25Oj/UKFiRc5p04rz2rdj2ZKPj9g2uWZNqtdIZuWny/ht929FegAHQJncWnbs+IU+fXrQqdNNtG17PtWqJbFpkyU2No7g452DMjIy2Ls3E4BatWrTo8c9PP74ozz77BRycvzUqVP30EM6cnJySE/fhc93+Lr0wXNGjoZiRCTi7NffsuvXNPx+Px8vXIxp2oTGZzel41WXU6tuHdasWIXf/8cVFI+0bvpXa9Zyw+23ce55bVi7ajUA/qM8sKL9ZR2Z+uzkQtdpz3vPgtZ737DhG0466WRuvrkzjRs3YenSRfj9OdSrdwq7d6fz/ffBi7zTp0/lzTeDF5Xr1z+Vq6++jnLlyvH667M45ZT6/P7776xduwaA9957m6FDB1ClSlVq1arFZ599AsBHH71faJ1FoR67iIMOZO0tlhksB7L2htUuMakaz44dx660XZx1TjMuuKQ940aO4aFe9wLQoOHppO744/M/j7RueqfOtzDsgYeJj4/nlAanklyzBjsLeH2eVue3ZfKTT4cV7M1atmDKhIn07Nf38HO0assbb8ymS5cbCQQCNG/egi1bNlOmTBkGDRrOyJFDyM4+SJ06JzFo0HAWL15w6LX9+vXnnnvu4qKLLmHEiDGMH/8YBw4coHz5CgwcOAyAQYNGMHr0MCZNeoamTc8utM6i0HrsYdJ67JGl9dgjp6D12L30zbqveH36qwzMvUh4ogUCAdauWs2CuR/Qb8iAIr9e67GLiJQwrzz/Al8sX3nYHPiR/QeSmZHxh7aXXnF5gdMmo52CXUQiqsnZZ9Hk7LM8e//be3Tj9h7dDts3cMyRH4rtIl08FRFxjIJdRMQxCnYREcco2EVEHKOLpyIOanxSfSqUKRfx82bu38e3W3+I+HmPZrPdyIpPl3Fr17+x5KMFfPvVenre/88ineNYp2BmZGQwatRQRo9+rEiv85qCXcRBFcqUK5b7LmbdPDHi5yzM1p9+5rfdu0/4+wLs2fM7mzZZT977eCjYRSSivln3FW+9Opu4+Dh2/rKDlm1bU6ZsWVYvW06AAA8OG8zmjZt47eXpBPwBatSqyV197qFKYlWmT36R9WvW4vP5aHleGy6/9mrmvDKTrH1ZvPnqayQmVQNg/Zdrmf3yTIaOHQPAko8WsNluomvvnoXWl7J1Gy889QwZezIoU7Ysd/TsxmmNGvLpoiW8O+cNysWXpXbtOgwaNIJx4/7Dr7+m8vDD/4qqXrvG2EUk4r6zG+nauycjx4/lw3fmUrlKFUY+OZZ69eszf+77TJkwkfsHPcyYZ8bTqEljXpr4PKk7drJ21ReMfnocQx4bw7affiY+IYFOXW6lRdtWXHfLjYfO37TZ2exOT2dHSgoAnyxYzEUdO4RV2zOPjePPf7maMc+Mp0v3rowf9W8OHjzIay/PoP/IoUydOoPatevy008/0LfvA1SvnhxVoQ4KdhEpBifXr0dScjJlypahUuVKNG0eXAuleo1k1ixfyWmNGpJcsyYAHa64jK+/XEe16kkkJCQwtF9/3n/rHW7tescR11H3+Xy0u/QSPlm4hF93pvLb7t1hreKYtW8fO7an0OqC8wBoeIahYqWKpGzdRovWrRj2r4d56qlxtG/f4dCyvNFIwS4iERcXd/gob2zs/6Im//pUgUCAnJwcYmNjGf7Ev7nx9tvI2LOHoff3J2XrtiO+x0UdO/D50k9YtuRj2l16SVh1+QtYGytA8P3v6NmNvgMeonLlyowYMYgPPpgb1jlLIgW7iJxQp5lGfLdhI6k7dgCwcN6HNGl2Fj9s3sKIhwZyxllN6dztTurWO4mUbduIPcKyusk1a1AtKYn5780LaxVHgPLly1OjVk1WfroMgE0bLL+l7+bkU+pxf7deVKpcmb/9rSuXX34VGzdaYmNjyTnK8sAlVVgXT40xtwEDgXhgnLX26XzHWwDPAQnAz0AXa+3uyJYqIi6oUrUKd93biydGjCE7O5vqNZK5u29vEqtVo2Fjw0O97qVMmTI0anIGzc5tyc6UX3h9+qu8+uI0ap90+CPkzmt/ISs+XXboomo47nngPqZMmMjsV2YSHx9P3wH9iYuP54YutzJ6wBAqla9I1aqJDBgwlEqVKlOzZi369OnBU089F+lvRbEpdNleY0xd4BOgJbAf+Ay41Vr7TUibj4FHrLXzjDFjgX3W2oFhvH99tGxvqaRleyOnoGV7XZrHfiQ5OTlMfGwcbS48/9CYeSSUlmV7OwILrbW7AIwxs4EbgOEhbWKByrlflwd2FbF2EYmgkhK+xSUQCNC7S1fOPKcZLc9rA8CG9V8z9dlJBbZ/cNjgIvXqo104wV4HSAnZTgFa52tzP/ChMWYckAm0iUh1IiIF8Pl8TJw59bB9Z5zZlNETxnlTUAkTTrDHAKHjJD7g0L9TjDHlgBeAjtbaFcaY+4FpwFXhFpH7TwopZZKTK3ldghN2HvkJcXKM4uJKzrySmJiYIv+uhBPsW4F2Idu1gO0h22cSHFNfkbv9HDCiKEVEyxi7RJbG2CMoEABfyXk8XrQrKWPsgUAAv9//h9+VkDH2AoXz19J84FJjTLIxpjzQCQh9pPZ3wMnGmLzZ/NcCK4tSvIgcu3LlyuI/cCAY7uKMQCBAZubvxMUVfJPW0RTaY7fWbjPGDAAWEZzOODl3yGUuMNhau8oY83dgljHGB+wE7ixyJSJyTE4++WRWfT6X5DKJ+FCv/Xhtzwr2kkuCuLgEEhOTi/66cBpZa2cAM/LtuzLk63nAvCK/u4gct/j4eGZvf7/whhIWF6bilpwrBCIiEhEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQcE+d1AdHiQPYBZt080esynHEg+4DXJYg4S8EepoS4BLaM6uR1Gc5oMGAOsN/rMkScpKEYERHHKNhFRByjYBcRcYyCXUTEMQp2ERHHKNhFRByjYBcRcUxY89iNMbcBA4F4YJy19ul8xw3wHJAI/ALcYq1Nj3CtIiIShkJ77MaYusAo4EKgOdDdGNMk5LgPeBsYY61tBqwB+hdLtSIiUqhwhmI6AguttbustZnAbOCGkOMtgExr7fu5248ATyMiIp4IZyimDpASsp0CtA7ZPh34xRjzAnAO8C3QJ2IVishRaR2jyHJhHaNwgj0GCIRs+wB/vnNcDFxkrV1ljBkBPA78PdwikpIqhttUHJKcXMnrEpyhdYwip8GAOSQnJ3hdxnEJJ9i3Au1CtmsB20O2fwE2WWtX5W7PJDhcE7a0tAz8/kDhDT2kEIq81NQ9XpfgBH02I6+kfzZjYnxH7RCHM8Y+H7jUGJNsjCkPdALeDzn+GZBsjGmWu30NsPoY6xURkeNUaLBba7cBA4BFwJfADGvtCmPMXGPMudbafcD1wCRjzNdAB6BfMdYsIiJHEdY8dmvtDGBGvn1Xhny9nMMvqIqIiEd056mIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGMU7CIijlGwi4g4RsEuIuIYBbuIiGPCCnZjzG3GmG+MMZuMMf84SrurjDHfR648EREpqkKD3RhTFxgFXAg0B7obY5oU0K4m8Bjgi3CNIiJSBHFhtOkILLTW7gIwxswGbgCG52s3GRgGjIlohSWE/+ABGgyY43UZzvAfPOB1CSLOCifY6wApIdspQOvQBsaYe4EvgM+PpYikpIrH8rIT7pp+b3ldgjPeGXstyckJXpchUqDk5Epel3Bcwgn2GCAQsu0D/HkbxpgzgU7ApcBJx1JEWloGfn+g8IYeivYfdEmUmrrH6xKcoM9m5JX0z2ZMjO+oHeJwLp5uBWqHbNcCtods35h7fBUwF6hjjPm46KWKiEgkhNNjnw8MNcYkA5kEe+fd8w5aa4cAQwCMMfWBxdbadpEvVUREwlFoj91auw0YACwCvgRmWGtXGGPmGmPOLeb6RESkiMLpsWOtnQHMyLfvygLa/QDUj0RhIiJybHTnqYiIYxTsIiKOUbCLiDhGwS4i4hgFu4iIYxTsIiKOUbCLiDhGwS4i4piwblASkZJLS0pHlgtLSivYRaJcTHyClpSOoHfGXgvs97qM46KhGBERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQcExdOI2PMbcBAIB4YZ619Ot/xa4FhgA/4HrjTWpse4VpFRCQMhfbYjTF1gVHAhUBzoLsxpknI8crAROAqa20zYB0wtDiKFRGRwoUzFNMRWGit3WWtzQRmAzeEHI8H/mGt3Za7vQ6oF9kyRUQkXOEMxdQBUkK2U4DWeRvW2jTgDQBjTDmgP/BUBGsUEZEiCCfYY4BAyLYP8OdvZIypQjDg11prpxaliKSkikVpLo5ITq7kdQkiBYr2z2Y4wb4VaBeyXQvYHtrAGFMb+ABYCNxX1CLS0jLw+wOFN/RQtP+gS6LU1D1el+AEfTYjr6R/NmNifEftEIcT7POBocaYZCAT6AR0zztojIkF3gFmWWtHHl+5IiJyvAoNdmvtNmPMAGARkABMttauMMbMBQYDJwMtgDhjTN5F1VXW2m7FVbSIiBxZWPPYrbUzgBn59l2Z++UqdKOTiEiJoUAWEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXGMgl1ExDEKdhERxyjYRUQco2AXEXFMXDiNjDG3AQOBeGCctfbpfMebA5OBysBSoKe1NjuypYqISDgK7bEbY+oCo4ALgeZAd2NMk3zNXgF6W2sbAT7g7gjXKSIiYQqnx94RWGit3QVgjJkN3AAMz90+BShnrf08t/1LwDBgYhjnjgWIifEVrWqP1Egs53UJTomWn3s00Gczskr6ZzOkvtiCjocT7HWAlJDtFKB1IcdPCrO+2gCJiRXCbO6tFwZe5nUJTklKquh1Cc7QZzOyouizWRvYnH9nOMEeAwRCtn2AvwjHj2Yl0I7gXwY5Yb5GRKS0iyUY6isLOhhOsG8lGL55agHb8x2vfZTjR7Mf+CTMtiIi8j9/6KnnCWe643zgUmNMsjGmPNAJeD/voLX2RyDLGHNB7q7bgXnHUayIiByHQoPdWrsNGAAsAr4EZlhrVxhj5hpjzs1t1hl4whizAagIPFlM9YqISCF8gUCg8FYiIhI1dOepiIhjFOwiIo5RsIuIOEbBLiLiGAW7iIhjFOwiIo4Ja9leKXmMMYOPdtxaO/xE1SJyJLlLfjcluELsDdbaaR6XVCqoxx69fIX8EfGUMWYMcCXwV4KdyDuNMWO9rap00A1KDjDGJANtCP7yLLPW7vC4JBGMMWuAFsAX1tpzjDFxwDprbf7nOUiEqcce5Ywxfya41MOdwN+AdcaYqz0tSiQob5XXvN5jGcJf+VWOg8bYo98o4EJr7fcAxpgGwOvAu55WJQKzgP8C1YwxfYE7gBmeVlRKqMce/eLzQh3AWrsF/VylBLDWPgq8ALwG1AMGWWsf8baq0kEBEP1+Msb0NcZUyv1zH/Cj10WJGGMSgBRr7QPAauBiY0x1j8sqFRTs0e8u4DxgC/B97tfdPa1IJOgVoLMxpjUwBPid4DORpZhpjD363WutvdnrIkQKcKq19iZjzKPAC9baR40xBT7KTSJLPfbod40xRvPWpSSKyx16uR54zxhTCyjncU2lgnrs0S8N2GCM+QLYl7fTWtvVu5JEAPgPsBx421q73hizERjkcU2lgoI9+k0tYJ/uOhPPWWtncPj0xsbW2hyv6ilNFOzRr461dnToDmOMppSJZ4wx71prrzbGfE++ToYxBmttA49KKzUU7FEqdx2OGsBfjDENQw7FAW2B//OkMBG4O/e/NwE7vSyktFKwR685QBPgUmBJyP5sYIQnFYkA1tqU3C+nWWsbe1pMKaVFwKKcMaaKtfY3r+sQyc8Y8yrwHrCCwy/s/+RZUaWEeuzR77rcpVATc7d9QMBaG+thTSIQXHG0Tb59AUBj7MVMPfYoZ4zZDFxrrV3vdS0iUjKoxx79tivUpSQyxtQDngQ6ELz2Mxe4z1qb6mlhpYCCPfqtNsbMBj4EsvJ26hFkUgJMJ7hs7+1ALMFnBkwl+FQlKUYK9uhXBdhDcPGvPAFAwS5eq2ytnRCy/YQx5u9eFVOaKNijnLX2TmNMPGAI/jzXW2uzPS5LBOAzY0wXa+0rAMaYq4A1HtdUKujiaZQzxrQkOKc9jeCibjWB6621yz0tTEo9Y8wOIJngVEc/UCHksGZuFSP12KPfk8DNeUFujGkLPAW09rQqEbjMWrvW6yJKIy3bG/0qhvbOrbWfA2U9rEckz6teF1Baqcce/XYZY6611r4FYIy5juCwjIjXvjHGDCa4dG/onadLvSupdFCwR7/uwLvGmBfIvesUON/bkkQAqAZckvsnT4DgvHYpRgr26HcFsBdoAZxGcN7wxcBGD2sSwVp7SeGtpDgo2KNfd6C1tXYvsC53lsxy4Hlvy5LSzhiziAIe+mKtVY+9mCnYo188cCBk+wB6gpKUDENDvo4HrgXSvSmldFGwR783gYXGmFkEA70T8JanFYkA1tol+XbNN8YsBwZ7UU9pohuUHGCMuQFoDxwEllpr3/S2IpFDi4Dl8QFnAuOttad7VFKpoR67A6y1s4HZXtchks8Sgv+K9BG88/RXoLenFZUSukFJRIrLLcDTwBnAZoKztuQEULCLSHEZD3wF/JXglNxz0PN4TwgFu4gUlxhr7YfA1cAca+3PaPj3hFCwi0hx2WuM6UfwTtN3jTH3Enx2gBQzBbuIFJfOBJfq7WStTQfqArd5W1LpoOmOIiKOUY9dRMQxCnYREcco2EWKwBhzqjFmjtd1iByNgl2kaE4h+OBwkRJLF0+lVDPGVAReBBoSvO19NdADuAoYCCQQvLnmX8AKwBKc3bHUWvtnL2oWKYx67FLaXQ9UstY2B1rl7jsNeAS40lp7DsE1718n+CzZbsBmhbqUZLoLTEq7T4BHjDGLgY+AccCfgNrAAmMOjbr4Aa1KKFFBPXYp1ay13xMM7NFAZWA+EAsssNY2z/sDtAXWe1aoSBEo2KVUM8b0IjjG/qG19iHgA4IPYb7MGHNGbpsrgXVAOSCb4NOAREosXTyVUs0YUwGYApxN8CLpT0BXoCMwgOBa4tlAX2vtx8aYasAiYD/QxlqrXyApcRTsIiKO0VCMiIhjFOwiIo5RsIuIOEbBLiLiGAW7iIhjFOwiIo5RsIuIOEbBLiLimP8HPUx1x9OfirsAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "temp = af[af.index == 'OVERALL']\n",
+    "temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']\n",
+    "temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']\n",
+    "temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']\n",
+    "g = temp[['mostly_tracked', 'partially_tracked', 'mostly_lost','set']].set_index(['set']).groupby(['set']).mean().plot(kind='bar', stacked=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MOTA "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>idf1</th>\n",
+       "      <th>idp</th>\n",
+       "      <th>idr</th>\n",
+       "      <th>recall</th>\n",
+       "      <th>precision</th>\n",
+       "      <th>num_unique_objects</th>\n",
+       "      <th>mostly_tracked</th>\n",
+       "      <th>partially_tracked</th>\n",
+       "      <th>mostly_lost</th>\n",
+       "      <th>num_false_positives</th>\n",
+       "      <th>num_misses</th>\n",
+       "      <th>num_switches</th>\n",
+       "      <th>num_fragmentations</th>\n",
+       "      <th>mota</th>\n",
+       "      <th>motp</th>\n",
+       "      <th>num_transfer</th>\n",
+       "      <th>num_ascend</th>\n",
+       "      <th>num_migrate</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>set</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>control</th>\n",
+       "      <td>0.722042</td>\n",
+       "      <td>0.879472</td>\n",
+       "      <td>0.612416</td>\n",
+       "      <td>0.658158</td>\n",
+       "      <td>0.945161</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>187.0</td>\n",
+       "      <td>1674.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>0.614662</td>\n",
+       "      <td>0.033957</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>surprise</th>\n",
+       "      <td>0.738122</td>\n",
+       "      <td>0.923004</td>\n",
+       "      <td>0.614946</td>\n",
+       "      <td>0.646612</td>\n",
+       "      <td>0.970532</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>558.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0.623813</td>\n",
+       "      <td>0.031067</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              idf1       idp       idr    recall  precision  \\\n",
+       "set                                                           \n",
+       "control   0.722042  0.879472  0.612416  0.658158   0.945161   \n",
+       "surprise  0.738122  0.923004  0.614946  0.646612   0.970532   \n",
+       "\n",
+       "          num_unique_objects  mostly_tracked  partially_tracked  mostly_lost  \\\n",
+       "set                                                                            \n",
+       "control                 86.0            35.0               22.0         29.0   \n",
+       "surprise                33.0            11.0                9.0         13.0   \n",
+       "\n",
+       "          num_false_positives  num_misses  num_switches  num_fragmentations  \\\n",
+       "set                                                                           \n",
+       "control                 187.0      1674.0          26.0                38.0   \n",
+       "surprise                 31.0       558.0           5.0                 6.0   \n",
+       "\n",
+       "              mota      motp  num_transfer  num_ascend  num_migrate  \n",
+       "set                                                                  \n",
+       "control   0.614662  0.033957           5.0        21.0          0.0  \n",
+       "surprise  0.623813  0.031067           0.0         5.0          0.0  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "af[af.index == 'OVERALL'].groupby(['set']).mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gate Openings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percept gate openings when visible: M: 1.02 , STD: 0.681, Count: 2281\n",
+      "Percept gate openings when occluded: M: 0.216 , STD: 0.48, Count: 564\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Percept gate openings when visible:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Percept gate openings when occluded:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "loci23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl2.ipynb b/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl2.ipynb
new file mode 100644
index 0000000..5b8e275
--- /dev/null
+++ b/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl2.ipynb
@@ -0,0 +1,469 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import scipy.stats as stats\n",
+    "import os\n",
+    "\n",
+    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+    "pd.options.mode.chained_assignment = None \n",
+    "plt.style.use('ggplot')\n",
+    "sns.color_palette(\"Paired\");\n",
+    "sns.set_theme();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setting path to results folder\n",
+    "root_path = '../../../out/pretrained/adept_ablations/lambda'\n",
+    "\n",
+    "# list all folders in root path that don't stat with a dot\n",
+    "nets = ['adept_level1_ablation_lambda.run411']\n",
+    "\n",
+    "# read pickle file\n",
+    "tf = pd.DataFrame()\n",
+    "sf = pd.DataFrame()\n",
+    "af = pd.DataFrame()\n",
+    "\n",
+    "# load statistics files from nets\n",
+    "for net in nets:\n",
+    "    path = os.path.join(root_path, net, 'results')\n",
+    "    with open(os.path.join(path, 'trialframe.csv'), 'rb') as f:\n",
+    "        tf_temp = pd.read_csv(f, index_col=0)\n",
+    "    tf_temp['net'] = net\n",
+    "    tf = pd.concat([tf,tf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:\n",
+    "        sf_temp = pd.read_csv(f, index_col=0)\n",
+    "    sf_temp['net'] = net\n",
+    "    sf = pd.concat([sf,sf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:\n",
+    "        af_temp = pd.read_csv(f, index_col=0)\n",
+    "    af_temp['net'] = net\n",
+    "    af = pd.concat([af,af_temp])\n",
+    "\n",
+    "# cast variables\n",
+    "sf['visible'] = sf['visible'].astype(bool)\n",
+    "sf['bound'] = sf['bound'].astype(bool)\n",
+    "sf['occluder'] = sf['occluder'].astype(bool)\n",
+    "sf['inimage'] = sf['inimage'].astype(bool)\n",
+    "sf['vanishing'] = sf['vanishing'].astype(bool)\n",
+    "sf['alpha_pos'] = 1-sf['alpha_pos']\n",
+    "sf['alpha_ges'] = 1-sf['alpha_ges']\n",
+    "\n",
+    "# scale to percentage\n",
+    "sf['TE'] = sf['TE'] * 100\n",
+    "\n",
+    "# add surprise as dummy code\n",
+    "tf['control'] = [('control' in set) for set in tf['set']]\n",
+    "sf['control'] = [('control' in set)  for set in sf['set']]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Tracking Error (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tracking Error when visible: M: 5.25 , STD: 7.52, Count: 1246\n",
+      "Tracking Error when occluded: M: 5.16 , STD: 4.93, Count: 342\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "\n",
+    "def get_stats(col):\n",
+    "    return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'\n",
+    "\n",
+    "# When Visible\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Tracking Error when visible:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Occluded\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Tracking Error when occluded:' + get_stats(temp['TE']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Succesfull Trackings (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>set</th>\n",
+       "      <th>evalmode</th>\n",
+       "      <th>tracked_pos</th>\n",
+       "      <th>tracked_neg</th>\n",
+       "      <th>tracked_pos_pro</th>\n",
+       "      <th>tracked_neg_pro</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>control</td>\n",
+       "      <td>open</td>\n",
+       "      <td>18</td>\n",
+       "      <td>15</td>\n",
+       "      <td>0.545455</td>\n",
+       "      <td>0.454545</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       set evalmode  tracked_pos  tracked_neg  tracked_pos_pro  \\\n",
+       "0  control     open           18           15         0.545455   \n",
+       "\n",
+       "   tracked_neg_pro  \n",
+       "0         0.454545  "
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target\n",
+    "# determine last visible frame numeric\n",
+    "grouping_factors = ['net','set','evalmode','scene','slot']\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).max()\n",
+    "ff.rename(columns = {'frame':'last_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['last_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# same for first bound frame\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()\n",
+    "ff.rename(columns = {'frame':'first_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['first_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf['last_visible'] = (sf['last_visible'] == sf['frame'])\n",
+    "\n",
+    "# extract the trials where the target was last visible and threshold the TE\n",
+    "ff = sf[sf['last_visible']] \n",
+    "ff['tracked_pos'] = (ff['TE'] < 10)\n",
+    "ff['tracked_neg'] = (ff['TE'] >= 10)\n",
+    "\n",
+    "# fill NaN with 0\n",
+    "sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')\n",
+    "sf['tracked_pos'].fillna(False, inplace=True)\n",
+    "sf['tracked_neg'].fillna(False, inplace=True)\n",
+    "\n",
+    "# Aggreagte over all scenes\n",
+    "temp = sf[(sf['frame']== 1) & ~sf.occluder & sf.control & (sf.first_visible < 20)]\n",
+    "temp = temp.groupby(['set', 'evalmode']).sum()\n",
+    "temp = temp[['tracked_pos', 'tracked_neg']]\n",
+    "temp = temp.reset_index()\n",
+    "\n",
+    "temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "\n",
+    "temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mostly Tracked stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "temp = af[af.index == 'OVERALL']\n",
+    "temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']\n",
+    "temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']\n",
+    "temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']\n",
+    "g = temp[['mostly_tracked', 'partially_tracked', 'mostly_lost','set']].set_index(['set']).groupby(['set']).mean().plot(kind='bar', stacked=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MOTA "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>idf1</th>\n",
+       "      <th>idp</th>\n",
+       "      <th>idr</th>\n",
+       "      <th>recall</th>\n",
+       "      <th>precision</th>\n",
+       "      <th>num_unique_objects</th>\n",
+       "      <th>mostly_tracked</th>\n",
+       "      <th>partially_tracked</th>\n",
+       "      <th>mostly_lost</th>\n",
+       "      <th>num_false_positives</th>\n",
+       "      <th>num_misses</th>\n",
+       "      <th>num_switches</th>\n",
+       "      <th>num_fragmentations</th>\n",
+       "      <th>mota</th>\n",
+       "      <th>motp</th>\n",
+       "      <th>num_transfer</th>\n",
+       "      <th>num_ascend</th>\n",
+       "      <th>num_migrate</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>set</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>control</th>\n",
+       "      <td>0.753959</td>\n",
+       "      <td>0.934199</td>\n",
+       "      <td>0.632020</td>\n",
+       "      <td>0.639984</td>\n",
+       "      <td>0.945970</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>43.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>179.0</td>\n",
+       "      <td>1763.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>0.602001</td>\n",
+       "      <td>0.059856</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>surprise</th>\n",
+       "      <td>0.751982</td>\n",
+       "      <td>0.930841</td>\n",
+       "      <td>0.630779</td>\n",
+       "      <td>0.644079</td>\n",
+       "      <td>0.950467</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>53.0</td>\n",
+       "      <td>562.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>0.608613</td>\n",
+       "      <td>0.058177</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              idf1       idp       idr    recall  precision  \\\n",
+       "set                                                           \n",
+       "control   0.753959  0.934199  0.632020  0.639984   0.945970   \n",
+       "surprise  0.751982  0.930841  0.630779  0.644079   0.950467   \n",
+       "\n",
+       "          num_unique_objects  mostly_tracked  partially_tracked  mostly_lost  \\\n",
+       "set                                                                            \n",
+       "control                 86.0            43.0                5.0         38.0   \n",
+       "surprise                33.0            13.0                6.0         14.0   \n",
+       "\n",
+       "          num_false_positives  num_misses  num_switches  num_fragmentations  \\\n",
+       "set                                                                           \n",
+       "control                 179.0      1763.0           7.0                22.0   \n",
+       "surprise                 53.0       562.0           3.0                11.0   \n",
+       "\n",
+       "              mota      motp  num_transfer  num_ascend  num_migrate  \n",
+       "set                                                                  \n",
+       "control   0.602001  0.059856           0.0         7.0          0.0  \n",
+       "surprise  0.608613  0.058177           0.0         3.0          0.0  "
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "af[af.index == 'OVERALL'].groupby(['set']).mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gate Openings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percept gate openings when visible: M: 0.061 , STD: 0.108, Count: 1246\n",
+      "Percept gate openings when occluded: M: 0.00026 , STD: 0.00481, Count: 342\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Percept gate openings when visible:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Percept gate openings when occluded:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "loci23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl3.ipynb b/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl3.ipynb
new file mode 100644
index 0000000..f137a5f
--- /dev/null
+++ b/evaluation/adept_ablation/lambda/evaluation_loci_looped_abl3.ipynb
@@ -0,0 +1,469 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import scipy.stats as stats\n",
+    "import os\n",
+    "\n",
+    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+    "pd.options.mode.chained_assignment = None \n",
+    "plt.style.use('ggplot')\n",
+    "sns.color_palette(\"Paired\");\n",
+    "sns.set_theme();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setting path to results folder\n",
+    "root_path = '../../../out/pretrained/adept_ablations/lambda'\n",
+    "\n",
+    "# list all folders in root path that don't stat with a dot\n",
+    "nets = ['adept_level1_ablation_lambda.run511']\n",
+    "\n",
+    "# read pickle file\n",
+    "tf = pd.DataFrame()\n",
+    "sf = pd.DataFrame()\n",
+    "af = pd.DataFrame()\n",
+    "\n",
+    "# load statistics files from nets\n",
+    "for net in nets:\n",
+    "    path = os.path.join(root_path, net, 'results')\n",
+    "    with open(os.path.join(path, 'trialframe.csv'), 'rb') as f:\n",
+    "        tf_temp = pd.read_csv(f, index_col=0)\n",
+    "    tf_temp['net'] = net\n",
+    "    tf = pd.concat([tf,tf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:\n",
+    "        sf_temp = pd.read_csv(f, index_col=0)\n",
+    "    sf_temp['net'] = net\n",
+    "    sf = pd.concat([sf,sf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:\n",
+    "        af_temp = pd.read_csv(f, index_col=0)\n",
+    "    af_temp['net'] = net\n",
+    "    af = pd.concat([af,af_temp])\n",
+    "\n",
+    "# cast variables\n",
+    "sf['visible'] = sf['visible'].astype(bool)\n",
+    "sf['bound'] = sf['bound'].astype(bool)\n",
+    "sf['occluder'] = sf['occluder'].astype(bool)\n",
+    "sf['inimage'] = sf['inimage'].astype(bool)\n",
+    "sf['vanishing'] = sf['vanishing'].astype(bool)\n",
+    "sf['alpha_pos'] = 1-sf['alpha_pos']\n",
+    "sf['alpha_ges'] = 1-sf['alpha_ges']\n",
+    "\n",
+    "# scale to percentage\n",
+    "sf['TE'] = sf['TE'] * 100\n",
+    "\n",
+    "# add surprise as dummy code\n",
+    "tf['control'] = [('control' in set) for set in tf['set']]\n",
+    "sf['control'] = [('control' in set)  for set in sf['set']]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Tracking Error (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tracking Error when visible: M: 3.34 , STD: 4.22, Count: 1873\n",
+      "Tracking Error when occluded: M: 2.78 , STD: 1.66, Count: 492\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "\n",
+    "def get_stats(col):\n",
+    "    return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'\n",
+    "\n",
+    "# When Visible\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Tracking Error when visible:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Occluded\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Tracking Error when occluded:' + get_stats(temp['TE']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Succesfull Trackings (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>set</th>\n",
+       "      <th>evalmode</th>\n",
+       "      <th>tracked_pos</th>\n",
+       "      <th>tracked_neg</th>\n",
+       "      <th>tracked_pos_pro</th>\n",
+       "      <th>tracked_neg_pro</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>control</td>\n",
+       "      <td>open</td>\n",
+       "      <td>37</td>\n",
+       "      <td>11</td>\n",
+       "      <td>0.770833</td>\n",
+       "      <td>0.229167</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       set evalmode  tracked_pos  tracked_neg  tracked_pos_pro  \\\n",
+       "0  control     open           37           11         0.770833   \n",
+       "\n",
+       "   tracked_neg_pro  \n",
+       "0         0.229167  "
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target\n",
+    "# determine last visible frame numeric\n",
+    "grouping_factors = ['net','set','evalmode','scene','slot']\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).max()\n",
+    "ff.rename(columns = {'frame':'last_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['last_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# same for first bound frame\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()\n",
+    "ff.rename(columns = {'frame':'first_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['first_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf['last_visible'] = (sf['last_visible'] == sf['frame'])\n",
+    "\n",
+    "# extract the trials where the target was last visible and threshold the TE\n",
+    "ff = sf[sf['last_visible']] \n",
+    "ff['tracked_pos'] = (ff['TE'] < 10)\n",
+    "ff['tracked_neg'] = (ff['TE'] >= 10)\n",
+    "\n",
+    "# fill NaN with 0\n",
+    "sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')\n",
+    "sf['tracked_pos'].fillna(False, inplace=True)\n",
+    "sf['tracked_neg'].fillna(False, inplace=True)\n",
+    "\n",
+    "# Aggreagte over all scenes\n",
+    "temp = sf[(sf['frame']== 1) & ~sf.occluder & sf.control & (sf.first_visible < 20)]\n",
+    "temp = temp.groupby(['set', 'evalmode']).sum()\n",
+    "temp = temp[['tracked_pos', 'tracked_neg']]\n",
+    "temp = temp.reset_index()\n",
+    "\n",
+    "temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "\n",
+    "temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mostly Tracked stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "temp = af[af.index == 'OVERALL']\n",
+    "temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']\n",
+    "temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']\n",
+    "temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']\n",
+    "g = temp[['mostly_tracked', 'partially_tracked', 'mostly_lost','set']].set_index(['set']).groupby(['set']).mean().plot(kind='bar', stacked=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MOTA "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>idf1</th>\n",
+       "      <th>idp</th>\n",
+       "      <th>idr</th>\n",
+       "      <th>recall</th>\n",
+       "      <th>precision</th>\n",
+       "      <th>num_unique_objects</th>\n",
+       "      <th>mostly_tracked</th>\n",
+       "      <th>partially_tracked</th>\n",
+       "      <th>mostly_lost</th>\n",
+       "      <th>num_false_positives</th>\n",
+       "      <th>num_misses</th>\n",
+       "      <th>num_switches</th>\n",
+       "      <th>num_fragmentations</th>\n",
+       "      <th>mota</th>\n",
+       "      <th>motp</th>\n",
+       "      <th>num_transfer</th>\n",
+       "      <th>num_ascend</th>\n",
+       "      <th>num_migrate</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>set</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>control</th>\n",
+       "      <td>0.773828</td>\n",
+       "      <td>0.943857</td>\n",
+       "      <td>0.655708</td>\n",
+       "      <td>0.673474</td>\n",
+       "      <td>0.969430</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>104.0</td>\n",
+       "      <td>1599.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>0.650398</td>\n",
+       "      <td>0.039370</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>surprise</th>\n",
+       "      <td>0.776620</td>\n",
+       "      <td>0.942186</td>\n",
+       "      <td>0.660545</td>\n",
+       "      <td>0.678911</td>\n",
+       "      <td>0.968383</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>507.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>0.654212</td>\n",
+       "      <td>0.039468</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              idf1       idp       idr    recall  precision  \\\n",
+       "set                                                           \n",
+       "control   0.773828  0.943857  0.655708  0.673474   0.969430   \n",
+       "surprise  0.776620  0.942186  0.660545  0.678911   0.968383   \n",
+       "\n",
+       "          num_unique_objects  mostly_tracked  partially_tracked  mostly_lost  \\\n",
+       "set                                                                            \n",
+       "control                 86.0            41.0               15.0         30.0   \n",
+       "surprise                33.0            16.0                4.0         13.0   \n",
+       "\n",
+       "          num_false_positives  num_misses  num_switches  num_fragmentations  \\\n",
+       "set                                                                           \n",
+       "control                 104.0      1599.0           9.0                31.0   \n",
+       "surprise                 35.0       507.0           4.0                12.0   \n",
+       "\n",
+       "              mota      motp  num_transfer  num_ascend  num_migrate  \n",
+       "set                                                                  \n",
+       "control   0.650398  0.039370           0.0         9.0          0.0  \n",
+       "surprise  0.654212  0.039468           2.0         2.0          0.0  "
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "af[af.index == 'OVERALL'].groupby(['set']).mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gate Openings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percept gate openings when visible: M: 0.132 , STD: 0.145, Count: 1873\n",
+      "Percept gate openings when occluded: M: 0.00809 , STD: 0.0444, Count: 492\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Percept gate openings when visible:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Percept gate openings when occluded:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "loci23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/evaluation/adept_ablation/recon/evaluation_loci_looped_norecon.ipynb b/evaluation/adept_ablation/recon/evaluation_loci_looped_norecon.ipynb
new file mode 100644
index 0000000..a1bbc32
--- /dev/null
+++ b/evaluation/adept_ablation/recon/evaluation_loci_looped_norecon.ipynb
@@ -0,0 +1,464 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import scipy.stats as stats\n",
+    "import os\n",
+    "\n",
+    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+    "pd.options.mode.chained_assignment = None \n",
+    "plt.style.use('ggplot')\n",
+    "sns.color_palette(\"Paired\");\n",
+    "sns.set_theme();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setting path to results folder\n",
+    "root_path = '../../../out/pretrained/adept_ablations/recon'\n",
+    "\n",
+    "# list all folders in root path that don't stat with a dot\n",
+    "nets = ['norecon']\n",
+    "\n",
+    "# read pickle file\n",
+    "tf = pd.DataFrame()\n",
+    "sf = pd.DataFrame()\n",
+    "af = pd.DataFrame()\n",
+    "\n",
+    "# load statistics files from nets\n",
+    "for net in nets:\n",
+    "    path = os.path.join(root_path, net, 'results')\n",
+    "    with open(os.path.join(path, 'trialframe.csv'), 'rb') as f:\n",
+    "        tf_temp = pd.read_csv(f, index_col=0)\n",
+    "    tf_temp['net'] = net\n",
+    "    tf = pd.concat([tf,tf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:\n",
+    "        sf_temp = pd.read_csv(f, index_col=0)\n",
+    "    sf_temp['net'] = net\n",
+    "    sf = pd.concat([sf,sf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:\n",
+    "        af_temp = pd.read_csv(f, index_col=0)\n",
+    "    af_temp['net'] = net\n",
+    "    af = pd.concat([af,af_temp])\n",
+    "\n",
+    "# cast variables\n",
+    "sf['visible'] = sf['visible'].astype(bool)\n",
+    "sf['bound'] = sf['bound'].astype(bool)\n",
+    "sf['occluder'] = sf['occluder'].astype(bool)\n",
+    "sf['inimage'] = sf['inimage'].astype(bool)\n",
+    "sf['vanishing'] = sf['vanishing'].astype(bool)\n",
+    "sf['alpha_pos'] = 1-sf['alpha_pos']\n",
+    "sf['alpha_ges'] = 1-sf['alpha_ges']\n",
+    "\n",
+    "# scale to percentage\n",
+    "sf['TE'] = sf['TE'] * 100\n",
+    "\n",
+    "# add surprise as dummy code\n",
+    "tf['control'] = [('control' in set) for set in tf['set']]\n",
+    "sf['control'] = [('control' in set)  for set in sf['set']]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Tracking Error (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tracking Error when visible: M: 1.75 , STD: 1.23, Count: 1563\n",
+      "Tracking Error when occluded: M: 2.09 , STD: 1.39, Count: 486\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "\n",
+    "def get_stats(col):\n",
+    "    return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'\n",
+    "\n",
+    "# When Visible\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Tracking Error when visible:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Occluded\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Tracking Error when occluded:' + get_stats(temp['TE']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Succesfull Trackings (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>set</th>\n",
+       "      <th>evalmode</th>\n",
+       "      <th>tracked_pos</th>\n",
+       "      <th>tracked_neg</th>\n",
+       "      <th>tracked_pos_pro</th>\n",
+       "      <th>tracked_neg_pro</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>control</td>\n",
+       "      <td>open</td>\n",
+       "      <td>47</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.979167</td>\n",
+       "      <td>0.020833</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       set evalmode  tracked_pos  tracked_neg  tracked_pos_pro  \\\n",
+       "0  control     open           47            1         0.979167   \n",
+       "\n",
+       "   tracked_neg_pro  \n",
+       "0         0.020833  "
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target\n",
+    "# determine last visible frame numeric\n",
+    "grouping_factors = ['net','set','evalmode','scene','slot']\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).max()\n",
+    "ff.rename(columns = {'frame':'last_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['last_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# same for first bound frame\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()\n",
+    "ff.rename(columns = {'frame':'first_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['first_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf['last_visible'] = (sf['last_visible'] == sf['frame'])\n",
+    "\n",
+    "# extract the trials where the target was last visible and threshold the TE\n",
+    "ff = sf[sf['last_visible']] \n",
+    "ff['tracked_pos'] = (ff['TE'] < 10)\n",
+    "ff['tracked_neg'] = (ff['TE'] >= 10)\n",
+    "\n",
+    "# fill NaN with 0\n",
+    "sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')\n",
+    "sf['tracked_pos'].fillna(False, inplace=True)\n",
+    "sf['tracked_neg'].fillna(False, inplace=True)\n",
+    "\n",
+    "# Aggreagte over all scenes\n",
+    "temp = sf[(sf['frame']== 1) & ~sf.occluder & sf.control & (sf.first_visible < 20)]\n",
+    "temp = temp.groupby(['set', 'evalmode']).sum()\n",
+    "temp = temp[['tracked_pos', 'tracked_neg']]\n",
+    "temp = temp.reset_index()\n",
+    "\n",
+    "temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "\n",
+    "temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mostly Tracked stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "temp = af[af.index == 'OVERALL']\n",
+    "temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']\n",
+    "temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']\n",
+    "temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']\n",
+    "g = temp[['mostly_tracked', 'partially_tracked', 'mostly_lost','set']].set_index(['set']).groupby(['set']).mean().plot(kind='bar', stacked=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MOTA "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>idf1</th>\n",
+       "      <th>idp</th>\n",
+       "      <th>idr</th>\n",
+       "      <th>recall</th>\n",
+       "      <th>precision</th>\n",
+       "      <th>num_unique_objects</th>\n",
+       "      <th>mostly_tracked</th>\n",
+       "      <th>partially_tracked</th>\n",
+       "      <th>mostly_lost</th>\n",
+       "      <th>num_false_positives</th>\n",
+       "      <th>num_misses</th>\n",
+       "      <th>num_switches</th>\n",
+       "      <th>num_fragmentations</th>\n",
+       "      <th>mota</th>\n",
+       "      <th>motp</th>\n",
+       "      <th>num_transfer</th>\n",
+       "      <th>num_ascend</th>\n",
+       "      <th>num_migrate</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>set</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>control</th>\n",
+       "      <td>0.793020</td>\n",
+       "      <td>0.965426</td>\n",
+       "      <td>0.672861</td>\n",
+       "      <td>0.675311</td>\n",
+       "      <td>0.968942</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>106.0</td>\n",
+       "      <td>1590.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>0.653257</td>\n",
+       "      <td>0.035403</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>surprise</th>\n",
+       "      <td>0.781989</td>\n",
+       "      <td>0.959484</td>\n",
+       "      <td>0.659911</td>\n",
+       "      <td>0.666244</td>\n",
+       "      <td>0.968692</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>527.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>0.643445</td>\n",
+       "      <td>0.034990</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              idf1       idp       idr    recall  precision  \\\n",
+       "set                                                           \n",
+       "control   0.793020  0.965426  0.672861  0.675311   0.968942   \n",
+       "surprise  0.781989  0.959484  0.659911  0.666244   0.968692   \n",
+       "\n",
+       "          num_unique_objects  mostly_tracked  partially_tracked  mostly_lost  \\\n",
+       "set                                                                            \n",
+       "control                 86.0            44.0               12.0         30.0   \n",
+       "surprise                33.0            13.0                7.0         13.0   \n",
+       "\n",
+       "          num_false_positives  num_misses  num_switches  num_fragmentations  \\\n",
+       "set                                                                           \n",
+       "control                 106.0      1590.0           2.0                37.0   \n",
+       "surprise                 34.0       527.0           2.0                11.0   \n",
+       "\n",
+       "              mota      motp  num_transfer  num_ascend  num_migrate  \n",
+       "set                                                                  \n",
+       "control   0.653257  0.035403           0.0         2.0          0.0  \n",
+       "surprise  0.643445  0.034990           0.0         2.0          0.0  "
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "af[af.index == 'OVERALL'].groupby(['set']).mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gate Openings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percept gate openings when visible: M: 0.257 , STD: 0.237, Count: 1563\n",
+      "Percept gate openings when occluded: M: 0.00921 , STD: 0.0524, Count: 486\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Percept gate openings when visible:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Percept gate openings when occluded:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "loci23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/evaluation/adept_ablation/recon/evaluation_loci_looped_recon.ipynb b/evaluation/adept_ablation/recon/evaluation_loci_looped_recon.ipynb
new file mode 100644
index 0000000..a6422e0
--- /dev/null
+++ b/evaluation/adept_ablation/recon/evaluation_loci_looped_recon.ipynb
@@ -0,0 +1,466 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import scipy.stats as stats\n",
+    "import os\n",
+    "\n",
+    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+    "pd.options.mode.chained_assignment = None \n",
+    "plt.style.use('ggplot')\n",
+    "sns.color_palette(\"Paired\");\n",
+    "sns.set_theme();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setting path to results folder\n",
+    "root_path = '../../../out/pretrained/adept_ablations/recon'\n",
+    "\n",
+    "# list all folders in root path that don't stat with a dot\n",
+    "nets = ['recon']\n",
+    "\n",
+    "# read pickle file\n",
+    "tf = pd.DataFrame()\n",
+    "sf = pd.DataFrame()\n",
+    "af = pd.DataFrame()\n",
+    "\n",
+    "# load statistics files from nets\n",
+    "for net in nets:\n",
+    "    path = os.path.join(root_path, net, 'results')\n",
+    "    with open(os.path.join(path, 'trialframe.csv'), 'rb') as f:\n",
+    "        tf_temp = pd.read_csv(f, index_col=0)\n",
+    "    tf_temp['net'] = net\n",
+    "    tf = pd.concat([tf,tf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:\n",
+    "        sf_temp = pd.read_csv(f, index_col=0)\n",
+    "    sf_temp['net'] = net\n",
+    "    sf = pd.concat([sf,sf_temp])\n",
+    "\n",
+    "    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:\n",
+    "        af_temp = pd.read_csv(f, index_col=0)\n",
+    "    af_temp['net'] = net\n",
+    "    af = pd.concat([af,af_temp])\n",
+    "\n",
+    "# cast variables\n",
+    "sf['visible'] = sf['visible'].astype(bool)\n",
+    "sf['bound'] = sf['bound'].astype(bool)\n",
+    "sf['occluder'] = sf['occluder'].astype(bool)\n",
+    "sf['inimage'] = sf['inimage'].astype(bool)\n",
+    "sf['vanishing'] = sf['vanishing'].astype(bool)\n",
+    "sf['alpha_pos'] = 1-sf['alpha_pos']\n",
+    "sf['alpha_ges'] = 1-sf['alpha_ges']\n",
+    "\n",
+    "# scale to percentage\n",
+    "sf['TE'] = sf['TE'] * 100\n",
+    "\n",
+    "# add surprise as dummy code\n",
+    "tf['control'] = [('control' in set) for set in tf['set']]\n",
+    "sf['control'] = [('control' in set)  for set in sf['set']]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Tracking Error (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tracking Error when visible: M: 2.95 , STD: 4.8, Count: 1686\n",
+      "Tracking Error when occluded: M: 2.54 , STD: 2.52, Count: 477\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "\n",
+    "def get_stats(col):\n",
+    "    return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'\n",
+    "\n",
+    "# When Visible\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Tracking Error when visible:' + get_stats(temp['TE']))\n",
+    "\n",
+    "# When Occluded\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Tracking Error when occluded:' + get_stats(temp['TE']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Succesfull Trackings (TE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>set</th>\n",
+       "      <th>evalmode</th>\n",
+       "      <th>tracked_pos</th>\n",
+       "      <th>tracked_neg</th>\n",
+       "      <th>tracked_pos_pro</th>\n",
+       "      <th>tracked_neg_pro</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>control</td>\n",
+       "      <td>open</td>\n",
+       "      <td>37</td>\n",
+       "      <td>9</td>\n",
+       "      <td>0.804348</td>\n",
+       "      <td>0.195652</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       set evalmode  tracked_pos  tracked_neg  tracked_pos_pro  \\\n",
+       "0  control     open           37            9         0.804348   \n",
+       "\n",
+       "   tracked_neg_pro  \n",
+       "0         0.195652  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target\n",
+    "# determine last visible frame numeric\n",
+    "grouping_factors = ['net','set','evalmode','scene','slot']\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).max()\n",
+    "ff.rename(columns = {'frame':'last_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['last_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# same for first bound frame\n",
+    "ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()\n",
+    "ff.rename(columns = {'frame':'first_visible'}, inplace = True)\n",
+    "sf = sf.merge(ff[['first_visible']], on=grouping_factors, how='left')\n",
+    "\n",
+    "# add dummy variable to sf\n",
+    "sf['last_visible'] = (sf['last_visible'] == sf['frame'])\n",
+    "\n",
+    "# extract the trials where the target was last visible and threshold the TE\n",
+    "ff = sf[sf['last_visible']] \n",
+    "ff['tracked_pos'] = (ff['TE'] < 10)\n",
+    "ff['tracked_neg'] = (ff['TE'] >= 10)\n",
+    "\n",
+    "# fill NaN with 0\n",
+    "sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')\n",
+    "sf['tracked_pos'].fillna(False, inplace=True)\n",
+    "sf['tracked_neg'].fillna(False, inplace=True)\n",
+    "\n",
+    "# Aggreagte over all scenes\n",
+    "temp = sf[(sf['frame']== 1) & ~sf.occluder & sf.control & (sf.first_visible < 20)]\n",
+    "temp = temp.groupby(['set', 'evalmode']).sum()\n",
+    "temp = temp[['tracked_pos', 'tracked_neg']]\n",
+    "temp = temp.reset_index()\n",
+    "\n",
+    "temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])\n",
+    "\n",
+    "temp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mostly Tracked stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "temp = af[af.index == 'OVERALL']\n",
+    "temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']\n",
+    "temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']\n",
+    "temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']\n",
+    "g = temp[['mostly_tracked', 'partially_tracked', 'mostly_lost','set']].set_index(['set']).groupby(['set']).mean().plot(kind='bar', stacked=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MOTA "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>idf1</th>\n",
+       "      <th>idp</th>\n",
+       "      <th>idr</th>\n",
+       "      <th>recall</th>\n",
+       "      <th>precision</th>\n",
+       "      <th>num_unique_objects</th>\n",
+       "      <th>mostly_tracked</th>\n",
+       "      <th>partially_tracked</th>\n",
+       "      <th>mostly_lost</th>\n",
+       "      <th>num_false_positives</th>\n",
+       "      <th>num_misses</th>\n",
+       "      <th>num_switches</th>\n",
+       "      <th>num_fragmentations</th>\n",
+       "      <th>mota</th>\n",
+       "      <th>motp</th>\n",
+       "      <th>num_transfer</th>\n",
+       "      <th>num_ascend</th>\n",
+       "      <th>num_migrate</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>set</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>control</th>\n",
+       "      <td>0.754576</td>\n",
+       "      <td>0.919577</td>\n",
+       "      <td>0.639779</td>\n",
+       "      <td>0.662855</td>\n",
+       "      <td>0.952744</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>161.0</td>\n",
+       "      <td>1651.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>0.627323</td>\n",
+       "      <td>0.037094</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>surprise</th>\n",
+       "      <td>0.790401</td>\n",
+       "      <td>0.968750</td>\n",
+       "      <td>0.667511</td>\n",
+       "      <td>0.667511</td>\n",
+       "      <td>0.968750</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>525.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>0.645978</td>\n",
+       "      <td>0.034979</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              idf1       idp       idr    recall  precision  \\\n",
+       "set                                                           \n",
+       "control   0.754576  0.919577  0.639779  0.662855   0.952744   \n",
+       "surprise  0.790401  0.968750  0.667511  0.667511   0.968750   \n",
+       "\n",
+       "          num_unique_objects  mostly_tracked  partially_tracked  mostly_lost  \\\n",
+       "set                                                                            \n",
+       "control                 86.0            38.0               18.0         30.0   \n",
+       "surprise                33.0            13.0                8.0         12.0   \n",
+       "\n",
+       "          num_false_positives  num_misses  num_switches  num_fragmentations  \\\n",
+       "set                                                                           \n",
+       "control                 161.0      1651.0          13.0                28.0   \n",
+       "surprise                 34.0       525.0           0.0                11.0   \n",
+       "\n",
+       "              mota      motp  num_transfer  num_ascend  num_migrate  \n",
+       "set                                                                  \n",
+       "control   0.627323  0.037094           0.0        12.0          0.0  \n",
+       "surprise  0.645978  0.034979           0.0         0.0          0.0  "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "af[af.index == 'OVERALL'].groupby(['set']).mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gate Openings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percept gate openings when visible: M: 0.223 , STD: 0.303, Count: 1686\n",
+      "Percept gate openings when occluded: M: 0.00995 , STD: 0.0471, Count: 477\n"
+     ]
+    }
+   ],
+   "source": [
+    "grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)\n",
+    "temp = sf[grouping & sf.visible]\n",
+    "print(f'Percept gate openings when visible:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))\n",
+    "temp = sf[grouping & ~sf.visible]\n",
+    "print(f'Percept gate openings when occluded:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "loci23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/model/loci.py b/model/loci.py
index 96088bd..46f89f7 100644
--- a/model/loci.py
+++ b/model/loci.py
@@ -66,11 +66,6 @@ class Loci(nn.Module):
         
         self.background = BackgroundEnhancer(
             input_size        = cfg.input_size,
-            gestalt_size      = cfg.background.gestalt_size,
-            img_channels      = cfg.img_channels,
-            depth             = cfg.background.num_layers, 
-            latent_channels   = cfg.background.latent_channels,
-            level1_channels   = cfg.background.level1_channels,
             batch_size        = cfg.batch_size,
         )
 
@@ -93,11 +88,16 @@ class Loci(nn.Module):
         self.modulator                         = ObjectModulator(cfg.num_objects)
         self.linear_gate                       = LinearInterpolation(cfg.num_objects)
 
-        self.background.set_level(cfg.level)
         self.encoder.set_level(cfg.level)
         self.decoder.set_level(cfg.level)
         self.initial_states.set_level(cfg.level)
 
+        # add flag option to enable/disable latent loss
+        if 'latent_loss_enabled' in cfg:
+            self.latent_loss_enabled = cfg.latent_loss_enabled
+        else:
+            self.latent_loss_enabled = False
+
     def get_init_status(self):
         init = []
         for module in self.modules():
@@ -133,9 +133,6 @@ class Loci(nn.Module):
         if reset:
             self.reset_state()
 
-        if train_background or self.get_init_status() < 1:
-            return self.background(*input)
-
         return self.run_end2end(*input, evaluate=evaluate, warmup=warmup, shuffleslots = shuffleslots, reset_mask = reset_mask, allow_spawn = allow_spawn, show_hidden = show_hidden, clean_slots = clean_slots)
 
     def run_decoder(
@@ -196,11 +193,12 @@ class Loci(nn.Module):
     ):
         position_loss = th.tensor(0, device=input.device)
         time_loss     = th.tensor(0, device=input.device)
+        latent_loss   = th.tensor(0, device=input.device)
         bg_mask       = None
         position_encoder = None
 
         if error_last is None or mask_last is None:
-            bg_mask = self.background(input, only_mask=True)
+            bg_mask = self.background(input)
             error_last = th.sqrt(reduce((input - background)**2, 'b c h w -> b 1 h w', 'mean')).detach()
 
         position_last, gestalt_last, priority_last, error_cur = self.initial_states(
@@ -214,7 +212,7 @@ class Loci(nn.Module):
         object_last_unprioritized = self.decoder(position_last, gestalt_last)[-1]
 
         # background and bg_mask for the next time point
-        bg_mask = self.background(input, error_last, mask_last[:,-1:], only_mask=True)
+        bg_mask = self.background(input)
 
         # position and gestalt for the current time point
         position_cur, gestalt_cur, priority_cur = self.encoder(input, error_last, mask_last, object_last_unprioritized, position_last, rawmask_last)
@@ -228,7 +226,7 @@ class Loci(nn.Module):
         slots_bounded,  slots_bounded_smooth, slots_occluded_cur, slots_partially_occluded_cur, slots_fully_visible_cur, slots_occlusionfactor_cur = self.occlusion_tracker(mask_cur, rawmask_cur, reset_mask)
 
         # do not project into the future in the warmup phase
-        slots_closed = th.ones_like(repeat(slots_bounded, 'b o -> b o c', c=2))
+        slots_closed = th.zeros_like(repeat(slots_bounded, 'b o -> b o c', c=2))
         if warmup:
             position_next = position_cur
             gestalt_next  = gestalt_cur
@@ -239,6 +237,7 @@ class Loci(nn.Module):
 
                 # update module
                 slots_closed =  (1-self.percept_gate_controller(position_cur, gestalt_cur, priority_cur, slots_occlusionfactor_cur, position_last, gestalt_last, priority_last, slots_occlusionfactor_last, self.position_last2, evaluate=evaluate))
+                #slots_closed = repeat(rearrange(slots_occlusionfactor_cur, 'b (o c) -> b o c', c=1), 'b o 1 -> b o 2')
 
                 position_cur = self.linear_gate(position_cur, position_last, slots_closed[:, :, 1])
                 priority_cur = self.linear_gate(priority_cur, priority_last, slots_closed[:, :, 1])
@@ -313,6 +312,10 @@ class Loci(nn.Module):
                     position_next.detach(),
                 )
 
+                # add latent loss: current perception as target for last prediction
+                if self.cfg.inner_loop_enabled and self.latent_loss_enabled:
+                    latent_loss = self.position_loss(position_cur.detach(), position_last, slots_bounded_smooth)
+
             return (
                 output_next, 
                 output_cur, 
@@ -326,6 +329,8 @@ class Loci(nn.Module):
                 slots_occlusionfactor_next,
                 position_loss,
                 time_loss,
-                slots_closed
+                latent_loss,
+                slots_closed,
+                slots_bounded
             )
 
diff --git a/model/nn/background.py b/model/nn/background.py
index 38ec325..ff14e02 100644
--- a/model/nn/background.py
+++ b/model/nn/background.py
@@ -14,154 +14,21 @@ class BackgroundEnhancer(nn.Module):
     def __init__(
         self, 
         input_size: Tuple[int, int], 
-        img_channels: int, 
-        level1_channels,
-        latent_channels,
-        gestalt_size,
         batch_size,
-        depth
     ):
         super(BackgroundEnhancer, self).__init__()
 
-        latent_size = [input_size[0] // 16, input_size[1] // 16]
-        self.input_size = input_size
-
-        self.register_buffer('init', th.zeros(1).long())
-        self.alpha = nn.Parameter(th.zeros(1)+1e-16)
-
-        self.level  = 1
-        self.down_level2 = nn.Sequential(
-            PatchDownConv(img_channels*2+2, level1_channels, alpha = 1e-16),
-            *[ResidualBlock(level1_channels, level1_channels, alpha_residual = True) for i in range(depth)]
-        )
-
-        self.down_level1 = nn.Sequential(
-            PatchDownConv(level1_channels, latent_channels, alpha = 1),
-            *[ResidualBlock(latent_channels, latent_channels, alpha_residual = False) for i in range(depth)]
-        )
-
-        self.down_level0 = nn.Sequential(
-            *[ResidualBlock(latent_channels, latent_channels) for i in range(depth)],
-            AggressiveConvToGestalt(latent_channels, gestalt_size, latent_size),
-            LambdaModule(lambda x: rearrange(x, 'b c 1 1 -> b c')),
-            Binarize(),
-        )
-
-        self.bias = nn.Parameter(th.zeros((1, gestalt_size, *latent_size)))
-
-        self.to_grid = nn.Sequential(
-            LinearResidual(gestalt_size, gestalt_size, input_relu = False),
-            LambdaModule(lambda x: rearrange(x, 'b c -> b c 1 1')),
-            LambdaModule(lambda x: x + self.bias),
-            *[ResidualBlock(gestalt_size, gestalt_size) for i in range(depth)],
-        )            
-
-
-        self.up_level0 = nn.Sequential(
-            ResidualBlock(gestalt_size, latent_channels),
-            *[ResidualBlock(latent_channels, latent_channels) for i in range(depth)],
-        )
-
-        self.up_level1 = nn.Sequential(
-            *[ResidualBlock(latent_channels, latent_channels, alpha_residual = False) for i in range(depth)],
-            PatchUpscale(latent_channels, level1_channels, alpha = 1),
-        )
-
-        self.up_level2 = nn.Sequential(
-            *[ResidualBlock(level1_channels, level1_channels, alpha_residual = True) for i in range(depth)],
-            PatchUpscale(level1_channels, img_channels, alpha = 1e-16),
-        )
-
-        self.to_channels = nn.ModuleList([
-            SkipConnection(img_channels*2+2, latent_channels),
-            SkipConnection(img_channels*2+2, level1_channels),
-            SkipConnection(img_channels*2+2, img_channels*2+2),
-        ])
-
-        self.to_img = nn.ModuleList([
-            SkipConnection(latent_channels, img_channels),
-            SkipConnection(level1_channels, img_channels),
-            SkipConnection(img_channels,    img_channels),
-        ])
-
+        self.batch_size = batch_size
+        self.height = input_size[0]
+        self.width  = input_size[1]
         self.mask   = nn.Parameter(th.ones(1, 1, *input_size) * 10)
-        self.object = nn.Parameter(th.ones(1, img_channels, *input_size))
-
-        self.register_buffer('latent', th.zeros((batch_size, gestalt_size)), persistent=False)
+        self.register_buffer('init', th.zeros(1).long())
 
     def get_init(self):
         return self.init.item()
-
-    def step_init(self):
-        self.init = self.init + 1
-
-    def detach(self):
-        self.latent = self.latent.detach()
-
-    def reset_state(self):
-        self.latent = th.zeros_like(self.latent)
-
-    def set_level(self, level):
-        self.level = level
-
-    def encoder(self, input):
-        latent = self.to_channels[self.level](input)
-
-        if self.level >= 2:
-            latent = self.down_level2(latent)
-
-        if self.level >= 1:
-            latent = self.down_level1(latent)
-
-        return self.down_level0(latent)
-
-    def get_last_latent_gird(self):
-        return self.to_grid(self.latent) * self.alpha
-
-    def decoder(self, latent, input):
-        grid   = self.to_grid(latent)
-        latent = self.up_level0(grid)
-
-        if self.level >= 1:
-            latent = self.up_level1(latent)
-
-        if self.level >= 2:
-            latent = self.up_level2(latent)
-
-        object = reduce(self.object, '1 c (h h2) (w w2) -> 1 c h w', 'mean', h = input.shape[2], w = input.shape[3])
-        object = repeat(object,      '1 c h w -> b c h w', b = input.shape[0])
-
-        return th.sigmoid(object + self.to_img[self.level](latent)), grid
-
-    def forward(self, input: th.Tensor, error: th.Tensor = None, mask: th.Tensor = None, only_mask: bool = False):
+    
+    def forward(self, input: th.Tensor):
         
-        if only_mask:
-            mask = reduce(self.mask, '1 1 (h h2) (w w2) -> 1 1 h w', 'mean', h = input.shape[2], w = input.shape[3])
-            mask = repeat(mask,      '1 1 h w -> b 1 h w', b = input.shape[0]) * 0.1
-            return mask
-
-        last_bg = self.decoder(self.latent, input)[0]
-
-        bg_error = th.sqrt(reduce((input - last_bg)**2, 'b c h w -> b 1 h w', 'mean')).detach()
-        bg_mask  = (bg_error < th.mean(bg_error) + th.std(bg_error)).float().detach()
-
-        if error is None or self.get_init() < 2:
-            error = bg_error
-
-        if mask is None or self.get_init() < 2:
-            mask = bg_mask
-
-        self.latent = self.encoder(th.cat((input, last_bg, error, mask), dim=1))
-
         mask = reduce(self.mask, '1 1 (h h2) (w w2) -> 1 1 h w', 'mean', h = input.shape[2], w = input.shape[3])
-        mask = repeat(mask,      '1 1 h w -> b 1 h w', b = input.shape[0]) * 0.1
-        
-        background, grid = self.decoder(self.latent, input)
-
-        if self.get_init() < 1:
-            return mask, background
-
-        if self.get_init() < 2:
-            return mask, th.zeros_like(background), th.zeros_like(grid), background
-
-        return mask, background, grid * self.alpha, background
+        mask = repeat(mask,      '1 1 h w -> b 1 h w', b = self.batch_size) * 0.1
+        return mask
diff --git a/model/nn/eprop_gate_l0rd.py b/model/nn/eprop_gate_l0rd.py
index 82a9895..c2473d1 100644
--- a/model/nn/eprop_gate_l0rd.py
+++ b/model/nn/eprop_gate_l0rd.py
@@ -49,7 +49,7 @@ class EpropGateL0rdFunction(Function):
             e_w_rx.clone(), e_w_rh.clone(), e_b_r.clone(), 
         )
 
-        return h, th.mean(H_g) 
+        return h, H_g
 
     @staticmethod
     def backward(ctx, dh, _):
@@ -169,6 +169,7 @@ class EpropGateL0rd(nn.Module):
         self.register_buffer("h_last", th.zeros(batch_size, num_hidden),             persistent=False)
 
         self.register_buffer("openings", th.zeros(1), persistent=False)
+        self.register_buffer("openings_perslot", th.zeros(batch_size), persistent=False)
 
         # initialize weights
         stdv_ih = np.sqrt(6/(self.num_inputs + self.num_hidden))
@@ -294,7 +295,7 @@ class EpropGateL0rdShared(EpropGateL0rd):
         return o * p, h_last
     
     def eprop_forward(self, x: th.Tensor, h_last: th.Tensor):
-        h, openings = self.fcn(
+        h, H_g = self.fcn(
             x, h_last,
             self.w_gx, self.w_gh, self.b_g, 
             self.w_rx, self.w_rh, self.b_r, 
@@ -305,7 +306,8 @@ class EpropGateL0rdShared(EpropGateL0rd):
             )
         )
 
-        self.openings = openings
+        self.openings = th.mean(H_g) 
+        self.openings_perslot =  th.mean(H_g, dim=1)
 
         p = th.tanh(x.mm(self.w_px.t()) + h.mm(self.w_ph.t()) + self.b_p)
         o = th.sigmoid(x.mm(self.w_ox.t()) + h.mm(self.w_oh.t()) + self.b_o)
diff --git a/model/nn/eprop_transformer.py b/model/nn/eprop_transformer.py
index 4d89ec4..d2341dd 100644
--- a/model/nn/eprop_transformer.py
+++ b/model/nn/eprop_transformer.py
@@ -35,13 +35,21 @@ class EpropGateL0rdTransformer(nn.Module):
 
         _layers.append(OutputEmbeding(num_hidden, num_outputs))
         self.layers = nn.Sequential(*_layers)
+        self.attention = []
+        self.l0rds = []
+        for l in self.layers: 
+            if 'AlphaAttention' in type(l).__name__:
+                self.attention.append(l)
+            elif 'EpropAlphaGateL0rd' in type(l).__name__:
+                self.l0rds.append(l)
 
     def get_openings(self):
-        openings = 0
+        openings = []
         for i in range(self.depth):
-            openings += self.layers[2 * (i + 1)].l0rd.openings.item()
+            openings.append(self.l0rds[i].l0rd.openings_perslot)
 
-        return openings / self.depth
+        openings = th.mean(th.stack(openings, dim=0), dim=0)
+        return openings
 
     def get_hidden(self):
         states = []
diff --git a/model/nn/eprop_transformer_shared.py b/model/nn/eprop_transformer_shared.py
index 23a1b0f..79223c1 100644
--- a/model/nn/eprop_transformer_shared.py
+++ b/model/nn/eprop_transformer_shared.py
@@ -39,11 +39,12 @@ class EpropGateL0rdTransformerShared(nn.Module):
         self.output_embeding = OutputEmbeding(num_hidden, num_outputs) 
 
     def get_openings(self):
-        openings = 0
+        openings = []
         for i in range(self.depth):
-            openings += self.l0rds[i].l0rd.openings.item()
+            openings.append(self.l0rds[i].l0rd.openings_perslot)
 
-        return openings / self.depth
+        openings = th.mean(th.stack(openings, dim=0), dim=0)
+        return openings
 
     def get_hidden(self):
         return self.hidden
diff --git a/model/nn/eprop_transformer_utils.py b/model/nn/eprop_transformer_utils.py
index 9e5e874..3219cd0 100644
--- a/model/nn/eprop_transformer_utils.py
+++ b/model/nn/eprop_transformer_utils.py
@@ -9,7 +9,8 @@ class AlphaAttention(nn.Module):
         num_hidden,
         num_objects,
         heads,
-        dropout = 0.0
+        dropout = 0.0,
+        need_weights = False
     ):
         super(AlphaAttention, self).__init__()
 
@@ -23,10 +24,13 @@ class AlphaAttention(nn.Module):
             dropout = dropout, 
             batch_first = True
         )
+        self.need_weights = need_weights
+        self.att_weights  = None
 
     def forward(self, x: th.Tensor):
         x = self.to_sequence(x)
-        x = x + self.alpha * self.attention(x, x, x, need_weights=False)[0]
+        att, self.att_weights = self.attention(x, x, x, need_weights=self.need_weights)
+        x = x + self.alpha * att
         return self.to_batch(x)
 
 class InputEmbeding(nn.Module):
diff --git a/model/nn/predictor.py b/model/nn/predictor.py
index 94f13b8..5f08de9 100644
--- a/model/nn/predictor.py
+++ b/model/nn/predictor.py
@@ -61,7 +61,9 @@ class LociPredictor(nn.Module):
         self.to_shared = LambdaModule(lambda x: rearrange(x, '(b o) c -> b (o c)', o=num_objects))
 
     def get_openings(self):
-        return self.predictor.get_openings()
+        openings = self.predictor.get_openings().detach()
+        openings = self.to_shared(openings[:, None])
+        return openings
 
     def get_hidden(self):
         return self.predictor.get_hidden()
@@ -69,6 +71,24 @@ class LociPredictor(nn.Module):
     def set_hidden(self, hidden):
         self.predictor.set_hidden(hidden)
 
+    def get_att_weights(self):
+        att_weights = []
+        for layer in self.predictor.attention:
+            if layer.att_weights is None:
+                return []
+            else:
+                att_weights.append(layer.att_weights)
+        att_weights = th.stack(att_weights)
+        return reduce(att_weights, 'l b o1 o2-> b o1 o2', 'mean')
+    
+    def enable_att_weights(self):
+        for layer in self.predictor.attention:
+            layer.need_weights = True
+
+    def disable_att_weights(self):
+        for layer in self.predictor.attention:
+            layer.need_weights = False
+
     def forward(
         self, 
         gestalt: th.Tensor, 
diff --git a/scripts/evaluation_adept.py b/scripts/evaluation_adept.py
index eab3ad9..b2a18c0 100644
--- a/scripts/evaluation_adept.py
+++ b/scripts/evaluation_adept.py
@@ -2,6 +2,7 @@ import torch as th
 from torch.utils.data import Dataset, DataLoader, Subset
 from torch import nn
 import os
+from scripts.utils.eval_adept import eval_adept
 from scripts.utils.plot_utils import plot_timestep
 from scripts.utils.configuration import Configuration
 from scripts.utils.io import init_device
@@ -21,10 +22,12 @@ def evaluate(cfg: Configuration, dataset: Dataset, file, n, plot_frequency= 1, p
     # Config
     cfg_net = cfg.model
     cfg_net.batch_size = 1
+    cfg_net.inner_loop_enabled = (cfg.max_updates > cfg.phases.start_inner_loop)
 
     # Load model 
     net = load_model(cfg, cfg_net, file, device)
     net.eval()
+    net.predictor.enable_att_weights()
 
     # Plot config
     object_view = True
@@ -216,7 +219,9 @@ def evaluate(cfg: Configuration, dataset: Dataset, file, n, plot_frequency= 1, p
 
                         # 4. Plot
                         if (t % plot_frequency == 0) and (i < plot_first_samples) and (t >= 0):
-                            plot_timestep(cfg, cfg_net, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, gt_positions_target_next, association_table, error_next, output_hidden, object_view, individual_views, statistics_complete_slots, statistics_batch, sequence_len, root_path, plot_path, t_index, t, i)
+                            att = net.predictor.get_att_weights()
+                            openings = net.get_openings()
+                            plot_timestep(cfg, cfg_net, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, gt_positions_target_next, association_table, error_next, output_hidden, object_view, individual_views, statistics_complete_slots, statistics_batch, sequence_len, root_path, plot_path, t_index, t, i, att= att, openings=openings)
                                 
                     # fill jumping statistics
                     statistics_complete_slots['vanishing'].extend(np.tile(slots_vanishing_memory.astype(int), t+1))
@@ -235,8 +240,11 @@ def evaluate(cfg: Configuration, dataset: Dataset, file, n, plot_frequency= 1, p
     pd.DataFrame(statistics_complete).to_csv(f'{root_path}/statistics/trialframe.csv')
     pd.DataFrame(statistics_complete_slots).to_csv(f'{root_path}/statistics/slotframe.csv')
     pd.DataFrame(acc_memory_complete).to_csv(f'{root_path}/statistics/accframe.csv')
+    
     if object_view and os.path.exists(f'{root_path}/tmp.jpg'):
         os.remove(f'{root_path}/tmp.jpg')
+
+    eval_adept(f'{root_path}/statistics')
     pass
 
 
@@ -309,6 +317,7 @@ def update_mota_acc(acc, gt_positions, estimated_positions, slots_bounded, cfg_n
 def calculate_tracking_error(gt_positions_target, gt_visibility_target, position_cur, cfg_num_slots, slots_bounded, slots_occluded_cur, association_table,  gt_occluder_mask):
 
     # tracking utils
+    gt_positions_target = gt_positions_target.clone()
     pdist = nn.PairwiseDistance(p=2).to(position_cur.device)
 
     # 1. association of newly bounded slots to ground truth objects
diff --git a/scripts/evaluation_adept_savi.py b/scripts/evaluation_adept_baselines.py
index 6a2d5c7..e5a8e7d 100644
--- a/scripts/evaluation_adept_savi.py
+++ b/scripts/evaluation_adept_baselines.py
@@ -5,15 +5,16 @@ import cv2
 import numpy as np
 import pandas as pd
 import os
-from data.datasets.ADEPT.dataset import AdeptDataset
 import motmetrics as mm
 from scripts.evaluation_adept import calculate_tracking_error, get_evaluation_sets, update_mota_acc
-from scripts.utils.eval_utils import setup_result_folders, store_statistics
+from scripts.utils.eval_utils import boxes_to_centroids, masks_to_boxes, setup_result_folders, store_statistics
 from scripts.utils.plot_utils import write_image
 
 FG_THRE = 0.95
 
-def evaluate(dataset: Dataset, file, n, plot_frequency= 1, plot_first_samples = 2):
+def evaluate(dataset: Dataset, file, n, model, plot_frequency= 1, plot_first_samples = 2):
+
+    assert model in ['savi', 'gswm']
 
     # read pkl file 
     masks_complete = pd.read_pickle(file)
@@ -21,8 +22,12 @@ def evaluate(dataset: Dataset, file, n, plot_frequency= 1, plot_first_samples =
     # plot config
     color_list = [[255,0,0], [0,255,0], [0,0,255], [255,255,0], [0,255,255], [255,0,255], [255,255,255]]
     dot_size = 2
-    skip_frames = 2
-    offset = 15
+    if model == 'savi':
+        skip_frames = 2
+        offset = 15
+    elif model == 'gswm':
+        skip_frames = 2
+        offset = 0
    
     # memory
     statistics_complete_slots = {'set': [], 'evalmode': [], 'scene': [], 'frame': [], 'slot':[], 'TE': [], 'visible': [], 'bound': [], 'occluder': [], 'inimage': [], 'slot_error': [], 'mask_size': [], 'rawmask_size': [],  'rawmask_size_hidden': [], 'alpha_pos': [], 'alpha_ges': [], 'object_id': []}
@@ -52,33 +57,53 @@ def evaluate(dataset: Dataset, file, n, plot_frequency= 1, plot_first_samples =
         tensor = tensor[:,range(0, tensor.shape[1], skip_frames)]
         sequence_len = tensor.shape[1]
 
-        # load data
-        masks = th.tensor(masks_complete['test'][f'control_{i}.mp4'])
-        masks_before_softmax = th.tensor(masks_complete['test_raw'][f'control_{i}.mp4'])
-
-        # calculate rawmasks
-        bg_mask = masks_before_softmax.mean(dim=1)
-        masks_raw = compute_maskraw(masks_before_softmax, bg_mask)
-        slots_bound = compute_slots_bound(masks_raw)
+        if model == 'savi':
+            # load data
+            masks = th.tensor(masks_complete['test'][f'control_{i}.mp4']) # N, O, 1, H, W
+            masks_before_softmax = th.tensor(masks_complete['test_raw'][f'control_{i}.mp4'])
+            imgs_model = None
+            recons_model = None
+
+            # calculate rawmasks
+            bg_mask = masks_before_softmax.mean(dim=1)
+            masks_raw = compute_maskraw(masks_before_softmax, bg_mask, n_slots=7)
+            slots_bound = compute_slots_bound(masks_raw)
+            
+        elif model == 'gswm':
+            # load data
+            masks = masks_complete[i]['visibility_mask'].squeeze(0)
+            masks_raw = masks_complete[i]['object_mask'].squeeze(0)
+            slots_bound = masks_complete[i]['z_pres'].squeeze(0)
+            slots_bound = (slots_bound > 0.9).float()
+
+            imgs_model = masks_complete[i]['imgs'].squeeze(0)
+            imgs_model[:] = imgs_model[:, [2,1,0]]
+            recons_model = masks_complete[i]['recon'].squeeze(0)
+            recons_model[:] = recons_model[:, [2,1,0]]
+
+            # consider only the first 7 slots
+            masks = masks[:,:7]
+            masks_raw = masks_raw[:,:7]
+            slots_bound = slots_bound[:,:7]
+        
+        n_slots = masks.shape[1]
 
         # threshold masks and calculate centroids
         masks_binary = (masks_raw > FG_THRE).float()
         masks2 = rearrange(masks_binary, 't o 1 h w -> (t o) h w')
         boxes = masks_to_boxes(masks2.long())
-        boxes = boxes.reshape(1, masks.shape[0], 7, 4)
+        boxes = boxes.reshape(1, masks.shape[0], n_slots, 4)
         centroids = boxes_to_centroids(boxes)
 
         # get rid of batch dimension
-        association_table = th.ones(7) * -1
+        association_table = th.ones(n_slots) * -1
 
         # iterate over frames
         for t_index in range(offset,min(sequence_len,masks.shape[0])):
 
             # move to next frame
             input  = tensor[:,t_index]
-            target = th.clip(tensor[:,t_index+1], 0, 1)
             gt_positions_target = gt_object_positions[:,t_index]
-            gt_positions_target_next = gt_object_positions[:,t_index+1]
             gt_visibility_target = gt_object_visibility[:,t_index]
 
             position_cur = centroids[t_index]
@@ -87,32 +112,32 @@ def evaluate(dataset: Dataset, file, n, plot_frequency= 1, plot_first_samples =
             slots_bound_cur = rearrange(slots_bound_cur, 'o c -> 1 (o c)')
 
             # calculate tracking error
-            tracking_error, tracking_error_perslot, association_table, slots_visible, slots_in_image, slots_occluder = calculate_tracking_error(gt_positions_target, gt_visibility_target, position_cur, 7, slots_bound_cur, None, association_table, gt_occluder_mask)
+            tracking_error, tracking_error_perslot, association_table, slots_visible, slots_in_image, slots_occluder = calculate_tracking_error(gt_positions_target, gt_visibility_target, position_cur, n_slots, slots_bound_cur, None, association_table, gt_occluder_mask)
 
             rawmask_size = reduce(masks_raw[t_index], 'o 1 h w-> 1 o', 'sum')
             mask_size = reduce(masks[t_index], 'o 1 h w-> 1 o', 'sum')
             
             statistics_complete_slots = store_statistics(statistics_complete_slots,
-                                                        ['control'] * 7,
-                                                        ['control'] * 7,
-                                                        [control_samples[i]] * 7,
-                                                        [t_index] * 7,
-                                                        range(7),
+                                                        ['control'] * n_slots,
+                                                        ['control'] * n_slots,
+                                                        [control_samples[i]] * n_slots,
+                                                        [t_index] * n_slots,
+                                                        range(n_slots),
                                                         tracking_error_perslot.cpu().numpy().flatten(),
                                                         slots_visible.cpu().numpy().flatten().astype(int),
                                                         slots_bound_cur.cpu().numpy().flatten().astype(int),
                                                         slots_occluder.cpu().numpy().flatten().astype(int),
                                                         slots_in_image.cpu().numpy().flatten().astype(int),
-                                                        [0] * 7,
+                                                        [0] * n_slots,
                                                         mask_size.cpu().numpy().flatten(),
                                                         rawmask_size.cpu().numpy().flatten(),
-                                                        [0] * 7,
-                                                        [0] * 7,
-                                                        [0] * 7,
+                                                        [0] * n_slots,
+                                                        [0] * n_slots,
+                                                        [0] * n_slots,
                                                         association_table[0].cpu().numpy().flatten().astype(int),
                                                         extend = True)
             
-            acc = update_mota_acc(acc, gt_positions_target, position_cur, slots_bound_cur, 7, gt_occluder_mask, slots_occluder, None)
+            acc = update_mota_acc(acc, gt_positions_target, position_cur, slots_bound_cur, n_slots, gt_occluder_mask, slots_occluder, None)
 
             # plot_option
             if (t_index % plot_frequency == 0) and (i < plot_first_samples) and (t_index >= 0):
@@ -141,7 +166,12 @@ def evaluate(dataset: Dataset, file, n, plot_frequency= 1, plot_first_samples =
                         slot_frame_single = mask.transpose((1,2,0)).repeat(3, axis=2)
                         slot_frame = np.concatenate((slot_frame, slot_frame_single), axis=1)
 
-                frame = np.concatenate((frame, slot_frame), axis=1)
+                if imgs_model is not None:
+                    frame_model = imgs_model[t_index].numpy().transpose(1,2,0)
+                    recon_model = recons_model[t_index].numpy().transpose(1,2,0)
+                    frame = np.concatenate((frame, frame_model, recon_model, slot_frame), axis=1)
+                else:
+                    frame = np.concatenate((frame, slot_frame), axis=1)
                 cv2.imwrite(f'{plot_path}object/objects-{i:04d}-{t_index:03d}.jpg', frame*255)
 
         acc_memory_eval.append(acc)
@@ -153,57 +183,6 @@ def evaluate(dataset: Dataset, file, n, plot_frequency= 1, plot_first_samples =
     pd.DataFrame(summary).to_csv(os.path.join(root_path, 'statistics' , 'accframe.csv'))
     pd.DataFrame(statistics_complete_slots).to_csv(os.path.join(root_path, 'statistics' , 'slotframe.csv'))
 
-def masks_to_boxes(masks: th.Tensor) -> th.Tensor:
-    """
-    Compute the bounding boxes around the provided masks.
-
-    Returns a [N, 4] tensor containing bounding boxes. The boxes are in ``(x1, y1, x2, y2)`` format with
-    ``0 <= x1 < x2`` and ``0 <= y1 < y2``.
-
-    Args:
-        masks (Tensor[N, H, W]): masks to transform where N is the number of masks
-            and (H, W) are the spatial dimensions.
-
-    Returns:
-        Tensor[N, 4]: bounding boxes
-    """
-    if masks.numel() == 0:
-        return th.zeros((0, 4), device=masks.device, dtype=th.float)
-
-    n = masks.shape[0]
-
-    bounding_boxes = th.zeros((n, 4), device=masks.device, dtype=th.float)
-
-    for index, mask in enumerate(masks):
-        if mask.sum() > 0:
-            y, x = th.where(mask != 0)
-
-            bounding_boxes[index, 0] = th.min(x)
-            bounding_boxes[index, 1] = th.min(y)
-            bounding_boxes[index, 2] = th.max(x)
-            bounding_boxes[index, 3] = th.max(y)
-
-    return bounding_boxes
-
-def boxes_to_centroids(boxes):
-    """Post-process masks instead of directly taking argmax.
-
-    Args:
-        bboxes: [B, T, N, 4], 4: [x1, y1, x2, y2]
-
-    Returns:
-        centroids: [B, T, N, 2], 2: [x, y]
-    """
-
-    centroids = (boxes[:, :, :, :2] + boxes[:, :, :, 2:]) / 2
-    centroids = centroids.squeeze(0)
-
-    # scale to [-1, 1]
-    centroids[:, :, 0] = centroids[:, :, 0] / 64 * 2 - 1
-    centroids[:, :, 1] = centroids[:, :, 1] / 64 * 2 - 1
-
-    return centroids
-
 def compute_slots_bound(masks):
 
     # take sum over axis 3,4 with th
@@ -211,7 +190,7 @@ def compute_slots_bound(masks):
     slots_bound = (masks_sum > FG_THRE).float()
     return slots_bound
 
-def compute_maskraw(mask, bg_mask):
+def compute_maskraw(mask, bg_mask, n_slots):
 
     # d is a diagonal matrix which defines what to take the softmax over
     d_mask = th.diag(th.ones(8))
@@ -224,7 +203,7 @@ def compute_maskraw(mask, bg_mask):
     maskraw = th.cat((mask, bg_mask), dim=1)
     maskraw = repeat(maskraw, 'b o h w -> b r o h w', r = 8)                 
     maskraw = maskraw[:,d_mask.bool()]
-    maskraw = rearrange(maskraw, 'b (o r) h w -> b o r h w', o = 7)
+    maskraw = rearrange(maskraw, 'b (o r) h w -> b o r h w', o = n_slots)
 
     # take softmax between each object mask and the background mask
     maskraw = th.squeeze(th.softmax(maskraw, dim=2)[:,:,0], dim=2)
diff --git a/scripts/evaluation_bb.py b/scripts/evaluation_bb.py
new file mode 100644
index 0000000..1d21cfe
--- /dev/null
+++ b/scripts/evaluation_bb.py
@@ -0,0 +1,385 @@
+import pickle
+import cv2
+import torch as th
+from torch.utils.data import Dataset, DataLoader, Subset
+from torch import nn
+import os
+from scripts.evaluation_adept import calculate_tracking_error
+from scripts.evaluation_clevrer import compute_statistics_summary
+from scripts.utils.plot_utils import plot_timestep
+from scripts.utils.eval_metrics import masks_to_boxes, pred_eval_step, postproc_mask
+from scripts.utils.eval_utils import append_statistics, compute_position_from_mask, load_model, setup_result_folders, store_statistics
+from scripts.utils.configuration import Configuration
+from scripts.utils.io import init_device
+import numpy as np
+from einops import rearrange, repeat, reduce
+from copy import deepcopy
+import lpips
+import torchvision.transforms as transforms
+import motmetrics as mm
+
+def evaluate(cfg: Configuration, dataset: Dataset, file, n, plot_first_samples = 0):
+
+    # Set up cpu or gpu training
+    device, verbose = init_device(cfg)
+
+    # Config 
+    cfg_net = cfg.model
+    cfg_net.batch_size = 2 if verbose else 32
+    #cfg_net.num_objects = 3
+    cfg_net.inner_loop_enabled = True
+    if 'num_objects_test' in cfg_net:
+        cfg_net.num_objects = cfg_net.num_objects_test
+    dataset = Subset(dataset, range(4)) if verbose else dataset
+    
+    # Load model 
+    net = load_model(cfg, cfg_net, file, device)
+    net.eval()
+    net.predictor.enable_att_weights()
+
+    # config
+    object_view = True
+    individual_views = False
+    root_path = None
+    use_meds = True
+
+    # get evaluation sets
+    set_test_array, evaluation_modes = get_evaluation_sets(dataset)
+
+    # memory
+    statistics_template = {'set': [], 'evalmode': [], 'scene': [], 'frame': [], 'image_error_mse': []}
+    statistics_complete_slots = {'set': [], 'evalmode': [], 'scene': [], 'frame': [], 'slot':[], 'bound': [], 'slot_error': [], 'rawmask_size': [], 'alpha_pos': [], 'alpha_ges': []}
+    metric_complete = None 
+
+    # Evaluation Specifics
+    burn_in_length = 10
+    rollout_length = 90
+    rollout_length_stats = 10 # only consider the first 10 frames for statistics
+    target_size = (64, 64)
+
+    # Losses
+    lpipsloss = lpips.LPIPS(net='vgg').to(device)
+    mseloss = nn.MSELoss()
+    
+    for set_test in set_test_array:
+        
+        for evaluation_mode in evaluation_modes:
+            print(f'Start evaluation loop: {evaluation_mode}')
+
+            # load data
+            dataloader = DataLoader(
+                dataset, 
+                num_workers = 0, 
+                pin_memory = False, 
+                batch_size = cfg_net.batch_size,
+                shuffle = False,
+                drop_last = True,
+            )
+
+            # memory
+            root_path, plot_path = setup_result_folders(file, n, set_test, evaluation_mode, object_view, individual_views)
+            metric_complete = {'mse': [], 'ssim': [], 'psnr': [], 'percept_dist': [], 'ari': [], 'fari': [], 'miou': [], 'ap': [], 'ar': [], 'meds': [], 'ari_hidden': [], 'fari_hidden': [], 'miou_hidden': []}
+            video_list = []
+
+            # set seed: if there is a number in the evaluation mode, use it as seed
+            plot_mode  = True
+            if evaluation_mode[-1].isdigit():
+                seed = int(evaluation_mode[-1])
+                th.manual_seed(seed)
+                np.random.seed(seed)
+                print(f'Set seed to {seed}')
+                if int(evaluation_mode[-1]) > 1:
+                    plot_mode = False
+
+            with th.no_grad():
+                for i, input in enumerate(dataloader):
+                    print(f'Processing sample {i+1}/{len(dataloader)}', flush=True)
+
+                    # Load data
+                    tensor = input[0].float().to(device)
+                    background_fix  = input[1].to(device)
+                    gt_pos          = input[2].to(device)
+                    gt_mask         = input[3].to(device)
+                    gt_pres_mask    = input[4].to(device)
+                    gt_hidden_mask  = input[5].to(device)
+                    sequence_len    = tensor.shape[1]
+
+                    # Placehodlers
+                    mask_cur       = None
+                    mask_last      = None
+                    rawmask_last   = None
+                    position_last  = None
+                    gestalt_last   = None
+                    priority_last  = None
+                    slots_occlusionfactor = None
+                    error_last  = None
+
+                    # Memory
+                    statistics_batch = deepcopy(statistics_template)
+                    pred_pos_batch        = th.zeros((cfg_net.batch_size, rollout_length, cfg_net.num_objects, 2)).to(device)
+                    gt_pos_batch          = th.zeros((cfg_net.batch_size, rollout_length, cfg_net.num_objects, 2)).to(device)
+                    pred_img_batch        = th.zeros((cfg_net.batch_size, rollout_length, 3, target_size[0], target_size[1])).to(device)
+                    gt_img_batch          = th.zeros((cfg_net.batch_size, rollout_length, 3, target_size[0], target_size[1])).to(device)
+                    pred_mask_batch       = th.zeros((cfg_net.batch_size, rollout_length, target_size[0], target_size[1])).to(device)
+                    pred_hidden_mask_batch       = th.zeros((cfg_net.batch_size, rollout_length, target_size[0], target_size[1])).to(device)
+
+                    # Counters
+                    num_rollout = 0
+                    num_burnin  = 0
+ 
+                    # Loop through frames
+                    for t_index,t in enumerate(range(-cfg.defaults.teacher_forcing, sequence_len-1)):
+
+                        # Move to next frame
+                        t_run = max(t, 0)
+                        input  = tensor[:,t_run]
+                        target_cur  = tensor[:,t_run]
+                        target = th.clip(tensor[:,t_run+1], 0, 1)
+                        gt_pos_t = gt_pos[:,t_run+1]/32-1
+                        gt_pos_t = th.concat((gt_pos_t, th.ones_like(gt_pos_t[:,:,:1])), dim=2)
+
+                        rollout_index = t_run - burn_in_length
+                        rollout_active = False
+                        if t>=0:
+                            if rollout_index >= 0:
+                                num_rollout += 1
+                                if ('vidpred_black' in evaluation_mode):
+                                    input = output_next * 0
+                                    rollout_active = True
+                                elif ('vidpred_auto' in evaluation_mode):
+                                    input = output_next
+                                    rollout_active = True
+                            else:
+                                num_burnin += 1  
+
+                        # obtain prediction
+                        (
+                            output_next, 
+                            position_next, 
+                            gestalt_next, 
+                            priority_next, 
+                            mask_next, 
+                            rawmask_next,
+                            object_next, 
+                            background, 
+                            slots_occlusionfactor,
+                            output_cur,
+                            position_cur,
+                            gestalt_cur,
+                            priority_cur,
+                            mask_cur,
+                            rawmask_cur,
+                            object_cur,
+                            position_encoder_cur,
+                            slots_bounded,
+                            slots_partially_occluded_cur,   
+                            slots_occluded_cur,
+                            slots_partially_occluded_next,
+                            slots_occluded_next,
+                            slots_closed,
+                            output_hidden,
+                            largest_object,
+                            rawmask_hidden,
+                            object_hidden
+                        ) = net(
+                            input, 
+                            error_last,
+                            mask_last, 
+                            rawmask_last,
+                            position_last, 
+                            gestalt_last,
+                            priority_last,
+                            background_fix,
+                            slots_occlusionfactor,
+                            reset = (t == -cfg.defaults.teacher_forcing),
+                            evaluate=True,
+                            warmup = (t < 0),
+                            shuffleslots = True,
+                            reset_mask = (t <= 0),
+                            allow_spawn = True,
+                            show_hidden = False,
+                            clean_slots = False,
+                        )
+
+                        # 1. Track error for plots
+                        if t >= 0:
+
+                            if (rollout_index >= 0):
+                                # store positions per batch
+                                if use_meds:
+                                    if False:
+                                        pred_pos_batch[:,rollout_index] = rearrange(position_next, 'b (o c) -> b o c', o=cfg_net.num_objects)[:,:,:2]
+                                    else:
+                                        pred_pos_batch[:,rollout_index] = compute_position_from_mask(rawmask_next)
+
+                                    gt_pos_batch[:,rollout_index] = gt_pos_t[:,:,:2]
+
+                                pred_img_batch[:,rollout_index] = output_next
+                                gt_img_batch[:,rollout_index] = target
+
+                                # Here we compute only the foreground segmentation mask
+                                pred_mask_batch[:,rollout_index] = postproc_mask(mask_next[:,None,:,None])[:, 0]
+
+                                # Here we compute the hidden segmentation
+                                occluded_cur        = th.clip(rawmask_next - mask_next, 0, 1)[:,:-1]
+                                occluded_sum_cur    = 1-(reduce(occluded_cur, 'b c h w -> b h w', 'max') > 0.5).float()
+                                occluded_cur        = th.cat((occluded_cur, occluded_sum_cur[:,None]), dim=1)
+                                pred_hidden_mask_batch[:,rollout_index] = postproc_mask(occluded_cur[:,None,:,None])[:, 0]
+
+                        # 2. Remember output
+                        mask_last     = mask_next.clone()
+                        rawmask_last  = rawmask_next.clone()
+                        position_last = position_next.clone()
+                        gestalt_last  = gestalt_next.clone()
+                        priority_last = priority_next.clone()
+                        
+                        # 3. Error for next frame
+                        bg_error_next = th.sqrt(reduce((target - background)**2, 'b c h w -> b 1 h w', 'mean')).detach()
+
+                        # prediction error
+                        error_next    = th.sqrt(reduce((target - output_next)**2, 'b c h w -> b 1 h w', 'mean')).detach()
+                        error_next    = th.sqrt(error_next) * bg_error_next
+                        error_last    = error_next.clone()
+
+                        # PLotting
+                        if i == 0 and plot_mode:
+                            att = net.predictor.get_att_weights()
+                            openings = net.get_openings()
+                            img_tensor = plot_timestep(cfg, cfg_net, input, target_cur, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, None, None, error_next, None, True, individual_views, None, None, sequence_len, root_path, None, t_index, t, i, rollout_mode=rollout_active, num_vid=plot_first_samples, att= att, openings=None)
+                            video_list.append(img_tensor)
+                            
+                    # log video
+                    if i == 0 and plot_mode:
+                        video_tensor = rearrange(th.stack(video_list, dim=0), 't b c h w -> b t h w c')
+                        save_videos(video_tensor, f'{plot_path}/object', verbose=verbose, trace_plot=True)
+
+                    # Compute prediction accuracy based on Slotformer metrics (ARI, FARI, mIoU, AP, AR)
+                    for b in range(cfg_net.batch_size):
+
+                        # perceptual similarity from slotformer paper
+                        metric_dict = pred_eval_step(
+                            gt              = gt_img_batch[b:b+1],
+                            pred            = pred_img_batch[b:b+1],
+                            pred_mask       = pred_mask_batch.long()[b:b+1],
+                            pred_mask_hidden = pred_hidden_mask_batch.long()[b:b+1],
+                            pred_bbox       = None,
+                            gt_mask         = gt_mask.long()[b:b+1, burn_in_length+1:],
+                            gt_mask_hidden  = gt_hidden_mask.long()[b:b+1, burn_in_length+1:],
+                            gt_pres_mask    = gt_pres_mask[b:b+1, burn_in_length+1:], 
+                            gt_bbox         = None,
+                            lpips_fn        = lpipsloss,
+                            eval_traj       = True,
+                        )
+
+                        metric_dict['meds'] = distance_eval_step(gt_pos_batch[b], pred_pos_batch[b])
+                        metric_complete = append_statistics(metric_dict, metric_complete)
+
+                    # sanity check
+                    if (num_rollout != rollout_length) and (num_burnin != burn_in_length) and ('vidpred' in evaluation_mode):
+                        raise ValueError('Number of rollout steps and burnin steps must be equal to the sequence length.')
+                    
+
+            average_dic = compute_statistics_summary(metric_complete, evaluation_mode, root_path=root_path, consider_first_n_frames=rollout_length_stats)
+
+            # Store statistics
+            with open(os.path.join(f'{root_path}/statistics', f'{evaluation_mode}_metric_complete.pkl'), 'wb') as f:
+                pickle.dump(metric_complete, f)
+            with open(os.path.join(f'{root_path}/statistics', f'{evaluation_mode}_metric_average.pkl'), 'wb') as f:
+                pickle.dump(average_dic, f)
+
+    print('-- Evaluation Done --')
+    if object_view and os.path.exists(f'{root_path}/tmp.jpg'):
+        os.remove(f'{root_path}/tmp.jpg')
+    pass
+
+# store videos as jpgs and then use ffmpeg to convert to video
+def save_videos(video_tensor, plot_path, verbose=False, fps=10, trace_plot=False):
+    video_tensor = video_tensor.cpu().numpy()
+    img_path = plot_path + '/img'
+    for b in range(video_tensor.shape[0]):
+        os.makedirs(img_path, exist_ok=True)
+        video = video_tensor[b]
+        video = (video).astype(np.uint8)
+        for t in range(video.shape[0]):
+            cv2.imwrite(f'{img_path}/{b}_{t:04d}.jpg', video[t])
+
+        if verbose:
+            os.system(f"ffmpeg -r {fps} -pattern_type glob -i '{img_path}/*.jpg'  -c:v libx264 -y {plot_path}/{b}.mp4")
+            os.system(f'rm -rf {img_path}')
+
+        if trace_plot:
+            # trace plot
+            start = 15
+            length = 20
+            frame = np.zeros_like(video[0])
+            for i in range(start,start+length):
+                current = video[i] * (0.1 + (i-start)/length)
+                frame = np.max(np.stack((frame, current)), axis=0)
+            cv2.imwrite(f'{plot_path}/{b}_trace.jpg', frame)
+
+
+def distance_eval_step(gt_pos, pred_pos):
+    meds_per_timestep = []
+    gt_pred_pairings = None
+    for t in range(pred_pos.shape[0]):
+        frame_gt = gt_pos[t].cpu().numpy()
+        frame_pred = pred_pos[t].cpu().numpy()
+        frame_gt = (frame_gt + 1) * 0.5
+        frame_pred = (frame_pred + 1) * 0.5
+
+        distances = mm.distances.norm2squared_matrix(frame_gt, frame_pred, max_d2=1)
+        if gt_pred_pairings is None:
+            frame_gt_ids = list(range(frame_gt.shape[0]))
+            frame_pred_ids = list(range(frame_pred.shape[0]))
+            gt_pred_pairings = [(frame_gt_ids[g], frame_pred_ids[p]) for g, p in zip(*mm.lap.linear_sum_assignment(distances))]
+
+        med = 0
+        for gt_id, pred_id in gt_pred_pairings:
+            curr_med = np.sqrt(((frame_gt[gt_id] - frame_pred[pred_id])**2).sum())
+            med += curr_med
+        if len(gt_pred_pairings) > 0:
+            meds_per_timestep.append(med / len(gt_pred_pairings))
+        else:
+            meds_per_timestep.append(np.nan)
+    return meds_per_timestep
+
+
+def compute_plot_statistics(cfg_net, statistics_complete_slots, mseloss, set_test, evaluation_mode, i, statistics_batch, t, target, output_next, mask_next, slots_bounded, slots_closed, rawmask_hidden):
+    statistics_batch = store_statistics(statistics_batch,
+                                                                set_test['type'],
+                                                                evaluation_mode,
+                                                                set_test['samples'][i],
+                                                                t,
+                                                                mseloss(output_next, target).item()
+                                                                )
+
+    # compute slot-wise prediction error
+    output_slot = repeat(mask_next[:,:-1], 'b o h w -> b o 3 h w') * repeat(output_next, 'b c h w -> b o c h w', o=cfg_net.num_objects)
+    target_slot = repeat(mask_next[:,:-1], 'b o h w -> b o 3 h w') * repeat(target, 'b c h w -> b o c h w', o=cfg_net.num_objects)
+    slot_error = reduce((output_slot - target_slot)**2, 'b o c h w -> b o', 'mean')
+
+    # compute rawmask_size
+    rawmask_size = reduce(rawmask_hidden[:, :-1], 'b o h w-> b o', 'sum')
+
+    statistics_complete_slots = store_statistics(statistics_complete_slots,
+                                                                            [set_test['type']] * cfg_net.num_objects,
+                                                                            [evaluation_mode] * cfg_net.num_objects,
+                                                                            [set_test['samples'][i]] * cfg_net.num_objects,
+                                                                            [t] * cfg_net.num_objects,
+                                                                            range(cfg_net.num_objects),
+                                                                            slots_bounded.cpu().numpy().flatten().astype(int),
+                                                                            slot_error.cpu().numpy().flatten(),
+                                                                            rawmask_size.cpu().numpy().flatten(),
+                                                                            slots_closed[:, :, 1].cpu().numpy().flatten(),
+                                                                            slots_closed[:, :, 0].cpu().numpy().flatten(),
+                                                                            extend = True)
+                                                
+    return statistics_complete_slots,statistics_batch
+
+def get_evaluation_sets(dataset):
+
+    set = {"samples": np.arange(len(dataset), dtype=int), "type": "test"}
+    evaluation_modes = ['open', 'vidpred_auto', 'vidpred_black_1', 'vidpred_black_2', 'vidpred_black_3', 'vidpred_black_4', 'vidpred_black_5'] # use 'open' for no blackouts
+    set_test_array = [set]
+
+    return set_test_array, evaluation_modes
diff --git a/scripts/evaluation_clevrer.py b/scripts/evaluation_clevrer.py
index a43d50c..168fba3 100644
--- a/scripts/evaluation_clevrer.py
+++ b/scripts/evaluation_clevrer.py
@@ -237,7 +237,7 @@ def evaluate(cfg: Configuration, dataset: Dataset, file, n, plot_frequency= 1, p
                         raise ValueError('Number of rollout steps and burnin steps must be equal to the sequence length.')
 
             if not plotting_mode:
-                average_dic = compute_statistics_summary(metric_complete, evaluation_mode)
+                average_dic = compute_statistics_summary(metric_complete, evaluation_mode, root_path=root_path)
 
                 # Store statistics
                 with open(os.path.join(f'{root_path}/statistics', f'{evaluation_mode}_metric_complete.pkl'), 'wb') as f:
@@ -250,24 +250,45 @@ def evaluate(cfg: Configuration, dataset: Dataset, file, n, plot_frequency= 1, p
         os.remove(f'{root_path}/tmp.jpg')
     pass
 
-def compute_statistics_summary(metric_complete, evaluation_mode):
+def compute_statistics_summary(metric_complete, evaluation_mode, root_path=None, consider_first_n_frames = None):
+    string = ''
+    def add_text(string, text, last=False):
+        string = string + ' \n ' + text
+        return string
+
     average_dic = {}
+    if consider_first_n_frames is not None:
+        for key in metric_complete:
+            for sample in range(len(metric_complete[key])):
+                metric_complete[key][sample] = metric_complete[key][sample][:consider_first_n_frames]
+
     for key in metric_complete:
                     # take average over all frames
-        average_dic[key + 'complete_average'] = np.mean(metric_complete[key])
-        average_dic[key + 'complete_std']     = np.std(metric_complete[key])
-        print(f'{key} complete average: {average_dic[key + "complete_average"]:.4f} +/- {average_dic[key + "complete_std"]:.4f}')
+        average_dic[key + '_complete_average']   = np.mean(metric_complete[key])
+        average_dic[key + '_complete_std']       = np.std(metric_complete[key])
+        average_dic[key + '_complete_sum']       = np.sum(np.mean(metric_complete[key], axis=0)) # checked with GSWM code!
+        string = add_text(string, f'{key} complete average: {average_dic[key + "_complete_average"]:.4f} +/- {average_dic[key + "_complete_std"]:.4f} (sum: {average_dic[key + "_complete_sum"]:.4f})')
+        #print(f'{key} complete average: {average_dic[key + "complete_average"]:.4f} +/- {average_dic[key + "complete_std"]:.4f} (sum: {average_dic[key + "complete_sum"]:.4f})')
 
         if evaluation_mode == 'blackout':
-                        # take average only for frames where blackout occurs
+            # take average only for frames where blackout occurs
             blackout_mask = np.array(metric_complete['blackout']) > 0
-            average_dic[key + 'blackout_average'] = np.mean(np.array(metric_complete[key])[blackout_mask])
-            average_dic[key + 'blackout_std']     = np.std(np.array(metric_complete[key])[blackout_mask])
-            average_dic[key + 'visible_average']  = np.mean(np.array(metric_complete[key])[blackout_mask == False])
-            average_dic[key + 'visible_std']      = np.std(np.array(metric_complete[key])[blackout_mask == False])
+            average_dic[key + '_blackout_average'] = np.mean(np.array(metric_complete[key])[blackout_mask])
+            average_dic[key + '_blackout_std']     = np.std(np.array(metric_complete[key])[blackout_mask])
+            average_dic[key + '_visible_average']  = np.mean(np.array(metric_complete[key])[blackout_mask == False])
+            average_dic[key + '_visible_std']      = np.std(np.array(metric_complete[key])[blackout_mask == False])
     
-            print(f'{key} blackout average: {average_dic[key + "blackout_average"]:.4f} +/- {average_dic[key + "blackout_std"]:.4f}')
-            print(f'{key} visible average: {average_dic[key + "visible_average"]:.4f} +/- {average_dic[key + "visible_std"]:.4f}')
+            #print(f'{key} blackout average: {average_dic[key + "blackout_average"]:.4f} +/- {average_dic[key + "blackout_std"]:.4f}')
+            #print(f'{key} visible average: {average_dic[key + "visible_average"]:.4f} +/- {average_dic[key + "visible_std"]:.4f}')
+            string = add_text(string, f'{key} blackout average: {average_dic[key + "_blackout_average"]:.4f} +/- {average_dic[key + "_blackout_std"]:.4f}')
+            string = add_text(string, f'{key} visible average: {average_dic[key + "_visible_average"]:.4f} +/- {average_dic[key + "_visible_std"]:.4f}')
+
+    print(string)
+    if root_path is not None:
+        f'{root_path}/statistics', f'{evaluation_mode}_metric_complete.pkl'
+        with open(os.path.join(f'{root_path}/statistics', f'{evaluation_mode}_metric_average.txt'), 'w') as f:
+            f.write(string)
+
     return average_dic
 
 def compute_plot_statistics(cfg_net, statistics_complete_slots, mseloss, set_test, evaluation_mode, i, statistics_batch, t, target, output_next, mask_next, slots_bounded, slots_closed, rawmask_hidden):
diff --git a/scripts/exec/eval.py b/scripts/exec/eval.py
index 96ed32d..bc461ec 100644
--- a/scripts/exec/eval.py
+++ b/scripts/exec/eval.py
@@ -1,10 +1,29 @@
 import argparse
 import sys
 from data.datasets.ADEPT.dataset import AdeptDataset
+from data.datasets.BOUNCINGBALLS.dataset import BouncingBallDataset
 from data.datasets.CLEVRER.dataset import ClevrerDataset, ClevrerSample, RamImage
 from scripts.utils.configuration import Configuration
-from scripts import evaluation_adept, evaluation_clevrer
+from scripts import evaluation_adept, evaluation_clevrer, evaluation_bb
 
+def main(load, n, cfg):
+    
+    size = (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2))
+
+     # Load dataset
+    if cfg.datatype == "clevrer":
+        testset  = ClevrerDataset("./", cfg.dataset, 'val', size, use_slotformer=True, evaluation=True)
+        evaluation_clevrer.evaluate(cfg, testset, load, n, plot_frequency= 2, plot_first_samples = 3) # only plotting
+        evaluation_clevrer.evaluate(cfg, testset, load, n, plot_first_samples = 0) # evaluation
+    elif cfg.datatype == "adept":
+        testset = AdeptDataset("./", cfg.dataset, 'createdown',  size)
+        evaluation_adept.evaluate(cfg, testset, load, n, plot_frequency= 1, plot_first_samples = 2)
+    elif cfg.datatype == "bouncingballs":
+        testset   = BouncingBallDataset("./", cfg.dataset, "test", size, type_name = cfg.scenario)
+        evaluation_bb.evaluate(cfg, testset, load, n, plot_first_samples = 4)
+    else:
+        raise Exception("Dataset not supported")
+    
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-cfg", default="", help='path to the configuration file')
@@ -16,13 +35,4 @@ if __name__ == "__main__":
     cfg = Configuration(args.cfg)
     print(f'Evaluating model {args.load}')
 
-    # Load dataset
-    if cfg.datatype == "clevrer":
-        testset  = ClevrerDataset("./", cfg.dataset, 'val', (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2)), use_slotformer=True, evaluation=True)
-        evaluation_clevrer.evaluate(cfg, testset, args.load, args.n, plot_frequency= 2, plot_first_samples = 3) # only plotting
-        evaluation_clevrer.evaluate(cfg, testset, args.load, args.n, plot_first_samples = 0) # evaluation
-    elif cfg.datatype == "adept":
-        testset = AdeptDataset("./", cfg.dataset, 'createdown',  (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2)))
-        evaluation_adept.evaluate(cfg, testset, args.load, args.n, plot_frequency= 1, plot_first_samples = 2)
-    else:
-        raise Exception("Dataset not supported")
-\ No newline at end of file
+    main(args.load, args.n, cfg)
+\ No newline at end of file
diff --git a/scripts/exec/eval_savi.py b/scripts/exec/eval_baselines.py
index 87d4e59..9e451ab 100644
--- a/scripts/exec/eval_savi.py
+++ b/scripts/exec/eval_baselines.py
@@ -1,12 +1,13 @@
 import argparse
 import sys
 from data.datasets.ADEPT.dataset import AdeptDataset
-from scripts.evaluation_adept_savi import evaluate
+from scripts.evaluation_adept_baselines import evaluate
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-load", default="", type=str, help='path to savi slots')
     parser.add_argument("-n", default="", type=str, help='results name')
+    parser.add_argument("-model", default="", type=str, help='model, either savi or gswm')
 
     # Load configuration
     args = parser.parse_args(sys.argv[1:])
@@ -14,4 +15,4 @@ if __name__ == "__main__":
 
     # Load dataset
     testset = AdeptDataset("./", 'adept', 'createdown',  (30 * 2**(2*2), 20 * 2**(2*2)))
-    evaluate(testset, args.load, args.n, plot_frequency= 1, plot_first_samples = 2)
-\ No newline at end of file
+    evaluate(testset, args.load, args.n, args.model, plot_frequency= 1, plot_first_samples = 2)
+\ No newline at end of file
diff --git a/scripts/exec/train.py b/scripts/exec/train.py
index f6e78fd..6fa6176 100644
--- a/scripts/exec/train.py
+++ b/scripts/exec/train.py
@@ -4,6 +4,8 @@ from scripts.utils.configuration import Configuration
 from scripts import training
 from data.datasets.CLEVRER.dataset import ClevrerDataset, ClevrerSample, RamImage
 from data.datasets.ADEPT.dataset import AdeptDataset
+from data.datasets.BOUNCINGBALLS.dataset import BouncingBallDataset
+from scripts import evaluation_adept, evaluation_clevrer, evaluation_bb
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
@@ -20,12 +22,17 @@ if __name__ == "__main__":
     print(f'Training model {cfg.model_path}')
 
     # Load dataset
+    size = (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2))
     if cfg.datatype == "clevrer":
-        trainset = ClevrerDataset("./", cfg.dataset, "train", (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2)), use_slotformer=False)
-        valset   = ClevrerDataset("./", cfg.dataset, "val", (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2)), use_slotformer=True)
+        trainset = ClevrerDataset("./", cfg.dataset, "train", size, use_slotformer=False)
+        valset   = ClevrerDataset("./", cfg.dataset, "val", size, use_slotformer=True)
     elif cfg.datatype == "adept":
-        trainset = AdeptDataset("./", cfg.dataset, "train", (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2)))
-        valset   = AdeptDataset("./", cfg.dataset, "test",  (cfg.model.latent_size[1] * 2**(cfg.model.level*2), cfg.model.latent_size[0] * 2**(cfg.model.level*2)))
+        trainset = AdeptDataset("./", cfg.dataset, "train", size)
+        valset   = AdeptDataset("./", cfg.dataset, "test",  size)
+        valset.train = True
+    elif cfg.datatype == "bouncingballs":
+        trainset = BouncingBallDataset("./", cfg.dataset, "train", size,  type_name = cfg.scenario)
+        valset   = BouncingBallDataset("./", cfg.dataset, "val",   size,  type_name = cfg.scenario)
     else:
         raise Exception("Dataset not supported")
     
diff --git a/scripts/training.py b/scripts/training.py
index b807e54..fd4a4bf 100644
--- a/scripts/training.py
+++ b/scripts/training.py
@@ -1,3 +1,4 @@
+from copy import deepcopy
 import torch as th
 from torch import nn
 from torch.utils.data import Dataset, DataLoader, Subset
@@ -5,15 +6,18 @@ import cv2
 import numpy as np
 import os
 from einops import rearrange, repeat, reduce
-from scripts.utils.configuration import Configuration
-from scripts.utils.io import init_device, model_path, LossLogger
+from scripts.utils.configuration import Configuration, Dict
+from scripts.utils.io import WriterWrapper, init_device, model_path, LossLogger
 from scripts.utils.optimizers import RAdam
 from model.loci import Loci
 import random
 from scripts.utils.io import Timer
-from scripts.utils.plot_utils import color_mask
-from scripts.validation import validation_clevrer, validation_adept
+from scripts.utils.plot_utils import color_mask, plot_timestep
+from scripts.validation import validation_bb, validation_clevrer, validation_adept
+from scripts.exec.eval import main as eval_main
 
+os.environ["WANDB__SERVICE_WAIT"] = "300"
+os.environ["WANDB_ DISABLE_SERVICE"] = "true"
 
 def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
 
@@ -21,6 +25,12 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
     device, verbose = init_device(cfg)
     if verbose:
         valset = Subset(valset, range(0, 8))
+    use_wandb = (verbose == False)
+
+    # generate random seed if not set
+    if not ('seed' in cfg.defaults):
+        cfg.defaults['seed'] = random.randint(0, 100)
+    th.manual_seed(cfg.defaults.seed)
 
     # Define model path
     path = model_path(cfg, overwrite=False)
@@ -34,12 +44,16 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
         teacher_forcing    = cfg.defaults.teacher_forcing
     )
     net = net.to(device=device)
+    #net = th.compile(net)
+    #net = th.jit.script(net) 
 
     # Log model size
     log_modelsize(net)
+    writer = WriterWrapper(use_wandb, cfg)
 
     # Init Optimizers
     optimizer_init, optimizer_encoder, optimizer_decoder, optimizer_predictor, optimizer_background, optimizer_update = init_optimizer(cfg, net)
+    scheduler = init_lr_scheduler_StepLR(cfg, optimizer_init, optimizer_encoder, optimizer_decoder, optimizer_predictor, optimizer_background, optimizer_update)
 
     # Option to load model
     if file != "":
@@ -58,9 +72,8 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
         print(f'loaded {file}', flush=True)
 
     # Set up data loaders
-    trainloader = get_loader(cfg, trainset, cfg_net, shuffle=True)
-    valset.train = True #valset.dataset.train = True
-    valloader = get_loader(cfg, valset, cfg_net, shuffle=False)
+    trainloader = get_loader(cfg, trainset, cfg_net, shuffle=True, verbose=verbose)
+    valloader = get_loader(cfg, valset, cfg_net, shuffle=False, verbose=verbose)
 
     # initial save    
     save_model(
@@ -80,16 +93,24 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
         print('!!! Net init status: ', net.get_init_status())
 
     # Set up statistics
-    loss_tracker = LossLogger()
+    loss_tracker = LossLogger(writer)
+
+    # Init loss function
+    imageloss = initialize_loss_function(cfg)
 
     # Set up training variables
     num_time_steps = 0
     bptt_steps = cfg.bptt.bptt_steps
+    if not 'plot_interval' in cfg.defaults:
+        cfg.defaults.plot_interval = 20000
+    blackout_rate = cfg.blackout.blackout_rate if ('blackout' in cfg) else 0.0
+    rollout_length = cfg.vp.rollout_length if ('vp' in cfg) else 0
+    burnin_length = cfg.vp.burnin_length if ('vp' in cfg) else 0
     increase_bptt_steps = False
     background_blendin_factor = 0.0
     th.backends.cudnn.benchmark = True
+    plot_next_sample = False
     timer = Timer()
-    bceloss    = nn.BCELoss()
 
     # Init net to current num_updates
     if num_updates >= cfg.phases.background_pretraining_end and net.get_init_status() < 1:
@@ -101,7 +122,7 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
     if num_updates >= cfg.phases.entity_pretraining_phase2_end and net.get_init_status() < 3:
         net.inc_init_level()
         for param in optimizer_init.param_groups:
-            param['lr'] = cfg.learning_rate
+            param['lr'] = cfg.learning_rate.lr
 
     if num_updates > cfg.phases.start_inner_loop:
         net.cfg.inner_loop_enabled = True
@@ -117,16 +138,18 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
         # Validation every epoch
         if epoch >= 0:
             if cfg.datatype == 'adept':
-                validation_adept(valloader, net, cfg, device)
+                validation_adept(valloader, net, cfg, device, writer, epoch, path)
             elif cfg.datatype == 'clevrer':
-                validation_clevrer(valloader, net, cfg, device)
+                validation_clevrer(valloader, net, cfg, device, writer, epoch, path)
+            elif cfg.datatype == "bouncingballs" and (epoch % 2 == 0):
+                validation_bb(valloader, net, cfg, device, writer, epoch, path)
 
         # Start epoch training
         print('Start epoch:', epoch)
 
         # Backprop through time steps
         if increase_bptt_steps:
-            bptt_steps = max(bptt_steps + 1, cfg.bptt.bptt_steps_max)
+            bptt_steps = min(bptt_steps + 1, cfg.bptt.bptt_steps_max)
             print('Increase closed loop steps to', bptt_steps)
         increase_bptt_steps = False
 
@@ -149,7 +172,8 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
             slots_occlusionfactor = None
 
             # Apply skip frames to sequence
-            selec = range(random.randrange(cfg.defaults.skip_frames), tensor.shape[1], cfg.defaults.skip_frames)
+            start = random.randrange(cfg.defaults.skip_frames) if rollout_length == 0 else random.randrange(0, (tensor.shape[1]-(rollout_length+burnin_length)))
+            selec = range(start, tensor.shape[1], cfg.defaults.skip_frames)
             tensor = tensor[:,selec]
             sequence_len = tensor.shape[1]
 
@@ -159,6 +183,12 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
             target     = th.clip(input, 0, 1).detach()
             error_last = None
 
+            # plotting mode
+            plot_this_sample = plot_next_sample
+            plot_next_sample = False
+            video_list = []
+            num_rollout = 0
+
             # First apply teacher forcing for the first x frames
             for t in range(-cfg.defaults.teacher_forcing, sequence_len-1):
 
@@ -185,13 +215,27 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
                     if net.get_init_status() > 2 and cfg.defaults.error_dropout > 0 and np.random.rand() < cfg.defaults.error_dropout:
                         error_last = th.zeros_like(error_last)
 
-                    # Apply sensation blackout when training clevrere
-                    if net.cfg.inner_loop_enabled and cfg.datatype == 'clevrer':
-                        if t >= 10:
-                            blackout    = th.tensor((np.random.rand(cfg_net.batch_size) < 0.2)[:,None,None,None]).float().to(device)
+                    # Apply sensation blackout when training clevrer
+                    if net.cfg.inner_loop_enabled and blackout_rate > 0:
+                        if t >= cfg.blackout.blackout_start_timestep:
+                            blackout    = th.tensor((np.random.rand(cfg_net.batch_size) < blackout_rate)[:,None,None,None]).float().to(device)
                             input       = blackout * (input * 0)         + (1-blackout) * input
                             error_last  = blackout * (error_last * 0)    + (1-blackout) * error_last
-                        
+
+                    # Apply rollout training
+                    if net.cfg.inner_loop_enabled and (rollout_length > 0) and (burnin_length-1) < t:
+                            input       = input * 0
+                            error_last  = error_last * 0
+                            num_rollout += 1
+                            
+                            if (burnin_length + rollout_length -1) == t:
+                                run_optimizers = True
+                                detach         = True
+
+                            if (burnin_length + rollout_length) == t:
+                                break
+
+
                 # Forward Pass
                 (
                     output_next, 
@@ -206,7 +250,9 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
                     slots_occlusionfactor,
                     position_loss,
                     time_loss,
-                    slots_closed
+                    latent_loss,
+                    slots_closed,
+                    slots_bounded
                     ) = net(
                     input,      # current frame
                     error_last, # error of last frame --> missing object
@@ -228,6 +274,8 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
                 # Loss weighting 
                 position_loss = position_loss * cfg_net.position_regularizer
                 time_loss     = time_loss     * cfg_net.time_regularizer
+                if latent_loss.item() > 0:
+                    latent_loss   = latent_loss   * cfg_net.latent_regularizer
 
                 # Compute background error
                 bg_error_cur  = th.sqrt(reduce((input - background)**2, 'b c h w -> b 1 h w', 'mean')).detach()
@@ -253,10 +301,14 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
                         background_blendin_factor = min(1, background_blendin_factor + 0.001)
 
                 # Final Loss computation
-                encoder_loss = th.mean((output_cur - input)**2) * cfg_net.encoder_regularizer
-                cliped_output_next = th.clip(output_next, 0, 1)
-                loss = bceloss(cliped_output_next, target) + encoder_loss + position_loss + time_loss
+                encoding_loss = imageloss(output_cur, input) * cfg_net.encoder_regularizer
+                prediction_loss = imageloss(output_next, target)
+                loss = prediction_loss + encoding_loss + position_loss + time_loss + latent_loss
                 
+                # apply loss decay according to num_rollout
+                if rollout_length > 0:
+                    loss = loss * 0.75**(num_rollout-1)
+
                 # Accumulate loss over BPP steps
                 summed_loss = loss if summed_loss is None else summed_loss + loss
                 mask = mask.detach()
@@ -295,6 +347,7 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
 
                     # Update net status
                     update_net_status(num_updates, net, cfg, optimizer_init)
+                    step_lr_scheduler(scheduler)
 
                     if num_updates == cfg.phases.start_inner_loop:
                         print('Start inner loop')
@@ -303,38 +356,39 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
                     if (cfg.bptt.increase_bptt_steps_every > 0) and ((num_updates-cfg.num_updates) % cfg.bptt.increase_bptt_steps_every == 0) and ((num_updates-cfg.num_updates) > 0):
                         increase_bptt_steps = True
 
+                    if net.cfg.inner_loop_enabled and ('blackout' in cfg) and (cfg.blackout.blackout_increase_every > 0) and ((num_updates-cfg.num_updates) % cfg.blackout.blackout_increase_every == 0) and ((num_updates-cfg.num_updates) > 0):
+                        blackout_rate = min(blackout_rate + cfg.blackout.blackout_increase_rate, cfg.blackout.blackout_rate_max)
+
                     # Plots for online evaluation
-                    if num_updates % 20000 == 0:
-                        plot_online(cfg, path, num_updates, input, background, mask, sequence_len, t, output_next, bg_error_next)
+                    if num_updates % cfg.defaults.plot_interval == 0:
+                        plot_next_sample = True
 
+                if plot_this_sample:
+                    img_tensor = plot_online(cfg, path, f'{epoch}_{batch_index}', input, background, mask, sequence_len, t, output_next, bg_error_next)
+                    video_list.append(img_tensor)
 
                 # Track statisitcs
                 if t >= cfg.defaults.statistics_offset:
-                    track_statistics(cfg_net, net, loss_tracker, input, gestalt, mask, target, output_next, output_cur, position_loss, time_loss, slots_closed, bg_error_cur, bg_error_next)
-                loss_tracker.update_average_loss(loss.item())
+                    track_statistics(cfg, net, loss_tracker, input, gestalt, mask, target, output_next, output_cur, encoding_loss, prediction_loss, position_loss, time_loss, latent_loss, slots_closed, slots_bounded, bg_error_cur, bg_error_next, scheduler, num_updates)
+                    loss_tracker.update_average_loss(loss.item(), num_updates)
+                    writer.add_scalar('Train/BPTT_steps', bptt_steps, num_updates)
+                    writer.add_scalar('Train/Background_Blendin', background_blendin_factor, num_updates)
+                    writer.add_scalar('Train/Blackout_Rate', blackout_rate, num_updates)
     
                 # Logging
                 if num_updates % 100 == 0 and run_optimizers:
                     print(f'Epoch[{num_updates}/{num_time_steps}/{sequence_len}]: {str(timer)}, {epoch + 1}, Blendin:{float(background_blendin_factor)}, i: {net.get_init_status() + net.initial_states.init.get():.2f},' + loss_tracker.get_log(), flush=True)
 
                 # Training finished
+                net_path = None
                 if num_updates > cfg.max_updates:
-                    save_model(
-                        os.path.join(path, 'nets', 'net_final.pt'),
-                        net, 
-                        optimizer_init, 
-                        optimizer_encoder, 
-                        optimizer_decoder, 
-                        optimizer_predictor,
-                        optimizer_background
-                    )
-                    print("Training finished")
-                    return
-
-                # Checkpointing
+                    net_path = os.path.join(path, 'nets', 'net_final.pt')
                 if num_updates % 50000 == 0 and run_optimizers:
+                    net_path = os.path.join(path, 'nets', f'net_{num_updates}.pt')
+
+                if net_path is not None:
                     save_model(
-                        os.path.join(path, 'nets', f'net_{num_updates}.pt'),
+                        net_path,
                         net, 
                         optimizer_init, 
                         optimizer_encoder, 
@@ -342,33 +396,56 @@ def train_loci(cfg: Configuration, trainset: Dataset, valset: Dataset, file):
                         optimizer_predictor,
                         optimizer_background
                     )
-    pass
+                    if ('final' in net_path) or ('num_objects_test' in cfg.model):
+                        eval_main(net_path, 1, deepcopy(cfg))
 
-def track_statistics(cfg_net, net, loss_tracker, input, gestalt, mask, target, output_next, output_cur, position_loss, time_loss, slots_closed, bg_error_cur, bg_error_next):
-    
-    # Prediction Loss
-    mseloss = nn.MSELoss()
-    loss_next = mseloss(output_next * bg_error_next, target * bg_error_next)
+                    if 'final' in net_path:
+                        print("Training finished")
+                        writer.flush()
+                        return
 
-    # Encoder Loss (only for stats)
-    loss_cur  = mseloss(output_cur * bg_error_cur,   input  * bg_error_cur)
+            if plot_this_sample:
+                video_tensor = rearrange(th.stack(video_list, dim=0)[None], 'b t h w c -> b t c h w')
+                writer.add_video('Train/Video', video_tensor, num_updates)
+
+    pass
 
+def track_statistics(cfg, net, loss_tracker, input, gestalt, mask, target, output_next, output_cur, encoding_loss, prediction_loss, position_loss, time_loss, latent_loss, slots_closed, slots_bounded, bg_error_cur, bg_error_next, scheduler, num_updates):
+    
     # area of foreground mask
     num_objects = th.mean(reduce((reduce(mask[:,:-1], 'b c h w -> b c', 'max') > 0.5).float(), 'b c -> b', 'sum')).item()
 
     # difference in shape
-    _gestalt  = reduce(th.min(th.abs(gestalt), th.abs(1 - gestalt)),    'b (o c) -> (b o)', 'mean', o = cfg_net.num_objects)
-    _gestalt2 = reduce(th.min(th.abs(gestalt), th.abs(1 - gestalt))**2, 'b (o c) -> (b o)', 'mean', o = cfg_net.num_objects)
+    _gestalt  = reduce(th.min(th.abs(gestalt), th.abs(1 - gestalt)),    'b (o c) -> (b o)', 'mean', o = cfg.model.num_objects)
+    _gestalt2 = reduce(th.min(th.abs(gestalt), th.abs(1 - gestalt))**2, 'b (o c) -> (b o)', 'mean', o = cfg.model.num_objects)
     max_mask     = (reduce(mask[:,:-1], 'b c h w -> (b c)', 'max') > 0.5).float()
     avg_gestalt = (th.sum(_gestalt  * max_mask) / (1e-16 + th.sum(max_mask)))
     avg_gestalt2 = (th.sum(_gestalt2 * max_mask) / (1e-16 + th.sum(max_mask)))
     avg_gestalt_mean = th.mean(th.clip(gestalt, 0, 1))
 
     # udpdate gates
-    avg_update_gestalt = slots_closed[:,:,0].mean()
-    avg_update_position = slots_closed[:,:,1].mean()
+    num_bounded = reduce(slots_bounded, 'b o -> b', 'sum').mean().item()
+    slots_closed = slots_closed * slots_bounded[:,:,None]
+    avg_update_gestalt = slots_closed[:,:,0].sum()/slots_bounded.sum() if slots_bounded.sum() > 0 else 0.0
+    avg_update_position = slots_closed[:,:,1].sum()/slots_bounded.sum() if slots_bounded.sum() > 0 else 0.0
+    avg_update_gestalt = float(avg_update_gestalt)
+    avg_update_position = float(avg_update_position)
+
+    # Prediction Loss + Encoder Loss as MSE + only foreground pixels
+    mseloss = nn.MSELoss()
+    loss_next = mseloss(output_next * bg_error_next, target * bg_error_next)
+    loss_cur  = mseloss(output_cur * bg_error_cur,   input  * bg_error_cur)
+
+    # learning rate
+    if scheduler is not None:
+        lr = scheduler[0].get_last_lr()[0]
+    else:
+        lr = cfg.learning_rate.lr
 
-    loss_tracker.update_complete(position_loss, time_loss, loss_cur, loss_next, loss_next, num_objects, net.get_openings(), avg_gestalt, avg_gestalt2, avg_gestalt_mean, avg_update_gestalt, avg_update_position)
+    # gatelORD openings
+    openings = th.mean(net.get_openings()).item()
+
+    loss_tracker.update_complete(position_loss, time_loss, latent_loss, loss_cur, loss_next, num_objects, openings, avg_gestalt, avg_gestalt2, avg_gestalt_mean, avg_update_gestalt, avg_update_position, num_bounded, lr, num_updates)
     pass
 
 def log_modelsize(net):
@@ -381,15 +458,49 @@ def log_modelsize(net):
     print("\n")
     pass
 
+def initialize_loss_function(cfg):
+    if not ('loss' in cfg.defaults):
+        cfg.defaults.loss = 'bce'
+        
+    if cfg.defaults.loss == 'mse':
+        imageloss = nn.MSELoss()
+    elif cfg.defaults.loss == 'bce':
+        imageloss = nn.BCELoss()
+    else:
+        raise NotImplementedError
+    
+    return imageloss
+    
 def init_optimizer(cfg, net):
-    optimizer_init = RAdam(net.initial_states.parameters(), lr = cfg.learning_rate * 30)
-    optimizer_encoder = RAdam(net.encoder.parameters(), lr = cfg.learning_rate)
-    optimizer_decoder = RAdam(net.decoder.parameters(), lr = cfg.learning_rate)
-    optimizer_predictor = RAdam(net.predictor.parameters(), lr = cfg.learning_rate)
-    optimizer_background = RAdam([net.background.mask], lr = cfg.learning_rate)
-    optimizer_update = RAdam(net.percept_gate_controller.parameters(), lr = cfg.learning_rate)
+    # backward compability:
+    if not isinstance(cfg.learning_rate, dict):
+        cfg.learning_rate = Dict({'lr': cfg.learning_rate})
+
+    lr  = cfg.learning_rate.lr     
+    optimizer_init = RAdam(net.initial_states.parameters(), lr = lr * 30)
+    optimizer_encoder = RAdam(net.encoder.parameters(), lr = lr)
+    optimizer_decoder = RAdam(net.decoder.parameters(), lr = lr)
+    optimizer_predictor = RAdam(net.predictor.parameters(), lr = lr)
+    optimizer_background = RAdam([net.background.mask], lr = lr)
+    optimizer_update = RAdam(net.percept_gate_controller.parameters(), lr = lr)
     return optimizer_init,optimizer_encoder,optimizer_decoder,optimizer_predictor,optimizer_background,optimizer_update
 
+def init_lr_scheduler_StepLR(cfg, *optimizer_list):
+    scheduler_list = None
+    if 'deacrease_lr_every' in cfg.learning_rate:
+        print('Init lr scheduler')
+        scheduler_list = []
+        for optimizer in optimizer_list:
+            scheduler = th.optim.lr_scheduler.StepLR(optimizer, step_size=cfg.learning_rate.deacrease_lr_every, gamma=cfg.learning_rate.deacrease_lr_factor)
+            scheduler_list.append(scheduler)
+    return scheduler_list
+
+def step_lr_scheduler(scheduler_list):
+    if scheduler_list is not None:
+        for scheduler in scheduler_list:
+            scheduler.step()
+    pass
+
 def save_model(
     file,
     net, 
@@ -432,23 +543,23 @@ def load_model(
     if load_optimizers:
         optimizer_init.load_state_dict(state[f'optimizer_init'])
         for n in range(len(optimizer_init.param_groups)):
-            optimizer_init.param_groups[n]['lr'] = cfg.learning_rate
+            optimizer_init.param_groups[n]['lr'] = cfg.learning_rate.lr
 
         optimizer_encoder.load_state_dict(state[f'optimizer_encoder'])
         for n in range(len(optimizer_encoder.param_groups)):
-            optimizer_encoder.param_groups[n]['lr'] = cfg.learning_rate
+            optimizer_encoder.param_groups[n]['lr'] = cfg.learning_rate.lr
 
         optimizer_decoder.load_state_dict(state[f'optimizer_decoder'])
         for n in range(len(optimizer_decoder.param_groups)):
-            optimizer_decoder.param_groups[n]['lr'] = cfg.learning_rate
+            optimizer_decoder.param_groups[n]['lr'] = cfg.learning_rate.lr
 
         optimizer_predictor.load_state_dict(state['optimizer_predictor'])
         for n in range(len(optimizer_predictor.param_groups)):
-            optimizer_predictor.param_groups[n]['lr'] = cfg.learning_rate
+            optimizer_predictor.param_groups[n]['lr'] = cfg.learning_rate.lr
 
         optimizer_background.load_state_dict(state['optimizer_background'])
         for n in range(len(optimizer_background.param_groups)):
-            optimizer_background.param_groups[n]['lr'] = cfg.model.background.learning_rate
+            optimizer_background.param_groups[n]['lr'] = cfg.model.background.learning_rate.lr
 
     # 1. Fill model with values of net 
     model = {}
@@ -484,40 +595,61 @@ def update_net_status(num_updates, net, cfg, optimizer_init):
     if num_updates == cfg.phases.entity_pretraining_phase2_end and net.get_init_status() < 3:
         net.inc_init_level()
         for param in optimizer_init.param_groups:
-            param['lr'] = cfg.learning_rate
+            param['lr'] = cfg.learning_rate.lr
 
     pass
     
 def plot_online(cfg, path, num_updates, input, background, mask, sequence_len, t, output_next, bg_error_next):
-    plot_path = os.path.join(path, 'plots', f'net_{num_updates}')
-    if not os.path.exists(plot_path):
+                
+    # highlight error
+    grayscale        = input[:,0:1] * 0.299 + input[:,1:2] * 0.587 + input[:,2:3] * 0.114
+    object_mask_cur  = th.sum(mask[:,:-1], dim=1).unsqueeze(dim=1)
+    highlited_input  = grayscale * (1 - object_mask_cur)
+    highlited_input += grayscale * object_mask_cur * 0.3333333
+    cmask = color_mask(mask[:,:-1])
+    highlited_input  = highlited_input + cmask * 0.6666666
+
+    input_ = rearrange(input[0], 'c h w -> h w c').detach().cpu()
+    background_ = rearrange(background[0], 'c h w -> h w c').detach().cpu()
+    mask_ = rearrange(mask[0,-1:], 'c h w -> h w c').detach().cpu()
+    output_next_ = rearrange(output_next[0], 'c h w -> h w c').detach().cpu()
+    bg_error_next_ = rearrange(bg_error_next[0], 'c h w -> h w c').detach().cpu()
+    highlited_input_ = rearrange(highlited_input[0], 'c h w -> h w c').detach().cpu()
+
+    if False:
+        plot_path = os.path.join(path, 'plots', f'net_{num_updates}')
         os.makedirs(plot_path, exist_ok=True)
-                    
-                        # highlight error
-        grayscale        = input[:,0:1] * 0.299 + input[:,1:2] * 0.587 + input[:,2:3] * 0.114
-        object_mask_cur  = th.sum(mask[:,:-1], dim=1).unsqueeze(dim=1)
-        highlited_input  = grayscale * (1 - object_mask_cur)
-        highlited_input += grayscale * object_mask_cur * 0.3333333
-        cmask = color_mask(mask[:,:-1])
-        highlited_input  = highlited_input + cmask * 0.6666666
-
-        cv2.imwrite(os.path.join(plot_path, f'input-{num_updates // sequence_len:05d}-{t+cfg.defaults.teacher_forcing:03d}.jpg'), rearrange(input[0], 'c h w -> h w c').detach().cpu().numpy() * 255)
-        cv2.imwrite(os.path.join(plot_path, f'background-{num_updates // sequence_len:05d}-{t+cfg.defaults.teacher_forcing:03d}.jpg'), rearrange(background[0], 'c h w -> h w c').detach().cpu().numpy() * 255)
-        cv2.imwrite(os.path.join(plot_path, f'error_mask-{num_updates // sequence_len:05d}-{t+cfg.defaults.teacher_forcing:03d}.jpg'), rearrange(bg_error_next[0], 'c h w -> h w c').detach().cpu().numpy() * 255)
-        cv2.imwrite(os.path.join(plot_path, f'background_mask-{num_updates // sequence_len:05d}-{t+cfg.defaults.teacher_forcing:03d}.jpg'), rearrange(mask[0,-1:], 'c h w -> h w c').detach().cpu().numpy() * 255)
-        cv2.imwrite(os.path.join(plot_path, f'output_next-{num_updates // sequence_len:05d}-{t+cfg.defaults.teacher_forcing:03d}.jpg'), rearrange(output_next[0], 'c h w -> h w c').detach().cpu().numpy() * 255)
-        cv2.imwrite(os.path.join(plot_path, f'output_highlight-{num_updates // sequence_len:05d}-{t+cfg.defaults.teacher_forcing:03d}.jpg'), rearrange(highlited_input[0], 'c h w -> h w c').detach().cpu().numpy() * 255)
-    pass
-
-def get_loader(cfg, set, cfg_net, shuffle = True):
-    loader = DataLoader(
-        set, 
-        pin_memory = True, 
-        num_workers = cfg.defaults.num_workers, 
-        batch_size = cfg_net.batch_size, 
-        shuffle = shuffle,
-        drop_last = True, 
-        prefetch_factor = cfg.defaults.prefetch_factor, 
-        persistent_workers = True
-    )
+        cv2.imwrite(os.path.join(plot_path, f'input-{t+cfg.defaults.teacher_forcing:03d}.jpg'), input_.numpy() * 255)
+        cv2.imwrite(os.path.join(plot_path, f'background-{t+cfg.defaults.teacher_forcing:03d}.jpg'), background_.numpy() * 255)
+        cv2.imwrite(os.path.join(plot_path, f'error_mask-{t+cfg.defaults.teacher_forcing:03d}.jpg'), bg_error_next_.numpy() * 255)
+        cv2.imwrite(os.path.join(plot_path, f'background_mask-{t+cfg.defaults.teacher_forcing:03d}.jpg'), mask_.numpy() * 255)
+        cv2.imwrite(os.path.join(plot_path, f'output_next-{t+cfg.defaults.teacher_forcing:03d}.jpg'), output_next_.numpy() * 255)
+        cv2.imwrite(os.path.join(plot_path, f'output_highlight-{t+cfg.defaults.teacher_forcing:03d}.jpg'), highlited_input_.numpy() * 255)
+
+    # stack input, output, mask and highlight into one image horizontally
+    img_tensor = th.cat([input_, highlited_input_, output_next_], dim=1)
+    return img_tensor
+
+def get_loader(cfg, set, cfg_net, shuffle = True, verbose=False):
+    if ((cfg.datatype == 'bouncingballs') and verbose) or ((cfg.datatype == 'adept') and not shuffle):
+        loader = DataLoader(
+            set, 
+            pin_memory = True, 
+            num_workers = 0, 
+            batch_size = cfg_net.batch_size, 
+            shuffle = shuffle,
+            drop_last = True, 
+            persistent_workers = False
+        )
+    else:
+        loader = DataLoader(
+            set, 
+            pin_memory = True, 
+            num_workers = cfg.defaults.num_workers, 
+            batch_size = cfg_net.batch_size, 
+            shuffle = shuffle,
+            drop_last = True, 
+            prefetch_factor = cfg.defaults.prefetch_factor, 
+            persistent_workers = True
+        )
     return loader
 \ No newline at end of file
diff --git a/scripts/utils/eval_adept.py b/scripts/utils/eval_adept.py
new file mode 100644
index 0000000..7b8dfa8
--- /dev/null
+++ b/scripts/utils/eval_adept.py
@@ -0,0 +1,169 @@
+import pandas as pd
+import warnings
+import os
+import argparse
+
+warnings.simplefilter(action='ignore', category=FutureWarning)
+pd.options.mode.chained_assignment = None 
+
+def eval_adept(path):
+    net = 'net1'
+
+    # read pickle file
+    tf = pd.DataFrame()
+    sf = pd.DataFrame()
+    af = pd.DataFrame()
+
+    with open(os.path.join(path, 'trialframe.csv'), 'rb') as f:
+        tf_temp = pd.read_csv(f, index_col=0)
+    tf_temp['net'] = net
+    tf = pd.concat([tf,tf_temp])
+
+    with open(os.path.join(path, 'slotframe.csv'), 'rb') as f:
+        sf_temp = pd.read_csv(f, index_col=0)
+    sf_temp['net'] = net
+    sf = pd.concat([sf,sf_temp])
+
+    with open(os.path.join(path, 'accframe.csv'), 'rb') as f:
+        af_temp = pd.read_csv(f, index_col=0)
+    af_temp['net'] = net
+    af = pd.concat([af,af_temp])
+
+    # cast variables
+    sf['visible'] = sf['visible'].astype(bool)
+    sf['bound'] = sf['bound'].astype(bool)
+    sf['occluder'] = sf['occluder'].astype(bool)
+    sf['inimage'] = sf['inimage'].astype(bool)
+    sf['vanishing'] = sf['vanishing'].astype(bool)
+    sf['alpha_pos'] = 1-sf['alpha_pos']
+    sf['alpha_ges'] = 1-sf['alpha_ges']
+
+    # scale to percentage
+    sf['TE'] = sf['TE'] * 100
+
+    # add surprise as dummy code
+    tf['control'] = [('control' in set) for set in tf['set']]
+    sf['control'] = [('control' in set)  for set in sf['set']]
+
+
+
+    # STATS:
+    tracking_error_visible = 0
+    tracking_error_occluded = 0
+    num_positive_trackings = 0
+    mota = 0
+    gate_openings_visible = 0
+    gate_openings_occluded = 0
+
+
+    print('Tracking Error ------------------------------')
+    grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)
+
+    def get_stats(col):
+        return f' M: {col.mean():.3} , STD: {col.std():.3}, Count: {col.count()}'
+
+    # When Visible
+    temp = sf[grouping & sf.visible]
+    print(f'Tracking Error when visible:' + get_stats(temp['TE']))
+    tracking_error_visible = temp['TE'].mean()
+
+    # When Occluded
+    temp = sf[grouping & ~sf.visible]
+    print(f'Tracking Error when occluded:' + get_stats(temp['TE']))
+    tracking_error_occluded = temp['TE'].mean()
+
+
+
+
+
+
+    print('Positive Trackings ------------------------------')
+    # succesfull trackings: In the last visible moment of the target, the slot was less than 10% away from the target
+    # determine last visible frame numeric
+    grouping_factors = ['net','set','evalmode','scene','slot']
+    ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).max()
+    ff.rename(columns = {'frame':'last_visible'}, inplace = True)
+    sf = sf.merge(ff[['last_visible']], on=grouping_factors, how='left')
+
+    # same for first bound frame
+    ff = sf[sf.visible & sf.bound & sf.inimage].groupby(grouping_factors).min()
+    ff.rename(columns = {'frame':'first_visible'}, inplace = True)
+    sf = sf.merge(ff[['first_visible']], on=grouping_factors, how='left')
+
+    # add dummy variable to sf
+    sf['last_visible'] = (sf['last_visible'] == sf['frame'])
+
+    # extract the trials where the target was last visible and threshold the TE
+    ff = sf[sf['last_visible']] 
+    ff['tracked_pos'] = (ff['TE'] < 10)
+    ff['tracked_neg'] = (ff['TE'] >= 10)
+
+    # fill NaN with 0
+    sf = sf.merge(ff[grouping_factors + ['tracked_pos', 'tracked_neg']], on=grouping_factors, how='left')
+    sf['tracked_pos'].fillna(False, inplace=True)
+    sf['tracked_neg'].fillna(False, inplace=True)
+
+    # Aggreagte over all scenes
+    temp = sf[(sf['frame']== 1) & ~sf.occluder & sf.control & (sf.first_visible < 20)]
+    temp = temp.groupby(['set', 'evalmode']).sum()
+    temp = temp[['tracked_pos', 'tracked_neg']]
+    temp = temp.reset_index()
+
+    temp['tracked_pos_pro'] = temp['tracked_pos'] / (temp['tracked_pos'] + temp['tracked_neg'])
+    temp['tracked_neg_pro'] = temp['tracked_neg'] / (temp['tracked_pos'] + temp['tracked_neg'])
+    print(temp)
+    num_positive_trackings = temp['tracked_pos_pro']
+
+
+
+
+
+    print('Mostly Trecked /MOTA ------------------------------')
+    temp = af[af.index == 'OVERALL']
+    temp['mostly_tracked'] = temp['mostly_tracked'] / temp['num_unique_objects']
+    temp['partially_tracked'] = temp['partially_tracked'] / temp['num_unique_objects']
+    temp['mostly_lost'] = temp['mostly_lost'] / temp['num_unique_objects']
+    print(temp)
+    mota = temp['mota']
+
+
+    print('Openings ------------------------------')
+    grouping = (sf.inimage & sf.bound & ~sf.occluder & sf.control)
+    temp = sf[grouping & sf.visible]
+    print(f'Percept gate openings when visible:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))
+    gate_openings_visible = temp['alpha_pos'].mean() + temp['alpha_ges'].mean()
+
+    temp = sf[grouping & ~sf.visible]
+    print(f'Percept gate openings when occluded:' + get_stats(temp['alpha_pos'] + temp['alpha_ges']))
+    gate_openings_occluded = temp['alpha_pos'].mean() + temp['alpha_ges'].mean()
+
+
+    print('------------------------------------------------')
+    print('------------------------------------------------')
+    str = ''
+    str += f'net: {net}\n'
+    str += f'Tracking Error when visible: {tracking_error_visible:.3}\n'
+    str += f'Tracking Error when occluded: {tracking_error_occluded:.3}\n'
+    str += 'Positive Trackings: ' + ', '.join(f'{val:.3}' for val in num_positive_trackings) + '\n'
+    str += 'MOTA: ' + ', '.join(f'{val:.3}' for val in mota) + '\n'
+    str += f'Percept gate openings when visible: {gate_openings_visible:.3}\n'
+    str += f'Percept gate openings when occluded: {gate_openings_occluded:.3}\n'
+
+    print(str)
+
+    # write tstring to file
+    with open(os.path.join(path, 'results.txt'), 'w') as f:
+        f.write(str)
+    
+
+    
+if __name__ == "__main__":
+
+    # use argparse to get the path to the results folder
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--path', type=str, default='')
+    args = parser.parse_args()
+
+    # setting path to results folder
+    path = args.path
+    eval_adept(path)
+\ No newline at end of file
diff --git a/scripts/utils/eval_metrics.py b/scripts/utils/eval_metrics.py
index 6f5106d..98af468 100644
--- a/scripts/utils/eval_metrics.py
+++ b/scripts/utils/eval_metrics.py
@@ -3,6 +3,8 @@ vp_utils.py
 SCRIPT TAKEN FROM https://github.com/pairlab/SlotFormer 
 '''
 
+import cv2
+from einops import rearrange
 import numpy as np
 from scipy.optimize import linear_sum_assignment
 from skimage.metrics import structural_similarity, peak_signal_noise_ratio
@@ -11,7 +13,7 @@ import torch
 import torch.nn.functional as F
 import torchvision.ops as vops
 
-FG_THRE = 0.5
+FG_THRE = 0.3 # 0.5 for the rest, 0.3 for bouncingballs
 PALETTE = [(0, 255, 0), (0, 0, 255), (0, 255, 255), (255, 255, 0),
            (255, 0, 255), (100, 100, 255), (200, 200, 100), (170, 120, 200),
            (255, 0, 0), (200, 100, 100), (10, 200, 100), (200, 200, 200),
@@ -272,6 +274,8 @@ def pred_eval_step(
     gt_bbox=None,
     pred_bbox=None,
     eval_traj=True,
+    gt_mask_hidden=None,
+    pred_mask_hidden=None,
 ):
     """Both of shape [B, T, C, H, W], torch.Tensor.
     masks of shape [B, T, H, W].
@@ -288,13 +292,14 @@ def pred_eval_step(
     if eval_traj:
         assert len(gt_mask.shape) == len(pred_mask.shape) == 4
         assert gt_mask.shape == pred_mask.shape
-    if eval_traj:
+    if eval_traj and gt_bbox is not None:
         assert len(gt_pres_mask.shape) == 3
         assert len(gt_bbox.shape) == len(pred_bbox.shape) == 4
     T = gt.shape[1]
 
     # compute perceptual dist & mask metrics before converting to numpy
     all_percept_dist, all_ari, all_fari, all_miou = [], [], [], []
+    all_ari_hidden, all_fari_hidden, all_miou_hidden = [], [], []
     for t in range(T):
         one_gt, one_pred = gt[:, t], pred[:, t]
         percept_dist = perceptual_dist(one_gt, one_pred, lpips_fn).item()
@@ -307,6 +312,29 @@ def pred_eval_step(
             all_ari.append(ari)
             all_fari.append(fari)
             all_miou.append(miou)
+
+            # hidden:
+            if gt_mask_hidden is not None:
+                one_gt_mask, one_pred_mask = gt_mask_hidden[:, t], pred_mask_hidden[:, t]
+                ari = ARI_metric(one_gt_mask, one_pred_mask)
+                fari = fARI_metric(one_gt_mask, one_pred_mask)
+                miou = miou_metric(one_gt_mask, one_pred_mask)
+                all_ari_hidden.append(ari)
+                all_fari_hidden.append(fari)
+                all_miou_hidden.append(miou)
+                
+
+            # dispalay masks with cv2
+            if False:
+                one_gt_mask_, one_pred_mask_ = one_gt_mask.clone(), one_pred_mask.clone()
+
+                # concat one_gt_mask and one_pred_mask horizontally
+                frame = np.concatenate((one_gt_mask_, one_pred_mask_), axis=1)
+                frame = rearrange(frame, 'c h w -> h w c') * (255/6)
+                frame = frame.astype(np.uint8)
+                cv2.imshow('frame', frame)
+                cv2.waitKey(0)
+            
         else:
             all_ari.append(0.)
             all_fari.append(0.)
@@ -315,14 +343,14 @@ def pred_eval_step(
     # compute bbox metrics
     all_ap, all_ar = [], []
     for t in range(T):
-        if not eval_traj:
+        if not eval_traj or gt_bbox is None:
             all_ap.append(0.)
             all_ar.append(0.)
             continue
         one_gt_pres_mask, one_gt_bbox, one_pred_bbox = \
             gt_pres_mask[:, t], gt_bbox[:, t], pred_bbox[:, t]
         ap, ar = batch_bbox_precision_recall(one_gt_pres_mask, one_gt_bbox,
-                                             one_pred_bbox)
+                                            one_pred_bbox)
         all_ap.append(ap)
         all_ar.append(ar)
 
@@ -333,11 +361,13 @@ def pred_eval_step(
         one_gt, one_pred = gt[:, t], pred[:, t]
         mse = mse_metric(one_gt, one_pred)
         psnr = psnr_metric(one_gt, one_pred)
-        ssim = ssim_metric(one_gt, one_pred)
+        #ssim = ssim_metric(one_gt, one_pred)
+        ssim = 0
         all_mse.append(mse)
         all_ssim.append(ssim)
         all_psnr.append(psnr)
-    return {
+
+    res = {
         'mse': all_mse,
         'ssim': all_ssim,
         'psnr': all_psnr,
@@ -346,5 +376,12 @@ def pred_eval_step(
         'fari': all_fari,
         'miou': all_miou,
         'ap': all_ap,
-        'ar': all_ar,
+        'ar': all_ar
     }
+
+    if gt_mask_hidden is not None:
+        res['ari_hidden'] = all_ari_hidden
+        res['fari_hidden'] = all_fari_hidden
+        res['miou_hidden'] = all_miou_hidden
+        
+    return res
diff --git a/scripts/utils/eval_utils.py b/scripts/utils/eval_utils.py
index faab7ec..a01ffd0 100644
--- a/scripts/utils/eval_utils.py
+++ b/scripts/utils/eval_utils.py
@@ -1,18 +1,92 @@
 import os
+import shutil
+from einops import rearrange
 import torch as th
 from model.loci import Loci
 
+def masks_to_boxes(masks: th.Tensor) -> th.Tensor:
+    """
+    Compute the bounding boxes around the provided masks.
+
+    Returns a [N, 4] tensor containing bounding boxes. The boxes are in ``(x1, y1, x2, y2)`` format with
+    ``0 <= x1 < x2`` and ``0 <= y1 < y2``.
+
+    Args:
+        masks (Tensor[N, H, W]): masks to transform where N is the number of masks
+            and (H, W) are the spatial dimensions.
+
+    Returns:
+        Tensor[N, 4]: bounding boxes
+    """
+    if masks.numel() == 0:
+        return th.zeros((0, 4), device=masks.device, dtype=th.float)
+
+    n = masks.shape[0]
+
+    bounding_boxes = th.zeros((n, 4), device=masks.device, dtype=th.float)
+
+    for index, mask in enumerate(masks):
+        if mask.sum() > 0:
+            y, x = th.where(mask != 0)
+
+            bounding_boxes[index, 0] = th.min(x)
+            bounding_boxes[index, 1] = th.min(y)
+            bounding_boxes[index, 2] = th.max(x)
+            bounding_boxes[index, 3] = th.max(y)
+
+    return bounding_boxes
+
+def boxes_to_centroids(boxes):
+    """Post-process masks instead of directly taking argmax.
+
+    Args:
+        bboxes: [B, T, N, 4], 4: [x1, y1, x2, y2]
+
+    Returns:
+        centroids: [B, T, N, 2], 2: [x, y]
+    """
+
+    centroids = (boxes[:, :, :, :2] + boxes[:, :, :, 2:]) / 2
+    centroids = centroids.squeeze(0)
+
+    # scale to [-1, 1]
+    centroids[:, :, 0] = centroids[:, :, 0] / 64 * 2 - 1
+    centroids[:, :, 1] = centroids[:, :, 1] / 64 * 2 - 1
+
+    return centroids
+
+def compute_position_from_mask(mask):
+    """
+    Compute the position of the object from the mask.
+
+    Args:
+        mask (Tensor[B, N, H, W]): masks to transform where N is the number of masks
+            and (H, W) are the spatial dimensions.
+    
+    Returns:
+        Tensor[B, N, 2]: position of the object
+    
+    """
+    masks_binary = (mask > 0.8).float()[:, :-1]
+    b, o, h, w = masks_binary.shape
+    masks2 = rearrange(masks_binary, 'b o h w -> (b o) h w')
+    boxes = masks_to_boxes(masks2.long())
+    boxes = rearrange(boxes, '(b o) c -> b 1 o c', b=b, o=o)
+    centroids = boxes_to_centroids(boxes)
+    centroids = centroids[:, :, :, [1, 0]].squeeze(1)
+    return centroids
+
 def setup_result_folders(file, name, set_test, evaluation_mode, object_view, individual_views):
 
     net_name = file.split('/')[-1].split('.')[0]
     #root_path = file.split('nets')[0]
-    root_path = os.path.join(*file.split('/')[0:-1])
+    root_path = os.path.join(*file.split('/')[0:-2])
     root_path = os.path.join(root_path, f'results{name}', net_name, set_test['type'])
     plot_path = os.path.join(root_path, evaluation_mode)
     
     # create directories
-    #if os.path.exists(plot_path):
-    #    shutil.rmtree(plot_path)
+    if os.path.exists(plot_path):
+        shutil.rmtree(plot_path)
     os.makedirs(plot_path, exist_ok = True)
     if object_view:
         os.makedirs(os.path.join(plot_path, 'object'), exist_ok = True)
@@ -59,13 +133,21 @@ def load_model(cfg, cfg_net, file, device):
         print(f"load {file} to device {device}")
         state = th.load(file, map_location=device)
 
-        # backward compatibility
+        # 1. Get keys of current model while ensuring backward compatibility
         model = {}
+        allowed_keys = []
+        rand_state = net.state_dict()
+        for key, value in rand_state.items():
+            allowed_keys.append(key)
+
+        # 2. Overwrite with values from file
         for key, value in state["model"].items():
             # replace update_module with percept_gate_controller in key string:
             key = key.replace("update_module", "percept_gate_controller")
-            model[key.replace(".module.", ".")] = value
 
+            if key in allowed_keys:
+                model[key.replace(".module.", ".")] = value
+                
         net.load_state_dict(model)
 
     # ???
diff --git a/scripts/utils/io.py b/scripts/utils/io.py
index 9bd8158..787c575 100644
--- a/scripts/utils/io.py
+++ b/scripts/utils/io.py
@@ -65,7 +65,7 @@ def model_path(cfg: Configuration, overwrite=False, move_old=True):
     :param move_old: Moves old folder with the same name to an old folder, if not overwrite
     :return: Model path
     """
-    _path = os.path.join('out')
+    _path = os.path.join('out', cfg.dataset)
     path = os.path.join(_path, cfg.model_path)
 
     if not os.path.exists(_path):
@@ -95,14 +95,15 @@ def model_path(cfg: Configuration, overwrite=False, move_old=True):
 
 class LossLogger:
 
-    def __init__(self):
+    def __init__(self, writer):
 
         self.avgloss                  = UEMA()
         self.avg_position_loss        = UEMA()
         self.avg_time_loss            = UEMA()
-        self.avg_encoder_loss         = UEMA()
-        self.avg_mse_object_loss      = UEMA()
-        self.avg_long_mse_object_loss = UEMA(33333)
+        self.avg_latent_loss          = UEMA()
+        self.avg_encoding_loss        = UEMA()
+        self.avg_prediction_loss      = UEMA()
+        self.avg_prediction_loss_long = UEMA(33333)
         self.avg_num_objects          = UEMA()
         self.avg_openings             = UEMA()
         self.avg_gestalt              = UEMA()
@@ -110,28 +111,73 @@ class LossLogger:
         self.avg_gestalt_mean         = UEMA()
         self.avg_update_gestalt       = UEMA()
         self.avg_update_position      = UEMA()
+        self.avg_num_bounded          = UEMA()
+
+        self.writer = writer
 
     
-    def update_complete(self, avg_position_loss, avg_time_loss, avg_encoder_loss, avg_mse_object_loss, avg_long_mse_object_loss, avg_num_objects, avg_openings, avg_gestalt, avg_gestalt2, avg_gestalt_mean, avg_update_gestalt, avg_update_position):
+    def update_complete(self, avg_position_loss, avg_time_loss, avg_latent_loss, avg_encoding_loss, avg_prediction_loss, avg_num_objects, avg_openings, avg_gestalt, avg_gestalt2, avg_gestalt_mean, avg_update_gestalt, avg_update_position, avg_num_bounded, lr, num_updates):
 
         self.avg_position_loss.update(avg_position_loss.item())
         self.avg_time_loss.update(avg_time_loss.item())
-        self.avg_encoder_loss.update(avg_encoder_loss.item())
-        self.avg_mse_object_loss.update(avg_mse_object_loss.item())
-        self.avg_long_mse_object_loss.update(avg_long_mse_object_loss.item())
+        self.avg_latent_loss.update(avg_latent_loss.item())
+        self.avg_encoding_loss.update(avg_encoding_loss.item())
+        self.avg_prediction_loss.update(avg_prediction_loss.item())
+        self.avg_prediction_loss_long.update(avg_prediction_loss.item())
         self.avg_num_objects.update(avg_num_objects)
         self.avg_openings.update(avg_openings)
         self.avg_gestalt.update(avg_gestalt.item())
         self.avg_gestalt2.update(avg_gestalt2.item())
         self.avg_gestalt_mean.update(avg_gestalt_mean.item())
-        self.avg_update_gestalt.update(avg_update_gestalt.item())
-        self.avg_update_position.update(avg_update_position.item())
+        self.avg_update_gestalt.update(avg_update_gestalt)
+        self.avg_update_position.update(avg_update_position)
+        self.avg_num_bounded.update(avg_num_bounded)
+
+        self.writer.add_scalar("Train/Position Loss", avg_position_loss.item(), num_updates)
+        self.writer.add_scalar("Train/Time Loss", avg_time_loss.item(), num_updates)
+        self.writer.add_scalar("Train/Latent Loss", avg_latent_loss.item(), num_updates)
+        self.writer.add_scalar("Train/Encoder Loss", avg_encoding_loss.item(), num_updates)
+        self.writer.add_scalar("Train/Prediction Loss", avg_prediction_loss.item(), num_updates)
+        self.writer.add_scalar("Train/Number of Objects", avg_num_objects, num_updates)
+        self.writer.add_scalar("Train/Openings", avg_openings, num_updates)
+        self.writer.add_scalar("Train/Gestalt", avg_gestalt.item(), num_updates)
+        self.writer.add_scalar("Train/Gestalt2", avg_gestalt2.item(), num_updates)
+        self.writer.add_scalar("Train/Gestalt Mean", avg_gestalt_mean.item(), num_updates)
+        self.writer.add_scalar("Train/Update Gestalt", avg_update_gestalt, num_updates)
+        self.writer.add_scalar("Train/Update Position", avg_update_position, num_updates)
+        self.writer.add_scalar("Train/Number Bounded", avg_num_bounded, num_updates)
+        self.writer.add_scalar("Train/Learning Rate", lr, num_updates)
+
         pass
 
-    def update_average_loss(self, avgloss):
+    def update_average_loss(self, avgloss, num_updates):
         self.avgloss.update(avgloss)
+        self.writer.add_scalar("Train/Loss", avgloss, num_updates)
         pass
 
     def get_log(self):
-        info = f'Loss: {np.abs(float(self.avgloss)):.2e}|{float(self.avg_mse_object_loss):.2e}|{float(self.avg_long_mse_object_loss):.2e}, reg: {float(self.avg_encoder_loss):.2e}|{float(self.avg_time_loss):.2e}|{float(self.avg_position_loss):.2e}, obj: {float(self.avg_num_objects):.1f}, open: {float(self.avg_openings):.2e}|{float(self.avg_gestalt):.2f}, bin: {float(self.avg_gestalt_mean):.2e}|{np.sqrt(float(self.avg_gestalt2) - float(self.avg_gestalt)**2):.2e} closed: {float(self.avg_update_gestalt):.2e}|{float(self.avg_update_position):.2e}'
+        info = f'Loss: {np.abs(float(self.avgloss)):.2e}|{float(self.avg_prediction_loss):.2e}|{float(self.avg_prediction_loss_long):.2e}, reg: {float(self.avg_encoding_loss):.2e}|{float(self.avg_time_loss):.2e}|{float(self.avg_latent_loss):.2e}|{float(self.avg_position_loss):.2e}, obj: {float(self.avg_num_objects):.1f}, open: {float(self.avg_openings):.2e}|{float(self.avg_gestalt):.2f}, bin: {float(self.avg_gestalt_mean):.2e}|{np.sqrt(float(self.avg_gestalt2) - float(self.avg_gestalt)**2):.2e} closed: {float(self.avg_update_gestalt):.2e}|{float(self.avg_update_position):.2e}'
         return info
+    
+class WriterWrapper():
+
+    def __init__(self, use_wandb: bool, cfg: Configuration):
+        if use_wandb:
+            from torch.utils.tensorboard import SummaryWriter
+            import wandb
+            wandb.init(project=f'Loci_Looped_{cfg.dataset}', name= cfg.model_path,  sync_tensorboard=True, config=cfg)
+            self.writer = SummaryWriter()
+        else:
+            self.writer = None
+
+    def add_scalar(self, name, value, step):
+        if self.writer is not None:
+            self.writer.add_scalar(name, value, step)
+
+    def add_video(self, name, value, step):
+        if self.writer is not None:
+            self.writer.add_video(name, value, step)
+
+    def flush(self):
+        if self.writer is not None:
+            self.writer.flush()
diff --git a/scripts/utils/plot_utils.py b/scripts/utils/plot_utils.py
index 5cb20de..1c83456 100644
--- a/scripts/utils/plot_utils.py
+++ b/scripts/utils/plot_utils.py
@@ -151,9 +151,10 @@ def to_rgb(tensor: th.Tensor):
         tensor
     ), dim=1)
 
-def visualise_gate(gate, h, w):
+def visualise_gate(gate, h, w, invert = False):
     bar = th.ones((1,h,w), device=gate.device) * 0.9
     black = int(w*gate.item())
+    black = w-black if invert else black
     if black > 0:
         bar[:,:, -black:] = 0
     return bar
@@ -266,28 +267,30 @@ def plot_online_error(error, error_name, target, t, i, sequence_len, root_path,
 
     return error_plot
 
-def plot_object_view(error_plot, error_plot2, error_plot_slots, error_plot_slots2, highlighted_input, output_hidden, object_next, rawmask_next, velocity_next2d, target, slots_closed, gt_positions_target_next, association_table, size, num_objects, largest_object):
+def plot_object_view(error_plot, error_plot2, error_plot_slots, error_plot_slots2, highlighted_input, output_hidden, object_next, rawmask_next, velocity_next2d, target, slots_closed, gt_positions_target_next, association_table, size, num_objects, largest_object, rollout_mode=False, openings=None):
 
     # add ground truth positions of objects to image
+    target = target.clone()
     if gt_positions_target_next is not None:
         for o in range(gt_positions_target_next.shape[1]):
             position = gt_positions_target_next[0, o]
             position = position/2 + 0.5
 
-            if position[2] > 0.0 and position[0] > 0.0 and position[0] < 1.0 and position[1] > 0.0 and position[1] < 1.0:
-                width = 5
-                w = np.clip(int(position[0]*target.shape[2]), width, target.shape[2]-width).item()
+            if (len(position.shape) < 3 or position[2] > 0.0) and position[0] > 0.0 and position[0] < 1.0 and position[1] > 0.0 and position[1] < 1.0:
+                width = int(target.shape[2]*0.05)
+                w = np.clip(int(position[0]*target.shape[2]), width, target.shape[2]-width).item() # made for bouncing balls
                 h = np.clip(int(position[1]*target.shape[3]), width, target.shape[3]-width).item()
                 col = get_color(o).view(3,1,1)
                 target[0,:,(w-width):(w+width), (h-width):(h+width)] = col
 
                 # add these positions to the associated slots velocity_next2d ilustration
-                slots = (association_table[0] == o).nonzero()
-                for s in slots.flatten():
-                    velocity_next2d[s,:,(w-width):(w+width), (h-width):(h+width)] = col
+                if association_table is not None:
+                    slots = (association_table[0] == o).nonzero()
+                    for s in slots.flatten():
+                        velocity_next2d[s,:,(w-width):(w+width), (h-width):(h+width)] = col
 
-                    if output_hidden is not None and s != largest_object:
-                        output_hidden[0,:,(w-width):(w+width), (h-width):(h+width)] = col
+                        if output_hidden is not None and s != largest_object:
+                            output_hidden[0,:,(w-width):(w+width), (h-width):(h+width)] = col
 
     gateheight = 60
     ch = 40
@@ -296,22 +299,28 @@ def plot_object_view(error_plot, error_plot2, error_plot_slots, error_plot_slots
     gh_margin = int((gh-gh_bar)/2)
     margin = 20
     slots_margin  = 10
-    height = size[0] * 6 + 18*5
+    height = size[0] * 6 + 18*6
     width  = size[1] * 4 + 18*2 + size[1]*num_objects + 6*(num_objects+1) + slots_margin*(num_objects+1)
     img = th.ones((3, height, width), device = object_next.device) * 0.4
     row = (lambda row_index: [2*size[0]*row_index + (row_index+1)*margin,   2*size[0]*(row_index+1) + (row_index+1)*margin])
     col1 = range(margin, margin + size[1]*2)
     col2 = range(width-(margin+size[1]*2), width-margin)
 
+    # add frame around image
+    if rollout_mode:
+        img[0,margin-2:margin+size[0]*2+2, margin-2:margin+size[1]*2+2] = 1
+
     img[:,row(0)[0]:row(0)[1], col1] = preprocess(highlighted_input.to(object_next.device), 2)[0] 
     img[:,row(1)[0]:row(1)[1], col1] = preprocess(output_hidden.to(object_next.device), 2)[0]
     img[:,row(2)[0]:row(2)[1], col1] = preprocess(target.to(object_next.device), 2)[0] 
 
+    # add large error plots to image
     if error_plot is not None:
         img[:,row(0)[0]+gh+ch+2*margin-gh_margin:row(0)[1]+gh+ch+2*margin-gh_margin, col2] = preprocess(error_plot.to(object_next.device), normalize= True)
     if error_plot2 is not None:
         img[:,row(2)[0]:row(2)[1], col2] = preprocess(error_plot2.to(object_next.device), normalize= True)
 
+    # fill colunmns with slots
     for o in range(num_objects):
 
         col = 18+size[1]*2+6+o*(6+size[1])+(o+1)*slots_margin
@@ -321,23 +330,35 @@ def plot_object_view(error_plot, error_plot2, error_plot_slots, error_plot_slots
         if (error_plot_slots2 is not None) and len(error_plot_slots2) > o:
             img[:,margin:margin+ch,  col] = get_color(o).view(3,1,1).to(object_next.device)
 
+        # gestalt gate
         img[:,margin+ch+2*margin:2*margin+gh_bar+ch+margin,  col] = visualise_gate(slots_closed[:,o, 0].to(object_next.device), h=gh_bar, w=len(col))
         offset = gh+margin-gh_margin+ch+2*margin
         row = (lambda row_index: [offset+(size[0]+6)*row_index, offset+size[0]*(row_index+1)+6*row_index])
         
         img[:,row(0)[0]:row(0)[1],  col] = preprocess(rawmask_next[0,o].to(object_next.device))
         img[:,row(1)[0]:row(1)[1],  col] = preprocess(object_next[:,o].to(object_next.device))
+
+        # small error plots top row
         if (error_plot_slots2 is not None) and len(error_plot_slots2) > o:
             img[:,row(2)[0]:row(2)[1],  col] = preprocess(error_plot_slots2[o].to(object_next.device), normalize=True)
 
+        # switch to bottom row
         offset = margin*2-8
         row = (lambda row_index: [offset+(size[0]+6)*row_index, offset+size[0]*(row_index+1)+6*row_index])   
+
+        # position gate
         img[:,row(4)[0]-gh+gh_margin:row(4)[0]-gh_margin,  col] = visualise_gate(slots_closed[:,o, 1].to(object_next.device), h=gh_bar, w=len(col))
         img[:,row(4)[0]:row(4)[1],  col]    = preprocess(velocity_next2d[o].to(object_next.device), normalize=True)[0]
+
+        # small error plots bottom row
         if (error_plot_slots is not None) and len(error_plot_slots) > o:
             img[:,row(5)[0]:row(5)[1],  col] = preprocess(error_plot_slots[o].to(object_next.device), normalize=True)
 
-    img = rearrange(img * 255, 'c h w -> h w c').cpu().numpy()
+        # add gatelord gate visualisation to image
+        if openings is not None:
+            img[:,row(5)[1]+gh_margin:row(5)[1]+gh-gh_margin,  col] = visualise_gate(openings[:,o].to(object_next.device), h=gh_bar, w=len(col), invert = True)
+
+    img = rearrange(img * 255, 'c h w -> h w c').cpu()
 
     return img
 
@@ -347,8 +368,57 @@ def write_image(file, img):
 
     pass
 
-def plot_timestep(cfg, cfg_net, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, gt_positions_target_next, association_table, error_next, output_hidden, object_view, individual_views, statistics_complete_slots, statistics_batch, sequence_len, root_path, plot_path, t_index, t, i):
-     
+def extract_element(tensor, index):
+    if tensor is None:
+        return None
+    return tensor[index:index+1]
+
+def plot_timestep(cfg, cfg_net, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, gt_positions_target_next, association_table, error_next, output_hidden, object_view, individual_views, statistics_complete_slots, statistics_batch, sequence_len, root_path, plot_path, t_index, t, sample_i, rollout_mode=False,  num_vid=2, att=None, openings=None):
+
+    if len(input) > 1:
+        img_list = None
+        for i in range(min(len(input), num_vid)):
+            _input = extract_element(input, i)
+            _target = extract_element(target, i)
+            _mask_cur = extract_element(mask_cur, i)
+            _mask_next = extract_element(mask_next, i)
+            _output_next = extract_element(output_next, i)
+            _position_encoder_cur = extract_element(position_encoder_cur, i)
+            _position_next = extract_element(position_next, i)
+            _rawmask_hidden = extract_element(rawmask_hidden, i)
+            _rawmask_cur = extract_element(rawmask_cur, i)
+            _rawmask_next = extract_element(rawmask_next, i)
+            _largest_object = extract_element(largest_object, i)
+            _object_cur = extract_element(object_cur, i)
+            _object_next = extract_element(object_next, i)
+            _object_hidden = extract_element(object_hidden, i)
+            _slots_bounded = extract_element(slots_bounded, i)
+            _slots_partially_occluded_cur = extract_element(slots_partially_occluded_cur, i)
+            _slots_occluded_cur = extract_element(slots_occluded_cur, i)
+            _slots_partially_occluded_next = extract_element(slots_partially_occluded_next, i)
+            _slots_occluded_next = extract_element(slots_occluded_next, i)
+            _slots_closed = extract_element(slots_closed, i)
+            _gt_positions_target_next = extract_element(gt_positions_target_next, i)
+            _association_table = extract_element(association_table, i)
+            _error_next = extract_element(error_next, i)
+            _output_hidden = extract_element(output_hidden, i)
+            _att = extract_element(att, i)
+            _openings = extract_element(openings, i)
+
+            img = plot_timestep_single(cfg, cfg_net, _input, _target, _mask_cur, _mask_next, _output_next, _position_encoder_cur, _position_next, _rawmask_hidden, _rawmask_cur, _rawmask_next, _largest_object, _object_cur, _object_next, _object_hidden, _slots_bounded, _slots_partially_occluded_cur, _slots_occluded_cur, _slots_partially_occluded_next, _slots_occluded_next, _slots_closed, _gt_positions_target_next, _association_table, _error_next, _output_hidden, object_view, individual_views, statistics_complete_slots, statistics_batch, sequence_len, root_path, plot_path, t_index, t, i, rollout_mode, att=_att, openings=_openings)
+            if img_list is None:
+                img_list = img.unsqueeze(0)
+            else:
+                img_list = th.cat((img_list, img.unsqueeze(0)), dim=0)
+
+        return img_list.permute(0, 3, 1, 2)
+    
+    else:
+        img = plot_timestep_single(cfg, cfg_net, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, gt_positions_target_next, association_table, error_next, output_hidden, object_view, individual_views, statistics_complete_slots, statistics_batch, sequence_len, root_path, plot_path, t_index, t, sample_i, rollout_mode, att=att, openings=openings)
+        return img
+
+def plot_timestep_single(cfg, cfg_net, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, gt_positions_target_next, association_table, error_next, output_hidden, object_view, individual_views, statistics_complete_slots, statistics_batch, sequence_len, root_path, plot_path, t_index, t, i, rollout_mode=False, att=None, openings=None):
+
     # Create eposition helpers
     size, gaus2d, vector2d, scale = get_position_helper(cfg_net, mask_cur.device)
     
@@ -364,7 +434,7 @@ def plot_timestep(cfg, cfg_net, input, target, mask_cur, mask_next, output_next,
     velocity_next2d = color_slots(velocity_next2d, slots_bounded, slots_partially_occluded_next, slots_occluded_next)
 
     # compute occlusion
-    if (cfg.datatype == "adept"):
+    if (cfg.datatype == "adept") and rawmask_hidden is not None:
         rawmask_cur_l, rawmask_next_l = compute_occlusion_mask(rawmask_cur, rawmask_next, mask_cur, mask_next, scale)
         rawmask_cur_h, rawmask_next_h = compute_occlusion_mask(rawmask_cur, rawmask_hidden, mask_cur, mask_next, scale)
         rawmask_cur_h[:,largest_object] = rawmask_cur_l[:,largest_object]
@@ -385,30 +455,39 @@ def plot_timestep(cfg, cfg_net, input, target, mask_cur, mask_next, output_next,
     mask_next       = rearrange(mask_next, 'b (o 1) h w -> b o 1 h w')
 
     if object_view:
-        if (cfg.datatype == "adept"):
+        if (cfg.datatype == "adept") and statistics_complete_slots is not None:
             num_objects = 4
             error_plot_slots = plot_online_error_slots(statistics_complete_slots['TE'][-cfg_net.num_objects*(t+1):], 'Tracking error', target, sequence_len, root_path, statistics_complete_slots['visible'][-cfg_net.num_objects*(t+1):], slots_bounded)
-            error_plot_slots2 = plot_online_error_slots(statistics_complete_slots['slot_error'][-cfg_net.num_objects*(t+1):], 'Image error', target, sequence_len, root_path, statistics_complete_slots['visible'][-cfg_net.num_objects*(t+1):], slots_bounded, ylim=0.0001)
+            #error_plot_slots2 = plot_online_error_slots(statistics_complete_slots['slot_error'][-cfg_net.num_objects*(t+1):], 'Image error', target, sequence_len, root_path, statistics_complete_slots['visible'][-cfg_net.num_objects*(t+1):], slots_bounded, ylim=0.0001)
             error_plot = plot_online_error(statistics_batch['image_error'], 'Prediction error', target, t, i, sequence_len, root_path)
             error_plot2 = plot_online_error(statistics_batch['TE'], 'Tracking error', target, t, i, sequence_len, root_path)
-            img = plot_object_view(error_plot, error_plot2, error_plot_slots, error_plot_slots2, highlighted_input, output_hidden, object_next, rawmask_next, velocity_next2d, target, slots_closed, gt_positions_target_next, association_table, size, num_objects, largest_object)
-        else:
+            att_histogram = plot_attention_histogram(att, target, root_path)
+            img = plot_object_view(error_plot, error_plot2, error_plot_slots, att_histogram, highlighted_input, output_hidden, object_next, rawmask_next, velocity_next2d, target, slots_closed, gt_positions_target_next, association_table, size, num_objects, largest_object, openings=openings)
+        elif (cfg.datatype == "clevrer") and statistics_complete_slots is not None:
             num_objects = cfg_net.num_objects
             error_plot_slots2 = plot_online_error_slots(statistics_complete_slots['slot_error'][-cfg_net.num_objects*(t+1):], 'Image error', target, sequence_len, root_path, statistics_complete_slots['slot_error'][-cfg_net.num_objects*(t+1):], slots_bounded, ylim=0.0001)
             error_plot = plot_online_error(statistics_batch['image_error_mse'], 'Prediction error', target, t, i, sequence_len, root_path)
-            img = plot_object_view(error_plot, None, None, error_plot_slots2, highlighted_input, output_next, object_next, rawmask_next, velocity_next2d, target, slots_closed, None, None, size, num_objects, largest_object)
-        
-        cv2.imwrite(f'{plot_path}object/gpnet-objects-{i:04d}-{t_index:03d}.jpg', img)
+            img = plot_object_view(error_plot, None, None, error_plot_slots2, highlighted_input, output_next, object_next, rawmask_next, velocity_next2d, target, slots_closed, gt_positions_target_next, association_table, size, num_objects, largest_object, openings=openings)
+        else:
+            num_objects = cfg_net.num_objects
+            att_histogram = plot_attention_histogram(att, target, root_path)
+            img = plot_object_view(None, None, att_histogram, None, input, output, object_next, rawmask_next, velocity_next2d, target, slots_closed, gt_positions_target_next, association_table, size, num_objects, largest_object, rollout_mode=rollout_mode, openings=openings)
+
+        if plot_path is not None:
+            cv2.imwrite(f'{plot_path}/object/{i:04d}-{t_index:03d}.jpg', img.numpy())
 
     if individual_views:
         # ['error', 'input', 'background', 'prediction', 'position', 'rawmask', 'mask', 'othermask']:
         write_image(f'{plot_path}/individual/error/error-{i:04d}-{t_index:03d}.jpg', error_next[0])
-        write_image(f'{plot_path}/individual/input/input-{i:04d}-{t_index:03d}.jpg', input[0])
+        write_image(f'{plot_path}/individual/input/input-{i:04d}-{t_index:03d}.jpg', target[0])
         write_image(f'{plot_path}/individual/background/background-{i:04d}-{t_index:03d}.jpg', mask_next[0,-1])
-        write_image(f'{plot_path}/individual/imagination/imagination-{i:04d}-{t_index:03d}.jpg', output_hidden[0])
+        #write_image(f'{plot_path}/individual/imagination/imagination-{i:04d}-{t_index:03d}.jpg', output_hidden[0])
         write_image(f'{plot_path}/individual/prediction/prediction-{i:04d}-{t_index:03d}.jpg', output_next[0])
+        for o in range(len(rawmask_next[0])):
+            write_image(f'{plot_path}/individual/rgb/object-{i:04d}-{o}-{t_index:03d}.jpg', object_next[0][o])
+            write_image(f'{plot_path}/individual/rawmask/rawmask-{i:04d}-{o}-{t_index:03d}.jpg', rawmask_next[0][o])
 
-    pass
+    return img
 
 def get_position_helper(cfg_net, device):
     size = cfg_net.input_size
@@ -425,4 +504,35 @@ def reshape_slots(slots_bounded, slots_partially_occluded_cur, slots_occluded_cu
     slots_partially_occluded_next = th.squeeze(slots_partially_occluded_next)[..., None,None,None]
     slots_occluded_next = th.squeeze(slots_occluded_next)[..., None,None,None]
 
-    return slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next
-\ No newline at end of file
+    return slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next
+
+def plot_attention_histogram(att, target, root_path):
+    att_plots = []
+    if (att is not None) and (len(att) > 0):
+        att = att[0]
+        for object_attention in att:
+
+            fig, ax = plt.subplots(figsize=(round(target.shape[3]/100,2), round(target.shape[2]/100,2)))
+
+            # Plot a bar plot over the 6 objects
+            num_objects = len(object_attention)
+            ax.bar(range(num_objects), object_attention.cpu())
+            ax.set_ylim([0,1])
+            ax.set_xlim([-1,num_objects])
+            ax.set_xticks(range(num_objects))
+            #ax.set_xticklabels(['1','2','3','4','5','6'])
+            ax.set_ylabel('attention')
+            ax.set_xlabel('object')
+            ax.set_title('Attention histogram')
+
+            # fixed
+            fig.tight_layout()
+            plt.savefig(f'{root_path}/tmp.jpg')
+            plot = PIL.Image.frombytes('RGB', fig.canvas.get_width_height(),fig.canvas.tostring_rgb())
+            plot = th.from_numpy(np.array(plot).transpose(2,0,1))
+            plt.close(fig)  
+            att_plots.append(plot)
+
+        return att_plots
+    else:
+        return None
+\ No newline at end of file
diff --git a/scripts/validation.py b/scripts/validation.py
index 5b1638d..b59cc39 100644
--- a/scripts/validation.py
+++ b/scripts/validation.py
@@ -1,8 +1,11 @@
+import os
 import torch as th
 from torch import nn
 from torch.utils.data import DataLoader
 import numpy as np
 from einops import rearrange, repeat, reduce
+from scripts.evaluation_bb import distance_eval_step
+from scripts.evaluation_clevrer import compute_statistics_summary
 from scripts.utils.configuration import Configuration
 from model.loci import Loci
 import time
@@ -10,12 +13,19 @@ import lpips
 from skimage.metrics import structural_similarity as ssimloss
 from skimage.metrics import peak_signal_noise_ratio as psnrloss
 
-def validation_adept(valloader: DataLoader, net: Loci, cfg: Configuration, device):
+from scripts.utils.eval_metrics import masks_to_boxes, postproc_mask, pred_eval_step
+from scripts.utils.eval_utils import append_statistics, compute_position_from_mask
+from scripts.utils.plot_utils import plot_timestep
+
+def validation_adept(valloader: DataLoader, net: Loci, cfg: Configuration, device, writer, epoch, root_path):
 
     # memory
     mseloss = nn.MSELoss()
-    avgloss = 0
+    loss_next = 0
     start_time = time.time()
+    cfg_net = cfg.model
+    num_steps = 0
+    plot_path = os.path.join(root_path, 'plots', f'epoch_{epoch}')
 
     with th.no_grad():
         for i, input in enumerate(valloader):
@@ -103,7 +113,8 @@ def validation_adept(valloader: DataLoader, net: Loci, cfg: Configuration, devic
                 # 1. Track error
                 if t >= 0:
                     loss = mseloss(output_next, target)
-                    avgloss += loss.item()
+                    loss_next += loss.item()
+                    num_steps += 1
 
                 # 2. Remember output
                 mask_last     = mask_next.clone()
@@ -122,12 +133,19 @@ def validation_adept(valloader: DataLoader, net: Loci, cfg: Configuration, devic
                 error_next    = th.sqrt(error_next) * bg_error_next
                 error_last    = error_next.clone()
 
-    print(f"Validation loss: {avgloss / len(valloader.dataset):.2e}, Time: {time.time() - start_time}")
-            
+                # PLotting
+                if (i == 0) and (t_index % 2 == 0) and (epoch % 3 == 0):
+                    os.makedirs(os.path.join(plot_path,  'object'), exist_ok=True)
+                    openings = net.get_openings()
+                    img_tensor = plot_timestep(cfg, cfg_net, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, None, None, error_next, None, True, False, None, None, sequence_len, root_path, plot_path, t_index, t, i, openings=openings)
+
+    print(f"Validation loss: {loss_next / num_steps:.2e}, Time: {time.time() - start_time}")
+    writer.add_scalar('Val/Prediction Loss', loss_next / num_steps, epoch)
+
     pass
 
 
-def validation_clevrer(valloader: DataLoader, net: Loci, cfg: Configuration, device):
+def validation_clevrer(valloader: DataLoader, net: Loci, cfg: Configuration, device, writer, epoch, root_path):
 
     # memory
     mseloss = nn.MSELoss()
@@ -140,6 +158,9 @@ def validation_clevrer(valloader: DataLoader, net: Loci, cfg: Configuration, dev
 
     burn_in_length = 6
     rollout_length = 42
+    
+    plot_path = os.path.join(root_path, 'plots', f'epoch_{epoch}')
+    os.makedirs(os.path.join(plot_path,  'object'), exist_ok=True)
 
     with th.no_grad():
         for i, input in enumerate(valloader):
@@ -256,6 +277,243 @@ def validation_clevrer(valloader: DataLoader, net: Loci, cfg: Configuration, dev
                 error_next    = th.sqrt(error_next) * bg_error_next
                 error_last    = error_next.clone()
 
+                # PLotting
+                if i == 0:
+                    openings = net.get_openings()
+                    img_tensor = plot_timestep(cfg, cfg.model, input, target, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, None, None, error_next, None, True, False, None, None, sequence_len, root_path, plot_path, t_index, t, i, openings=openings)
+
+
     print(f"MSE loss: {avgloss_mse / len(valloader.dataset):.2e}, LPIPS loss: {avgloss_lpips / len(valloader.dataset):.2e}, PSNR loss: {avgloss_psnr / len(valloader.dataset):.2e}, SSIM loss: {avgloss_ssim / len(valloader.dataset):.2e}, Time: {time.time() - start_time}")
+    writer.add_scalar('Val/Prediction Loss', avgloss_mse / len(valloader.dataset), epoch)
+    writer.add_scalar('Val/LPIPS Loss', avgloss_lpips / len(valloader.dataset), epoch)
+    writer.add_scalar('Val/PSNR Loss', avgloss_psnr / len(valloader.dataset), epoch)
+    writer.add_scalar('Val/SSIM Loss', avgloss_ssim / len(valloader.dataset), epoch)
+
+    pass
+
+
+def validation_bb(valloader: DataLoader, net: Loci, cfg: Configuration, device, writer, epoch, root_path):
+
+    # memory
+    start_time = time.time()
+    net.eval()
+    evaluation_mode = 'vidpred_black'
+    use_meds = True
+
+    # Evaluation Specifics
+    burn_in_length = 10
+    rollout_length = 20
+    rollout_length_stats = 10 # only consider the first 10 frames for statistics
+    target_size = (64, 64)
+
+    # Losses
+    lpipsloss = lpips.LPIPS(net='vgg').to(device)
+    mseloss = nn.MSELoss()
+    metric_complete = {'mse': [], 'ssim': [], 'psnr': [], 'percept_dist': [], 'ari': [], 'fari': [], 'miou': [], 'ap': [], 'ar': [], 'meds': [], 'ari_hidden': [], 'fari_hidden': [], 'miou_hidden': []}
+    loss_next = 0.0
+    loss_cur  = 0.0
+    num_steps = 0
+    plot_path = os.path.join(root_path, 'plots', f'epoch_{epoch}')
+    os.makedirs(os.path.join(plot_path,  'object'), exist_ok=True)
+
+    with th.no_grad():
+        for i, input in enumerate(valloader):
+
+            # Load data
+            tensor = input[0].float().to(device)
+            background_fix  = input[1].to(device)
+            gt_pos          = input[2].to(device)
+            gt_mask         = input[3].to(device)
+            gt_pres_mask    = input[4].to(device)
+            gt_hidden_mask  = input[5].to(device)
+            sequence_len    = tensor.shape[1]
+
+            # placehodlers
+            mask_cur       = None
+            mask_last      = None
+            rawmask_last   = None
+            position_last  = None
+            gestalt_last   = None
+            priority_last  = None
+            gt_positions_target = None
+            slots_occlusionfactor = None
+            error_last  = None
+
+            # Memory
+            cfg_net = cfg.model
+            num_objects_bb = gt_pos.shape[2]
+            pred_pos_batch        = th.zeros((cfg_net.batch_size, rollout_length, num_objects_bb, 2)).to(device)
+            gt_pos_batch          = th.zeros((cfg_net.batch_size, rollout_length, num_objects_bb, 2)).to(device)
+            pred_img_batch        = th.zeros((cfg_net.batch_size, rollout_length, 3, target_size[0], target_size[1])).to(device)
+            gt_img_batch          = th.zeros((cfg_net.batch_size, rollout_length, 3, target_size[0], target_size[1])).to(device)
+            pred_mask_batch       = th.zeros((cfg_net.batch_size, rollout_length, target_size[0], target_size[1])).to(device)
+            pred_hidden_mask_batch   = th.zeros((cfg_net.batch_size, rollout_length, target_size[0], target_size[1])).to(device)
             
+            # Counters
+            num_rollout = 0
+            num_burnin  = 0
+            
+            # loop through frames
+            for t_index,t in enumerate(range(-cfg.defaults.teacher_forcing, burn_in_length+rollout_length)):
+
+                # Move to next frame
+                t_run = max(t, 0)
+                input  = tensor[:,t_run]
+                target_cur  = tensor[:,t_run]
+                target = th.clip(tensor[:,t_run+1], 0, 1)
+                gt_pos_t = gt_pos[:,t_run+1]/32-1
+                gt_pos_t = th.concat((gt_pos_t, th.ones_like(gt_pos_t[:,:,:1])), dim=2)
+
+                rollout_index = t_run - burn_in_length
+                rollout_active = False
+                if t>=0:
+                    if rollout_index >= 0:
+                        num_rollout += 1
+                        if (evaluation_mode == 'vidpred_black'):
+                            input = output_next * 0
+                            error_last = error_last * 0
+                            rollout_active = True
+                        elif (evaluation_mode == 'vidpred_auto'):
+                            input = output_next
+                            error_last = error_last * 0
+                            rollout_active = True
+                    else:
+                        num_burnin += 1  
+
+                # obtain prediction
+                (
+                    output_next, 
+                    position_next, 
+                    gestalt_next, 
+                    priority_next, 
+                    mask_next, 
+                    rawmask_next,
+                    object_next, 
+                    background, 
+                    slots_occlusionfactor,
+                    output_cur,
+                    position_cur,
+                    gestalt_cur,
+                    priority_cur,
+                    mask_cur,
+                    rawmask_cur,
+                    object_cur,
+                    position_encoder_cur,
+                    slots_bounded,
+                    slots_partially_occluded_cur,   
+                    slots_occluded_cur,
+                    slots_partially_occluded_next,
+                    slots_occluded_next,
+                    slots_closed,
+                    output_hidden,
+                    largest_object,
+                    rawmask_hidden,
+                    object_hidden
+                ) = net(
+                    input, 
+                    error_last,
+                    mask_last, 
+                    rawmask_last,
+                    position_last, 
+                    gestalt_last,
+                    priority_last,
+                    background_fix,
+                    slots_occlusionfactor,
+                    reset = (t == -cfg.defaults.teacher_forcing),
+                    evaluate=True,
+                    warmup = (t < 0),
+                    shuffleslots = True,
+                    reset_mask = (t <= 0),
+                    allow_spawn = True,
+                    show_hidden = False,
+                    clean_slots = False,
+                )
+
+                # 1. Track error
+                if t >= 0:
+
+                    if (rollout_index >= 0):
+                        # store positions per batch
+                        if use_meds:
+                            if False:
+                                pred_pos_batch[:,rollout_index] = rearrange(position_next, 'b (o c) -> b o c', o=cfg_net.num_objects)[:,:,:2]
+                            else:
+                                pred_pos_batch[:,rollout_index] = compute_position_from_mask(rawmask_next)
+
+                            gt_pos_batch[:,rollout_index] = gt_pos_t[:,:,:2]
+
+                        pred_img_batch[:,rollout_index] = output_next
+                        gt_img_batch[:,rollout_index] = target
+
+                        # Here we compute only the foreground segmentation mask
+                        pred_mask_batch[:,rollout_index] = postproc_mask(mask_next[:,None,:,None])[:, 0]
+
+                        # Here we compute the hidden segmentation
+                        occluded_cur        = th.clip(rawmask_next - mask_next, 0, 1)[:,:-1]
+                        occluded_sum_cur    = 1-(reduce(occluded_cur, 'b c h w -> b h w', 'max') > 0.5).float()
+                        occluded_cur        = th.cat((occluded_cur, occluded_sum_cur[:,None]), dim=1)
+                        pred_hidden_mask_batch[:,rollout_index] = postproc_mask(occluded_cur[:,None,:,None])[:, 0]
+
+                # 2. Remember output
+                mask_last     = mask_next.clone()
+                rawmask_last  = rawmask_next.clone()
+                position_last = position_next.clone()
+                gestalt_last  = gestalt_next.clone()
+                priority_last = priority_next.clone()
+                        
+                # 3. Error for next frame
+                # background error
+                bg_error_cur  = th.sqrt(reduce((input - background)**2, 'b c h w -> b 1 h w', 'mean')).detach()
+                bg_error_next = th.sqrt(reduce((target - background)**2, 'b c h w -> b 1 h w', 'mean')).detach()
+
+                # prediction error
+                error_next    = th.sqrt(reduce((target - output_next)**2, 'b c h w -> b 1 h w', 'mean')).detach()
+                error_next    = th.sqrt(error_next) * bg_error_next
+                error_last    = error_next.clone()
+
+                # Prediction and encoder Loss
+                loss_next += mseloss(output_next * bg_error_next, target * bg_error_next)
+                loss_cur  += mseloss(output_cur * bg_error_cur,   input  * bg_error_cur)
+                num_steps += 1
+
+                # PLotting
+                if i == 0:
+                    openings = net.get_openings()
+                    img_tensor = plot_timestep(cfg, cfg_net, input, target_cur, mask_cur, mask_next, output_next, position_encoder_cur, position_next, rawmask_hidden, rawmask_cur, rawmask_next, largest_object, object_cur, object_next, object_hidden, slots_bounded, slots_partially_occluded_cur, slots_occluded_cur, slots_partially_occluded_next, slots_occluded_next, slots_closed, gt_pos_t, None, error_next, None, True, False, None, None, sequence_len, root_path, plot_path, t_index, t, i, rollout_mode=rollout_active, openings=openings)
+
+        for b in range(cfg_net.batch_size):
+
+            # perceptual similarity from slotformer paper
+            metric_dict = pred_eval_step(
+                gt              = gt_img_batch[b:b+1],
+                pred            = pred_img_batch[b:b+1],
+                pred_mask       = pred_mask_batch.long()[b:b+1],
+                pred_mask_hidden = pred_hidden_mask_batch.long()[b:b+1],
+                pred_bbox       = None,
+                gt_mask         = gt_mask.long()[b:b+1, burn_in_length+1:burn_in_length+rollout_length+1],
+                gt_mask_hidden  = gt_hidden_mask.long()[b:b+1, burn_in_length+1:burn_in_length+rollout_length+1],
+                gt_pres_mask    = gt_pres_mask[b:b+1, burn_in_length+1:burn_in_length+rollout_length+1], 
+                gt_bbox         = None,
+                lpips_fn        = lpipsloss,
+                eval_traj       = True,
+            )
+
+            metric_dict['meds'] = distance_eval_step(gt_pos_batch[b], pred_pos_batch[b])
+            metric_complete = append_statistics(metric_dict, metric_complete)
+
+        # sanity check
+        if (num_rollout != rollout_length) and (num_burnin != burn_in_length):
+            raise ValueError('Number of rollout steps and burnin steps must be equal to the sequence length.')
+        
+    dic = compute_statistics_summary(metric_complete, evaluation_mode, consider_first_n_frames=rollout_length_stats)
+    writer.add_scalar('Val/Meds', dic['meds_complete_sum'], epoch)
+
+    writer.add_scalar('Val/ARI_hidden', dic['ari_hidden_complete_average'], epoch)
+    writer.add_scalar('Val/ARI', dic['ari_complete_average'], epoch)
+    writer.add_scalar('Val/LPIPS', dic['percept_dist_complete_average'], epoch)
+
+    writer.add_scalar('Val/Prediction Loss', loss_next / num_steps, epoch)
+    writer.add_scalar('Val/Encoding Loss', loss_cur / num_steps, epoch)
+
+    net.train()
     pass
 \ No newline at end of file
author	fredeee	2024-03-23 13:27:00 +0100
committer	fredeee	2024-03-23 13:27:00 +0100
commit	6bcf6b8306ce4903734fb31824799a50281cea69 (patch)
tree	0545ff1b8beb051993c2d75fd81306db1a22274d
parent	ad0b64a7f0140406151d18b19ab2ed5d19b6c511 (diff)