notebooks/optimal/cherry.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorithm performance and running time comparison on credit card data (Figures 2, 3, EC.8, EC.9)\n",
    "\n",
    "In this notebook we produce plots to compare the performance of the algorithms presented in the paper in terms of utility and running time for instances generated based on real data. The resulting plots are presented in Figures 2, 3, EC.8 & EC.9.\n",
    "\n",
    "**Required script execution:** cherry.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.chdir(\"../\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import container\n",
    "import matplotlib.ticker as mtick\n",
    "plt.style.use('default')\n",
    "import seaborn as sns\n",
    "import glob\n",
    "import json\n",
    "from lib import utils\n",
    "from matplotlib.colors import LogNorm\n",
    "import copy\n",
    "from mpl_toolkits.axes_grid1.inset_locator import zoomed_inset_axes\n",
    "from mpl_toolkits.axes_grid1.inset_locator import mark_inset\n",
    "sns.set_context(\"paper\", font_scale=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, set the value of $\\gamma$ (choose from the ones listed below) and the type of cost function (choose from \\{max_percentile_shift, euclidean\\})."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "name=\"cherry\"\n",
    "datas=\"credit\"\n",
    "# gamma=0.8326266551572056  #40-th percentile\n",
    "gamma=0.8563985631883158  #50-th percentile\n",
    "# gamma=0.8719260871092159    #60-th percentile\n",
    "cost_method='max_percentile_shift'\n",
    "# cost_method='euclidean'\n",
    "final_df = []\n",
    "cols = sns.color_palette(\"Set2\",9)\n",
    "col_dict = {\"Non-Strategic\": cols[0],\n",
    "            \"Bruteforce\": cols[1],\n",
    "            \"Threshold\": cols[2],\n",
    "            \"Iterative\": cols[3],\n",
    "            \"Iterative (Optimized)\": cols[4],\n",
    "            \"DP\": cols[5]\n",
    "           }\n",
    "linestyles_dict = {\"Non-Strategic\": \"-.\",\n",
    "            \"Bruteforce\": \"-\",\n",
    "            \"Threshold\": \"-\",\n",
    "            \"Iterative\": \"--\",\n",
    "            \"Iterative (Optimized)\": \"-.\",\n",
    "            \"DP\": \":\"\n",
    "           }\n",
    "markers_dict = {\"Non-Strategic\": \"v\",\n",
    "            \"Bruteforce\": \"s\",\n",
    "            \"Threshold\": \"^\",\n",
    "            \"Iterative\": \"o\",\n",
    "            \"Iterative (Optimized)\": \"P\",\n",
    "            \"DP\": \"D\"\n",
    "           }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "files = glob.glob(\"./outputs/optimal/{name}_thres_data_{datas}_cost_{cost_method}_*_gamma_{gamma}_*config.json\".format(name=name, datas=datas, cost_method=cost_method, gamma=gamma))\n",
    "data = []\n",
    "\n",
    "for fi in files:\n",
    "    with open(fi,\"r\") as file:\n",
    "        data.append(json.load(file))\n",
    "\n",
    "df_standard = pd.DataFrame(data)\n",
    "final_df.append(df_standard.melt(id_vars=[\"m\", \"seed\", \"kappa\", \"alpha\", \"sparsity\", \"time\", \"pi\", \"strategic_threshold_br\"], var_name=\"algorithm\", value_name=\"utility\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "files = glob.glob(\"./outputs/optimal/{name}_iterative*_data_{datas}_cost_{cost_method}_*_gamma_{gamma}_*config.json\".format(name=name, datas=datas, cost_method=cost_method, gamma=gamma))\n",
    "data = []\n",
    "\n",
    "for fi in files:\n",
    "    with open(fi,\"r\") as file:\n",
    "        data.append(json.load(file))\n",
    "df_standard = pd.DataFrame(data)\n",
    "final_df.append(df_standard.melt(id_vars=[\"m\", \"seed\", \"kappa\", \"alpha\", \"components\", \"sparsity\", \"time\", \"parallel\", \"iterations\", \"pi\", \"strategic_br\", \"pi_non_strategic\", \"non_strategic_br\", \"strategic_deter_br\", \"pi_strategic_deter\", \"strategic_deter\", \"split_components\"], var_name=\"algorithm\", value_name=\"utility\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/gy/xwt8ngc15hj3w_8vq_bk0yz80000gt/T/ipykernel_4260/1023273751.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['algorithm'][df['algorithm']==\"strategic\"] = df['algorithm'][df['algorithm']==\"strategic\"]+df['split_components'][df['algorithm']==\"strategic\"].astype(str)\n",
      "/var/folders/gy/xwt8ngc15hj3w_8vq_bk0yz80000gt/T/ipykernel_4260/1023273751.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['algorithm'][df['algorithm']==\"strategic\"] = df['algorithm'][df['algorithm']==\"strategic\"]+df['split_components'][df['algorithm']==\"strategic\"].astype(str)\n"
     ]
    }
   ],
   "source": [
    "df = pd.concat(final_df)\n",
    "df['algorithm'][df['algorithm']==\"strategic\"] = df['algorithm'][df['algorithm']==\"strategic\"]+df['split_components'][df['algorithm']==\"strategic\"].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['algorithm'] = df['algorithm'].str.replace(\"non_strategic\", \"Non-Strategic\")\n",
    "df['algorithm'] = df['algorithm'].str.replace(\"strategic_threshold\", \"Threshold\")\n",
    "df['algorithm'] = df['algorithm'].str.replace(\"strategicTrue\", \"Iterative (Optimized)\")\n",
    "df['algorithm'] = df['algorithm'].str.replace(\"strategicFalse\", \"Iterative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['confounding', 'Threshold', 'Iterative', 'Iterative (Optimized)',\n",
       "       'Non-Strategic'], dtype=object)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['algorithm'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "if cost_method=='euclidean':\n",
    "    df['alpha'] = 1/df['alpha']\n",
    "else:\n",
    "    df['alpha'] = (1/df['alpha']*100).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 50,  30, 100,  10,  20])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['alpha'].unique()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Utility plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "utils.latexify(8,5, font_scale=3.0)\n",
    "ax = plt.gca()\n",
    "df.sort_values([\"algorithm\"], inplace=True)\n",
    "algorithms=[\"Non-Strategic\", \"Threshold\", \"Iterative\"]\n",
    "colors = [col_dict[alg] for alg in algorithms]\n",
    "markers = [markers_dict[alg] for alg in algorithms]\n",
    "linestyles = [linestyles_dict[alg] for alg in algorithms]\n",
    "\n",
    "lines={}\n",
    "alphas=df['alpha'].unique()\n",
    "for alg in algorithms:\n",
    "    lines[alg]=[]\n",
    "    for x_val in alphas:\n",
    "        line_l=pd.DataFrame(df[(df['algorithm']==alg) & (df['alpha']==x_val)], columns=['utility']).values.tolist()\n",
    "        lines[alg].append((x_val,np.mean(line_l),np.std(line_l)))\n",
    "\n",
    "ax=plt.subplot(111)\n",
    "new_handles = []\n",
    "for alg in algorithms:\n",
    "    line_sorted=sorted(lines[alg], key=lambda x:x[0], reverse=True)\n",
    "    x_vals=[x[0] for x in line_sorted]\n",
    "    y_vals=[x[1] for x in line_sorted]\n",
    "    h, = ax.plot(x_vals, y_vals, linestyle=linestyles_dict[alg], marker=markers_dict[alg], label=alg, markersize=9, color=col_dict[alg], linewidth=2)\n",
    "    new_handles.append(copy.copy(h))\n",
    "\n",
    "for ind, alg in enumerate(algorithms):\n",
    "    new_handles[ind].set_color('w')\n",
    "    new_handles[ind].set_markerfacecolor(col_dict[alg])\n",
    "    new_handles[ind].set_markeredgecolor(col_dict[alg])\n",
    "    new_handles[ind].set_markersize(9)\n",
    "    new_handles[ind].set_markeredgewidth(1)\n",
    "\n",
    "plt.legend(handles=new_handles, shadow=None, loc=2, labelspacing=0.1, handletextpad=0.3)\n",
    "plt.ylabel(\"Utility, $u(\\\\pi,\\\\gamma)$\")\n",
    "if cost_method=='euclidean':\n",
    "    plt.xlabel(\"$1/\\\\tau$\")\n",
    "    temp = plt.xticks(ticks=x_vals, labels=[\"{:.1f}\".format(x) for x in x_vals])\n",
    "else:\n",
    "    plt.xlabel(\"Allowed percentile shift, $1/\\\\tau$\")\n",
    "    temp = plt.xticks(ticks=x_vals, labels=[str(x)+'\\%' for x in x_vals])    \n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "# temp = plt.xticks(ticks=x_vals, labels=[str(x)+'\\%' for x in x_vals])\n",
    "plt.savefig(\"./figures/optimal/{name}_{datas}_u_gamma_{gamma}_cost_{cost_method}.pdf\".format(name=name, datas=datas, gamma=str(gamma).replace('.',''), cost_method=cost_method),bbox_inches='tight', )\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "utils.latexify(8,5, font_scale=3.0)\n",
    "ax = plt.gca()\n",
    "df.sort_values([\"algorithm\"], inplace=True)\n",
    "algorithms=[\"Non-Strategic\", \"Threshold\", \"Iterative\"]\n",
    "x_vals=sorted(df['alpha'].unique())\n",
    "\n",
    "df_filtered = df[df['algorithm'].isin(['Threshold', 'Iterative'])]\n",
    "df_pivoted = df_filtered.pivot(index='alpha', columns='algorithm', values='utility')\n",
    "df_pivoted['percent_improvement'] = ((df_pivoted['Iterative'] - df_pivoted['Threshold']) / df_pivoted['Threshold']) * 100\n",
    "\n",
    "ax=plt.subplot(111)\n",
    "ax.bar(df_pivoted.index, df_pivoted['percent_improvement'], width=4, color=cols[6])\n",
    "\n",
    "plt.ylabel(\"Utility gain of $\\\\pi_I$ over $\\\\pi_T$\")\n",
    "if cost_method=='euclidean':\n",
    "    plt.xlabel(\"$1/\\\\tau$\")\n",
    "    temp = plt.xticks(ticks=x_vals, labels=[\"{:.1f}\".format(x) for x in x_vals])\n",
    "else:\n",
    "    plt.xlabel(\"Allowed percentile shift, $1/\\\\tau$\")\n",
    "    temp = plt.xticks(ticks=x_vals, labels=[str(x)+'\\%' for x in x_vals])    \n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.yaxis.set_major_formatter(mtick.PercentFormatter(decimals=0))\n",
    "\n",
    "plt.savefig(\"./figures/optimal/{name}_{datas}_u_improvement_gamma_{gamma}_cost_{cost_method}.pdf\".format(name=name, datas=datas, gamma=str(gamma).replace('.',''), cost_method=cost_method),bbox_inches='tight', )\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Runtime plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "utils.latexify(8,5, font_scale=3.0)\n",
    "lines={}\n",
    "algorithms=[\"Threshold\", \"Iterative\", \"Iterative (Optimized)\"]\n",
    "alphas=df['alpha'].unique()\n",
    "for alg in algorithms:\n",
    "    lines[alg]=[]\n",
    "    for x_val in alphas:\n",
    "        line_l=pd.DataFrame(df[(df['algorithm']==alg) & (df['alpha']==x_val)], columns=['time']).values.tolist()\n",
    "        lines[alg].append((x_val,np.mean(line_l),np.std(line_l)))\n",
    "\n",
    "ax=plt.subplot(111)\n",
    "new_handles = []\n",
    "for alg in algorithms:\n",
    "    line_sorted=sorted(lines[alg], key=lambda x:x[0])\n",
    "    x_vals=[x[0] for x in line_sorted]\n",
    "    y_vals=[x[1] for x in line_sorted]\n",
    "    h, = ax.plot(x_vals, y_vals, linestyle=linestyles_dict[alg], marker=markers_dict[alg], label=alg, markersize=9, color=col_dict[alg], linewidth=2)\n",
    "    new_handles.append(copy.copy(h))\n",
    "\n",
    "for ind, alg in enumerate(algorithms):\n",
    "    new_handles[ind].set_color('w')\n",
    "    new_handles[ind].set_markerfacecolor(col_dict[alg])\n",
    "    new_handles[ind].set_markeredgecolor(col_dict[alg])\n",
    "    new_handles[ind].set_markersize(9)\n",
    "    new_handles[ind].set_markeredgewidth(1)\n",
    "\n",
    "plt.legend(handles=new_handles, shadow=None, loc=1, labelspacing=0.1, handletextpad=0.3)\n",
    "plt.ylabel(\"Time (s)\")\n",
    "plt.xlabel(\"Allowed percentile shift, $1/\\\\tau$\")\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "temp = plt.xticks(ticks=x_vals, labels=[str(x)+'\\%' for x in x_vals])\n",
    "plt.yscale('log') \n",
    "top_lim = 500000\n",
    "plt.ylim(top=top_lim)\n",
    "plt.savefig(\"./figures/optimal/{name}_{datas}_t.pdf\".format(name=name, datas=datas),bbox_inches='tight', )\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "utils.latexify(8,5, font_scale=3.0)\n",
    "lines={}\n",
    "algorithms=[\"Iterative (Optimized)\"]\n",
    "alphas=df['alpha'].unique()\n",
    "for alg in algorithms:\n",
    "    lines[alg]=[]\n",
    "    for x_val in alphas:\n",
    "        line_l=pd.DataFrame(df[(df['algorithm']==alg) & (df['alpha']==x_val)], columns=['components']).values.tolist()\n",
    "        lines[alg].append((x_val,np.mean(line_l),np.std(line_l)))\n",
    "\n",
    "ax=plt.subplot(111)\n",
    "for alg in algorithms:\n",
    "    line_sorted=sorted(lines[alg], key=lambda x:x[0])\n",
    "    x_vals=[x[0] for x in line_sorted]\n",
    "    y_vals=[x[1] for x in line_sorted]\n",
    "    ax.plot(x_vals, y_vals, linestyle='-', marker='o', markersize=9, color=cols[6], linewidth=2)\n",
    "\n",
    "plt.ylabel(\"Connected components\")\n",
    "# plt.ylabel(\"Subproblems\")\n",
    "plt.xlabel(\"Allowed percentile shift, $1/\\\\tau$\")\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "temp = plt.xticks(ticks=x_vals, labels=[str(x)+'\\%' for x in x_vals])\n",
    "plt.savefig(\"./figures/optimal/{name}_{datas}_comp.pdf\".format(name=name, datas=datas),bbox_inches='tight', )\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Population movement plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/gy/xwt8ngc15hj3w_8vq_bk0yz80000gt/T/ipykernel_64236/4020874639.py:3: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  u = pd.read_csv('data/processed/'+datas+'_pyx.csv', index_col=0, names=[\"ID\", \"Probability\"], header=0, dtype={'Probability': np.float})\n"
     ]
    }
   ],
   "source": [
    "# Read data\n",
    "px = pd.read_csv('data/processed/'+datas+'_px.csv', index_col=0, header=0)\n",
    "u = pd.read_csv('data/processed/'+datas+'_pyx.csv', index_col=0, names=[\"ID\", \"Probability\"], header=0, dtype={'Probability': np.float})\n",
    "vecs = pd.read_csv('data/processed/'+datas+'_vectors.csv', index_col=0, header=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged = pd.merge(px, u, left_index=True, right_index=True)\n",
    "merged = merged.sort_values(by=['Probability'])\n",
    "merged['Population']= merged['Population'].cumsum()-merged['Population']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "limits=[0]\n",
    "for per in np.arange(0.1, 1.0, 0.1):\n",
    "    limits.append(merged['Probability'].loc[(merged['Population']>=per).idxmax()])\n",
    "\n",
    "limits.append(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "util_class = np.zeros(u.size, dtype=int)\n",
    "for ind,lower in enumerate(limits[:-1]):\n",
    "    indexes=u[(u['Probability']>=limits[ind]) & (u['Probability']<limits[ind+1])].index\n",
    "    for i in indexes:\n",
    "        util_class[i]=ind\n",
    "\n",
    "u['Class']=list(util_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "fi = \"./outputs/optimal/{name}_iterative_data_{datas}_cost_{cost_method}_a_1_gamma_{gamma}_seed_1_config.json\".format(name=name, datas=datas, cost_method=cost_method, gamma=gamma)\n",
    "total_accepted = 0\n",
    "with open(fi,\"r\") as file:\n",
    "    obj = json.load(file)\n",
    "    pi = obj['pi_non_strategic']\n",
    "    non_strategic_br = obj['non_strategic_br']\n",
    "    movement_matrix = np.zeros((10, 10))\n",
    "    for s, t in non_strategic_br.items():\n",
    "        source = int(s)\n",
    "        target = int(t)\n",
    "        movement_matrix[int(u.loc[source]['Class']),int(u.loc[target]['Class'])] += px.loc[source]['Population']\n",
    "        total_accepted += (px.loc[source]['Population'] * pi[str(t)])\n",
    "\n",
    "total_accepted = int(np.rint(100*total_accepted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "utils.latexify(8.8,5.5, font_scale=3.0)\n",
    "my_cmap = sns.cubehelix_palette(light=0.97, dark=0.3, as_cmap=True)\n",
    "plt.imshow(movement_matrix, cmap=my_cmap)\n",
    "lab = range(0,10,2)\n",
    "plt.xticks(ticks=lab,labels=[str(np.around(limits[l+1],3)) for l in lab])\n",
    "plt.yticks(ticks=lab,labels=[str(np.around(limits[l+1],3)) for l in lab])\n",
    "plt.xlabel('Final '+r'$P(y=1\\,|\\,\\bm{x})$')\n",
    "plt.ylabel('Initial '+r'$P(y=1\\,|\\,\\bm{x})$')\n",
    "\n",
    "props = dict(boxstyle='round', facecolor='white', alpha=0.5)\n",
    "# place a text box in upper left in axes coords\n",
    "plt.text(0.05, 8.5, 'Positive decision: '+r'{total_accepted}'.format(total_accepted=total_accepted)+'\\%', \n",
    "        verticalalignment='center', bbox=props)\n",
    "\n",
    "plt.colorbar()\n",
    "plt.savefig(\"./figures/optimal/movement_{datas}_gamma_{gamma}_cost_{cost_method}_non_strategic.pdf\".format(datas=datas, gamma=str(gamma).replace('.',''), cost_method=cost_method),bbox_inches='tight', )\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the $\\alpha$ parameter to be used for plotting.\n",
    "\n",
    "Values used: Non-strategic, 10, 3.3, 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "fi = \"./outputs/optimal/{name}_iterative_data_{datas}_cost_{cost_method}_a_{alpha}_gamma_{gamma}_seed_1_config.json\".format(name=name, datas=datas, cost_method=cost_method, gamma=gamma, alpha=alpha)\n",
    "total_accepted=0\n",
    "with open(fi,\"r\") as file:\n",
    "    obj = json.load(file)\n",
    "    pi = obj['pi']\n",
    "    strategic_br = obj['strategic_br']\n",
    "    movement_matrix = np.zeros((10, 10))\n",
    "    for s, t in strategic_br.items():\n",
    "        source = int(s)\n",
    "        target = int(t)\n",
    "        movement_matrix[int(u.loc[source]['Class']),int(u.loc[target]['Class'])] += px.loc[source]['Population']\n",
    "        total_accepted += (px.loc[source]['Population'] * pi[str(t)])\n",
    "\n",
    "total_accepted = int(np.rint(100*total_accepted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "utils.latexify(8.8,5.5, font_scale=3.0)\n",
    "my_cmap = sns.cubehelix_palette(light=0.97, dark=0.3, as_cmap=True)\n",
    "plt.imshow(movement_matrix, cmap=my_cmap)\n",
    "lab = range(0,10,2)\n",
    "plt.xticks(ticks=lab,labels=[str(np.around(limits[l+1],3)) for l in lab])\n",
    "plt.yticks(ticks=lab,labels=[str(np.around(limits[l+1],3)) for l in lab])\n",
    "plt.xlabel('Final '+r'$P(y=1\\,|\\,\\bm{x})$')\n",
    "plt.ylabel('Initial '+r'$P(y=1\\,|\\,\\bm{x})$')\n",
    "\n",
    "props = dict(boxstyle='round', facecolor='white', alpha=0.5)\n",
    "# place a text box in upper left in axes coords\n",
    "plt.text(0.05, 8.5, 'Positive decision: '+r'{total_accepted}'.format(total_accepted=total_accepted)+'\\%', \n",
    "        verticalalignment='center', bbox=props)\n",
    "        \n",
    "plt.colorbar()\n",
    "plt.savefig(\"./figures/optimal/movement_{datas}_gamma_{gamma}_cost_{cost_method}__alpha_{alpha}.pdf\".format(datas=datas, gamma=str(gamma).replace('.',''), cost_method=cost_method, alpha=str(alpha).replace('.','_')),bbox_inches='tight', )\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.1 ('env': venv)",
   "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.11.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "0ddb0c2da25db7768b0241d542d21cb35172a6678fcb32e19d61594f5477b3c6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}