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