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