diff options
Diffstat (limited to 'evaluation/adept_ablation/lambda/evaluation_loci_looped_abl2.ipynb')
| -rw-r--r-- | evaluation/adept_ablation/lambda/evaluation_loci_looped_abl2.ipynb | 469 |
1 files changed, 469 insertions, 0 deletions
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 +} |