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