plots-main-paper.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## Learning the policies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:04.067095Z",
     "start_time": "2019-04-19T16:43:04.049687Z"
    }
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:04.753547Z",
     "start_time": "2019-04-19T16:43:04.068986Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cf.counterfactual as cf\n",
    "import cf.utils as utils\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import itertools as it\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "from scipy.linalg import block_diag\n",
    "\n",
    "# Sepsis Simulator code\n",
    "from sepsisSimDiabetes.State import State\n",
    "from sepsisSimDiabetes.Action import Action\n",
    "from sepsisSimDiabetes.DataGenerator import DataGenerator\n",
    "import sepsisSimDiabetes.MDP as simulator \n",
    "\n",
    "import mdptoolboxSrc.mdp as mdptools\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "# Avoid Type 3 fonts\n",
    "import matplotlib\n",
    "matplotlib.rcParams['pdf.fonttype'] = 42\n",
    "matplotlib.rcParams['ps.fonttype'] = 42\n",
    "\n",
    "figpath = \"./figs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:04.753547Z",
     "start_time": "2019-04-19T16:43:04.068986Z"
    }
   },
   "outputs": [],
   "source": [
    "fig_prefix = \"main-paper\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:04.769134Z",
     "start_time": "2019-04-19T16:43:04.755230Z"
    }
   },
   "outputs": [],
   "source": [
    "SEED = 1  # Note this is not the only random seed, see the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:04.787255Z",
     "start_time": "2019-04-19T16:43:04.770642Z"
    }
   },
   "outputs": [],
   "source": [
    "np.random.seed(SEED)\n",
    "NSIMSAMPS = 1000  # Samples to draw from the simulator\n",
    "NSTEPS = 20  # Max length of each trajectory\n",
    "NCFSAMPS = 5  # Counterfactual Samples per observed sample\n",
    "DISCOUNT_Pol = 0.99 # Used for computing optimal policies\n",
    "DISCOUNT = 1 # Used for computing actual reward\n",
    "PHYS_EPSILON = 0.05 # Used for sampling using physician pol as eps greedy\n",
    "\n",
    "PROB_DIAB = 0.2\n",
    "\n",
    "# Option 1: Use bootstrapping w/replacement on the original NSIMSAMPS to estimate errors\n",
    "USE_BOOSTRAP=True\n",
    "N_BOOTSTRAP = 100\n",
    "\n",
    "# Option 2: Use repeated sampling (i.e., NSIMSAMPS fresh simulations each time) to get error bars; \n",
    "# This is done in the appendix of the paper, but not in the main paper\n",
    "N_REPEAT_SAMPLING = 1\n",
    "\n",
    "# These are properties of the simulator, do not change\n",
    "n_actions = Action.NUM_ACTIONS_TOTAL\n",
    "n_components = 2\n",
    "\n",
    "# These are added as absorbing states\n",
    "n_states_abs = State.NUM_OBS_STATES + 2\n",
    "discStateIdx = n_states_abs - 1\n",
    "deadStateIdx = n_states_abs - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transition / Reward Mats for full-information vs. marginalized MDP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we'll load the transition and reward matricies from file.  Because our simulator works in \"vitals space\" according to clinical logic, we need to do some legwork to convert this to a matrix representation.  Most notably, due to the complexity of the transitions in the simulator, it is not straightforward to read out the transition matrix from the simulator code, so we estimate it using a large amount of data from each transition (see the relevant notebook `learn_mdp_paramters.ipynb`)\n",
    "\n",
    "Once we have this \"ground truth\" transition / reward matrix learned from an arbitrarily large amount of data (or rather, two transition / reward matricies, one for each value of diabetes), we will manipulate it to construct the \"observed\" transition / reward matricies used by the physician and RL policies respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:04.944514Z",
     "start_time": "2019-04-19T16:43:04.789044Z"
    }
   },
   "outputs": [],
   "source": [
    "# Get the transition and reward matrix from file\n",
    "with open(\"./data/diab_txr_mats-replication.pkl\", \"rb\") as f:\n",
    "    mdict = pickle.load(f)\n",
    "\n",
    "tx_mat = mdict[\"tx_mat\"]\n",
    "r_mat = mdict[\"r_mat\"]\n",
    "p_mixture = np.array([1 - PROB_DIAB, PROB_DIAB])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:05.064330Z",
     "start_time": "2019-04-19T16:43:04.946096Z"
    }
   },
   "outputs": [],
   "source": [
    "from scipy.linalg import block_diag\n",
    "\n",
    "tx_mat_full = np.zeros((n_actions, State.NUM_FULL_STATES, State.NUM_FULL_STATES))\n",
    "r_mat_full = np.zeros((n_actions, State.NUM_FULL_STATES, State.NUM_FULL_STATES))\n",
    "\n",
    "for a in range(n_actions):\n",
    "    tx_mat_full[a, ...] = block_diag(tx_mat[0, a, ...], tx_mat[1, a,...])\n",
    "    r_mat_full[a, ...] = block_diag(r_mat[0, a, ...], r_mat[1, a, ...])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:14.717995Z",
     "start_time": "2019-04-19T16:43:05.066210Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min, sys: 544 ms, total: 1min 1s\n",
      "Wall time: 4.53 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "fullMDP = cf.MatrixMDP(tx_mat_full, r_mat_full)\n",
    "fullPol = fullMDP.policyIteration(discount=DISCOUNT_Pol, eval_type=1)\n",
    "\n",
    "physPolSoft = np.copy(fullPol)\n",
    "physPolSoft[physPolSoft == 1] = 1 - PHYS_EPSILON\n",
    "physPolSoft[physPolSoft == 0] = PHYS_EPSILON / (n_actions - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T16:43:14.761240Z",
     "start_time": "2019-04-19T16:43:14.740751Z"
    }
   },
   "outputs": [],
   "source": [
    "obs_reward = []\n",
    "offpol_opt_reward_WIS_hard = []                         \n",
    "offpol_opt_reward_WIS_soft = [] \n",
    "offpol_opt_reward_mb = []\n",
    "offpol_opt_reward_cf = []\n",
    "true_rl_reward = []\n",
    "\n",
    "# Store all of our samples\n",
    "all_samps = []\n",
    "\n",
    "# Store all of the samples selected by Hard WIS\n",
    "wis_samps = []\n",
    "\n",
    "# Track the number of samples which match per WIS\n",
    "wis_counts = []\n",
    "\n",
    "# We will save the detailed samples from the first run\n",
    "saved_material = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a QA function to ensure that the RL policy is only taking actions that have been observed\n",
    "def check_rl_policy(rl_policy, obs_samps, proj_lookup):\n",
    "    passes = True\n",
    "    # Check the observed actions for each state\n",
    "    obs_pol = np.zeros_like(rl_policy)\n",
    "    for eps_idx in range(NSIMSAMPS):\n",
    "        for time_idx in range(NSTEPS):\n",
    "            this_obs_action = int(obs_samps[eps_idx, time_idx, 1])\n",
    "            # Need to get projected state\n",
    "            if this_obs_action == -1:\n",
    "                continue\n",
    "            this_obs_state = proj_lookup[int(obs_samps[eps_idx, time_idx, 2])]\n",
    "            obs_pol[this_obs_state, this_obs_action] += 1\n",
    "\n",
    "    # Check if each RL action conforms to an observed action\n",
    "    for eps_idx in range(NSIMSAMPS):\n",
    "        for time_idx in range(NSTEPS):\n",
    "            this_full_state_unobserved = int(obs_samps[eps_idx, time_idx, 1])\n",
    "            this_obs_state = proj_lookup[this_full_state_unobserved]\n",
    "            this_obs_action = int(obs_samps[eps_idx, time_idx, 1])\n",
    "\n",
    "            if this_obs_action == -1:\n",
    "                continue\n",
    "            # This is key: In some of these trajectories, you die or get discharge.  \n",
    "            # In this case, no action is taken because the sequence has terminated, so there's nothing to compare the RL action to\n",
    "            true_death_states = r_mat[0, 0, 0, :] == -1\n",
    "            true_disch_states = r_mat[0, 0, 0, :] == 1\n",
    "            if np.logical_or(true_death_states, true_disch_states)[this_full_state_unobserved]:\n",
    "                continue\n",
    "\n",
    "            this_rl_action = rl_policy[proj_lookup[this_obs_state]].argmax()\n",
    "            if obs_pol[this_obs_state, this_rl_action] == 0:\n",
    "                print(\"Eps: {} \\t RL Action {} in State {} never observed\".format(\n",
    "                    int(time_idx / NSTEPS), this_rl_action, this_obs_state))\n",
    "                passes = False\n",
    "    return passes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct the projection matrix for obs->proj states\n",
    "n_proj_states = int((n_states_abs - 2) / 5) + 2\n",
    "proj_matrix = np.zeros((n_states_abs, n_proj_states))\n",
    "for i in range(n_states_abs - 2):\n",
    "    this_state = State(state_idx = i, idx_type='obs', \n",
    "                       diabetic_idx = 1)  # Diab a req argument, no difference\n",
    "    # assert this_state == State(state_idx = i, idx_type = 'obs', diabetic_idx = 0)\n",
    "    j = this_state.get_state_idx('proj_obs')\n",
    "    proj_matrix[i, j] = 1\n",
    "\n",
    "# Add the projection to death and discharge\n",
    "proj_matrix[deadStateIdx, -2] = 1\n",
    "proj_matrix[discStateIdx, -1] = 1\n",
    "\n",
    "proj_matrix = proj_matrix.astype(int)\n",
    "\n",
    "proj_lookup = proj_matrix.argmax(axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T17:12:19.338614Z",
     "start_time": "2019-04-19T16:43:14.787770Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ae849bffe47240b88ff88c8df72fd83e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Outer Loop', max=1, style=ProgressStyle(description_width='in…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d3078f2e6e2b4c76b220ff4bd498ce75",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='CF OPE', max=1000, style=ProgressStyle(description_width='ini…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for it in tqdm(range(N_REPEAT_SAMPLING), desc=\"Outer Loop\"):\n",
    "    np.random.seed(it)\n",
    "    dgen = DataGenerator()\n",
    "    states, actions, lengths, rewards, diab, emp_tx_totals, emp_r_totals = dgen.simulate(\n",
    "       NSIMSAMPS, NSTEPS, policy=physPolSoft, policy_idx_type='full', \n",
    "       p_diabetes=PROB_DIAB, use_tqdm=False) #True, tqdm_desc='Behaviour Policy Simulation')\n",
    "\n",
    "    obs_samps = utils.format_dgen_samps(\n",
    "       states, actions, rewards, diab, NSTEPS, NSIMSAMPS)\n",
    "    \n",
    "    emp_tx_mat = np.copy(emp_tx_totals)\n",
    "    emp_r_mat = np.copy(emp_r_totals)\n",
    "\n",
    "    ############## Construct the Transition Matrix w/proj states ##############\n",
    "    proj_tx_cts = np.zeros((n_actions, n_proj_states, n_proj_states))\n",
    "    proj_tx_mat = np.zeros_like(proj_tx_cts)\n",
    "\n",
    "    # (1) NOTE: Previous code marginalized here, but now we are just getting observed quantities out, no components\n",
    "    est_tx_cts = np.copy(emp_tx_totals)\n",
    "    assert est_tx_cts.ndim == 3\n",
    "\n",
    "    # (2) Add new aborbing states, and a new est_tx_mat with Absorbing states\n",
    "    death_states = (emp_r_mat.sum(axis=0).sum(axis=0) < 0)\n",
    "    disch_states = (emp_r_mat.sum(axis=0).sum(axis=0) > 0)\n",
    "\n",
    "    est_tx_cts_abs = np.zeros((n_actions, n_states_abs, n_states_abs))\n",
    "    est_tx_cts_abs[:, :-2, :-2] = np.copy(est_tx_cts)\n",
    "\n",
    "    death_states = np.concatenate([death_states, np.array([True, False])])\n",
    "    disch_states = np.concatenate([disch_states, np.array([False, True])])\n",
    "    assert est_tx_cts_abs[:, death_states, :].sum() == 0\n",
    "    assert est_tx_cts_abs[:, disch_states, :].sum() == 0\n",
    "\n",
    "    est_tx_cts_abs[:, death_states, deadStateIdx] = 1\n",
    "    est_tx_cts_abs[:, disch_states, discStateIdx] = 1\n",
    "\n",
    "    # (3) Project the new est_tx_cts_abs to the reduced state space\n",
    "    for a in range(n_actions):\n",
    "        proj_tx_cts[a] = proj_matrix.T.dot(est_tx_cts_abs[a]).dot(proj_matrix)\n",
    "\n",
    "    # Normalize\n",
    "    nonzero_idx = proj_tx_cts.sum(axis=-1) != 0\n",
    "    proj_tx_mat[nonzero_idx] = proj_tx_cts[nonzero_idx]\n",
    "\n",
    "    proj_tx_mat[nonzero_idx] /= proj_tx_mat[nonzero_idx].sum(axis=-1, keepdims=True)\n",
    "\n",
    "    ############ Construct the reward matrix, which is known ##################\n",
    "    proj_r_mat = np.zeros((n_actions, n_proj_states, n_proj_states))\n",
    "    proj_r_mat[..., -2] = -1\n",
    "    proj_r_mat[..., -1] = 1\n",
    "\n",
    "    proj_r_mat[..., -2, -2] = 0 # No reward once in aborbing state\n",
    "    proj_r_mat[..., -1, -1] = 0\n",
    "\n",
    "    ############ Construct the empirical prior on the initial state ##################\n",
    "    initial_state_arr = np.copy(states[:, 0, 0])\n",
    "    initial_state_counts = np.zeros((n_states_abs,1))\n",
    "    for i in range(initial_state_arr.shape[0]):\n",
    "        initial_state_counts[initial_state_arr[i]] += 1\n",
    "\n",
    "    # Project initial state counts to new states\n",
    "    proj_state_counts = proj_matrix.T.dot(initial_state_counts).T\n",
    "    proj_p_initial_state = proj_state_counts / proj_state_counts.sum()\n",
    "\n",
    "    # Because some SA pairs are never observed, assume they cause instant death\n",
    "    zero_sa_pairs = proj_tx_mat.sum(axis=-1) == 0\n",
    "    proj_tx_mat[zero_sa_pairs, -2] = 1  # Always insta-death if you take a never-taken action\n",
    "\n",
    "    # Construct an extra axis for the mixture component, of which there is only one\n",
    "    projMDP = cf.MatrixMDP(proj_tx_mat, proj_r_mat, \n",
    "                           p_initial_state=proj_p_initial_state)\n",
    "    try:\n",
    "        RlPol = projMDP.policyIteration(discount=DISCOUNT_Pol)\n",
    "    except:\n",
    "        assert np.allclose(proj_tx_mat.sum(axis=-1), 1)\n",
    "        RlPol = projMDP.policyIteration(discount=DISCOUNT_Pol, skip_check=True)\n",
    "\n",
    "    # Estimate the observed policy\n",
    "    obs_pol_proj = proj_tx_cts.sum(axis=-1)  # Sum over the \"to\" state\n",
    "    obs_pol_proj = obs_pol_proj.T # Switch from (a, s) to (s, a)\n",
    "    obs_states = obs_pol_proj.sum(axis=-1) > 0 # Observed \"from\" states\n",
    "\n",
    "    obs_pol_proj[obs_states] /= obs_pol_proj[obs_states].sum(axis=-1, keepdims=True)\n",
    "    \n",
    "    # Check if we always observe the RL policy in the non-absorbing states\n",
    "    prop_rl_obs = (obs_pol_proj[:-2, :][RlPol[:-2, :]==1] > 0).mean()\n",
    "    if prop_rl_obs < 1:\n",
    "        assert check_rl_policy(RlPol, obs_samps, proj_lookup), 'RL policy validation failed'\n",
    "\n",
    "    def projection_func(obs_state_idx):\n",
    "        if obs_state_idx == -1:\n",
    "            return -1\n",
    "        else:\n",
    "            return proj_lookup[obs_state_idx]\n",
    "\n",
    "    proj_f = np.vectorize(projection_func)\n",
    "    states_proj = proj_f(states)\n",
    "    assert states_proj.shape == states.shape\n",
    "\n",
    "    obs_samps_proj = utils.format_dgen_samps(\n",
    "       states_proj, actions, rewards, diab, NSTEPS, NSIMSAMPS)\n",
    "        \n",
    "    # Get the true RL reward as a sanity check\n",
    "    # Note that the RL policy includes actions for \"death\" and \"discharge\" absorbing states, which we ignore by taking [:-2, :]\n",
    "    NSIMSAMPS_RL = NSIMSAMPS\n",
    "    states_rl, actions_rl, lengths_rl, rewards_rl, diab_rl, _, _ = dgen.simulate(\n",
    "       NSIMSAMPS_RL, NSTEPS, policy=RlPol[:-2, :], policy_idx_type='proj_obs', \n",
    "       p_diabetes=PROB_DIAB, use_tqdm=False) #True, tqdm_desc='RL Policy Simulation')\n",
    "\n",
    "    obs_samps_rlpol = utils.format_dgen_samps(\n",
    "       states_rl, actions_rl, rewards_rl, diab_rl, NSTEPS, NSIMSAMPS_RL)\n",
    "\n",
    "    this_true_rl_reward = cf.eval_on_policy(\n",
    "        obs_samps_rlpol, discount=DISCOUNT, \n",
    "        bootstrap=USE_BOOSTRAP, n_bootstrap=N_BOOTSTRAP)  # Need a second axis to concat later\n",
    "\n",
    "    # Get a soft version of the RL policy for WIS\n",
    "    RlPolSoft = np.copy(RlPol).astype(float)\n",
    "    RlPolSoft[RlPolSoft == 1] = 0.99\n",
    "    RlPolSoft[RlPolSoft == 0] = 0.01 / (n_actions - 1)\n",
    "\n",
    "    # This is the observed reward from the samples given\n",
    "    this_obs_reward = cf.eval_on_policy(\n",
    "        obs_samps_proj, discount=DISCOUNT, \n",
    "        bootstrap=USE_BOOSTRAP, n_bootstrap=N_BOOTSTRAP)\n",
    "\n",
    "    # This is the off-policy reward using WIS\n",
    "    this_offpol_opt_reward_WIS_hard, this_wis_samps, this_wis_ct = cf.eval_wis(\n",
    "        obs_samps_proj, discount=DISCOUNT,\n",
    "        bootstrap=USE_BOOSTRAP, n_bootstrap=N_BOOTSTRAP, \n",
    "        obs_policy=obs_pol_proj, new_policy=RlPol)\n",
    "\n",
    "    this_offpol_opt_reward_WIS_soft, _, _ = cf.eval_wis(\n",
    "        obs_samps_proj, discount=DISCOUNT,\n",
    "        bootstrap=USE_BOOSTRAP, n_bootstrap=N_BOOTSTRAP, \n",
    "        obs_policy=obs_pol_proj, new_policy=RlPolSoft)\n",
    "    \n",
    "    # Draw samples from the MDP under the new policy to get a model-based estimate of reward\n",
    "    BSampler = cf.BatchSampler(mdp=projMDP)\n",
    "    this_mb_samples_opt = BSampler.on_policy_sample(\n",
    "        policy=RlPol, n_steps=NSTEPS, n_samps=NSIMSAMPS_RL, \n",
    "        use_tqdm=False) #, tqdm_desc='Model-Based OPE') \n",
    "\n",
    "    this_offpol_opt_reward_mb = cf.eval_on_policy(\n",
    "        this_mb_samples_opt, discount=DISCOUNT,\n",
    "        bootstrap=USE_BOOSTRAP, n_bootstrap=N_BOOTSTRAP) \n",
    "    \n",
    "     # Get samples from the counterfactual rollouts of optimal pol\n",
    "    this_cf_opt_samps_proj = BSampler.cf_trajectory(\n",
    "        obs_samps_proj, \n",
    "        cf_policy=RlPol, \n",
    "        n_cf_samps=NCFSAMPS, use_tqdm=True, tqdm_desc='CF OPE')\n",
    "    \n",
    "    this_cf_opt_samps_proj_reshaped = \\\n",
    "    this_cf_opt_samps_proj.reshape(\n",
    "        this_cf_opt_samps_proj.shape[0] * this_cf_opt_samps_proj.shape[1],\n",
    "        this_cf_opt_samps_proj.shape[2], this_cf_opt_samps_proj.shape[3])\n",
    "\n",
    "    this_offpol_opt_reward_cf = cf.eval_on_policy(\n",
    "        this_cf_opt_samps_proj_reshaped, \n",
    "        discount=DISCOUNT, \n",
    "        bootstrap=USE_BOOSTRAP, n_bootstrap=N_BOOTSTRAP)\n",
    "    \n",
    "    if saved_material is None:\n",
    "        saved_material = {'cf_samps': np.copy(this_cf_opt_samps_proj),\n",
    "                         'obs_samps': np.copy(obs_samps)}\n",
    "    \n",
    "    wis_counts.append(this_wis_ct)\n",
    "    wis_samps.append(this_wis_samps)\n",
    "    all_samps.append(obs_samps)\n",
    "\n",
    "    obs_reward.append(this_obs_reward)\n",
    "    offpol_opt_reward_WIS_hard.append(this_offpol_opt_reward_WIS_hard)                       \n",
    "    offpol_opt_reward_WIS_soft.append(this_offpol_opt_reward_WIS_soft)\n",
    "    offpol_opt_reward_mb.append(this_offpol_opt_reward_mb)\n",
    "    offpol_opt_reward_cf.append(this_offpol_opt_reward_cf)\n",
    "    true_rl_reward.append(this_true_rl_reward)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T17:12:19.355539Z",
     "start_time": "2019-04-19T17:12:19.340377Z"
    }
   },
   "outputs": [],
   "source": [
    "def conv_to_np(this_list):\n",
    "    this_arr = np.array(this_list)[:, np.newaxis]\n",
    "    # Make this idempotent\n",
    "    this_arr = this_arr.squeeze()[:, np.newaxis]\n",
    "    return this_arr\n",
    "\n",
    "obs_reward = conv_to_np(obs_reward)\n",
    "offpol_opt_reward_WIS_hard = conv_to_np(offpol_opt_reward_WIS_hard)\n",
    "offpol_opt_reward_WIS_soft = conv_to_np(offpol_opt_reward_WIS_soft)\n",
    "offpol_opt_reward_mb = conv_to_np(offpol_opt_reward_mb)\n",
    "offpol_opt_reward_cf = conv_to_np(offpol_opt_reward_cf)\n",
    "true_rl_reward = conv_to_np(true_rl_reward)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T18:12:29.839468Z",
     "start_time": "2019-04-19T18:12:29.629901Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams.update({'font.size': 20})\n",
    "reward = np.concatenate([obs_reward, \n",
    "                         offpol_opt_reward_WIS_hard,                         \n",
    "#                         offpol_opt_reward_WIS_soft, \n",
    "                         offpol_opt_reward_mb,\n",
    "                         offpol_opt_reward_cf,\n",
    "                         true_rl_reward,\n",
    "                         ], axis=1)\n",
    "reward_df = pd.DataFrame(reward, columns=['Obs', \n",
    "                                          'WIS',\n",
    "#                                          'WIS Soft',                                          \n",
    "                                          'MB',\n",
    "                                          'CF',\n",
    "                                          'True'\n",
    "                                         ])\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "sns.boxplot(data=reward_df, whis=[2.5, 97.5])\n",
    "plt.ylabel(\"Average Reward\")\n",
    "plt.savefig(\"{}/{}-ope_wis_mb_cf_true.pdf\".format(\n",
    "    figpath, fig_prefix))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-19T18:13:58.113270Z",
     "start_time": "2019-04-19T18:13:58.086468Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS:\n",
      "\tObserved Reward:  0.3240 \t 95% Range: 0.2889 to 0.3692\n",
      "\tTrue RL Reward:\t -0.4907 \t 95% Range: -0.5405 to -0.4445\n",
      "\tWIS Estimate:\t 0.6286 \t 95% Range: 0.0680 to 0.9458\n",
      "\tMB Estimate:\t 0.9164 \t 95% Range: 0.8950 to 0.9365\n",
      "\tCF Estimate:\t 0.9531 \t 95% Range: 0.9460 to 0.9600\n"
     ]
    }
   ],
   "source": [
    "print((\"RESULTS:\"\n",
    "       \"\\n\\tObserved Reward:  {:.4f} \\t 95% Range: {:.4f} to {:.4f}\"\n",
    "       \"\\n\\tTrue RL Reward:\\t {:.4f} \\t 95% Range: {:.4f} to {:.4f}\"\n",
    "       \"\\n\\tWIS Estimate:\\t {:.4f} \\t 95% Range: {:.4f} to {:.4f}\"\n",
    "       \"\\n\\tMB Estimate:\\t {:.4f} \\t 95% Range: {:.4f} to {:.4f}\"\n",
    "       \"\\n\\tCF Estimate:\\t {:.4f} \\t 95% Range: {:.4f} to {:.4f}\").format(\n",
    "    obs_reward.mean(), \n",
    "    np.quantile(obs_reward, 0.025), \n",
    "    np.quantile(obs_reward, 0.975), \n",
    "    true_rl_reward.mean(), \n",
    "    np.quantile(true_rl_reward,0.025), \n",
    "    np.quantile(true_rl_reward, 0.975),\n",
    "    offpol_opt_reward_WIS_hard.mean(), \n",
    "    np.quantile(offpol_opt_reward_WIS_hard,0.025), \n",
    "    np.quantile(offpol_opt_reward_WIS_hard,0.975),\n",
    "    offpol_opt_reward_mb.mean(), \n",
    "    np.quantile(offpol_opt_reward_mb,0.025), \n",
    "    np.quantile(offpol_opt_reward_mb,0.975),\n",
    "    offpol_opt_reward_cf.mean(), \n",
    "    np.quantile(offpol_opt_reward_cf,0.025), \n",
    "    np.quantile(offpol_opt_reward_cf,0.975)\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Counterfactuals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "this_cf_opt_samps_proj = saved_material['cf_samps']\n",
    "cf_obs_samps = saved_material['obs_samps']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "colTime = 0\n",
    "colAction = 1\n",
    "colS0 = 2\n",
    "colS1 = 3\n",
    "colDiab = 4\n",
    "colR = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_vs_cf_reward = pd.DataFrame(\n",
    "    np.zeros((NSIMSAMPS, 2)),\n",
    "    columns = ['Obs Reward', 'CF Reward'])\n",
    "\n",
    "for obs_idx in range(NSIMSAMPS):\n",
    "    # Get the MAP counterfactual reward\n",
    "    cf_r_all = this_cf_opt_samps_proj[obs_idx][..., colR].sum(axis=-1)\n",
    "    (_, idx, cts) = np.unique(cf_r_all, return_index=True, return_counts=True)\n",
    "    cf_idx = idx[np.argmax(cts)]\n",
    "    cf_r = cf_r_all[cf_idx]\n",
    "    assert cf_r in [-1, 0, 1]    \n",
    "    \n",
    "    # Get the observed reward\n",
    "    obs_r = cf_obs_samps[obs_idx][..., colR].sum()\n",
    "    assert obs_r in [-1, 0, 1]\n",
    "    \n",
    "    obs_vs_cf_reward.iloc[obs_idx] = np.array([obs_r, cf_r])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_mat = np.zeros((3, 3))\n",
    "\n",
    "cf_idxs = [obs_vs_cf_reward['CF Reward'] == i for i in [-1, 0, 1]]\n",
    "obs_idxs = [obs_vs_cf_reward['Obs Reward'] == i for i in [-1, 0, 1]]\n",
    "\n",
    "import itertools\n",
    "for i, j in itertools.product(range(3), range(3)):\n",
    "    result_mat[i, j] = np.logical_and(obs_idxs[i], cf_idxs[j]).sum()\n",
    "    \n",
    "result_mat /= result_mat.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "plt.rcParams.update({'font.size': 48})\n",
    "ax = sns.heatmap(result_mat, annot=True, \n",
    "                 annot_kws={'fontsize': 72},\n",
    "                 fmt='.0%', cbar=False, cmap='Blues')\n",
    "ax.set_xlabel(\"\\nCounterfactual Outcome\")\n",
    "ax.set_ylabel(\"Observed Outcome\\n\")\n",
    "ax.set_xticklabels(['Died', 'No Chg.', 'Disch.'])\n",
    "ax.set_yticklabels(['Died', 'No Chg.', 'Disch.'])\n",
    "for tick in ax.yaxis.get_major_ticks():\n",
    "    tick.label1.set_verticalalignment('center')\n",
    "plt.savefig(\"{}/{}-optimistic_decomp.pdf\".format(figpath, fig_prefix), bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 103 patients who the model believes would have been discharged\n"
     ]
    }
   ],
   "source": [
    "would_have_lived_idx = np.logical_and(cf_idxs[2], obs_idxs[0])\n",
    "print(\"There are {} patients who the model believes would have been discharged\".format(\n",
    "would_have_lived_idx.sum()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_obs_trajectories = cf_obs_samps[would_have_lived_idx]\n",
    "selected_cf_trajectories = this_cf_opt_samps_proj[would_have_lived_idx]\n",
    "num_selected_traj = selected_obs_trajectories.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get lengths as the time until action = -1\n",
    "obs_lengths = np.ones(num_selected_traj)*NSTEPS\n",
    "for traj_idx in range(num_selected_traj):\n",
    "    for time_idx in range(NSTEPS):\n",
    "        if selected_obs_trajectories[traj_idx, time_idx, colR] != 0:\n",
    "            #print(\"Setting {} to length {}\".format(traj_idx, time_idx))\n",
    "            obs_lengths[traj_idx] = time_idx\n",
    "            break\n",
    "\n",
    "obs_lengths = obs_lengths.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([16, 19, 20, 21, 22, 28, 30, 36, 43, 45, 47, 52, 58, 63, 66, 67, 71,\n",
       "        74, 77, 82, 85, 86, 87, 88, 92, 96, 97]),)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This gives all of the trajectories with a reasonable length, for further inspection\n",
    "np.where(obs_lengths > 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams.update({'font.size': 14})\n",
    "\n",
    "# RL policy attempts no treatment from the start, mistake due to glucose\n",
    "# 16; 20; 21; 30; 45; 47; 52; 58; 66; 71; 74; 77; 82; 85; 97\n",
    "\n",
    "# RL policy thinks it could have stabilized, then discharged, but glucose would still have been off\n",
    "# 19*; 28; 43; 67; 86*; 87*; 88; 96\n",
    "\n",
    "# RL policy thinks it could have stabilized, then discharged;  Might be correct, glucose was not abnormal\n",
    "# 22; 36; 92\n",
    "\n",
    "# Other\n",
    "# 63; \n",
    "\n",
    "traj_idx = 86\n",
    "\n",
    "fig, axes = utils.plot_trajectory(\n",
    "        selected_obs_trajectories, \n",
    "        pt_idx=traj_idx, \n",
    "        cf=True, \n",
    "        cf_samps=selected_cf_trajectories, \n",
    "        cf_proj=True\n",
    "        )\n",
    "\n",
    "plt.savefig('{}/{}-example-trajectory-{}.pdf'.format(figpath, fig_prefix, traj_idx), bbox_inches='tight')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.2"
  },
  "toc-showcode": false,
  "toc-showmarkdowntxt": true,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 2
}