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